path: root/src/fsm/psk31.c

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 Matthias P. Braendli
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
*/

#include "psk31.h"
#include "common.h"
#include "audio.h"
#include <string.h>
#include "arm_math.h"

/* Kernel includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"

/* PSK31 generator
 *
 * Concept:
 *
 * +----------------------+                       +--------------+
 * | psk31_push_message() | -> psk31_msg_queue -> | psk31_task() |
 * +----------------------+                       +--------------+
 *                                                       |
 *      _________________________________________________/
 *     /
 *     |
 *    \|/
 *     V
 *
 * psk31_audio_queue
 *
 * The psk31_fill_buffer() function can be called to fetch audio from the audio_queue
 */

#define PSK31_MAX_MESSAGE_LEN 10240
#define PHASE_BUFFER_SIZE (20 + PSK31_MAX_MESSAGE_LEN + 20)

struct psk31_out_message_s {
    // Contains a sequence of ones and zeros corresponding to
    // the BPSK31 phase
    char    phase_buffer[PHASE_BUFFER_SIZE];
    size_t  phase_buffer_end;

    int     freq; // Audio frequency for signal center
};

// The queue contains above structs
QueueHandle_t psk31_msg_queue;

// Queue that contains audio data
QueueHandle_t psk31_audio_queue;
static int    psk31_samplerate;

static int    psk31_transmit_ongoing;

static void psk31_task(void *pvParameters);
static void psk31_str_to_bits(const char* instr, char* outbits);


void psk31_init(unsigned int samplerate)
{
    psk31_samplerate = samplerate;
    psk31_transmit_ongoing = 0;

    psk31_msg_queue = xQueueCreate(15, sizeof(struct psk31_out_message_s));
    if (psk31_msg_queue == 0) {
        while(1); /* fatal error */
    }

    psk31_audio_queue = xQueueCreate(2, AUDIO_BUF_LEN * sizeof(int16_t));
    if (psk31_audio_queue == 0) {
        while(1); /* fatal error */
    }

    xTaskCreate(
            psk31_task,
            "TaskPSK31",
            8*configMINIMAL_STACK_SIZE,
            (void*) NULL,
            tskIDLE_PRIORITY + 2UL,
            NULL);
}

int psk31_push_message(const char* text, int frequency)
{
    if (strlen(text) > PSK31_MAX_MESSAGE_LEN) {
        return 0;
    }

    struct psk31_out_message_s msg;
    msg.phase_buffer_end = 0;
    msg.freq = frequency;

    psk31_str_to_bits(text, msg.phase_buffer);

    xQueueSendToBack(psk31_msg_queue, &msg, portMAX_DELAY);

    return 1;
}

// Write the waveform into the buffer (stereo)
size_t psk31_fill_buffer(int16_t *buf, size_t bufsize);

// Return 1 if the psk31 generator has completed transmission
int psk31_busy(void);

