From 6dcc8baad448d000ef355abc6d9abf7a3490a800 Mon Sep 17 00:00:00 2001 From: Andreas Eversberg Date: Sun, 1 Sep 2019 15:38:16 +0200 Subject: [PATCH] Split FSK modem code into separate modulator and demodulator --- src/bnetz/bnetz.h | 3 +- src/bnetz/dialer.c | 10 +- src/bnetz/dsp.c | 15 ++- src/libfsk/fsk.c | 232 ++++++++++++++++++++++++++------------------- src/libfsk/fsk.h | 32 ++++--- src/nmt/dsp.c | 17 ++-- src/nmt/nmt.h | 3 +- src/r2000/dsp.c | 32 ++++--- src/r2000/r2000.h | 6 +- 9 files changed, 213 insertions(+), 137 deletions(-) diff --git a/src/bnetz/bnetz.h b/src/bnetz/bnetz.h index c520902..38aa078 100644 --- a/src/bnetz/bnetz.h +++ b/src/bnetz/bnetz.h @@ -87,7 +87,8 @@ typedef struct bnetz { /* dsp states */ enum dsp_mode dsp_mode; /* current mode: audio, durable tone 0 or 1, "Telegramm" */ - fsk_t fsk; /* fsk modem instance */ + fsk_mod_t fsk_mod; /* fsk modem instance */ + fsk_demod_t fsk_demod; uint16_t rx_telegramm; /* rx shift register for receiveing telegramm */ double rx_telegramm_quality[16];/* quality of each bit in telegramm */ double rx_telegramm_level[16]; /* level of each bit in telegramm */ diff --git a/src/bnetz/dialer.c b/src/bnetz/dialer.c index 05195e3..e44ddf5 100644 --- a/src/bnetz/dialer.c +++ b/src/bnetz/dialer.c @@ -61,7 +61,7 @@ int tx_telegramm_pos = 0; int latspl; /* instances */ -fsk_t fsk; +fsk_mod_t fsk_mod; #ifdef HAVE_ALSA void *audio = NULL; #endif @@ -226,7 +226,7 @@ again: break; case TX_MODE_FSK: /* send FSK until it stops, then fill with silence */ - count = fsk_send(&fsk, samples, length, 0); + count = fsk_mod_send(&fsk_mod, samples, length, 0); samples += count; length -= count; if (length) @@ -286,7 +286,7 @@ int main(int argc, char *argv[]) /* init */ bnetz_init_telegramm(); - memset(&fsk, 0, sizeof(fsk)); + memset(&fsk_mod, 0, sizeof(fsk_mod)); /* latency of send buffer in samples */ latspl = samplerate * latency / 1000; @@ -340,7 +340,7 @@ int main(int argc, char *argv[]) sprintf(funkwahl, "wwww%c%s%se%c%s%se", start_digit, station_id, dialing + 1, start_digit, station_id, dialing + 1); /* init fsk */ - if (fsk_init(&fsk, NULL, fsk_send_bit, NULL, samplerate, BIT_RATE, F0, F1, 1.0, 0, 0) < 0) { + if (fsk_mod_init(&fsk_mod, NULL, fsk_send_bit, samplerate, BIT_RATE, F0, F1, 1.0, 0) < 0) { PDEBUG(DDSP, DEBUG_ERROR, "FSK init failed!\n"); goto exit; } @@ -389,7 +389,7 @@ exit: #endif /* exit fsk */ - fsk_cleanup(&fsk); + fsk_mod_cleanup(&fsk_mod); return 0; } diff --git a/src/bnetz/dsp.c b/src/bnetz/dsp.c index e05973a..e2928ba 100644 --- a/src/bnetz/dsp.c +++ b/src/bnetz/dsp.c @@ -96,7 +96,11 @@ int dsp_init_sender(bnetz_t *bnetz, double squelch_db) PDEBUG(DDSP, DEBUG_DEBUG, "Using FSK level of %.3f (%.3f KHz deviation @ 2000 Hz)\n", TX_PEAK_FSK, 4.0); /* init fsk */ - if (fsk_init(&bnetz->fsk, bnetz, fsk_send_bit, fsk_receive_bit, bnetz->sender.samplerate, BIT_RATE, F0, F1, TX_PEAK_FSK, 0, BIT_ADJUST) < 0) { + if (fsk_mod_init(&bnetz->fsk_mod, bnetz, fsk_send_bit, bnetz->sender.samplerate, BIT_RATE, F0, F1, TX_PEAK_FSK, 0) < 0) { + PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); + return -EINVAL; + } + if (fsk_demod_init(&bnetz->fsk_demod, bnetz, fsk_receive_bit, bnetz->sender.samplerate, BIT_RATE, F0, F1, BIT_ADJUST) < 0) { PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); return -EINVAL; } @@ -121,7 +125,8 @@ void dsp_cleanup_sender(bnetz_t *bnetz) { PDEBUG_CHAN(DDSP, DEBUG_DEBUG, "Cleanup DSP for 'Sender'.\n"); - fsk_cleanup(&bnetz->fsk); + fsk_mod_cleanup(&bnetz->fsk_mod); + fsk_demod_cleanup(&bnetz->fsk_demod); } /* If good tone is received, we just set this tone, if not already and reset counters. @@ -270,7 +275,7 @@ void sender_receive(sender_t *sender, sample_t *samples, int length, double rf_l int i; /* fsk/tone signal */ - fsk_receive(&bnetz->fsk, samples, length); + fsk_demod_receive(&bnetz->fsk_demod, samples, length); /* process signal mute/loss, without signalling tone / FSK frames */ switch (squelch(&bnetz->squelch, rf_level_db, (double)length / (double)bnetz->sender.samplerate)) { @@ -375,7 +380,7 @@ again: case DSP_MODE_TELEGRAMM: /* Encode tone/frame into audio stream. If frames have * stopped, process again for rest of stream. */ - count = fsk_send(&bnetz->fsk, samples, length, 0); + count = fsk_mod_send(&bnetz->fsk_mod, samples, length, 0); samples += count; length -= count; if (length) @@ -412,7 +417,7 @@ void bnetz_set_dsp_mode(bnetz_t *bnetz, enum dsp_mode mode) /* reset telegramm */ if (mode == DSP_MODE_TELEGRAMM && bnetz->dsp_mode != mode) { bnetz->tx_telegramm = 0; - fsk_tx_reset(&bnetz->fsk); + fsk_mod_tx_reset(&bnetz->fsk_mod); } PDEBUG_CHAN(DDSP, DEBUG_DEBUG, "DSP mode %s -> %s\n", bnetz_dsp_mode_name(bnetz->dsp_mode), bnetz_dsp_mode_name(mode)); diff --git a/src/libfsk/fsk.c b/src/libfsk/fsk.c index 6b5fe03..7f1ed6e 100644 --- a/src/libfsk/fsk.c +++ b/src/libfsk/fsk.c @@ -33,21 +33,18 @@ * fsk = instance of fsk modem * inst = instance of user * send_bit() = function to be called whenever a new bit has to be sent - * receive_bit() = function to be called whenever a new bit was received * samplerate = samplerate * bitrate = bits per second * f0, f1 = two frequencies for bit 0 and bit 1 * level = level to modulate the frequencies * coherent = use coherent modulation (FFSK) - * bitadjust = how much to adjust the sample clock when a bitchange was detected. (0 = nothing, don't use this, 0.5 full adjustment) */ -int fsk_init(fsk_t *fsk, void *inst, int (*send_bit)(void *inst), void (*receive_bit)(void *inst, int bit, double quality, double level), int samplerate, double bitrate, double f0, double f1, double level, int coherent, double bitadjust) +int fsk_mod_init(fsk_mod_t *fsk, void *inst, int (*send_bit)(void *inst), int samplerate, double bitrate, double f0, double f1, double level, int coherent) { - double bandwidth; int i; int rc; - PDEBUG(DDSP, DEBUG_DEBUG, "Setup FSK for Transceiver. (F0 = %.1f, F1 = %.1f, peak = %.1f)\n", f0, f1, level); + PDEBUG(DDSP, DEBUG_DEBUG, "Setup FSK for Transmitter. (F0 = %.1f, F1 = %.1f, peak = %.1f)\n", f0, f1, level); memset(fsk, 0, sizeof(*fsk)); @@ -62,9 +59,6 @@ int fsk_init(fsk_t *fsk, void *inst, int (*send_bit)(void *inst), void (*receive fsk->sin_tab[i] = sin((double)i / 65536.0 * 2.0 * PI) * level; fsk->inst = inst; - fsk->rx_bit = -1; - fsk->rx_bitadjust = bitadjust; - fsk->receive_bit = receive_bit; fsk->tx_bit = -1; fsk->level = level; fsk->send_bit = send_bit; @@ -78,14 +72,6 @@ int fsk_init(fsk_t *fsk, void *inst, int (*send_bit)(void *inst), void (*receive fsk->high_bit = 0; } - /* calculate bandwidth */ - bandwidth = fabs(f0 - f1) * 2.0; - - /* init fm demodulator */ - rc = fm_demod_init(&fsk->demod, (double)samplerate, (f0 + f1) / 2.0, bandwidth); - if (rc < 0) - goto error; - fsk->bits_per_sample = (double)bitrate / (double)samplerate; PDEBUG(DDSP, DEBUG_DEBUG, "Bitduration of %.4f bits per sample @ %d.\n", fsk->bits_per_sample, samplerate); @@ -118,19 +104,150 @@ int fsk_init(fsk_t *fsk, void *inst, int (*send_bit)(void *inst), void (*receive return 0; error: - fsk_cleanup(fsk); + fsk_mod_cleanup(fsk); return rc; } /* Cleanup transceiver instance. */ -void fsk_cleanup(fsk_t *fsk) +void fsk_mod_cleanup(fsk_mod_t *fsk) { - PDEBUG(DDSP, DEBUG_DEBUG, "Cleanup FSK for Transceiver.\n"); + PDEBUG(DDSP, DEBUG_DEBUG, "Cleanup FSK for Transmitter.\n"); if (fsk->sin_tab) { free(fsk->sin_tab); fsk->sin_tab = NULL; } +} + +/* modulate bits + * + * If first/next bit is required, callback function send_bit() is called. + * If there is no (more) data to be transmitted, the callback functions shall + * return -1. In this case, this function stops and returns the number of + * samples that have been rendered so far, if any. + * + * For coherent mode (FSK), we round the phase on every bit change to the + * next zero crossing. This prevents phase shifts due to rounding errors. + */ +int fsk_mod_send(fsk_mod_t *fsk, sample_t *sample, int length, int add) +{ + int count = 0; + double phase, phaseshift; + + phase = fsk->tx_phase65536; + + /* get next bit */ + if (fsk->tx_bit < 0) { +next_bit: + fsk->tx_bit = fsk->send_bit(fsk->inst); +#ifdef DEBUG_MODULATOR + printf("bit change to %d\n", fsk->tx_bit); +#endif + if (fsk->tx_bit < 0) + goto done; + /* correct phase when changing bit */ + if (fsk->coherent) { + /* round phase to nearest zero crossing */ + if (phase > 16384.0 && phase < 49152.0) + phase = 32768.0; + else + phase = 0; + /* set phase according to current position in bit */ + phase += fsk->tx_bitpos * fsk->cycles_per_bit65536[fsk->tx_bit & 1]; +#ifdef DEBUG_MODULATOR + printf("phase %.3f bitpos=%.6f\n", phase, fsk->tx_bitpos); +#endif + } + } + + /* modulate bit */ + phaseshift = fsk->phaseshift65536[fsk->tx_bit & 1]; + while (count < length && fsk->tx_bitpos < 1.0) { + if (add) + sample[count++] += fsk->sin_tab[(uint16_t)phase]; + else + sample[count++] = fsk->sin_tab[(uint16_t)phase]; +#ifdef DEBUG_MODULATOR + printf("|%s|\n", debug_amplitude(fsk->sin_tab[(uint16_t)phase] / fsk->level)); +#endif + phase += phaseshift; + if (phase >= 65536.0) + phase -= 65536.0; + fsk->tx_bitpos += fsk->bits_per_sample; + } + if (fsk->tx_bitpos >= 1.0) { + fsk->tx_bitpos -= 1.0; + goto next_bit; + } + +done: + fsk->tx_phase65536 = phase; + + return count; +} + +/* reset transmitter state, so we get a clean start */ +void fsk_mod_tx_reset(fsk_mod_t *fsk) +{ + fsk->tx_phase65536 = 0; + fsk->tx_bitpos = 0; + fsk->tx_bit = -1; +} + +/* + * fsk = instance of fsk modem + * inst = instance of user + * receive_bit() = function to be called whenever a new bit was received + * samplerate = samplerate + * bitrate = bits per second + * f0, f1 = two frequencies for bit 0 and bit 1 + * bitadjust = how much to adjust the sample clock when a bitchange was detected. (0 = nothing, don't use this, 0.5 full adjustment) + */ +int fsk_demod_init(fsk_demod_t *fsk, void *inst, void (*receive_bit)(void *inst, int bit, double quality, double level), int samplerate, double bitrate, double f0, double f1, double bitadjust) +{ + double bandwidth; + int rc; + + PDEBUG(DDSP, DEBUG_DEBUG, "Setup FSK for Receiver. (F0 = %.1f, F1 = %.1f)\n", f0, f1); + + memset(fsk, 0, sizeof(*fsk)); + + fsk->inst = inst; + fsk->rx_bit = -1; + fsk->rx_bitadjust = bitadjust; + fsk->receive_bit = receive_bit; + fsk->f0_deviation = (f0 - f1) / 2.0; + fsk->f1_deviation = (f1 - f0) / 2.0; + if (f0 < f1) { + fsk->low_bit = 0; + fsk->high_bit = 1; + } else { + fsk->low_bit = 1; + fsk->high_bit = 0; + } + + /* calculate bandwidth */ + bandwidth = fabs(f0 - f1) * 2.0; + + /* init fm demodulator */ + rc = fm_demod_init(&fsk->demod, (double)samplerate, (f0 + f1) / 2.0, bandwidth); + if (rc < 0) + goto error; + + fsk->bits_per_sample = (double)bitrate / (double)samplerate; + PDEBUG(DDSP, DEBUG_DEBUG, "Bitduration of %.4f bits per sample @ %d.\n", fsk->bits_per_sample, samplerate); + + return 0; + +error: + fsk_demod_cleanup(fsk); + return rc; +} + +/* Cleanup transceiver instance. */ +void fsk_demod_cleanup(fsk_demod_t *fsk) +{ + PDEBUG(DDSP, DEBUG_DEBUG, "Cleanup FSK for Receiver.\n"); fm_demod_exit(&fsk->demod); } @@ -150,7 +267,7 @@ void fsk_cleanup(fsk_t *fsk) * Therefore we change the sample counter only slightly, so bit slips may not * happen so quickly. */ -void fsk_receive(fsk_t *fsk, sample_t *sample, int length) +void fsk_demod_receive(fsk_demod_t *fsk, sample_t *sample, int length) { sample_t I[length], Q[length], frequency[length], f; int i; @@ -211,78 +328,3 @@ void fsk_receive(fsk_t *fsk, sample_t *sample, int length) } } -/* modulate bits - * - * If first/next bit is required, callback function send_bit() is called. - * If there is no (more) data to be transmitted, the callback functions shall - * return -1. In this case, this function stops and returns the number of - * samples that have been rendered so far, if any. - * - * For coherent mode (FSK), we round the phase on every bit change to the - * next zero crossing. This prevents phase shifts due to rounding errors. - */ -int fsk_send(fsk_t *fsk, sample_t *sample, int length, int add) -{ - int count = 0; - double phase, phaseshift; - - phase = fsk->tx_phase65536; - - /* get next bit */ - if (fsk->tx_bit < 0) { -next_bit: - fsk->tx_bit = fsk->send_bit(fsk->inst); -#ifdef DEBUG_MODULATOR - printf("bit change to %d\n", fsk->tx_bit); -#endif - if (fsk->tx_bit < 0) - goto done; - /* correct phase when changing bit */ - if (fsk->coherent) { - /* round phase to nearest zero crossing */ - if (phase > 16384.0 && phase < 49152.0) - phase = 32768.0; - else - phase = 0; - /* set phase according to current position in bit */ - phase += fsk->tx_bitpos * fsk->cycles_per_bit65536[fsk->tx_bit & 1]; -#ifdef DEBUG_MODULATOR - printf("phase %.3f bitpos=%.6f\n", phase, fsk->tx_bitpos); -#endif - } - } - - /* modulate bit */ - phaseshift = fsk->phaseshift65536[fsk->tx_bit & 1]; - while (count < length && fsk->tx_bitpos < 1.0) { - if (add) - sample[count++] += fsk->sin_tab[(uint16_t)phase]; - else - sample[count++] = fsk->sin_tab[(uint16_t)phase]; -#ifdef DEBUG_MODULATOR - printf("|%s|\n", debug_amplitude(fsk->sin_tab[(uint16_t)phase] / fsk->level)); -#endif - phase += phaseshift; - if (phase >= 65536.0) - phase -= 65536.0; - fsk->tx_bitpos += fsk->bits_per_sample; - } - if (fsk->tx_bitpos >= 1.0) { - fsk->tx_bitpos -= 1.0; - goto next_bit; - } - -done: - fsk->tx_phase65536 = phase; - - return count; -} - -/* reset transmitter state, so we get a clean start */ -void fsk_tx_reset(fsk_t *fsk) -{ - fsk->tx_phase65536 = 0; - fsk->tx_bitpos = 0; - fsk->tx_bit = -1; -} - diff --git a/src/libfsk/fsk.h b/src/libfsk/fsk.h index a7cc428..395e915 100644 --- a/src/libfsk/fsk.h +++ b/src/libfsk/fsk.h @@ -1,14 +1,12 @@ #include "../libfm/fm.h" -typedef struct ffsk { +typedef struct fsk_mod { void *inst; int (*send_bit)(void *inst); - void (*receive_bit)(void *inst, int bit, double quality, double level); - fm_demod_t demod; double bits_per_sample; /* fraction of a bit per sample */ double *sin_tab; /* sine table with correct peak level */ double phaseshift65536[2]; /* how much the phase of fsk synbol changes per sample */ - double cycles_per_bit65536[2]; /* cacles of one bit */ + double cycles_per_bit65536[2]; /* cycles of one bit */ double tx_phase65536; /* current transmit phase */ double level; /* level (amplitude) of signal */ int coherent; /* set, if coherent TX mode */ @@ -16,15 +14,27 @@ typedef struct ffsk { double f1_deviation; int low_bit, high_bit; /* a low or high deviation means which bit? */ int tx_bit; /* current transmitting bit (-1 if not set) */ - int rx_bit; /* current receiving bit (-1 if not yet measured) */ double tx_bitpos; /* current transmit position in bit */ +} fsk_mod_t; + +typedef struct fsk_demod { + void *inst; + void (*receive_bit)(void *inst, int bit, double quality, double level); + fm_demod_t demod; + double bits_per_sample; /* fraction of a bit per sample */ + double f0_deviation; /* deviation of frequencies, relative to center */ + double f1_deviation; + int low_bit, high_bit; /* a low or high deviation means which bit? */ + int rx_bit; /* current receiving bit (-1 if not yet measured) */ double rx_bitpos; /* current receive position in bit (sampleclock) */ double rx_bitadjust; /* how much does a bit change cause the sample clock to be adjusted in phase */ -} fsk_t; +} fsk_demod_t; -int fsk_init(fsk_t *fsk, void *inst, int (*send_bit)(void *inst), void (*receive_bit)(void *inst, int bit, double quality, double level), int samplerate, double bitrate, double f0, double f1, double level, int coherent, double bitadjust); -void fsk_cleanup(fsk_t *fsk); -void fsk_receive(fsk_t *fsk, sample_t *sample, int length); -int fsk_send(fsk_t *fsk, sample_t *sample, int length, int add); -void fsk_tx_reset(fsk_t *fsk); +int fsk_mod_init(fsk_mod_t *fsk, void *inst, int (*send_bit)(void *inst), int samplerate, double bitrate, double f0, double f1, double level, int coherent); +void fsk_mod_cleanup(fsk_mod_t *fsk); +int fsk_mod_send(fsk_mod_t *fsk, sample_t *sample, int length, int add); +void fsk_mod_tx_reset(fsk_mod_t *fsk); +int fsk_demod_init(fsk_demod_t *fsk, void *inst, void (*receive_bit)(void *inst, int bit, double quality, double level), int samplerate, double bitrate, double f0, double f1, double bitadjust); +void fsk_demod_cleanup(fsk_demod_t *fsk); +void fsk_demod_receive(fsk_demod_t *fsk, sample_t *sample, int length); diff --git a/src/nmt/dsp.c b/src/nmt/dsp.c index 9103722..1dcd606 100644 --- a/src/nmt/dsp.c +++ b/src/nmt/dsp.c @@ -120,7 +120,11 @@ int dsp_init_sender(nmt_t *nmt, double deviation_factor) PDEBUG(DDSP, DEBUG_DEBUG, "Using Supervisory level of %.3f (%.3f KHz deviation @ 4015 Hz)\n", TX_PEAK_SUPER * deviation_factor, 0.3 * deviation_factor); /* init fsk */ - if (fsk_init(&nmt->fsk, nmt, fsk_send_bit, fsk_receive_bit, nmt->sender.samplerate, BIT_RATE, F0, F1, TX_PEAK_FSK, 1, BIT_ADJUST) < 0) { + if (fsk_mod_init(&nmt->fsk_mod, nmt, fsk_send_bit, nmt->sender.samplerate, BIT_RATE, F0, F1, TX_PEAK_FSK, 1) < 0) { + PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); + return -EINVAL; + } + if (fsk_demod_init(&nmt->fsk_demod, nmt, fsk_receive_bit, nmt->sender.samplerate, BIT_RATE, F0, F1, BIT_ADJUST) < 0) { PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); return -EINVAL; } @@ -163,7 +167,8 @@ void dsp_cleanup_sender(nmt_t *nmt) { PDEBUG_CHAN(DDSP, DEBUG_DEBUG, "Cleanup DSP for Transceiver.\n"); - fsk_cleanup(&nmt->fsk); + fsk_mod_cleanup(&nmt->fsk_mod); + fsk_demod_cleanup(&nmt->fsk_demod); if (nmt->super_filter_spl) { free(nmt->super_filter_spl); @@ -336,7 +341,7 @@ void sender_receive(sender_t *sender, sample_t *samples, int length, double __at nmt->super_filter_pos = pos; /* fsk signal */ - fsk_receive(&nmt->fsk, samples, length); + fsk_demod_receive(&nmt->fsk_demod, samples, length); /* muting audio while receiving frame */ for (i = 0; i < length; i++) { @@ -449,7 +454,7 @@ again: jitter_load(&nmt->sender.dejitter, samples, length); /* send after dejitter, so audio is flushed */ if (nmt->dms.tx_frame_valid) { - fsk_send(&nmt->fsk, samples, length, 0); + fsk_mod_send(&nmt->fsk_mod, samples, length, 0); break; } if (nmt->supervisory) @@ -464,7 +469,7 @@ again: case DSP_MODE_FRAME: /* Encode frame into audio stream. If frames have * stopped, process again for rest of stream. */ - count = fsk_send(&nmt->fsk, samples, length, 0); + count = fsk_mod_send(&nmt->fsk_mod, samples, length, 0); /* special case: add supervisory signal to frame at loop test */ if (nmt->sender.loopback && nmt->supervisory) super_encode(nmt, samples, count); @@ -501,7 +506,7 @@ void nmt_set_dsp_mode(nmt_t *nmt, enum dsp_mode mode) { /* reset frame */ if (mode == DSP_MODE_FRAME && nmt->dsp_mode != mode) { - fsk_tx_reset(&nmt->fsk); + fsk_mod_tx_reset(&nmt->fsk_mod); nmt->tx_frame_length = 0; } diff --git a/src/nmt/nmt.h b/src/nmt/nmt.h index 6700b35..31d68f6 100644 --- a/src/nmt/nmt.h +++ b/src/nmt/nmt.h @@ -104,7 +104,8 @@ typedef struct nmt { /* dsp states */ enum dsp_mode dsp_mode; /* current mode: audio, durable tone 0 or 1, paging */ - fsk_t fsk; /* fsk processing */ + fsk_mod_t fsk_mod; /* fsk processing */ + fsk_demod_t fsk_demod; int super_samples; /* number of samples in buffer for supervisory detection */ goertzel_t super_goertzel[5]; /* filter for supervisory decoding */ sample_t *super_filter_spl; /* array with sample buffer for supervisory detection */ diff --git a/src/r2000/dsp.c b/src/r2000/dsp.c index fd438e4..d52e8eb 100644 --- a/src/r2000/dsp.c +++ b/src/r2000/dsp.c @@ -85,7 +85,11 @@ int dsp_init_sender(r2000_t *r2000) PDEBUG(DDSP, DEBUG_DEBUG, "Using FSK level of %.3f\n", TX_PEAK_FSK); /* init fsk */ - if (fsk_init(&r2000->fsk, r2000, fsk_send_bit, fsk_receive_bit, r2000->sender.samplerate, FSK_BIT_RATE, FSK_F0, FSK_F1, TX_PEAK_FSK, 1, FSK_BIT_ADJUST) < 0) { + if (fsk_mod_init(&r2000->fsk_mod, r2000, fsk_send_bit, r2000->sender.samplerate, FSK_BIT_RATE, FSK_F0, FSK_F1, TX_PEAK_FSK, 1) < 0) { + PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); + return -EINVAL; + } + if (fsk_demod_init(&r2000->fsk_demod, r2000, fsk_receive_bit, r2000->sender.samplerate, FSK_BIT_RATE, FSK_F0, FSK_F1, FSK_BIT_ADJUST) < 0) { PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); return -EINVAL; } @@ -95,7 +99,11 @@ int dsp_init_sender(r2000_t *r2000) r2000->rx_max = 144; /* init supervisorty fsk */ - if (fsk_init(&r2000->super_fsk, r2000, super_send_bit, super_receive_bit, r2000->sender.samplerate, SUPER_BIT_RATE, SUPER_F0, SUPER_F1, TX_PEAK_SUPER, 0, SUPER_BIT_ADJUST) < 0) { + if (fsk_mod_init(&r2000->super_fsk_mod, r2000, super_send_bit, r2000->sender.samplerate, SUPER_BIT_RATE, SUPER_F0, SUPER_F1, TX_PEAK_SUPER, 0) < 0) { + PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); + return -EINVAL; + } + if (fsk_demod_init(&r2000->super_fsk_demod, r2000, super_receive_bit, r2000->sender.samplerate, SUPER_BIT_RATE, SUPER_F0, SUPER_F1, SUPER_BIT_ADJUST) < 0) { PDEBUG_CHAN(DDSP, DEBUG_ERROR, "FSK init failed!\n"); return -EINVAL; } @@ -122,8 +130,10 @@ void dsp_cleanup_sender(r2000_t *r2000) { PDEBUG_CHAN(DDSP, DEBUG_DEBUG, "Cleanup DSP for Transceiver.\n"); - fsk_cleanup(&r2000->fsk); - fsk_cleanup(&r2000->super_fsk); + fsk_mod_cleanup(&r2000->fsk_mod); + fsk_demod_cleanup(&r2000->fsk_demod); + fsk_mod_cleanup(&r2000->super_fsk_mod); + fsk_demod_cleanup(&r2000->super_fsk_demod); } /* Check for SYNC bits, then collect data bits */ @@ -254,14 +264,14 @@ void sender_receive(sender_t *sender, sample_t *samples, int length, double __at if (r2000->dsp_mode == DSP_MODE_AUDIO_TX || r2000->dsp_mode == DSP_MODE_AUDIO_TX_RX || r2000->sender.loopback) - fsk_receive(&r2000->super_fsk, samples, length); + fsk_demod_receive(&r2000->super_fsk_demod, samples, length); /* do de-emphasis */ if (r2000->de_emphasis) de_emphasis(&r2000->estate, samples, length); /* fsk signal */ - fsk_receive(&r2000->fsk, samples, length); + fsk_demod_receive(&r2000->fsk_demod, samples, length); /* we must have audio mode for both ways and a call */ if (r2000->dsp_mode == DSP_MODE_AUDIO_TX_RX @@ -342,19 +352,19 @@ again: if (r2000->pre_emphasis) pre_emphasis(&r2000->estate, samples, length); /* add supervisory to sample buffer */ - fsk_send(&r2000->super_fsk, samples, length, 1); + fsk_mod_send(&r2000->super_fsk_mod, samples, length, 1); break; case DSP_MODE_FRAME: /* Encode frame into audio stream. If frames have * stopped, process again for rest of stream. */ - count = fsk_send(&r2000->fsk, samples, length, 0); + count = fsk_mod_send(&r2000->fsk_mod, samples, length, 0); /* do pre-emphasis */ if (r2000->pre_emphasis) pre_emphasis(&r2000->estate, samples, count); /* special case: add supervisory signal to frame at loop test */ if (r2000->sender.loopback) { /* add supervisory to sample buffer */ - fsk_send(&r2000->super_fsk, samples, count, 1); + fsk_mod_send(&r2000->super_fsk_mod, samples, count, 1); } memset(power, 1, count); samples += count; @@ -390,12 +400,12 @@ void r2000_set_dsp_mode(r2000_t *r2000, enum dsp_mode mode, int super) /* reset telegramm */ if (mode == DSP_MODE_FRAME && r2000->dsp_mode != mode) { r2000->tx_frame_length = 0; - fsk_tx_reset(&r2000->fsk); + fsk_mod_tx_reset(&r2000->fsk_mod); } if ((mode == DSP_MODE_AUDIO_TX || mode == DSP_MODE_AUDIO_TX_RX) && (r2000->dsp_mode != DSP_MODE_AUDIO_TX && r2000->dsp_mode != DSP_MODE_AUDIO_TX_RX)) { r2000->super_tx_word_length = 0; - fsk_tx_reset(&r2000->super_fsk); + fsk_mod_tx_reset(&r2000->super_fsk_mod); } if (super >= 0) { diff --git a/src/r2000/r2000.h b/src/r2000/r2000.h index 2efd3f3..edfdffe 100644 --- a/src/r2000/r2000.h +++ b/src/r2000/r2000.h @@ -85,7 +85,8 @@ typedef struct r2000 { /* dsp states */ enum dsp_mode dsp_mode; /* current mode: audio, durable tone 0 or 1, paging */ - fsk_t fsk; /* fsk processing */ + fsk_mod_t fsk_mod; /* fsk processing */ + fsk_demod_t fsk_demod; char tx_frame[208]; /* carries bits of one frame to transmit */ int tx_frame_length; int tx_frame_pos; @@ -102,7 +103,8 @@ typedef struct r2000 { uint64_t rx_bits_count_last; /* sample counter of last frame */ /* supervisory dsp states */ - fsk_t super_fsk; /* fsk processing */ + fsk_mod_t super_fsk_mod; /* fsk processing */ + fsk_demod_t super_fsk_demod; uint32_t super_tx_word; /* supervisory info to transmit */ int super_tx_word_length; int super_tx_word_pos;