546 lines
18 KiB
C
546 lines
18 KiB
C
// NEED TO FIGURE OUT A SIMPLER WAY TO DO THIS... THIS IS JUST TO GET ENABLE_GPIO_KEYER!
|
|
#include <Python.h> // used by quisk.h
|
|
#include <complex.h> // Used by quisk.h
|
|
#include "quisk.h"
|
|
|
|
#if defined(ENABLE_GPIO_KEYER)
|
|
|
|
// gcc iambic.c -o iambic -l pigpio -lpthread
|
|
// or make, to run sudo ./iambic [options]
|
|
|
|
/*
|
|
|
|
10/12/2016, Rick Koch / N1GP, I adapted Phil's verilog code from
|
|
the openHPSDR Hermes iambic.v implementation to build
|
|
and run on a raspberry PI 3.
|
|
|
|
1/7/2017, N1GP, adapted to work with Jack Audio, much better timing.
|
|
|
|
--------------------------------------------------------------------------------
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with this library; if not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
--------------------------------------------------------------------------------
|
|
|
|
|
|
---------------------------------------------------------------------------------
|
|
Copywrite (C) Phil Harman VK6PH May 2014
|
|
---------------------------------------------------------------------------------
|
|
|
|
The code implements an Iambic CW keyer. The following features are supported:
|
|
|
|
* Variable speed control from 1 to 60 WPM
|
|
* Dot and Dash memory
|
|
* Straight, Bug, Iambic Mode A or B Modes
|
|
* Variable character weighting
|
|
* Automatic Letter spacing
|
|
* Paddle swap
|
|
|
|
Dot and Dash memory works by registering an alternative paddle closure whilst a paddle is pressed.
|
|
The alternate paddle closure can occur at any time during a paddle closure and is not limited to being
|
|
half way through the current dot or dash. This feature could be added if required.
|
|
|
|
In Straight mode, closing the DASH paddle will result in the output following the input state. This enables a
|
|
straight morse key or external Iambic keyer to be connected.
|
|
|
|
In Bug mode closing the dot paddle will send repeated dots.
|
|
|
|
The difference between Iambic Mode A and B lies in what the keyer does when both paddles are released. In Mode A the
|
|
keyer completes the element being sent when both paddles are released. In Mode B the keyer sends an additional
|
|
element opposite to the one being sent when the paddles are released.
|
|
|
|
This only effects letters and characters like C, period or AR.
|
|
|
|
Automatic Letter Space works as follows: When enabled, if you pause for more than one dot time between a dot or dash
|
|
the keyer will interpret this as a letter-space and will not send the next dot or dash until the letter-space time has been met.
|
|
The normal letter-space is 3 dot periods. The keyer has a paddle event memory so that you can enter dots or dashes during the
|
|
inter-letter space and the keyer will send them as they were entered.
|
|
|
|
Speed calculation - Using standard PARIS timing, dot_period(mS) = 1200/WPM
|
|
*/
|
|
|
|
#define DEBUG
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <stdint.h>
|
|
#include <fcntl.h>
|
|
#include <poll.h>
|
|
#include <sched.h>
|
|
#include <time.h>
|
|
#include <sys/mman.h>
|
|
#include <pthread.h>
|
|
#include <signal.h>
|
|
#include <semaphore.h>
|
|
#include <wiringPi.h>
|
|
|
|
static void* keyer_thread(void *arg);
|
|
static pthread_t keyer_thread_id;
|
|
|
|
// GPIO pins
|
|
//#define LEFT_PADDLE_GPIO 22
|
|
//#define RIGHT_PADDLE_GPIO 27
|
|
//#define KEY_OUT_GPIO 23
|
|
//#define PTT_OUT_GPIO 24
|
|
static int left_paddle_gpio = 22;
|
|
static int right_paddle_gpio = 27;
|
|
static int keyer_out_gpio = 23;
|
|
static int tr_switch_gpio = 24;
|
|
|
|
// Keyer modes
|
|
#define KEYER_STRAIGHT 0
|
|
#define KEYER_MODE_A 1
|
|
#define KEYER_MODE_B 2
|
|
#define NUM_KEYER_MODES 3
|
|
|
|
#define NSEC_PER_SEC (1000000000)
|
|
|
|
enum {
|
|
CHECK = 0,
|
|
PREDOT,
|
|
PREDASH,
|
|
SENDDOT,
|
|
SENDDASH,
|
|
DOTDELAY,
|
|
DASHDELAY,
|
|
DOTHELD,
|
|
DASHHELD,
|
|
LETTERSPACE,
|
|
HANGTIME,
|
|
EXITLOOP
|
|
};
|
|
|
|
static int dot_memory = 0;
|
|
static int dash_memory = 0;
|
|
static int key_state = 0;
|
|
static int kdelay = 0;
|
|
static int dot_delay = 0;
|
|
static int dash_delay = 0;
|
|
static volatile int kcwl = 0;
|
|
static volatile int kcwr = 0;
|
|
static int *kdot;
|
|
static int *kdash;
|
|
static int cw_keyer_speed = 20;
|
|
static int cw_keyer_weight = 55;
|
|
static int cw_keys_reversed = 0;
|
|
static int cw_keyer_mode = KEYER_MODE_A;
|
|
static int cw_keyer_spacing = 0;
|
|
static int cw_active_state = 0;
|
|
static sem_t cw_event;
|
|
#if defined(DEBUG)
|
|
static int cw_event_value;
|
|
#endif
|
|
static int cw_hangtime_msec = 250;
|
|
|
|
static int running, keyer_out = 0;
|
|
|
|
// Function prototypes
|
|
|
|
void keyer_update(void);
|
|
void keyer_event(int, int, uint32_t);
|
|
void keyer_event_left(void);
|
|
void keyer_event_right(void);
|
|
void clear_memory(void);
|
|
static void set_keyer_out(int);
|
|
static void* keyer_thread(void*);
|
|
|
|
/////
|
|
|
|
void keyer_update() {
|
|
dot_delay = 1200 / cw_keyer_speed;
|
|
// will be 3 * dot length at standard weight
|
|
dash_delay = (dot_delay * 3 * cw_keyer_weight) / 50;
|
|
|
|
if (cw_keys_reversed) {
|
|
kdot = &kcwr;
|
|
kdash = &kcwl;
|
|
} else {
|
|
kdot = &kcwl;
|
|
kdash = &kcwr;
|
|
}
|
|
|
|
// need to actually dynamically set this at some point...
|
|
cw_hangtime_msec = (int)(0.25f * 1000.0f);
|
|
}
|
|
|
|
void keyer_event(int gpio, int level, uint32_t tick) {
|
|
int state = (cw_active_state == 0) ? (level == 0) : (level != 0);
|
|
|
|
if (gpio == left_paddle_gpio)
|
|
kcwl = state;
|
|
else // RIGHT_PADDLE_GPIO
|
|
kcwr = state;
|
|
|
|
if (state) // || cw_keyer_mode == KEYER_STRAIGHT)
|
|
sem_post(&cw_event);
|
|
}
|
|
|
|
// Added to support WiringPi, which uses a different type of callback.
|
|
void keyer_event_left()
|
|
{
|
|
int level = digitalRead(left_paddle_gpio);
|
|
keyer_event(left_paddle_gpio, level, 0);
|
|
#if defined(DEBUG)
|
|
sem_getvalue(&cw_event, &cw_event_value);
|
|
fprintf(stdout, "left paddle pressed - %d\n", cw_event_value);
|
|
#endif
|
|
}
|
|
|
|
// Added to support WiringPi, which uses a different type of callback.
|
|
void keyer_event_right()
|
|
{
|
|
int level = digitalRead(right_paddle_gpio);
|
|
keyer_event(right_paddle_gpio, level, 0);
|
|
#if defined(DEBUG)
|
|
sem_getvalue(&cw_event, &cw_event_value);
|
|
fprintf(stdout, "right paddle pressed - %d\n", cw_event_value);
|
|
#endif
|
|
}
|
|
|
|
void clear_memory() {
|
|
dot_memory = 0;
|
|
dash_memory = 0;
|
|
}
|
|
|
|
|
|
static void set_keyer_out(int state) {
|
|
if (state && tr_switch_gpio) {
|
|
digitalWrite(tr_switch_gpio, 1);
|
|
}
|
|
keyer_out = state;
|
|
digitalWrite(keyer_out_gpio, keyer_out);
|
|
}
|
|
|
|
static void* keyer_thread(void *arg) {
|
|
struct timespec loop_delay;
|
|
int interval = 1000000; // 1 ms
|
|
int hangtime_elapsed = 0;
|
|
|
|
while (running) {
|
|
#if defined(DEBUG)
|
|
sem_getvalue(&cw_event, &cw_event_value);
|
|
fprintf(stdout, "waiting - %d\n", cw_event_value);
|
|
#endif
|
|
sem_wait(&cw_event);
|
|
key_state = CHECK;
|
|
|
|
while (key_state != EXITLOOP) {
|
|
if (keyer_out)
|
|
hangtime_elapsed = 0;
|
|
|
|
switch(key_state) {
|
|
|
|
case HANGTIME:
|
|
if (hangtime_elapsed >= cw_hangtime_msec) {
|
|
if (tr_switch_gpio) {
|
|
#if defined(DEBUG)
|
|
sem_getvalue(&cw_event, &cw_event_value);
|
|
fprintf(stdout, "hangtime complete, %d msec - %d\n", cw_hangtime_msec, cw_event_value);
|
|
#endif
|
|
digitalWrite(tr_switch_gpio, 0);
|
|
key_state = EXITLOOP;
|
|
}
|
|
}
|
|
// INTENTIONALLY FALLING THROUGH TO 'CHECK' STATE (no 'break')
|
|
|
|
case CHECK: // check for key press
|
|
if (cw_keyer_mode == KEYER_STRAIGHT) { // Straight/External key or bug
|
|
if (*kdash) { // send manual dashes
|
|
if (!keyer_out) {
|
|
set_keyer_out(1);
|
|
key_state = HANGTIME; //EXITLOOP;
|
|
}
|
|
}
|
|
else if (*kdot) // and automatic dots
|
|
key_state = PREDOT;
|
|
else if (key_state == HANGTIME) {
|
|
if (keyer_out)
|
|
set_keyer_out(0);
|
|
} else {
|
|
// NOTE: not working right
|
|
//set_keyer_out(0);
|
|
key_state = EXITLOOP;
|
|
}
|
|
}
|
|
else {
|
|
if (*kdot)
|
|
key_state = PREDOT;
|
|
else if (*kdash)
|
|
key_state = PREDASH;
|
|
else if (key_state != HANGTIME) {
|
|
// Do we really need to do this? Aren't these covered in other states?
|
|
//set_keyer_out(0);
|
|
key_state = EXITLOOP;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PREDOT: // need to clear any pending dots or dashes
|
|
clear_memory();
|
|
key_state = SENDDOT;
|
|
break;
|
|
|
|
case PREDASH:
|
|
clear_memory();
|
|
key_state = SENDDASH;
|
|
break;
|
|
|
|
// dot paddle pressed so set keyer_out high for time dependant on speed
|
|
// also check if dash paddle is pressed during this time
|
|
case SENDDOT:
|
|
set_keyer_out(1);
|
|
if (kdelay == dot_delay) {
|
|
kdelay = 0;
|
|
set_keyer_out(0);
|
|
key_state = DOTDELAY; // add inter-character spacing of one dot length
|
|
}
|
|
else kdelay++;
|
|
|
|
// if Mode A and both paddels are relesed then clear dash memory
|
|
if (cw_keyer_mode == KEYER_MODE_A) {
|
|
if (!*kdot & !*kdash)
|
|
dash_memory = 0;
|
|
}
|
|
|
|
if (*kdash) { // set dash memory
|
|
dash_memory = 1;
|
|
}
|
|
break;
|
|
|
|
// dash paddle pressed so set keyer_out high for time dependant on 3 x dot delay and weight
|
|
// also check if dot paddle is pressed during this time
|
|
case SENDDASH:
|
|
set_keyer_out(1);
|
|
if (kdelay == dash_delay) {
|
|
kdelay = 0;
|
|
set_keyer_out(0);
|
|
key_state = DASHDELAY; // add inter-character spacing of one dot length
|
|
}
|
|
else kdelay++;
|
|
|
|
// if Mode A and both padles are relesed then clear dot memory
|
|
if (cw_keyer_mode == KEYER_MODE_A) {
|
|
if (!*kdot & !*kdash)
|
|
dot_memory = 0;
|
|
}
|
|
|
|
if (*kdot) { // set dot memory
|
|
dot_memory = 1;
|
|
}
|
|
break;
|
|
|
|
// add dot delay at end of the dot and check for dash memory, then check if paddle still held
|
|
case DOTDELAY:
|
|
if (kdelay == dot_delay) {
|
|
kdelay = 0;
|
|
if(!*kdot && cw_keyer_mode == KEYER_STRAIGHT) // just return if in bug mode
|
|
key_state = HANGTIME;
|
|
else if (dash_memory) // dash has been set during the dot so service
|
|
key_state = PREDASH;
|
|
else key_state = DOTHELD; // dot is still active so service
|
|
}
|
|
else kdelay++;
|
|
|
|
if (*kdash) { // set dash memory
|
|
dash_memory = 1;
|
|
}
|
|
break;
|
|
|
|
// add dot delay at end of the dash and check for dot memory, then check if paddle still held
|
|
case DASHDELAY:
|
|
if (kdelay == dot_delay) {
|
|
kdelay = 0;
|
|
|
|
if (dot_memory) // dot has been set during the dash so service
|
|
key_state = PREDOT;
|
|
else key_state = DASHHELD; // dash is still active so service
|
|
}
|
|
else kdelay++;
|
|
|
|
if (*kdot) { // set dot memory
|
|
dot_memory = 1;
|
|
}
|
|
break;
|
|
|
|
// check if dot paddle is still held, if so repeat the dot. Else check if Letter space is required
|
|
case DOTHELD:
|
|
if (*kdot) // dot has been set during the dash so service
|
|
key_state = PREDOT;
|
|
else if (*kdash) // has dash paddle been pressed
|
|
key_state = PREDASH;
|
|
else if (cw_keyer_spacing) { // Letter space enabled so clear any pending dots or dashes
|
|
clear_memory();
|
|
key_state = LETTERSPACE;
|
|
}
|
|
else key_state = HANGTIME;
|
|
break;
|
|
|
|
// check if dash paddle is still held, if so repeat the dash. Else check if Letter space is required
|
|
case DASHHELD:
|
|
if (*kdash) // dash has been set during the dot so service
|
|
key_state = PREDASH;
|
|
else if (*kdot) // has dot paddle been pressed
|
|
key_state = PREDOT;
|
|
else if (cw_keyer_spacing) { // Letter space enabled so clear any pending dots or dashes
|
|
clear_memory();
|
|
key_state = LETTERSPACE;
|
|
}
|
|
else key_state = HANGTIME;
|
|
break;
|
|
|
|
// Add letter space (3 x dot delay) to end of character and check if a paddle is pressed during this time.
|
|
// Actually add 2 x dot_delay since we already have a dot delay at the end of the character.
|
|
case LETTERSPACE:
|
|
if (kdelay == 2 * dot_delay) {
|
|
kdelay = 0;
|
|
if (dot_memory) // check if a dot or dash paddle was pressed during the delay.
|
|
key_state = PREDOT;
|
|
else if (dash_memory)
|
|
key_state = PREDASH;
|
|
else key_state = HANGTIME; // no memories set so restart
|
|
}
|
|
else kdelay++;
|
|
|
|
// save any key presses during the letter space delay
|
|
if (*kdot) dot_memory = 1;
|
|
if (*kdash) dash_memory = 1;
|
|
break;
|
|
|
|
default:
|
|
key_state = EXITLOOP;
|
|
}
|
|
|
|
if (!keyer_out)
|
|
hangtime_elapsed++;
|
|
|
|
if (key_state != EXITLOOP) {
|
|
clock_gettime(CLOCK_MONOTONIC, &loop_delay);
|
|
loop_delay.tv_nsec += interval;
|
|
while (loop_delay.tv_nsec >= NSEC_PER_SEC) {
|
|
loop_delay.tv_nsec -= NSEC_PER_SEC;
|
|
loop_delay.tv_sec++;
|
|
}
|
|
clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &loop_delay, NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int open_key_gpiokeyer(const char * name)
|
|
{
|
|
int i;
|
|
|
|
if (sscanf(name, "gpio:%d,%d,%d,%d", &left_paddle_gpio, &right_paddle_gpio, &keyer_out_gpio, &tr_switch_gpio) < 4) {
|
|
fprintf(stderr, "Insufficient parameters for GPIO Keyer: %s\n", name);
|
|
return -1;
|
|
}
|
|
|
|
#if defined(DEBUG)
|
|
fprintf(stdout, "GPIO Keyer selected:\n - left paddle GPIO: %d\n - right paddle GPIO: %d\n - keyer out GPIO: %d\n - T/R switch GPIO: %d\n",
|
|
left_paddle_gpio, right_paddle_gpio, keyer_out_gpio, tr_switch_gpio);
|
|
#endif
|
|
|
|
|
|
if (wiringPiSetupGpio () < 0) {
|
|
fprintf(stderr, "Unable to setup wiringPi: %s\n", strerror (errno));
|
|
return -1;
|
|
}
|
|
|
|
pinMode(right_paddle_gpio, INPUT);
|
|
pullUpDnControl(right_paddle_gpio, PUD_UP);
|
|
usleep(100000);
|
|
wiringPiISR(right_paddle_gpio, INT_EDGE_BOTH, keyer_event_right);
|
|
|
|
pinMode(left_paddle_gpio, INPUT);
|
|
pullUpDnControl(left_paddle_gpio, PUD_UP);
|
|
usleep(100000);
|
|
wiringPiISR(left_paddle_gpio, INT_EDGE_BOTH, keyer_event_left);
|
|
|
|
if (keyer_out_gpio) {
|
|
pinMode(keyer_out_gpio, OUTPUT);
|
|
digitalWrite(keyer_out_gpio, 0);
|
|
}
|
|
|
|
if (tr_switch_gpio) {
|
|
pinMode(tr_switch_gpio, OUTPUT);
|
|
digitalWrite(tr_switch_gpio, 0);
|
|
}
|
|
|
|
keyer_update();
|
|
|
|
i = sem_init(&cw_event, 0, 0);
|
|
running = 1;
|
|
i |= pthread_create(&keyer_thread_id, NULL, keyer_thread, NULL);
|
|
if(i < 0) {
|
|
fprintf(stderr,"pthread_create for keyer_thread failed %d\n", i);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void close_key_gpiokeyer(void)
|
|
{
|
|
running = 0;
|
|
sem_post(&cw_event);
|
|
pthread_join(keyer_thread_id, 0);
|
|
sem_destroy(&cw_event);
|
|
}
|
|
|
|
int is_key_down_gpiokeyer(void)
|
|
{
|
|
static int retval;
|
|
retval = keyer_out;
|
|
return retval;
|
|
}
|
|
|
|
void quisk_set_gpio_keyer_mode(int mode)
|
|
{
|
|
#if defined(DEBUG)
|
|
fprintf(stdout, "MODE CHANGE\n");
|
|
#endif
|
|
if ((mode > -1) && (mode < NUM_KEYER_MODES))
|
|
cw_keyer_mode = mode;
|
|
}
|
|
|
|
void quisk_set_gpio_keyer_speed(int wpm)
|
|
{
|
|
#if defined(DEBUG)
|
|
fprintf(stdout, "SPEED CHANGE\n");
|
|
#endif
|
|
cw_keyer_speed = wpm;
|
|
keyer_update();
|
|
}
|
|
|
|
void quisk_set_gpio_keyer_weight(int weight)
|
|
{
|
|
if ((weight > 32) && (weight < 67))
|
|
cw_keyer_weight = weight;
|
|
keyer_update();
|
|
}
|
|
|
|
void quisk_set_gpio_keyer_reversed(int flag)
|
|
{
|
|
cw_keys_reversed = (flag == 0 ? 0 : 1);
|
|
keyer_update();
|
|
}
|
|
|
|
void quisk_set_gpio_keyer_strict(int flag)
|
|
{
|
|
cw_keyer_spacing = (flag == 0 ? 0 : 1);
|
|
}
|
|
|
|
#endif
|