951 lines
27 KiB
C
951 lines
27 KiB
C
/*
|
|
* ESP32-H2 + CC1101 POCSAG pager receiver
|
|
* Native ESP-IDF; no third-party libraries.
|
|
*
|
|
* Hardware:
|
|
* CC1101: SCLK=GPIO4, MOSI=GPIO5, MISO=GPIO0, CSN=GPIO1, GDO0=GPIO3
|
|
* SPI SSD1306 128x64: SCLK=GPIO4, MOSI=GPIO5, CS=GPIO13,
|
|
* DC=GPIO14, RESET=GPIO12
|
|
*
|
|
* Assumptions:
|
|
* - CC1101 module has a 26 MHz crystal.
|
|
* - RF centre frequency is set with RF_FREQ_HZ below.
|
|
* - OLED is a 7-pin SPI SSD1306 (not I2C, not SH1106).
|
|
*
|
|
* This is an experimental receiver. It does not guarantee reception
|
|
* under weak/noisy signals. Validate RF frequency, deviation, polarity,
|
|
* and timing against a known-good POCSAG transmitter.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
|
|
#include "esp_err.h"
|
|
#include "esp_log.h"
|
|
#include "esp_attr.h"
|
|
|
|
#include "driver/gpio.h"
|
|
#include "driver/spi_master.h"
|
|
#include "driver/gptimer.h"
|
|
|
|
/* ---------------------------- Pins/config ---------------------------- */
|
|
|
|
#define SPI_HOST_USED SPI2_HOST
|
|
#define PIN_SPI_SCLK GPIO_NUM_4
|
|
#define PIN_SPI_MOSI GPIO_NUM_5
|
|
#define PIN_SPI_MISO GPIO_NUM_0
|
|
|
|
#define PIN_CC1101_CS GPIO_NUM_1
|
|
#define PIN_CC1101_GDO0 GPIO_NUM_3
|
|
|
|
#define PIN_OLED_CS GPIO_NUM_10
|
|
#define PIN_OLED_DC GPIO_NUM_11
|
|
#define PIN_OLED_RESET GPIO_NUM_12
|
|
|
|
/* Change this one value to tune the receiver. Rebuild and flash afterwards. */
|
|
#define RF_FREQ_HZ 435000000UL
|
|
#define CC1101_XTAL_HZ 26000000UL
|
|
|
|
#define SAMPLE_TIMER_HZ 1000000UL
|
|
#define SAMPLE_PERIOD_TICKS 26UL
|
|
#define SAMPLE_RATE_HZ (SAMPLE_TIMER_HZ / SAMPLE_PERIOD_TICKS)
|
|
|
|
#define SAMPLE_BUF_SIZE 16384U
|
|
#define SAMPLE_BUF_MASK (SAMPLE_BUF_SIZE - 1U)
|
|
#define SPI_TRANSFER_CHUNK 64U
|
|
|
|
#define HISTORY_COUNT 8
|
|
#define MESSAGE_SIZE 160
|
|
|
|
static const char *TAG = "pager";
|
|
|
|
/* ---------------------------- SPI devices ---------------------------- */
|
|
|
|
static spi_device_handle_t cc_dev;
|
|
static spi_device_handle_t oled_dev;
|
|
static gptimer_handle_t sample_timer;
|
|
static unsigned display_baud;
|
|
|
|
static esp_err_t spi_tx(spi_device_handle_t dev,
|
|
const uint8_t *data, size_t len)
|
|
{
|
|
spi_transaction_t t = {
|
|
.length = len * 8,
|
|
.tx_buffer = data,
|
|
};
|
|
return spi_device_polling_transmit(dev, &t);
|
|
}
|
|
|
|
static esp_err_t spi_txrx(spi_device_handle_t dev,
|
|
const uint8_t *tx, uint8_t *rx, size_t len)
|
|
{
|
|
spi_transaction_t t = {
|
|
.length = len * 8,
|
|
.tx_buffer = tx,
|
|
.rx_buffer = rx,
|
|
};
|
|
return spi_device_polling_transmit(dev, &t);
|
|
}
|
|
|
|
static void setup_spi(void)
|
|
{
|
|
spi_bus_config_t bus = {
|
|
.mosi_io_num = PIN_SPI_MOSI,
|
|
.miso_io_num = PIN_SPI_MISO,
|
|
.sclk_io_num = PIN_SPI_SCLK,
|
|
.quadwp_io_num = -1,
|
|
.quadhd_io_num = -1,
|
|
.max_transfer_sz = SPI_TRANSFER_CHUNK,
|
|
};
|
|
ESP_ERROR_CHECK(spi_bus_initialize(SPI_HOST_USED, &bus, SPI_DMA_DISABLED));
|
|
|
|
spi_device_interface_config_t cc_cfg = {
|
|
.clock_speed_hz = 1000000,
|
|
.mode = 0,
|
|
.spics_io_num = PIN_CC1101_CS,
|
|
.queue_size = 1,
|
|
};
|
|
ESP_ERROR_CHECK(spi_bus_add_device(SPI_HOST_USED, &cc_cfg, &cc_dev));
|
|
|
|
spi_device_interface_config_t oled_cfg = {
|
|
.clock_speed_hz = 4000000,
|
|
.mode = 0,
|
|
.spics_io_num = PIN_OLED_CS,
|
|
.queue_size = 1,
|
|
};
|
|
ESP_ERROR_CHECK(spi_bus_add_device(SPI_HOST_USED, &oled_cfg, &oled_dev));
|
|
}
|
|
|
|
/* ------------------------------- CC1101 ------------------------------- */
|
|
|
|
static void cc_write(uint8_t reg, uint8_t val)
|
|
{
|
|
uint8_t b[2] = { reg, val };
|
|
ESP_ERROR_CHECK(spi_tx(cc_dev, b, sizeof(b)));
|
|
}
|
|
|
|
static uint8_t cc_read_status(uint8_t reg)
|
|
{
|
|
uint8_t tx[2] = { (uint8_t)(reg | 0xC0), 0 };
|
|
uint8_t rx[2] = { 0 };
|
|
ESP_ERROR_CHECK(spi_txrx(cc_dev, tx, rx, sizeof(tx)));
|
|
return rx[1];
|
|
}
|
|
|
|
static void cc_strobe(uint8_t cmd)
|
|
{
|
|
ESP_ERROR_CHECK(spi_tx(cc_dev, &cmd, 1));
|
|
}
|
|
|
|
/* CC1101 frequency word: FREQ = RF * 2^16 / crystal frequency. */
|
|
static uint32_t cc1101_set_frequency(uint32_t frequency_hz)
|
|
{
|
|
uint64_t numerator = ((uint64_t)frequency_hz << 16) +
|
|
(CC1101_XTAL_HZ / 2U);
|
|
uint32_t word = (uint32_t)(numerator / CC1101_XTAL_HZ);
|
|
|
|
cc_write(0x0D, (uint8_t)(word >> 16));
|
|
cc_write(0x0E, (uint8_t)(word >> 8));
|
|
cc_write(0x0F, (uint8_t)word);
|
|
|
|
return (uint32_t)(((uint64_t)word * CC1101_XTAL_HZ + 32768U) >> 16);
|
|
}
|
|
|
|
static void cc1101_init(void)
|
|
{
|
|
ESP_LOGI(TAG, "Resetting CC1101");
|
|
cc_strobe(0x30); /* SRES */
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
|
|
/*
|
|
* Async serial output on GDO0. Packet engine is bypassed.
|
|
* MDMCFG4/3 select a wide receiver bandwidth and a 1200-baud
|
|
* modem rate; software validates the POCSAG preamble rate.
|
|
*/
|
|
const uint8_t regs[][2] = {
|
|
{0x00, 0x0D}, /* IOCFG2 */
|
|
{0x01, 0x2E}, /* IOCFG1 */
|
|
{0x02, 0x0D}, /* IOCFG0: async data */
|
|
{0x06, 0xFF}, /* PKTLEN */
|
|
{0x07, 0x04}, /* PKTCTRL1 */
|
|
{0x08, 0x32}, /* PKTCTRL0: async serial */
|
|
{0x0B, 0x06}, /* FSCTRL1 */
|
|
{0x0C, 0x00}, /* FSCTRL0 */
|
|
{0x10, 0xB5}, /* MDMCFG4: 1200 baud, wide channel BW */
|
|
{0x11, 0x83}, /* MDMCFG3 */
|
|
{0x12, 0x00}, /* MDMCFG2: 2-FSK */
|
|
{0x13, 0x22}, /* MDMCFG1 */
|
|
{0x14, 0xF8}, /* MDMCFG0 */
|
|
{0x15, 0x14}, /* DEVIATN */
|
|
{0x18, 0x18}, /* MCSM0 */
|
|
{0x19, 0x16}, /* FOCCFG */
|
|
{0x1A, 0x6C}, /* BSCFG */
|
|
{0x1B, 0x43}, /* AGCCTRL2 */
|
|
{0x1C, 0x40}, /* AGCCTRL1 */
|
|
{0x1D, 0x91}, /* AGCCTRL0 */
|
|
};
|
|
|
|
for (size_t i = 0; i < sizeof(regs) / sizeof(regs[0]); i++)
|
|
cc_write(regs[i][0], regs[i][1]);
|
|
|
|
uint32_t actual_hz = cc1101_set_frequency(RF_FREQ_HZ);
|
|
ESP_LOGI(TAG, "RF target=%lu Hz, actual=%lu Hz, crystal=%lu Hz",
|
|
(unsigned long)RF_FREQ_HZ,
|
|
(unsigned long)actual_hz,
|
|
(unsigned long)CC1101_XTAL_HZ);
|
|
|
|
cc_strobe(0x33); /* SCAL */
|
|
vTaskDelay(pdMS_TO_TICKS(5));
|
|
cc_strobe(0x3A); /* SFRX */
|
|
cc_strobe(0x34); /* SRX */
|
|
|
|
ESP_LOGI(TAG, "CC1101 PARTNUM=0x%02X VERSION=0x%02X",
|
|
cc_read_status(0x30), cc_read_status(0x31));
|
|
}
|
|
|
|
/* ------------------------------ SSD1306 ------------------------------ */
|
|
|
|
static uint8_t fb[1024];
|
|
|
|
/* Small 5x7 font for uppercase letters, digits and common punctuation.
|
|
* Lowercase input is converted to uppercase on display. */
|
|
static const uint8_t font[][5] = {
|
|
{0,0,0,0,0}, /* space */
|
|
{0,0,0x5F,0,0}, /* ! */
|
|
{0x03,0x00,0x03,0x00,0}, /* " */
|
|
{0x14,0x7F,0x14,0x7F,0x14}, /* # */
|
|
{0x24,0x2A,0x7F,0x2A,0x12}, /* $ */
|
|
{0x23,0x13,0x08,0x64,0x62}, /* % */
|
|
{0x36,0x49,0x55,0x22,0x50}, /* & */
|
|
{0x05,0x03,0,0,0}, /* ' */
|
|
{0x1C,0x22,0x41,0,0}, /* ( */
|
|
{0x41,0x22,0x1C,0,0}, /* ) */
|
|
{0x14,0x08,0x3E,0x08,0x14}, /* * */
|
|
{0x08,0x08,0x3E,0x08,0x08}, /* + */
|
|
{0x50,0x30,0,0,0}, /* , */
|
|
{0x08,0x08,0x08,0x08,0x08}, /* - */
|
|
{0x60,0x60,0,0,0}, /* . */
|
|
{0x20,0x10,0x08,0x04,0x02}, /* / */
|
|
{0x3E,0x51,0x49,0x45,0x3E}, /* 0 */
|
|
{0x00,0x42,0x7F,0x40,0x00}, /* 1 */
|
|
{0x42,0x61,0x51,0x49,0x46}, /* 2 */
|
|
{0x21,0x41,0x45,0x4B,0x31}, /* 3 */
|
|
{0x18,0x14,0x12,0x7F,0x10}, /* 4 */
|
|
{0x27,0x45,0x45,0x45,0x39}, /* 5 */
|
|
{0x3C,0x4A,0x49,0x49,0x30}, /* 6 */
|
|
{0x01,0x71,0x09,0x05,0x03}, /* 7 */
|
|
{0x36,0x49,0x49,0x49,0x36}, /* 8 */
|
|
{0x06,0x49,0x49,0x29,0x1E}, /* 9 */
|
|
{0x7E,0x11,0x11,0x11,0x7E}, /* A */
|
|
{0x7F,0x49,0x49,0x49,0x36}, /* B */
|
|
{0x3E,0x41,0x41,0x41,0x22}, /* C */
|
|
{0x7F,0x41,0x41,0x22,0x1C}, /* D */
|
|
{0x7F,0x49,0x49,0x49,0x41}, /* E */
|
|
{0x7F,0x09,0x09,0x09,0x01}, /* F */
|
|
{0x3E,0x41,0x49,0x49,0x7A}, /* G */
|
|
{0x7F,0x08,0x08,0x08,0x7F}, /* H */
|
|
{0x00,0x41,0x7F,0x41,0x00}, /* I */
|
|
{0x20,0x40,0x41,0x3F,0x01}, /* J */
|
|
{0x7F,0x08,0x14,0x22,0x41}, /* K */
|
|
{0x7F,0x40,0x40,0x40,0x40}, /* L */
|
|
{0x7F,0x02,0x0C,0x02,0x7F}, /* M */
|
|
{0x7F,0x04,0x08,0x10,0x7F}, /* N */
|
|
{0x3E,0x41,0x41,0x41,0x3E}, /* O */
|
|
{0x7F,0x09,0x09,0x09,0x06}, /* P */
|
|
{0x3E,0x41,0x51,0x21,0x5E}, /* Q */
|
|
{0x7F,0x09,0x19,0x29,0x46}, /* R */
|
|
{0x46,0x49,0x49,0x49,0x31}, /* S */
|
|
{0x01,0x01,0x7F,0x01,0x01}, /* T */
|
|
{0x3F,0x40,0x40,0x40,0x3F}, /* U */
|
|
{0x1F,0x20,0x40,0x20,0x1F}, /* V */
|
|
{0x3F,0x40,0x38,0x40,0x3F}, /* W */
|
|
{0x63,0x14,0x08,0x14,0x63}, /* X */
|
|
{0x07,0x08,0x70,0x08,0x07}, /* Y */
|
|
{0x61,0x51,0x49,0x45,0x43}, /* Z */
|
|
{0x7F,0x41,0x41,0,0}, /* [ */
|
|
{0x02,0x04,0x08,0x10,0x20}, /* backslash */
|
|
{0,0x41,0x41,0x7F,0}, /* ] */
|
|
{0x04,0x02,0x01,0x02,0x04}, /* ^ */
|
|
{0x40,0x40,0x40,0x40,0x40}, /* _ */
|
|
{0x01,0x02,0x04,0,0}, /* ` */
|
|
{0x20,0x54,0x54,0x54,0x78}, /* a */
|
|
{0x7F,0x48,0x44,0x44,0x38}, /* b */
|
|
{0x38,0x44,0x44,0x44,0x20}, /* c */
|
|
{0x38,0x44,0x44,0x48,0x7F}, /* d */
|
|
{0x38,0x54,0x54,0x54,0x18}, /* e */
|
|
{0x08,0x7E,0x09,0x01,0x02}, /* f */
|
|
{0x0C,0x52,0x52,0x52,0x3E}, /* g */
|
|
{0x7F,0x08,0x04,0x04,0x78}, /* h */
|
|
{0,0x44,0x7D,0x40,0}, /* i */
|
|
{0x20,0x40,0x44,0x3D,0}, /* j */
|
|
{0x7F,0x10,0x28,0x44,0}, /* k */
|
|
{0,0x41,0x7F,0x40,0}, /* l */
|
|
{0x7C,0x04,0x18,0x04,0x78}, /* m */
|
|
{0x7C,0x08,0x04,0x04,0x78}, /* n */
|
|
{0x38,0x44,0x44,0x44,0x38}, /* o */
|
|
{0x7C,0x14,0x14,0x14,0x08}, /* p */
|
|
{0x08,0x14,0x14,0x18,0x7C}, /* q */
|
|
{0x7C,0x08,0x04,0x04,0x08}, /* r */
|
|
{0x48,0x54,0x54,0x54,0x20}, /* s */
|
|
{0x04,0x3F,0x44,0x40,0x20}, /* t */
|
|
{0x3C,0x40,0x40,0x20,0x7C}, /* u */
|
|
{0x1C,0x20,0x40,0x20,0x1C}, /* v */
|
|
{0x3C,0x40,0x30,0x40,0x3C}, /* w */
|
|
{0x44,0x28,0x10,0x28,0x44}, /* x */
|
|
{0x0C,0x50,0x50,0x50,0x3C}, /* y */
|
|
{0x44,0x64,0x54,0x4C,0x44}, /* z */
|
|
};
|
|
|
|
static void oled_cmd(uint8_t cmd)
|
|
{
|
|
gpio_set_level(PIN_OLED_DC, 0);
|
|
ESP_ERROR_CHECK(spi_tx(oled_dev, &cmd, 1));
|
|
}
|
|
|
|
static void oled_data(const uint8_t *data, size_t len)
|
|
{
|
|
gpio_set_level(PIN_OLED_DC, 1);
|
|
while (len > 0) {
|
|
size_t chunk = len > SPI_TRANSFER_CHUNK ? SPI_TRANSFER_CHUNK : len;
|
|
ESP_ERROR_CHECK(spi_tx(oled_dev, data, chunk));
|
|
data += chunk;
|
|
len -= chunk;
|
|
}
|
|
}
|
|
|
|
static void oled_init(void)
|
|
{
|
|
gpio_config_t out = {
|
|
.pin_bit_mask = (1ULL << PIN_OLED_DC) | (1ULL << PIN_OLED_RESET),
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&out));
|
|
|
|
gpio_set_level(PIN_OLED_RESET, 0);
|
|
vTaskDelay(pdMS_TO_TICKS(30));
|
|
gpio_set_level(PIN_OLED_RESET, 1);
|
|
vTaskDelay(pdMS_TO_TICKS(30));
|
|
|
|
const uint8_t init_seq[] = {
|
|
0xAE, 0xD5, 0x80, 0xA8, 0x3F, 0xD3, 0x00,
|
|
0x40, 0x8D, 0x14, 0x20, 0x00, 0xA1, 0xC8,
|
|
0xDA, 0x12, 0x81, 0x7F, 0xD9, 0xF1, 0xDB,
|
|
0x40, 0xA4, 0xA6, 0xAF
|
|
};
|
|
for (size_t i = 0; i < sizeof(init_seq); i++)
|
|
oled_cmd(init_seq[i]);
|
|
|
|
memset(fb, 0, sizeof(fb));
|
|
}
|
|
|
|
static void oled_flush(void)
|
|
{
|
|
oled_cmd(0x21); oled_cmd(0); oled_cmd(127);
|
|
oled_cmd(0x22); oled_cmd(0); oled_cmd(7);
|
|
oled_data(fb, sizeof(fb));
|
|
}
|
|
|
|
static void oled_clear(void)
|
|
{
|
|
memset(fb, 0, sizeof(fb));
|
|
}
|
|
|
|
static void oled_pixel(int x, int y)
|
|
{
|
|
if (x < 0 || x >= 128 || y < 0 || y >= 64)
|
|
return;
|
|
fb[(y / 8) * 128 + x] |= (uint8_t)(1U << (y & 7));
|
|
}
|
|
|
|
static void oled_char(int x, int y, char c)
|
|
{
|
|
if (c >= 'a' && c <= 'z')
|
|
c = (char)(c - 'a' + 'A');
|
|
|
|
unsigned idx;
|
|
if (c == ' ')
|
|
idx = 0;
|
|
else if (c >= '!' && c <= '/')
|
|
idx = (unsigned)(c - ' ');
|
|
else if (c >= '0' && c <= '9')
|
|
idx = 16U + (unsigned)(c - '0');
|
|
else if (c >= 'A' && c <= 'Z')
|
|
idx = 26U + (unsigned)(c - 'A');
|
|
else if (c >= '[' && c <= '`')
|
|
idx = 52U + (unsigned)(c - '[');
|
|
else
|
|
idx = 0;
|
|
|
|
if (idx >= sizeof(font) / sizeof(font[0]))
|
|
idx = 0;
|
|
|
|
for (int col = 0; col < 5; col++) {
|
|
uint8_t bits = font[idx][col];
|
|
for (int row = 0; row < 7; row++)
|
|
if (bits & (1U << row))
|
|
oled_pixel(x + col, y + row);
|
|
}
|
|
}
|
|
|
|
static void oled_text(int x, int y, const char *s)
|
|
{
|
|
while (*s && x <= 122) {
|
|
oled_char(x, y, *s++);
|
|
x += 6;
|
|
}
|
|
}
|
|
|
|
static void oled_number(char *dst, size_t n, uint32_t value)
|
|
{
|
|
snprintf(dst, n, "%lu", (unsigned long)value);
|
|
}
|
|
|
|
/* -------------------------- Message history -------------------------- */
|
|
|
|
typedef struct {
|
|
uint32_t ric;
|
|
unsigned baud;
|
|
unsigned function;
|
|
char text[MESSAGE_SIZE];
|
|
} pager_message_t;
|
|
|
|
static pager_message_t history[HISTORY_COUNT];
|
|
static unsigned history_count = 0;
|
|
static unsigned history_head = 0;
|
|
|
|
static void history_add(uint32_t ric, unsigned baud, unsigned function,
|
|
const char *text)
|
|
{
|
|
if (!text || !text[0])
|
|
return;
|
|
|
|
pager_message_t *m = &history[history_head];
|
|
m->ric = ric;
|
|
m->baud = baud;
|
|
m->function = function;
|
|
strlcpy(m->text, text, sizeof(m->text));
|
|
|
|
history_head = (history_head + 1) % HISTORY_COUNT;
|
|
if (history_count < HISTORY_COUNT)
|
|
history_count++;
|
|
|
|
ESP_LOGI(TAG, "PAGER RIC=%lu function=%u baud=%u: %s",
|
|
(unsigned long)ric, function, baud, text);
|
|
}
|
|
|
|
static void oled_draw_history(void)
|
|
{
|
|
char line[24];
|
|
oled_clear();
|
|
oled_text(0, 0, "POCSAG RECEIVER");
|
|
|
|
snprintf(line, sizeof(line), "%lu.%03lu MHZ",
|
|
(unsigned long)(RF_FREQ_HZ / 1000000UL),
|
|
(unsigned long)((RF_FREQ_HZ / 1000UL) % 1000UL));
|
|
oled_text(0, 8, line);
|
|
|
|
if (display_baud)
|
|
snprintf(line, sizeof(line), "%u BAUD", display_baud);
|
|
else
|
|
snprintf(line, sizeof(line), "WAITING FOR SIGNAL");
|
|
oled_text(0, 16, line);
|
|
|
|
if (history_count) {
|
|
pager_message_t *m = &history[(history_head + HISTORY_COUNT - 1U)
|
|
% HISTORY_COUNT];
|
|
snprintf(line, sizeof(line), "RIC %lu F%u",
|
|
(unsigned long)m->ric, m->function);
|
|
oled_text(0, 27, line);
|
|
oled_text(0, 37, m->text);
|
|
if (strlen(m->text) > 21U)
|
|
oled_text(0, 45, m->text + 21);
|
|
if (strlen(m->text) > 42U)
|
|
oled_text(0, 53, m->text + 42);
|
|
} else {
|
|
oled_text(0, 32, "NO MESSAGES YET");
|
|
}
|
|
|
|
oled_flush();
|
|
}
|
|
|
|
/* ------------------------------- BCH --------------------------------- */
|
|
|
|
#define POCSAG_SYNC 0x7CD215D8UL
|
|
#define POCSAG_IDLE 0x7A89C197UL
|
|
#define BCH_POLY 0x769U
|
|
|
|
static uint32_t syndrome_errors[1024];
|
|
|
|
static uint16_t bch_syndrome(uint32_t value)
|
|
{
|
|
for (int bit = 30; bit >= 10; bit--) {
|
|
if (value & (1UL << bit))
|
|
value ^= (uint32_t)BCH_POLY << (bit - 10);
|
|
}
|
|
return (uint16_t)(value & 0x3FF);
|
|
}
|
|
|
|
static void bch_init(void)
|
|
{
|
|
memset(syndrome_errors, 0, sizeof(syndrome_errors));
|
|
|
|
for (int i = 0; i < 31; i++) {
|
|
uint32_t e = 1UL << i;
|
|
syndrome_errors[bch_syndrome(e)] = e;
|
|
}
|
|
|
|
for (int i = 0; i < 31; i++) {
|
|
for (int j = i + 1; j < 31; j++) {
|
|
uint32_t e = (1UL << i) | (1UL << j);
|
|
syndrome_errors[bch_syndrome(e)] = e;
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool bch_correct(uint32_t *word, unsigned *ncorrected)
|
|
{
|
|
uint32_t upper31 = *word >> 1;
|
|
uint16_t syn = bch_syndrome(upper31);
|
|
uint32_t error = syndrome_errors[syn];
|
|
|
|
if (syn && !error)
|
|
return false;
|
|
|
|
upper31 ^= error;
|
|
|
|
unsigned parity = 0;
|
|
for (int i = 1; i < 32; i++)
|
|
parity ^= (upper31 >> (i - 1)) & 1U;
|
|
|
|
unsigned parity_error = ((*word & 1U) != parity);
|
|
unsigned error_count = (unsigned)__builtin_popcount(error);
|
|
if (error_count + parity_error > 2U)
|
|
return false;
|
|
|
|
uint32_t rebuilt = (upper31 << 1) | parity;
|
|
|
|
*word = rebuilt;
|
|
*ncorrected = error_count + parity_error;
|
|
return true;
|
|
}
|
|
|
|
/* ---------------------------- POCSAG decode --------------------------- */
|
|
|
|
typedef enum {
|
|
RATE_UNKNOWN = 0,
|
|
RATE_512 = 512,
|
|
RATE_1200 = 1200,
|
|
RATE_2400 = 2400
|
|
} baud_t;
|
|
|
|
static baud_t current_baud = RATE_UNKNOWN;
|
|
static uint32_t bit_period_q16;
|
|
static uint32_t phase_q16;
|
|
|
|
static uint32_t edge_samples;
|
|
static unsigned hit512, hit1200, hit2400;
|
|
static uint8_t last_sample;
|
|
static uint32_t observed_edges;
|
|
static uint32_t edge_period_sum;
|
|
static uint32_t edge_period_min = UINT32_MAX;
|
|
static uint32_t edge_period_max;
|
|
static unsigned edge_period_count;
|
|
|
|
static uint32_t sync_shift;
|
|
static unsigned sync_bits;
|
|
static bool batch_locked;
|
|
static bool invert_bits;
|
|
|
|
static uint32_t codeword_shift;
|
|
static unsigned codeword_bits;
|
|
static unsigned batch_word_index;
|
|
|
|
static uint32_t current_ric;
|
|
static unsigned current_function;
|
|
static bool message_active;
|
|
static char message[MESSAGE_SIZE];
|
|
static size_t message_len;
|
|
|
|
static uint32_t alpha_acc;
|
|
static unsigned alpha_nbits;
|
|
|
|
static unsigned numeric_nibble_count;
|
|
static const char numeric_chars[16] = {
|
|
'0','1','2','3','4','5','6','7',
|
|
'8','9','U',' ','-','[',']','?'
|
|
};
|
|
|
|
static void message_finish(void)
|
|
{
|
|
if (message_active && message_len) {
|
|
message[message_len] = '\0';
|
|
history_add(current_ric, (unsigned)current_baud, current_function, message);
|
|
oled_draw_history();
|
|
}
|
|
|
|
message_active = false;
|
|
current_ric = 0;
|
|
current_function = 0;
|
|
message_len = 0;
|
|
memset(message, 0, sizeof(message));
|
|
alpha_acc = 0;
|
|
alpha_nbits = 0;
|
|
numeric_nibble_count = 0;
|
|
}
|
|
|
|
static void message_abort(void)
|
|
{
|
|
message_active = false;
|
|
current_ric = 0;
|
|
current_function = 0;
|
|
message_len = 0;
|
|
memset(message, 0, sizeof(message));
|
|
alpha_acc = 0;
|
|
alpha_nbits = 0;
|
|
numeric_nibble_count = 0;
|
|
}
|
|
|
|
static void append_message_char(char c)
|
|
{
|
|
if (message_len < MESSAGE_SIZE - 1)
|
|
message[message_len++] = c;
|
|
}
|
|
|
|
static void decode_numeric(uint32_t payload)
|
|
{
|
|
for (int shift = 16; shift >= 0; shift -= 4) {
|
|
unsigned nibble = (payload >> shift) & 0xF;
|
|
char c = numeric_chars[nibble];
|
|
|
|
/* POCSAG numeric filler/padding. */
|
|
if (nibble == 0xF)
|
|
continue;
|
|
|
|
append_message_char(c);
|
|
numeric_nibble_count++;
|
|
}
|
|
}
|
|
|
|
static void decode_alpha(uint32_t payload)
|
|
{
|
|
/* Codewords arrive MSB first, but each 7-bit ASCII character is
|
|
transmitted least-significant bit first. Keep the character
|
|
accumulator across codeword boundaries. */
|
|
for (int bit = 19; bit >= 0; bit--) {
|
|
unsigned incoming = (payload >> bit) & 1U;
|
|
alpha_acc |= incoming << alpha_nbits;
|
|
alpha_nbits++;
|
|
|
|
if (alpha_nbits == 7U) {
|
|
unsigned ch = alpha_acc & 0x7FU;
|
|
alpha_acc = 0;
|
|
alpha_nbits = 0;
|
|
|
|
if (ch == 0x0DU || ch == 0x0AU)
|
|
append_message_char(' ');
|
|
else if (ch >= 0x20U && ch <= 0x7EU)
|
|
append_message_char((char)ch);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void decode_codeword(uint32_t raw, unsigned slot)
|
|
{
|
|
if (raw == POCSAG_IDLE) {
|
|
message_finish();
|
|
return;
|
|
}
|
|
|
|
unsigned fixed = 0;
|
|
if (!bch_correct(&raw, &fixed)) {
|
|
ESP_LOGW(TAG, "BCH failure, raw=%08lX",
|
|
(unsigned long)raw);
|
|
message_abort();
|
|
batch_locked = false;
|
|
sync_bits = 0;
|
|
sync_shift = 0;
|
|
codeword_bits = 0;
|
|
codeword_shift = 0;
|
|
return;
|
|
}
|
|
|
|
if (fixed)
|
|
ESP_LOGD(TAG, "Corrected %u bit(s)", fixed);
|
|
|
|
if (raw == POCSAG_IDLE) {
|
|
message_finish();
|
|
return;
|
|
}
|
|
|
|
unsigned is_message = (raw >> 31) & 1U;
|
|
uint32_t payload = (raw >> 11) & 0xFFFFFU;
|
|
|
|
if (!is_message) {
|
|
message_finish();
|
|
|
|
unsigned address = payload >> 2;
|
|
current_function = payload & 3U;
|
|
unsigned frame = (slot / 2U) & 7U;
|
|
current_ric = (address << 3) | frame;
|
|
|
|
/*
|
|
* POCSAG function bits:
|
|
* 00 / 01: numeric format
|
|
* 10 / 11: alphanumeric format
|
|
*
|
|
* A tone-only page is represented by an address with
|
|
* no subsequent message codewords, not by function 00.
|
|
*/
|
|
message_active = true;
|
|
message_len = 0;
|
|
alpha_acc = 0;
|
|
alpha_nbits = 0;
|
|
numeric_nibble_count = 0;
|
|
|
|
ESP_LOGI(TAG, "Address RIC=%lu function=%u",
|
|
(unsigned long)current_ric, current_function);
|
|
} else if (message_active) {
|
|
if (current_function <= 1)
|
|
decode_numeric(payload);
|
|
else
|
|
decode_alpha(payload);
|
|
}
|
|
}
|
|
|
|
static void process_bit(uint8_t bit)
|
|
{
|
|
if (invert_bits)
|
|
bit ^= 1U;
|
|
|
|
if (!batch_locked) {
|
|
sync_shift = (sync_shift << 1) | bit;
|
|
if (sync_bits < 32)
|
|
sync_bits++;
|
|
|
|
if (sync_bits == 32) {
|
|
if (sync_shift == POCSAG_SYNC) {
|
|
batch_locked = true;
|
|
batch_word_index = 0;
|
|
codeword_bits = 0;
|
|
codeword_shift = 0;
|
|
ESP_LOGI(TAG, "POCSAG sync");
|
|
} else if (sync_shift == ~POCSAG_SYNC) {
|
|
invert_bits = true;
|
|
batch_locked = true;
|
|
batch_word_index = 0;
|
|
codeword_bits = 0;
|
|
codeword_shift = 0;
|
|
ESP_LOGI(TAG, "POCSAG sync (inverted)");
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
codeword_shift = (codeword_shift << 1) | bit;
|
|
codeword_bits++;
|
|
|
|
if (codeword_bits == 32) {
|
|
decode_codeword(codeword_shift, batch_word_index);
|
|
batch_word_index++;
|
|
codeword_bits = 0;
|
|
codeword_shift = 0;
|
|
|
|
if (batch_word_index == 16) {
|
|
batch_locked = false;
|
|
sync_bits = 0;
|
|
sync_shift = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void set_detected_baud(baud_t rate)
|
|
{
|
|
if (current_baud != RATE_UNKNOWN)
|
|
return;
|
|
|
|
current_baud = rate;
|
|
bit_period_q16 = (uint32_t)(((uint64_t)SAMPLE_RATE_HZ << 16) /
|
|
(unsigned)rate);
|
|
phase_q16 = bit_period_q16 / 2U;
|
|
|
|
sync_shift = 0;
|
|
sync_bits = 0;
|
|
batch_locked = false;
|
|
|
|
display_baud = (unsigned)rate;
|
|
ESP_LOGI(TAG, "Detected baud: %u", (unsigned)rate);
|
|
oled_draw_history();
|
|
}
|
|
|
|
static void process_sample(uint8_t sample)
|
|
{
|
|
if (current_baud == RATE_UNKNOWN) {
|
|
edge_samples++;
|
|
|
|
if (sample != last_sample) {
|
|
observed_edges++;
|
|
if (edge_samples <= 200) {
|
|
edge_period_sum += edge_samples;
|
|
edge_period_count++;
|
|
if (edge_samples < edge_period_min)
|
|
edge_period_min = edge_samples;
|
|
if (edge_samples > edge_period_max)
|
|
edge_period_max = edge_samples;
|
|
}
|
|
|
|
if (edge_samples >= 69 && edge_samples <= 81) {
|
|
hit512++; hit1200 = hit2400 = 0;
|
|
} else if (edge_samples >= 28 && edge_samples <= 36) {
|
|
hit1200++; hit512 = hit2400 = 0;
|
|
} else if (edge_samples >= 13 && edge_samples <= 19) {
|
|
hit2400++; hit512 = hit1200 = 0;
|
|
} else {
|
|
hit512 = hit1200 = hit2400 = 0;
|
|
}
|
|
|
|
edge_samples = 0;
|
|
last_sample = sample;
|
|
|
|
if (hit512 >= 12) set_detected_baud(RATE_512);
|
|
else if (hit1200 >= 12) set_detected_baud(RATE_1200);
|
|
else if (hit2400 >= 12) set_detected_baud(RATE_2400);
|
|
}
|
|
return;
|
|
}
|
|
|
|
phase_q16 += 65536U;
|
|
if (phase_q16 >= bit_period_q16) {
|
|
phase_q16 -= bit_period_q16;
|
|
process_bit(sample);
|
|
}
|
|
}
|
|
|
|
/* ------------------------------ GPTimer ------------------------------- */
|
|
|
|
static uint8_t sample_buf[SAMPLE_BUF_SIZE];
|
|
static volatile uint32_t sample_wr;
|
|
static volatile uint32_t sample_rd;
|
|
static volatile uint32_t sample_drops;
|
|
|
|
static bool IRAM_ATTR sample_alarm_cb(gptimer_handle_t timer,
|
|
const gptimer_alarm_event_data_t *edata,
|
|
void *ctx)
|
|
{
|
|
(void)timer; (void)edata; (void)ctx;
|
|
|
|
uint32_t wr = sample_wr;
|
|
uint32_t rd = sample_rd;
|
|
|
|
if ((uint32_t)(wr - rd) < SAMPLE_BUF_SIZE) {
|
|
sample_buf[wr & SAMPLE_BUF_MASK] =
|
|
gpio_get_level(PIN_CC1101_GDO0) ? 1 : 0;
|
|
sample_wr = wr + 1;
|
|
} else {
|
|
sample_drops++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void start_sampler(void)
|
|
{
|
|
gptimer_config_t cfg = {
|
|
.clk_src = GPTIMER_CLK_SRC_DEFAULT,
|
|
.direction = GPTIMER_COUNT_UP,
|
|
.resolution_hz = SAMPLE_TIMER_HZ,
|
|
};
|
|
ESP_ERROR_CHECK(gptimer_new_timer(&cfg, &sample_timer));
|
|
|
|
gptimer_event_callbacks_t cbs = {
|
|
.on_alarm = sample_alarm_cb,
|
|
};
|
|
ESP_ERROR_CHECK(gptimer_register_event_callbacks(sample_timer, &cbs, NULL));
|
|
|
|
gptimer_alarm_config_t alarm = {
|
|
.alarm_count = SAMPLE_PERIOD_TICKS,
|
|
.reload_count = 0,
|
|
.flags.auto_reload_on_alarm = true,
|
|
};
|
|
ESP_ERROR_CHECK(gptimer_set_alarm_action(sample_timer, &alarm));
|
|
ESP_ERROR_CHECK(gptimer_enable(sample_timer));
|
|
ESP_ERROR_CHECK(gptimer_start(sample_timer));
|
|
|
|
ESP_LOGI(TAG, "Sample rate nominally %lu Hz",
|
|
(unsigned long)SAMPLE_RATE_HZ);
|
|
}
|
|
|
|
/* -------------------------------- main -------------------------------- */
|
|
|
|
void app_main(void)
|
|
{
|
|
ESP_LOGI(TAG, "ESP32-H2 POCSAG pager receiver");
|
|
|
|
gpio_config_t gdo_cfg = {
|
|
.pin_bit_mask = 1ULL << PIN_CC1101_GDO0,
|
|
.mode = GPIO_MODE_INPUT,
|
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&gdo_cfg));
|
|
|
|
gpio_config_t oled_cs_cfg = {
|
|
.pin_bit_mask = 1ULL << PIN_OLED_CS,
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&oled_cs_cfg));
|
|
gpio_set_level(PIN_OLED_CS, 1);
|
|
|
|
setup_spi();
|
|
oled_init();
|
|
oled_text(0, 0, "POCSAG RECEIVER");
|
|
oled_text(0, 16, "WAITING FOR RF");
|
|
oled_flush();
|
|
|
|
bch_init();
|
|
cc1101_init();
|
|
oled_draw_history();
|
|
|
|
start_sampler();
|
|
|
|
TickType_t last_status = xTaskGetTickCount();
|
|
|
|
while (1) {
|
|
while (sample_rd != sample_wr) {
|
|
uint32_t rd = sample_rd;
|
|
uint8_t s = sample_buf[rd & SAMPLE_BUF_MASK];
|
|
sample_rd = rd + 1;
|
|
process_sample(s);
|
|
}
|
|
|
|
if (xTaskGetTickCount() - last_status >= pdMS_TO_TICKS(5000)) {
|
|
last_status = xTaskGetTickCount();
|
|
unsigned edge_period_avg = edge_period_count
|
|
? edge_period_sum / edge_period_count : 0;
|
|
ESP_LOGI(TAG,
|
|
"baud=%u samples=%lu dropped=%lu history=%u "
|
|
"GDO_edges=%lu period_samples=%lu..%lu avg=%u",
|
|
(unsigned)current_baud,
|
|
(unsigned long)sample_wr,
|
|
(unsigned long)sample_drops,
|
|
history_count,
|
|
(unsigned long)observed_edges,
|
|
(unsigned long)(edge_period_count ? edge_period_min : 0),
|
|
(unsigned long)edge_period_max,
|
|
edge_period_avg);
|
|
observed_edges = 0;
|
|
edge_period_sum = 0;
|
|
edge_period_min = UINT32_MAX;
|
|
edge_period_max = 0;
|
|
edge_period_count = 0;
|
|
}
|
|
|
|
vTaskDelay(1);
|
|
}
|
|
}
|