static int16_t psk31_audio_buf[AUDIO_BUF_LEN];
static void psk31_task(void *pvParameters)
{
    struct psk31_out_message_s psk31_fill_msg_current;

    float nco_phase = 0.0f;
    float ampl = 0.0f;

    int   buf_pos = 0;

    while (1) {
        int status = xQueueReceive(psk31_msg_queue, &psk31_fill_msg_current, portMAX_DELAY);
        if (status == pdTRUE) {

            psk31_transmit_ongoing = 1;

            /* BPSK31 is at 31.25 symbols per second. */
            const int samples_per_symbol = psk31_samplerate * 100 / 3125;

            // Angular frequency of NCO
            const float omega = 2.0f * FLOAT_PI * psk31_fill_msg_current.freq /
                (float)psk31_samplerate;

            int current_psk_phase = 0;

            for (int i = 0; i < psk31_fill_msg_current.phase_buffer_end; i++) {
                for (int t = 0; t < samples_per_symbol; t++) {
                    int16_t s = 0;

                    if (psk31_fill_msg_current.phase_buffer[i]) {
                        ampl = 32000.0f;
                    }
                    else {
                        ampl =
                            (float)current_psk_phase *
                            32000.0f *
                            arm_cos_f32(
                                    FLOAT_PI*(float)t/(float)samples_per_symbol);
                    }

                    nco_phase += omega;
                    if (nco_phase > FLOAT_PI) {
                        nco_phase -= 2.0f * FLOAT_PI;
                    }

                    s = ampl * arm_sin_f32(nco_phase);

                    if (buf_pos == AUDIO_BUF_LEN) {
                        xQueueSendToBack(psk31_audio_queue, &psk31_audio_buf, portMAX_DELAY);
                        buf_pos = 0;
                    }
                    psk31_audio_buf[buf_pos++] = s;

                    // Stereo
                    if (buf_pos == AUDIO_BUF_LEN) {
                        xQueueSendToBack(psk31_audio_queue, &psk31_audio_buf, portMAX_DELAY);
                        buf_pos = 0;
                    }
                    psk31_audio_buf[buf_pos++] = s;
                }


                if (! psk31_fill_msg_current.phase_buffer[i]) {
                    current_psk_phase *= -1;
                }
            }

            // We have completed this message

            psk31_transmit_ongoing = 0;
        }
    }
}

/*
 * Turn a null terminated ASCII string into a null terminated
 * string of '0's and '1's representing the PSK31 varicode for the input.
 *
 * outstr must be at least size 20 + strlen(instr)*12 + 20 to accomodate
 * the header and tail
 */
static void psk31_str_to_bits(const char* instr, char* outbits)
{
    int i=0, j, k;

    /* Header of 0s */
    for (j=0; j < 20; j++) {
        outbits[i++] = '0';
    }

    /* Encode the message, with 00 between letters */
    for (j=0; j < strlen(instr); j++) {
        const char* varicode_bits = psk31_varicode[(int)instr[j]];
        for(k=0; k < strlen(varicode_bits); k++) {
            outbits[i++] = varicode_bits[k];
        }
        outbits[i++] = '0';
        outbits[i++] = '0';
    }

    /* Tail of 0s */
    for (j=0; j < 20; j++) {
        outbits[i++] = '0';
    }

    /* NULL terminate */
    outbits[i] = 0;
}

#if 0
/*
 * Turn a null terminated string `bits` containing '0's and '1's
 * into `outlen` IQ samples for BPSK, `outbuf`.
 * Note that `outlen` is set to the number of IQ samples, i.e. half the
 * number of bytes in `outbuf`.
 * Allocates memory (possibly lots of memory) for the IQ samples, which
 * should be freed elsewhere.
 * Modulation:
 * '0': swap phase, smoothed by a cosine
 * '1': maintain phase
 * Output: I carries data, Q constantly 0
 */
void bits_to_iq(char* bits, uint8_t** outbuf, int* outlen)
{
    *outlen = strlen(bits) * 256000 * 2;
    *outbuf = malloc(*outlen);
    int8_t *buf = (int8_t*)(*outbuf);
    if(*outbuf == NULL) {
        fprintf(stderr, "Could not allocate memory for IQ buffer\n");
        exit(EXIT_FAILURE);
    }

    int i, j, phase = 1;
    for(i=0; i<strlen(bits); i++) {
        if(bits[i] == '1') {
            for(j=0; j<256000; j++) {
                buf[i*256000*2 + 2*j] = phase*50;
                buf[i*256000*2 + 2*j + 1] = 0;
            }
        } else {
            for(j=0; j<256000; j++) {
                buf[i*256000*2 + 2*j] = phase *
                    (int8_t)(50.0f * cosf(M_PI*(float)j/256000.0f));
                buf[i*256000*2 + 2*j + 1] = 0;
            }
            phase *= -1;
        }
    }
}
#endif