raspikeyer/src/raspi_keyer.cpp

#include <stdio.h>

#include "bsp/board.h"
#include "pico/multicore.h"
#include "pico/stdlib.h"
#include "pico/util/queue.h"
#include "tusb.h"

#include "keyer.h"
#include "settings.h"
#include "tusb_config.h"

namespace
{

}

extern const uint LED_PIN = PICO_DEFAULT_LED_PIN;
extern const uint LEFT_PADDLE_PIN = 14;
extern const uint RIGHT_PADDLE_PIN = 15;
extern const uint BUZZER_PIN = 18;
extern const uint CW_OUT_PIN = 17;
extern const uint AUDIO_OUT_PIN = 16;

// Stuff for communicating between cores
enum class KeyerQueueCommand {
    Run,
    Stop,
    Config,
    Wait,
};
struct KeyerQueueData {
    KeyerQueueCommand cmd;
    uint8_t wpm;
    Mode mode;
};

queue_t keyerQueue;

void setup()
{
    stdio_init_all();
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    gpio_put(LED_PIN, 0);

    // Setup pins for left and right paddles
    gpio_init(LEFT_PADDLE_PIN);
    gpio_set_dir(LEFT_PADDLE_PIN, GPIO_IN);
    gpio_pull_up(LEFT_PADDLE_PIN);
    gpio_init(RIGHT_PADDLE_PIN);
    gpio_set_dir(RIGHT_PADDLE_PIN, GPIO_IN);
    gpio_pull_up(RIGHT_PADDLE_PIN);
    gpio_init(CW_OUT_PIN);
    gpio_set_dir(CW_OUT_PIN, GPIO_OUT);
    gpio_put(CW_OUT_PIN, 0);
}

/* Let's do all the keying stuff in the second core, so there are no timing problems. */
void core1_main()
{
    printf("Hello from core1!\n");
    KeyerQueueData data;
    queue_remove_blocking(&keyerQueue, &data);

    Keyer keyer(data.wpm, data.mode);

    while (true) {
        queue_try_remove(&keyerQueue, &data);

        switch (data.cmd) {
        case KeyerQueueCommand::Run:
            keyer.run();
            break;
        case KeyerQueueCommand::Stop:
            keyer.stop();
            data.cmd = KeyerQueueCommand::Wait;
            break;
        case KeyerQueueCommand::Config:
            keyer.setSpeed(data.wpm);
            keyer.setMode(data.mode);
            data.cmd = KeyerQueueCommand::Run;
            break;
        case KeyerQueueCommand::Wait:
            break;
        default:
            break;
        }
    }
}

[[maybe_unused]]
static void echo_serial_port(uint8_t itf, uint8_t buf[], uint32_t count)
{
  for(uint32_t i=0; i<count; i++)
  {
    tud_cdc_n_write_char(itf, buf[i]);
  }

  tud_cdc_n_write_flush(itf);
}

void cdc_task()
{
    const uint8_t UsbInIf = 1;

    if (tud_cdc_n_available(UsbInIf)) {
        uint8_t buf[64];

        uint32_t count = tud_cdc_n_read(UsbInIf, buf, sizeof(buf));
        if (count > 1) {
            printf("Command received …\n");
            switch (buf[0]) {
                case 0: // ADMIN COMMAND
                switch (buf[1]) {
                    case 2: // Host Open
                    // TODO: send back revision code
                    default:
                    printf("Unknown admin command.\n");
                }
                break;
            default:
                printf("Unknown command.\n");
            }
        }
    }
}

int main()
{
    // timer_hw->dbgpause = 2; // workaround for problem with debug and sleep_ms
    //  https://github.com/raspberrypi/pico-sdk/issues/1152#issuecomment-1418248639

    setup();
    board_init();
    tud_init(BOARD_TUD_RHPORT);

    printf("Hello from core0!\n");

    Settings settings {read_settings()};
    settings.wpm = 25; // TODO: remove!

    queue_init(&keyerQueue, sizeof(KeyerQueueData), 2);
    multicore_reset_core1();
    multicore_launch_core1(core1_main);

    KeyerQueueData keyerQueueData {KeyerQueueCommand::Run, settings.wpm, settings.mode};
    queue_add_blocking(&keyerQueue, &keyerQueueData);

    while (true) {
        tud_task();
        cdc_task();
    }

    return 0;
}