// // 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 " capture finished, n bytes // "PD " raw captured bytes (logical bits, as stored) // "PR " 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; } }