Files
brnQuanFW/app/fskmodem.c
T
BRNSystemsandClaude Opus 5.5 4a99a21a21 Fix the spectrum labels, bandscope build, OOK on F+7, save flash
- Spectrum: GUI_DisplaySmallest() now draws with gFontSmall (7 px per
  character) for the status bar; the spectrum layout needs the 3x5 font
  (4 px), so it gets its own renderer again. Its labels were overlapping.
- make BANDSCOPE=1: spectrum instead of the FM radio. Both do not fit in
  60 KB together (FM radio is 4.9 KB). Debug log off and -finline-limit=1
  in that edition; it fits with a few bytes to spare.
- OOK sender on F+7 / long 7 (the VOX key is free, VOX is not built);
  F+EXIT is back to only cancelling F.
- POCSAG deviation tuning keys behind POCSAG_DEVIATION_TUNING (default 0).
- Smaller code: shared end of SMS/POCSAG transmissions, non-inlined fast
  SPI wait, compact OOK field tables, sprintf message header, shorter OOK
  strings.
- Makefile: EXTRA_CFLAGS for passing defines.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 01:24:16 +01:00

969 lines
34 KiB
C

//
// Created by bruno on 25.2.2025.
//
#include "fskmodem.h"
#include "app/pocsag.h"
//#include "messages.h"
#include "driver/uart.h"
#include "../ui/messages.h"
#include "ui/ui.h"
uint16_t TONE2_FREQ;
DataPacket dataPacket;
DataPacket inBoundPacket;
char *dataPTR = gMessageText;
SMSEnteringState gEnteringSMS = SMS_NOT_ENTERING;
SMSResponseState gSMSResponseState = SMS_RESPONSE_IDLE;
bool gGotACK = false;
uint8_t SMSResponseCounter = 0;
typedef enum {
Receiving,
Ready
} RXState;
RXState rxState = Ready;
uint8_t SMSResponseCounterTarget = 6;
// ---------------------------------------------------------------------------
// POCSAG 1200 modem (BK4819 native 2-FSK, NRZ)
//
// * Each 16-bit word in the FSK FIFO (REG_5F) goes on air LOW byte first (each
// byte MSB first). Verified with a URH capture of this firmware.
// * POCSAG sends a logical 1 as the LOWER frequency. The BK4819 sends a raw 1 as
// the higher one, so every bit is inverted on the way in and out of the FIFO.
// Both the TX path and the RX sync pattern follow POCSAG_INVERT.
// * The chip always prepends its own preamble + 4 byte sync. Its sync is set to the
// preamble pattern (1010..., the same in either byte order) for TX and RX:
// - TX: it just extends the 576 bit POCSAG preamble; the real preamble and sync
// codeword are part of the encoded frame.
// - RX: the chip locks somewhere in the preamble and captures a full frame;
// POCSAG_Decode() then finds the sync codeword at bit level.
// ---------------------------------------------------------------------------
#ifndef POCSAG_INVERT
#define POCSAG_INVERT 1
#endif
// REG_40<11:0> FM deviation for POCSAG (+-4.5 kHz nominal). 899 (reference fork)
// gave a ~6 kHz tone spacing; tune live with keys 2/8 on the messages screen.
#ifndef POCSAG_DEVIATION
#define POCSAG_DEVIATION 963U // measured: decodes on a CC1101 POCSAG receiver at Tone2 gain 127
#endif
// REG_70<6:0> Tone2 gain = FSK TX level (0..127). Max: the BK4819 FSK shift is on the low side.
#ifndef POCSAG_TONE2_GAIN
#define POCSAG_TONE2_GAIN 127U
#endif
#define POCSAG_REG58 0x03C1U // FSK 1.2K TX/RX, 1.2K RX BW, 0xAA/0x55 preamble, RX gain 3, FSK on
#define POCSAG_REG59 ((6U << 4) | FSK_SYNC_LEN_BIT) // 7 byte chip preamble, 4 byte sync, no scramble
#define POCSAG_REG5C 0xAA30U // CRC off
// POCSAG 512 / 1200 / 2400 baud, selected by the modem mode
static uint16_t POCSAG_Baud(void)
{
switch (gEeprom.FSKMode) {
case MOD_POCSAG_512: return 512;
case MOD_POCSAG_2400: return 2400;
default: return 1200;
}
}
// REG_72 = baud * 10.32444 (1200 -> 0x3065)
#define POCSAG_REG72(baud) ((uint16_t) (((uint32_t) (baud) * 103244UL + 5000UL) / 10000UL))
// wider FSK RX bandwidth for 2400 baud
#define POCSAG_REG58_FOR(baud) (POCSAG_REG58 | ((baud) > 1200U ? FSK_RX_BW_2_4K_FFSK_1200_2400 : FSK_RX_BW_1_2K))
#define POCSAG_RX_BYTES POCSAG_MAX_FRAME_SIZE // captured after the chip locks on the preamble
#define POCSAG_CHIP_SYNC 0xAAAAU // logical preamble pattern
// REG_43 for POCSAG: +-4.5 kHz deviation at 1200 baud occupies ~10.2 kHz (Carson),
// so use 25 kHz channel mode with a 7.5 kHz RF filter, kept wide for weak signals too.
#define POCSAG_REG43 ((4U << 12) | /* RF filter 3.75 kHz (x2 in 25k mode) */ \
(4U << 9) | /* same RF filter when the signal is weak */ \
(6U << 6) | /* TX AF LPF (bypassed for FSK) */ \
(2U << 4) | /* 25 kHz channel mode */ \
(1U << 3))
#if POCSAG_DEVIATION_TUNING
// Runtime-tunable TX deviation (REG_40<11:0>), keys 2/8 on the messages screen.
uint16_t gPocsagDeviation = POCSAG_DEVIATION;
void POCSAG_AdjustDeviation(const int delta)
{
char text[12] = "DEV ";
int value = (int) gPocsagDeviation + delta;
if (value < 0x40)
value = 0x40;
if (value > 0x0FFF)
value = 0x0FFF;
gPocsagDeviation = (uint16_t) value;
itoa(gPocsagDeviation, text + 4);
UI_DisplayPopup(text);
gUpdateDisplay = true;
}
#else
#define gPocsagDeviation POCSAG_DEVIATION
#endif
static uint16_t POCSAG_Raw16(const uint16_t logical)
{
return POCSAG_INVERT ? (uint16_t) ~logical : logical;
}
static void POCSAG_ConfigureModem(const bool rx)
{
// The FSK modulator is driven through Tone2: with Tone2 disabled / gain 0 the
// carrier barely shifts. The gain (together with REG_40) sets the FSK deviation.
BK4819_WriteRegister(BK4819_REG_70, TONE2_ENABLE_BIT | (POCSAG_TONE2_GAIN & TONE2_GAIN_MASK));
const uint16_t baud = POCSAG_Baud();
BK4819_WriteRegister(BK4819_REG_72, POCSAG_REG72(baud));
BK4819_WriteRegister(BK4819_REG_58, POCSAG_REG58_FOR(baud));
if (rx) {
// "FSK" channel bandwidth: BK4819_SetFilterBandwidth() leaves REG_43 alone,
// so pick the filter the POCSAG signal needs.
if (gRxVfo->CHANNEL_BANDWIDTH == BK4819_FILTER_BW_FSK_OFFLOAD)
BK4819_WriteRegister(BK4819_REG_43, POCSAG_REG43);
}
BK4819_WriteRegister(BK4819_REG_5A, POCSAG_Raw16(POCSAG_CHIP_SYNC));
BK4819_WriteRegister(BK4819_REG_5B, POCSAG_Raw16(POCSAG_CHIP_SYNC));
BK4819_WriteRegister(BK4819_REG_5C, POCSAG_REG5C);
BK4819_WriteRegister(BK4819_REG_5E, (64U << 3) | 4U); // RX FIFO almost full: 4 words
// REG_5D<15:8> = data length - 1 (bytes)
const uint16_t length = rx ? POCSAG_RX_BYTES : POCSAG_MAX_FRAME_SIZE;
BK4819_WriteRegister(BK4819_REG_5D, (uint16_t) ((length - 1U) << 8));
BK4819_WriteRegister(BK4819_REG_59, FSK_CLEAR_TX_FIFO | FSK_CLEAR_RX_FIFO | POCSAG_REG59);
BK4819_WriteRegister(BK4819_REG_59, POCSAG_REG59);
// No REG_02 write here: this also runs from inside the interrupt loop (RX re-arm)
// and clearing REG_02 there drops pending events such as squelch close.
}
static uint8_t pocsagRxBuffer[POCSAG_RX_BYTES];
static size_t pocsagRxSize;
static uint32_t lastPocsagSender;
static char lastPocsagMessage[POCSAG_MAX_MESSAGE_LENGTH + 1U];
static uint8_t pocsagDuplicateTimeout;
// New page alert: yellow (red + green) LED flashing and a speaker beep. The beep
// waits until RX has ended, AUDIO_PlayBeep() does nothing while receiving.
#define POCSAG_ALERT_FLASHES 10U // 500 ms half periods
static uint8_t pocsagAlertTicks;
static bool pocsagBeepPending;
static void POCSAG_StartAlert(void)
{
pocsagAlertTicks = POCSAG_ALERT_FLASHES;
pocsagBeepPending = true;
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true);
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, true);
}
static void POCSAG_AlertTimeSlice500ms(void)
{
if (pocsagAlertTicks > 0) {
pocsagAlertTicks--;
const bool on = (pocsagAlertTicks & 1U) != 0;
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, on);
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, on);
}
if (pocsagBeepPending && !FUNCTION_IsRx() && gCurrentFunction != FUNCTION_TRANSMIT) {
pocsagBeepPending = false;
AUDIO_PlayBeep(BEEP_880HZ_60MS_DOUBLE_BEEP); // not affected by the key beep setting
}
}
void FSKModem_TimeSlice500ms(void) {
if (MODEM_IS_POCSAG(gEeprom.FSKMode)) {
if (pocsagDuplicateTimeout > 0)
pocsagDuplicateTimeout--;
POCSAG_AlertTimeSlice500ms();
return;
}
if (SMSResponseCounter && FUNCTION_IsRx() && SMSResponseCounter++ > SMSResponseCounterTarget) {
switch (gSMSResponseState) {
case SMS_RESPONSE_ACK:
MSG_FSKSendData(&inBoundPacket);
gSMSResponseState = SMS_RESPONSE_IDLE;
SMSResponseCounter = 0;
break;
case SMS_RESPONSE_RETRANSMIT:
MSG_FSKSendData(&inBoundPacket);
gSMSResponseState = SMS_RESPONSE_IDLE;
SMSResponseCounter = 0;
break;
case SMS_RESPONSE_RESEND:
MSG_FSKSendData(&dataPacket);
gSMSResponseState = SMS_RESPONSE_IDLE;
SMSResponseCounter = 0;
break;
case SMS_RESPONSE_ACK_LIGHT:
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false);
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
gSMSResponseState = SMS_RESPONSE_IDLE;
SMSResponseCounter = 0;
break;
default:
break;
}
}
}
void MSG_ConfigureFSK(bool rx) {
if (MODEM_IS_POCSAG(gEeprom.FSKMode)) {
POCSAG_ConfigureModem(rx);
return;
}
// quick helper
bool isAFSK = (gEeprom.FSKMode == MOD_AFSK_1200 ||
gEeprom.FSKMode == MOD_AFSK_2400 ||
gEeprom.FSKMode == MOD_NOAA_SAME);
// Base tone config
uint16_t tone1 = 0, tone2 = 0;
#define BK4819_FREQ_WORD(freq_hz) ((uint16_t)((freq_hz) * 10.32444f))
if (isAFSK) {
// Bell-202 style tones for AFSK/NOAA
switch (gEeprom.FSKMode) {
case MOD_AFSK_1200:
tone1 = BK4819_FREQ_WORD(1200.0f); // mark
tone2 = BK4819_FREQ_WORD(2200.0f); // space
break;
case MOD_AFSK_2400:
tone1 = BK4819_FREQ_WORD(1200.0f);
tone2 = BK4819_FREQ_WORD(2400.0f);
break;
case MOD_NOAA_SAME:
tone1 = BK4819_FREQ_WORD(1562.5f); // typical mark
tone2 = BK4819_FREQ_WORD(2083.3f); // typical space
break;
default:
tone1 = BK4819_FREQ_WORD(1200.0f);
tone2 = BK4819_FREQ_WORD(2200.0f);
break;
}
BK4819_WriteRegister(BK4819_REG_71, tone1);
BK4819_WriteRegister(BK4819_REG_72, tone2);
// enable both tones
BK4819_WriteRegister(BK4819_REG_70,
TONE1_ENABLE_BIT | TONE2_ENABLE_BIT |
(96U << 8) | (96U << 0));
} else {
// plain FSK path: only TONE2 used (frequency for binary shift display/debug)
switch (gEeprom.FSKMode) {
case MOD_FSK_450:
tone2 = BK4819_FREQ_WORD(450.0f);
break;
case MOD_FSK_700:
tone2 = BK4819_FREQ_WORD(700.0f);
break;
case MOD_FSK_1200:
tone2 = BK4819_FREQ_WORD(1200.0f);
break;
case MOD_FSK_2400:
tone2 = BK4819_FREQ_WORD(2400.0f);
break;
default:
tone2 = BK4819_FREQ_WORD(1200.0f);
break;
}
BK4819_WriteRegister(BK4819_REG_72, tone2);
BK4819_WriteRegister(BK4819_REG_70, TONE2_ENABLE_BIT | (96U << 0));
}
// Base FSK config
uint16_t fskConfig = FSK_ENABLE_BIT | FSK_PREAMBLE_TYPE_AA;
// Compose the correct fields into REG_58:
// - TX mode bits are at <15:13> (use your FSK_TX_MODE_* macros which are <<13)
// - RX mode bits are at <12:10> (use your FSK_RX_MODE_* macros which are <<10)
// - RX BW bits are at <3:1> (use your FSK_RX_BW_* macros which are <<1)
switch (gEeprom.FSKMode) {
case MOD_AFSK_1200:
fskConfig |= FSK_TX_MODE_FFSK_1200_1800 /*<<13 in macro*/
| FSK_RX_MODE_FFSK_1200_1800 /*<<10 in macro*/
| FSK_RX_BW_FFSK_1200_1800; /*<<1 in macro*/
break;
case MOD_AFSK_2400:
fskConfig |= FSK_TX_MODE_FFSK_1200_2400
| FSK_RX_MODE_FFSK_1200_2400
| FSK_RX_BW_2_4K_FFSK_1200_2400;
break;
case MOD_NOAA_SAME:
fskConfig |= FSK_TX_MODE_NOAA_SAME
| FSK_RX_MODE_FSK_1_2K_2_4K_NOAA
| FSK_RX_BW_NOAA_SAME;
break;
case MOD_FSK_2400:
// binary FSK 1.2k/2.4k - use default FSK TX/RX modes and 1.2k BW
fskConfig |= FSK_TX_MODE_FSK_1_2K_2_4K
| FSK_RX_MODE_FSK_1_2K_2_4K_NOAA
| FSK_RX_BW_2_4K_FFSK_1200_2400;
break;
case MOD_FSK_700:
case MOD_FSK_450:
case MOD_FSK_1200:
default:
// binary FSK 1.2k/2.4k - use default FSK TX/RX modes and 1.2k BW
fskConfig |= FSK_TX_MODE_FSK_1_2K_2_4K
| FSK_RX_MODE_FSK_1_2K_2_4K_NOAA
| FSK_RX_BW_1_2K;
break;
}
BK4819_WriteRegister(BK4819_REG_58, fskConfig);
BK4819_WriteRegister(BK4819_REG_5A, FSK_SYNC_BYTE0 << 8 | FSK_SYNC_BYTE1);
BK4819_WriteRegister(BK4819_REG_5B, FSK_SYNC_BYTE2 << 8 | FSK_SYNC_BYTE3);
BK4819_WriteRegister(BK4819_REG_5C, FSK_CRC_ON);
if (rx) {
uint8_t threshold;
switch (gEeprom.FSKMode) {
case MOD_AFSK_1200:
case MOD_NOAA_SAME:
threshold = 1U;
break;
case MOD_AFSK_2400:
threshold = 2U; // Slightly higher; 2400 baud can fill FIFO faster
break;
default:
threshold = 4U; // FSK modes
break;
}
BK4819_WriteRegister(BK4819_REG_5E, (64U << 3) | threshold);
}
// Data length (REG_5D<15:8>)
size_t size = sizeof(dataPacket);
if (rx) size = (((size + 1) / 2) * 2) + 2;
BK4819_WriteRegister(BK4819_REG_5D, (size << 8));
BK4819_FskClearFifo();
// REG_59: clear flags, preamble len, sync len etc.
//uint16_t fskParams = FSK_SYNC_LEN_BIT | ((rx ? 0U : 15U) << 4);
uint16_t preamble_len = (gEeprom.FSKMode == MOD_AFSK_1200 || gEeprom.FSKMode == MOD_AFSK_2400 || gEeprom.FSKMode == MOD_NOAA_SAME) ? 10U : (rx ? 0U
: 15U);
uint16_t fskParams = FSK_SYNC_LEN_BIT | (preamble_len << 4);
if (gCurrentVfo->SCRAMBLING_TYPE > 0) fskParams |= FSK_SCRAMBLE_ENABLE;
BK4819_WriteRegister(BK4819_REG_59, fskParams);
// Clear interrupt flags
BK4819_WriteRegister(BK4819_REG_02, 0);
// Enable AF path filters for tone demodulation in AFSK/NOAA modes
if (gEeprom.FSKMode == MOD_AFSK_1200 ||
gEeprom.FSKMode == MOD_AFSK_2400 ||
gEeprom.FSKMode == MOD_NOAA_SAME) {
// Keep DC cancel, disable only deemphasis
BK4819_WriteRegister(BK4819_REG_2B,
(1U << 15) | (1U << 14) | (1U << 8));
} else {
//BK4819_WriteRegister(BK4819_REG_2B, (1u << 2) | (1u << 0));
}
// set the FM deviation level
const uint16_t dev_val = BK4819_ReadRegister(BK4819_REG_40);
uint16_t deviation;
switch (gEeprom.FSKMode) {
case MOD_AFSK_1200:
case MOD_AFSK_2400:
case MOD_NOAA_SAME:
deviation = 650; // 0.65 kHz for audio-based tones (linear region)
break;
case MOD_FSK_450:
deviation = 225; // ≈ half of 450 Hz separation
break;
case MOD_FSK_700:
deviation = 350; // ≈ half of 700 Hz separation
break;
case MOD_FSK_1200:
deviation = 600; // halfway between 1200 and 2400 = 1.8 kHz spacing → ±900 Hz dev
break;
case MOD_FSK_2400:
deviation = 1200; // halfway between 1200 and 2400 = 1.8 kHz spacing → ±900 Hz dev
break;
default:
deviation = 750; // safe fallback
break;
}
if (gCurrentVfo->CHANNEL_BANDWIDTH == BK4819_FILTER_BW_FSK_OFFLOAD) {
BK4819_WriteRegister(BK4819_REG_40, (dev_val & 0xf000) | (deviation & 0x0fff));
}
// restore FM deviation level
//BK4819_WriteRegister(BK4819_REG_40, dev_val);
}
uint16_t calculateCRC(uint8_t *data, size_t length) {
uint16_t crc = 0xFFFF; // Example CRC-16 initialization
for (size_t i = 0; i < length; i++) {
crc ^= data[i];
for (uint8_t j = 0; j < 8; j++) {
if (crc & 1) {
crc = (crc >> 1) ^ 0xA001; // Example polynomial (CRC-16-IBM)
} else {
crc >>= 1;
}
}
}
return crc;
}
void processReceivedPacket(DataPacket *packet) {
char String[18];
char numBuf[11]; // Enough for any 64-bit unsigned integer
const unsigned int vfo = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_VFO
: gEeprom.TX_VFO;
typedef struct {
uint16_t ID;
uint16_t Size;
} Header_t;
Header_t Header;
Header.ID = 0x06FE;
Header.Size = sizeof(DataPacket);
UART_Send(&Header, sizeof(Header));
UART_Send(packet, sizeof(DataPacket));
if (packet->dest == gEeprom.FSKSRCAddress) {
if ((packet->flags & 0x80)) {
if (packet->flags & 0x40) {
uint16_t crcSent = calculateCRC(dataPacket.data, 20);
uint16_t crcGot = inBoundPacket.data[0] | (inBoundPacket.data[1] << 8);
if (crcSent == crcGot) {
gGotACK = true;
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true);
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, true);
SMSResponseCounter = 1;
gSMSResponseState = SMS_RESPONSE_ACK_LIGHT;
} else {
if (--dataPacket.ttl) {
gSMSResponseState = SMS_RESPONSE_RESEND;
SMSResponseCounter = 1;
}
}
} else {
AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP);
BK4819_PlaySingleTone(1000, 250, 127, true);
strcpy(String, "SMS by ");
itoa(packet->src, numBuf); // Convert number to string
strcat(String, numBuf);
MESSAGES_SAVE(inBoundPacket.src, inBoundPacket.seq, inBoundPacket.ttl, inBoundPacket.flags,
inBoundPacket.data, DataPacketDataSize);
gRequestDisplayScreen = DISPLAY_MESSAGES;
GUI_SelectNextDisplay(gRequestDisplayScreen);
MESSAGES_ShowNewest();
UI_DisplayPopup(String);
inBoundPacket.flags |= 0x40;
inBoundPacket.dest = inBoundPacket.src;
inBoundPacket.src = gEeprom.FSKSRCAddress;
uint16_t crcTest = calculateCRC(inBoundPacket.data, 20);
memset(inBoundPacket.data, 0, DataPacketDataSize);
inBoundPacket.data[0] = crcTest & 0xFF;
inBoundPacket.data[1] = (crcTest >> 8) & 0xFF;
gSMSResponseState = SMS_RESPONSE_ACK;
SMSResponseCounter = 1;
UI_PrintStringSmallNormal(String, 2, 0, 4);
}
}
} else if (VfoState[vfo] == VFO_STATE_NORMAL && !TX_freq_check(gCurrentVfo->freq_config_TX.Frequency)) {
if (packet->ttl--) {
SMSResponseCounter = 1;
gSMSResponseState = SMS_RESPONSE_RETRANSMIT;
}
}
}
static void MSG_POCSAGStoreReceived(void);
// The chip locks somewhere in the preamble, so it usually has not collected all
// POCSAG_RX_BYTES when the carrier drops. Squelch close / VFO switching re-arms
// RX through here: decode what was captured before it is thrown away.
static void POCSAG_FlushCapture(void)
{
if (!MODEM_IS_POCSAG(gEeprom.FSKMode) || rxState != Receiving)
return;
rxState = Ready;
if (pocsagRxSize >= 4U * 3U) // at least sync + address + one message word
MSG_POCSAGStoreReceived();
pocsagRxSize = 0;
}
void MSG_EnableRX(const bool enable) {
POCSAG_FlushCapture();
if (enable) {
MSG_ConfigureFSK(true);
//if(gEeprom.MESSENGER_CONFIG.data.receive)
BK4819_FskEnableRx();
} else {
BK4819_WriteRegister(BK4819_REG_70, 0);
BK4819_WriteRegister(BK4819_REG_58, 0);
}
}
// Common end of a data transmission (SMS and POCSAG): back to RX, FSK RX re-armed.
static void MSG_EndDataTransmission(const bool audioWasEnabled)
{
APP_EndTransmission();
FUNCTION_Select(FUNCTION_FOREGROUND);
gUpdateStatus = true;
gUpdateDisplay = true;
gFlagEndTransmission = false;
if (audioWasEnabled) {
AUDIO_AudioPathOn();
gEnableSpeaker = true;
BK4819_ExitTxMute();
}
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false);
MSG_EnableRX(true);
gVfoConfigureMode = VFO_CONFIGURE;
dataPTR = gMessageText;
}
void MSG_POCSAGSend(const uint32_t ric, const char *text)
{
uint8_t frame[POCSAG_MAX_FRAME_SIZE];
size_t frameSize;
const unsigned int vfo = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_VFO
: gEeprom.TX_VFO;
if (!POCSAG_Encode(ric, text, frame, sizeof(frame), &frameSize)) {
AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
return;
}
if (VfoState[vfo] != VFO_STATE_NORMAL || TX_freq_check(gCurrentVfo->freq_config_TX.Frequency))
return;
const bool audioWasEnabled = gEnableSpeaker;
RADIO_PrepareTX();
if (gCurrentFunction != FUNCTION_TRANSMIT)
return;
// Registers changed for the data burst, restored before returning to RX.
static const BK4819_REGISTER_t savedRegs[] = {
BK4819_REG_2B, BK4819_REG_31, BK4819_REG_3F, BK4819_REG_40,
BK4819_REG_43, BK4819_REG_4B, BK4819_REG_51, BK4819_REG_7E,
BK4819_REG_30,
};
uint16_t saved[ARRAY_SIZE(savedRegs)];
for (unsigned int i = 0; i < ARRAY_SIZE(savedRegs); i++)
saved[i] = BK4819_ReadRegister(savedRegs[i]);
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true);
// Clean, flat, wide FM path for the NRZ data:
BK4819_WriteRegister(BK4819_REG_30, saved[8] & ~BK4819_REG_30_MASK_ENABLE_MIC_ADC); // mic off
BK4819_WriteRegister(BK4819_REG_51, 0); // no CTCSS/DCS
BK4819_WriteRegister(BK4819_REG_31, saved[1] & ~((1U << 1) | (1U << 3))); // scrambler + compander off
BK4819_WriteRegister(BK4819_REG_2B, (saved[0] & 0xF8F8U) | 0x0707U); // bypass AF filters + emphasis
BK4819_WriteRegister(BK4819_REG_7E, saved[7] & 0xFFC0U); // DC filters off
BK4819_WriteRegister(BK4819_REG_4B, saved[5] | (1U << 5)); // ALC off
BK4819_WriteRegister(BK4819_REG_43, POCSAG_REG43); // 25 kHz channel for +-4.5 kHz
BK4819_WriteRegister(BK4819_REG_40, (saved[3] & 0xE000U) | (1U << 12) | (gPocsagDeviation & 0x0FFFU));
POCSAG_ConfigureModem(false);
BK4819_WriteRegister(BK4819_REG_3F, BK4819_REG_3F_FSK_TX_FINISHED);
// Low byte of each FIFO word is transmitted first.
for (size_t i = 0; i + 1U < frameSize; i += 2U)
BK4819_WriteRegister(BK4819_REG_5F, POCSAG_Raw16((uint16_t) (frame[i] | (frame[i + 1U] << 8))));
SYSTEM_DelayMs(20);
BK4819_FskEnableTx();
// chip preamble/sync + frame, plus 1 s margin (512 baud: ~4.4 s)
const unsigned int timeoutMs =
(unsigned int) (((frameSize + 11U) * 8U * 1000U) / POCSAG_Baud()) + 1000U;
for (unsigned int timeout = 0; timeout < timeoutMs / 5U; timeout++) {
SYSTEM_DelayMs(5);
if (BK4819_ReadRegister(BK4819_REG_0C) & 1U) {
BK4819_WriteRegister(BK4819_REG_02, 0);
if (BK4819_ReadRegister(BK4819_REG_02) & BK4819_REG_02_FSK_TX_FINISHED)
break;
}
}
SYSTEM_DelayMs(20); // let the last bits leave the modulator
BK4819_WriteRegister(BK4819_REG_59, POCSAG_REG59); // FSK TX off
BK4819_WriteRegister(BK4819_REG_58, 0);
BK4819_WriteRegister(BK4819_REG_02, 0);
for (unsigned int i = 0; i < ARRAY_SIZE(savedRegs); i++)
BK4819_WriteRegister(savedRegs[i], saved[i]);
MSG_EndDataTransmission(audioWasEnabled);
}
void MSG_FSKSendData(DataPacket *dataPacketIn) {
if (MODEM_IS_POCSAG(gEeprom.FSKMode)) { // e.g. UART command 0x06FF
char text[DataPacketDataSize + 1U];
memcpy(text, dataPacketIn->data, DataPacketDataSize);
text[DataPacketDataSize] = '\0';
MSG_POCSAGSend(dataPacketIn->dest, text);
return;
}
const unsigned int vfo = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_VFO
: gEeprom.TX_VFO;
if (VfoState[vfo] == VFO_STATE_NORMAL &&
!TX_freq_check(gCurrentVfo->freq_config_TX.Frequency)) {
RADIO_PrepareTX();
BK4819_SetScramble(gCurrentVfo->SCRAMBLING_TYPE);
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true);
bool isAudioOn = gEnableSpeaker;
if (gEnableSpeaker) {
AUDIO_AudioPathOff();
BK4819_EnterTxMute();
gEnableSpeaker = false;
}
// turn off CTCSS/CDCSS during FFSK
const uint16_t css_val = BK4819_ReadRegister(BK4819_REG_51);
BK4819_WriteRegister(BK4819_REG_51, 0);
// REG_2B 0
//
// <15> 1 Enable CTCSS/CDCSS DC cancellation after FM Demodulation 1 = enable 0 = disable
// <14> 1 Enable AF DC cancellation after FM Demodulation 1 = enable 0 = disable
// <10> 0 AF RX HPF 300Hz filter 0 = enable 1 = disable
// <9> 0 AF RX LPF 3kHz filter 0 = enable 1 = disable
// <8> 0 AF RX de-emphasis filter 0 = enable 1 = disable
// <2> 0 AF TX HPF 300Hz filter 0 = enable 1 = disable
// <1> 0 AF TX LPF filter 0 = enable 1 = disable
// <0> 0 AF TX pre-emphasis filter 0 = enable 1 = disable
//
// disable the 300Hz HPF and FM pre-emphasis filter
//
const uint16_t filt_val = BK4819_ReadRegister(BK4819_REG_2B);
// Enable AF path filters for tone demodulation in AFSK/NOAA modes
if (gEeprom.FSKMode == MOD_AFSK_1200 ||
gEeprom.FSKMode == MOD_AFSK_2400 ||
gEeprom.FSKMode == MOD_NOAA_SAME) {
// Keep DC cancel, disable only deemphasis
BK4819_WriteRegister(BK4819_REG_2B,
(1U << 15) | (1U << 14) | (1U << 8));
} else {
BK4819_WriteRegister(BK4819_REG_2B, (1u << 2) | (1u << 0));
}
MSG_ConfigureFSK(false);
SYSTEM_DelayMs(100);
{ // load the entire packet data into the TX FIFO buffer
uint16_t *ptr = (uint16_t *) dataPacketIn;
size_t wordCount = sizeof(*dataPacketIn) / sizeof(uint16_t);
for (size_t i = 0; i < wordCount; i++) {
BK4819_WriteRegister(BK4819_REG_5F, ptr[i]);
}
}
// enable FSK TX
BK4819_FskEnableTx();
{
// allow up to 310ms for the TX to complete
// if it takes any longer then somethings gone wrong, we shut the TX down
unsigned int timeout = 1000 / 5;
while (timeout-- > 0) {
SYSTEM_DelayMs(5);
if (BK4819_ReadRegister(BK4819_REG_0C) & (1u << 0)) { // we have interrupt flags
BK4819_WriteRegister(BK4819_REG_02, 0);
if (BK4819_ReadRegister(BK4819_REG_02) & BK4819_REG_02_FSK_TX_FINISHED)
timeout = 0; // TX is complete
}
}
}
//BK4819_WriteRegister(BK4819_REG_02, 0);
SYSTEM_DelayMs(100);
// disable TX
MSG_ConfigureFSK(true);
// restore TX/RX filtering
BK4819_WriteRegister(BK4819_REG_2B, filt_val);
// restore the CTCSS/CDCSS setting
BK4819_WriteRegister(BK4819_REG_51, css_val);
SYSTEM_DelayMs(50);
//if (!(dataPacketIn->flags & 0x64)) {
if (!(dataPacketIn->flags & 0x40)) {
gGotACK = false;
}
MSG_EndDataTransmission(isAudioOn);
}
}
void prepareDataPacket() {
dataPacket.src = gEeprom.FSKSRCAddress;
uint8_t Data[8];
EEPROM_ReadBuffer(SEQParameterEEPROM, Data, 8);
dataPacket.seq = Data[0];
Data[0]++;
EEPROM_WriteBuffer(SEQParameterEEPROM, Data);
dataPacket.ttl = 20;
}
// UART debug log for POCSAG RX (38400 8N1 on the programming cable):
// "PS" chip locked on the preamble (FSK RX sync)
// "PF <n>" capture finished, n bytes
// "PD <hex>" raw captured bytes (logical bits, as stored)
// "PR <ric> <m>" decoded a page (any RIC), "PX" nothing decodable
#ifndef POCSAG_DEBUG_UART
#define POCSAG_DEBUG_UART 1
#endif
#if POCSAG_DEBUG_UART
static void POCSAG_Log(const char *text)
{
UART_Send(text, strlen(text));
}
static void POCSAG_LogNumber(const char *tag, const uint32_t value)
{
char number[12];
itoa(value, number);
POCSAG_Log(tag);
POCSAG_Log(number);
}
static void POCSAG_LogHex(const char *tag, const uint8_t *data, const size_t size)
{
static const char digits[] = "0123456789ABCDEF";
POCSAG_Log(tag);
for (size_t i = 0; i < size; i++) {
const char pair[2] = {digits[data[i] >> 4], digits[data[i] & 15U]};
UART_Send(pair, 2);
}
POCSAG_Log("\r\n");
}
#else
#define POCSAG_Log(text) do { } while (0)
#define POCSAG_LogNumber(tag, value) do { } while (0)
#define POCSAG_LogHex(tag, data, size) do { } while (0)
#endif
static void POCSAG_SwapBytePairs(void)
{
for (size_t i = 0; i + 1U < pocsagRxSize; i += 2U) {
const uint8_t b = pocsagRxBuffer[i];
pocsagRxBuffer[i] = pocsagRxBuffer[i + 1U];
pocsagRxBuffer[i + 1U] = b;
}
}
// The RX FIFO byte order has not been verified on hardware: try both.
static bool POCSAG_TryDecode(const uint32_t ric, uint32_t *sender, char *message, const size_t capacity)
{
if (POCSAG_Decode(pocsagRxBuffer, pocsagRxSize, ric, sender, message, capacity))
return true;
POCSAG_SwapBytePairs();
const bool ok = POCSAG_Decode(pocsagRxBuffer, pocsagRxSize, ric, sender, message, capacity);
POCSAG_SwapBytePairs();
return ok;
}
static void MSG_POCSAGStoreReceived(void)
{
uint32_t sender;
char message[POCSAG_MAX_MESSAGE_LENGTH + 1U];
POCSAG_LogNumber("PF ", pocsagRxSize);
POCSAG_Log("\r\n");
POCSAG_LogHex("PD ", pocsagRxBuffer, pocsagRxSize);
// monitor mode: accept pages for every RIC, otherwise only our own
const uint32_t ric = gEeprom.POCSAG_MONITOR ? POCSAG_ANY_RIC : gEeprom.FSKSRCAddress;
const bool decoded = POCSAG_TryDecode(ric, &sender, message, sizeof(message));
#if POCSAG_DEBUG_UART
if (decoded || POCSAG_TryDecode(POCSAG_ANY_RIC, &sender, message, sizeof(message))) {
POCSAG_LogNumber(decoded ? "PR " : "PO ", sender); // PO: page for another RIC
POCSAG_Log(" ");
POCSAG_Log(message);
POCSAG_Log("\r\n");
} else {
POCSAG_Log("PX\r\n");
}
#endif
if (!decoded || message[0] == '\0')
return;
if (pocsagDuplicateTimeout > 0 && sender == lastPocsagSender &&
strcmp(message, lastPocsagMessage) == 0)
return;
lastPocsagSender = sender;
strcpy(lastPocsagMessage, message);
pocsagDuplicateTimeout = 20;
MESSAGES_SAVE(sender, 0, 0, MESSAGE_FLAG_POCSAG, (const uint8_t *) message, strlen(message));
POCSAG_StartAlert();
MESSAGES_ShowNewest();
gRequestDisplayScreen = DISPLAY_MESSAGES;
GUI_SelectNextDisplay(DISPLAY_MESSAGES);
UI_DisplayPopup("POCSAG received");
gUpdateDisplay = true;
}
static void POCSAG_HandleIRQ(const bool rx_sync, const bool rx_fifo_almost_full, const bool rx_finished)
{
if (rx_sync) {
// locked on the preamble; the decoder searches for the sync codeword itself
pocsagRxSize = 0;
rxState = Receiving;
AUDIO_AudioPathOff();
POCSAG_Log("PS\r\n");
}
if (rx_fifo_almost_full && rxState == Receiving) {
const uint16_t count = BK4819_ReadRegister(BK4819_REG_5E) & 7U;
for (uint16_t i = 0; i < count; i++) {
const uint16_t word = POCSAG_Raw16(BK4819_ReadRegister(BK4819_REG_5F));
if (pocsagRxSize + 2U <= sizeof(pocsagRxBuffer)) {
pocsagRxBuffer[pocsagRxSize++] = (uint8_t) word; // low byte arrived first
pocsagRxBuffer[pocsagRxSize++] = (uint8_t) (word >> 8);
}
}
}
if (rx_finished) {
if (rxState == Receiving)
MSG_POCSAGStoreReceived();
rxState = Ready;
pocsagRxSize = 0;
// re-arm the FSK receiver for the next page
MSG_EnableRX(true);
gUpdateStatus = true;
gUpdateDisplay = true;
}
}
void FSK_HANDLE_IRQ(unsigned short irq) {
//const uint16_t rx_sync_flags = BK4819_ReadRegister(BK4819_REG_0B);
const bool rx_sync = (irq & BK4819_REG_02_FSK_RX_SYNC) != 0;
const bool rx_fifo_almost_full = (irq & BK4819_REG_02_FSK_FIFO_ALMOST_FULL) != 0;
const bool rx_finished = (irq & BK4819_REG_02_FSK_RX_FINISHED) != 0;
//UART_printf("\nMSG : S%i, F%i, E%i | %i", rx_sync, rx_fifo_almost_full, rx_finished, irq);
if (MODEM_IS_POCSAG(gEeprom.FSKMode)) {
POCSAG_HandleIRQ(rx_sync, rx_fifo_almost_full, rx_finished);
return;
}
if (rx_sync) {
// prevent listening to fsk data and squelch (kamilsss655)
// CTCSS codes seem to false trigger the rx_sync
if (gCurrentCodeType == CODE_TYPE_OFF)
AUDIO_AudioPathOff();
gFSKWriteIndex = 0;
memset(&inBoundPacket, 0, sizeof(DataPacket));
rxState = Receiving;
}
if (rx_fifo_almost_full && rxState == Receiving) {
const uint16_t count = BK4819_ReadRegister(BK4819_REG_5E) & 7U;
uint16_t *ptr = (uint16_t *) &inBoundPacket;
size_t wordCount = sizeof(inBoundPacket) / sizeof(uint16_t);
for (uint16_t i = 0; i < count && gFSKWriteIndex < wordCount; i++) {
ptr[gFSKWriteIndex++] = BK4819_ReadRegister(BK4819_REG_5F);
//UART_Send((const void *) &ptr[gFSKWriteIndex - 1], 2);
}
SYSTEM_DelayMs(2);
}
if (rx_finished) {
// Turn off green LED
BK4819_FskClearFifo();
rxState = Ready;
if (gFSKWriteIndex > 2) {
// Validate checksum (assuming last 2 bytes are CRC-16)
//size_t dataLength = sizeof(inBoundPacket.data) - 2;
//uint16_t receivedCRC = (inBoundPacket.data[dataLength] << 8) | inBoundPacket.data[dataLength + 1];
//uint16_t calculatedCRC = calculateCRC(inBoundPacket.data, dataLength);
//if (receivedCRC == calculatedCRC) {
processReceivedPacket(&inBoundPacket);
//}
}
APP_EndTransmission();
FUNCTION_Select(FUNCTION_FOREGROUND);
gUpdateStatus = true;
gUpdateDisplay = true;
gFlagEndTransmission = false;
gFSKWriteIndex = 0;
}
}