815 lines
29 KiB
C
815 lines
29 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;
|
|
|
|
uint8_t *dataPTR = dataPacket.data;
|
|
|
|
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). Value from the
|
|
// uv-k5-pocsag reference; measure with an SDR and adjust if needed.
|
|
#ifndef POCSAG_DEVIATION
|
|
#define POCSAG_DEVIATION 0x383U
|
|
#endif
|
|
|
|
// REG_70<6:0> Tone2 gain = FSK TX level (0..127). 96 is what the stock aircopy/SMS use.
|
|
#ifndef POCSAG_TONE2_GAIN
|
|
#define POCSAG_TONE2_GAIN 96U
|
|
#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
|
|
#define POCSAG_REG72 0x3065U // 1200 baud (1200 * 10.32444)
|
|
#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))
|
|
|
|
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));
|
|
BK4819_WriteRegister(BK4819_REG_72, POCSAG_REG72);
|
|
BK4819_WriteRegister(BK4819_REG_58, POCSAG_REG58);
|
|
|
|
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);
|
|
BK4819_WriteRegister(BK4819_REG_02, 0);
|
|
}
|
|
|
|
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;
|
|
|
|
void FSKModem_TimeSlice500ms(void) {
|
|
if (gEeprom.FSKMode == MOD_POCSAG_1200) {
|
|
if (pocsagDuplicateTimeout > 0)
|
|
pocsagDuplicateTimeout--;
|
|
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 (gEeprom.FSKMode == MOD_POCSAG_1200) {
|
|
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();
|
|
gRequestDisplayScreen = DISPLAY_MESSAGES;
|
|
GUI_SelectNextDisplay(gRequestDisplayScreen);
|
|
gActiveMessageBank = MESSAGES_COUNT / 3 - 1;
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MSG_EnableRX(const bool enable) {
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
static void MSG_POCSAGSendData(DataPacket *packet)
|
|
{
|
|
uint8_t frame[POCSAG_MAX_FRAME_SIZE];
|
|
char message[DataPacketDataSize + 1U];
|
|
size_t frameSize;
|
|
const unsigned int vfo = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_VFO
|
|
: gEeprom.TX_VFO;
|
|
|
|
memcpy(message, packet->data, DataPacketDataSize);
|
|
message[DataPacketDataSize] = '\0';
|
|
if (!POCSAG_Encode(packet->dest, message, 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) | (POCSAG_DEVIATION & 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();
|
|
|
|
// ~(208 + 11) bytes at 1200 baud = 1.46 s; allow 3 s.
|
|
for (unsigned int timeout = 0; timeout < 600U; 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]);
|
|
|
|
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 = dataPacket.data;
|
|
}
|
|
|
|
void MSG_FSKSendData(DataPacket *dataPacketIn) {
|
|
if (gEeprom.FSKMode == MOD_POCSAG_1200) {
|
|
MSG_POCSAGSendData(dataPacketIn);
|
|
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);
|
|
APP_EndTransmission();
|
|
FUNCTION_Select(FUNCTION_FOREGROUND);
|
|
gUpdateStatus = true;
|
|
gUpdateDisplay = true;
|
|
gFlagEndTransmission = false;
|
|
|
|
if (isAudioOn) {
|
|
AUDIO_AudioPathOn();
|
|
gEnableSpeaker = true;
|
|
BK4819_ExitTxMute();
|
|
}
|
|
|
|
//if (!(dataPacketIn->flags & 0x64)) {
|
|
if (!(dataPacketIn->flags & 0x40)) {
|
|
gGotACK = false;
|
|
}
|
|
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false);
|
|
MSG_EnableRX(true);
|
|
gVfoConfigureMode = VFO_CONFIGURE;
|
|
dataPTR = dataPacket.data;
|
|
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static void MSG_POCSAGStoreReceived(void)
|
|
{
|
|
uint32_t sender;
|
|
char message[POCSAG_MAX_MESSAGE_LENGTH + 1U];
|
|
|
|
if (!POCSAG_Decode(pocsagRxBuffer, pocsagRxSize, gEeprom.FSKSRCAddress,
|
|
&sender, message, sizeof(message)) || message[0] == '\0')
|
|
return;
|
|
|
|
if (pocsagDuplicateTimeout > 0 && sender == lastPocsagSender &&
|
|
strcmp(message, lastPocsagMessage) == 0)
|
|
return;
|
|
|
|
lastPocsagSender = sender;
|
|
strcpy(lastPocsagMessage, message);
|
|
pocsagDuplicateTimeout = 20;
|
|
|
|
memset(&inBoundPacket, 0, sizeof(inBoundPacket));
|
|
inBoundPacket.dest = gEeprom.FSKSRCAddress;
|
|
inBoundPacket.src = sender;
|
|
inBoundPacket.flags = MESSAGE_FLAG_POCSAG;
|
|
memcpy(inBoundPacket.data, message, strlen(message) + 1U);
|
|
MESSAGES_SAVE();
|
|
|
|
gActiveMessageBank = MESSAGES_COUNT / 3U - 1U;
|
|
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();
|
|
}
|
|
|
|
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 (gEeprom.FSKMode == MOD_POCSAG_1200) {
|
|
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;
|
|
}
|
|
} |