commit 65fdc2a95feb610ab67e30d89c3dc6b0c614c1d3 Author: Bruno Rybársky Date: Thu Nov 12 18:46:57 2026 +0100 Init diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..dafb8ad --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,13 @@ +ARG DOCKER_TAG=latest +FROM espressif/idf:${DOCKER_TAG} + +ENV LC_ALL=C.UTF-8 +ENV LANG=C.UTF-8 + +RUN apt-get update -y && apt-get install udev -y + +RUN echo "source /opt/esp/idf/export.sh > /dev/null 2>&1" >> ~/.bashrc + +ENTRYPOINT [ "/opt/esp/entrypoint.sh" ] + +CMD ["/bin/bash", "-c"] \ No newline at end of file diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..ff6a739 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,18 @@ +{ + "name": "ESP-IDF QEMU", + "build": { + "dockerfile": "Dockerfile" + }, + "customizations": { + "vscode": { + "settings": { + "terminal.integrated.defaultProfile.linux": "bash" + }, + "extensions": [ + "espressif.esp-idf-extension", + "espressif.esp-idf-web" + ] + } + }, + "runArgs": ["--privileged"] +} \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7805557 --- /dev/null +++ b/.gitignore @@ -0,0 +1,78 @@ +# macOS +.DS_Store +.AppleDouble +.LSOverride + +# Directory metadata +.directory + +# Temporary files +*~ +*.swp +*.swo +*.bak +*.tmp + +# Log files +*.log + +# Build artifacts and directories +**/build/ +build/ +*.o +*.a +*.out +*.exe # For any host-side utilities compiled on Windows + +# ESP-IDF specific build outputs +*.bin +*.elf +*.map +flasher_args.json # Generated in build directory +sdkconfig.old +sdkconfig + +# ESP-IDF dependencies +# For older versions or manual component management +/components/.idf/ +**/components/.idf/ +# For modern ESP-IDF component manager +managed_components/ +# If ESP-IDF tools are installed/referenced locally to the project +.espressif/ + +# CMake generated files +CMakeCache.txt +CMakeFiles/ +cmake_install.cmake +install_manifest.txt +CTestTestfile.cmake + +# Python environment files +*.pyc +*.pyo +*.pyd +__pycache__/ +*.egg-info/ +dist/ + +# Virtual environment folders +venv/ +.venv/ +env/ + +# Language Servers +.clangd/ +.ccls-cache/ +compile_commands.json + +# Windows specific +Thumbs.db +ehthumbs.db +Desktop.ini + +# User-specific configuration files +*.user +*.workspace # General workspace files, can be from various tools +*.suo # Visual Studio Solution User Options +*.sln.docstates # Visual Studio diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json new file mode 100644 index 0000000..27fad04 --- /dev/null +++ b/.vscode/c_cpp_properties.json @@ -0,0 +1,20 @@ +{ + "configurations": [ + { + "name": "ESP-IDF", + "compilerPath": "", + "compileCommands": "${config:idf.buildPath}/compile_commands.json", + "intelliSenseMode": "gcc-x86", + "includePath": [ + "${workspaceFolder}/**" + ], + "browse": { + "path": [ + "${workspaceFolder}" + ], + "limitSymbolsToIncludedHeaders": true + } + } + ], + "version": 4 +} \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..3694ae4 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,10 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "type": "gdbtarget", + "request": "attach", + "name": "Eclipse CDT GDB Adapter" + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..bf6065d --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,31 @@ +{ + "C_Cpp.intelliSenseEngine": "default", + "idf.extensionActivationMode": "always", + "cmake.configureOnOpen": false, + "cmake.configureOnEdit": false, + "cmake.automaticReconfigure": false, + "cmake.autoSelectActiveFolder": false, + "cmake.options.advanced": { + "build": { + "statusBarVisibility": "inherit", + "inheritDefault": "hidden" + }, + "launch": { + "statusBarVisibility": "inherit", + "inheritDefault": "hidden" + }, + "debug": { + "statusBarVisibility": "inherit", + "inheritDefault": "hidden" + } + }, + "idf.openOcdConfigs": [ + "board/esp32h2-builtin.cfg" + ], + "idf.port": "/dev/ttyACM0", + "idf.currentSetup": "/home/bruno/.espressif/v6.0/esp-idf", + "idf.customExtraVars": { + "IDF_TARGET": "esp32h2" + }, + "idf.flashType": "UART" +} diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..01fb17c --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,6 @@ +# The following five lines of boilerplate have to be in your project's +# CMakeLists in this exact order for cmake to work correctly +cmake_minimum_required(VERSION 3.22) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +project(pager) diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt new file mode 100644 index 0000000..cf2c455 --- /dev/null +++ b/main/CMakeLists.txt @@ -0,0 +1,2 @@ +idf_component_register(SRCS "main.c" + INCLUDE_DIRS ".") diff --git a/main/main.c b/main/main.c new file mode 100644 index 0000000..5a38137 --- /dev/null +++ b/main/main.c @@ -0,0 +1,950 @@ +/* + * 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 +#include +#include +#include +#include + +#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); + } +}