1608 lines
46 KiB
C
1608 lines
46 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=GPIO10,
|
|
* DC=GPIO11, 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"
|
|
#include "led_strip.h"
|
|
#include "esp_adc/adc_oneshot.h"
|
|
#include "esp_adc/adc_cali_scheme.h"
|
|
#include "nvs.h"
|
|
#include "nvs_flash.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
|
|
#define PIN_BUTTON_BOOT GPIO_NUM_9
|
|
#define PIN_BUTTON_UP GPIO_NUM_6
|
|
#define PIN_BUTTON_DOWN GPIO_NUM_7
|
|
#define PIN_BUTTON_SELECT GPIO_NUM_14
|
|
#define PIN_BATTERY_ADC GPIO_NUM_2
|
|
#define PIN_STATUS_LED GPIO_NUM_13
|
|
#define PIN_NEOPIXEL GPIO_NUM_8
|
|
|
|
/* Change this one value to tune the receiver. Rebuild and flash afterwards. */
|
|
#define RF_FREQ_HZ 435000000UL
|
|
#define CC1101_XTAL_HZ 26000000UL
|
|
#define TUNE_MIN_HZ 433000000UL
|
|
#define TUNE_MAX_HZ 435500000UL
|
|
#define TUNE_STEP_HZ 25000UL
|
|
#define MY_RIC 1234567UL
|
|
#define OLED_IDLE_OFF_MS 60000U
|
|
#define OWN_PAGE_ALERT_MS 3000U
|
|
|
|
/* Enable after wiring BAT+ through a divider to GPIO2 and BAT- to GND. */
|
|
#define BATTERY_MONITOR_ENABLE 0
|
|
#define BATTERY_DIVIDER_TOP_OHMS 100000U
|
|
#define BATTERY_DIVIDER_BOTTOM_OHMS 100000U
|
|
|
|
#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 led_strip_handle_t neopixel;
|
|
static unsigned display_baud;
|
|
static uint32_t radio_frequency_hz = RF_FREQ_HZ;
|
|
static bool oled_is_on = true;
|
|
static TickType_t ui_last_activity;
|
|
|
|
#if BATTERY_MONITOR_ENABLE
|
|
static bool battery_voltage_valid;
|
|
static uint32_t battery_voltage_mv;
|
|
static adc_oneshot_unit_handle_t battery_adc_unit;
|
|
static adc_cali_handle_t battery_adc_calibration;
|
|
static adc_channel_t battery_adc_channel;
|
|
static bool battery_adc_ready;
|
|
#endif
|
|
|
|
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(radio_frequency_hz);
|
|
ESP_LOGI(TAG, "RF target=%lu Hz, actual=%lu Hz, crystal=%lu Hz",
|
|
(unsigned long)radio_frequency_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));
|
|
}
|
|
|
|
static void cc1101_retune(uint32_t frequency_hz)
|
|
{
|
|
cc_strobe(0x36); /* SIDLE */
|
|
cc_strobe(0x3A); /* SFRX */
|
|
radio_frequency_hz = cc1101_set_frequency(frequency_hz);
|
|
cc_strobe(0x33); /* SCAL */
|
|
vTaskDelay(pdMS_TO_TICKS(5));
|
|
cc_strobe(0x34); /* SRX */
|
|
ESP_LOGI(TAG, "Receiver tuned to %lu Hz",
|
|
(unsigned long)radio_frequency_hz);
|
|
}
|
|
|
|
/* ------------------------------ 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_power_on(void)
|
|
{
|
|
if (!oled_is_on) {
|
|
oled_cmd(0xAF);
|
|
oled_is_on = true;
|
|
}
|
|
}
|
|
|
|
static void oled_power_off(void)
|
|
{
|
|
if (oled_is_on) {
|
|
oled_cmd(0xAE);
|
|
oled_is_on = false;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
/* -------------------------- 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 unsigned history_cursor;
|
|
static bool monitor_mode = true;
|
|
static unsigned ui_screen;
|
|
static unsigned menu_cursor;
|
|
static bool live_page;
|
|
static unsigned text_page;
|
|
static nvs_handle_t history_nvs;
|
|
static bool history_nvs_ready;
|
|
|
|
#define HISTORY_STORAGE_VERSION 1U
|
|
#define HISTORY_NVS_NAMESPACE "pager"
|
|
#define HISTORY_NVS_KEY "history"
|
|
|
|
typedef struct {
|
|
uint32_t version;
|
|
uint32_t count;
|
|
uint32_t head;
|
|
pager_message_t entries[HISTORY_COUNT];
|
|
} history_storage_t;
|
|
|
|
static void ui_render(void);
|
|
static void ui_note_activity(void);
|
|
|
|
static void history_storage_save(void)
|
|
{
|
|
if (!history_nvs_ready)
|
|
return;
|
|
|
|
history_storage_t storage = {
|
|
.version = HISTORY_STORAGE_VERSION,
|
|
.count = history_count,
|
|
.head = history_head,
|
|
};
|
|
memcpy(storage.entries, history, sizeof(history));
|
|
|
|
esp_err_t err = nvs_set_blob(history_nvs, HISTORY_NVS_KEY,
|
|
&storage, sizeof(storage));
|
|
if (err == ESP_OK)
|
|
err = nvs_commit(history_nvs);
|
|
if (err != ESP_OK)
|
|
ESP_LOGE(TAG, "Could not save message history: %s",
|
|
esp_err_to_name(err));
|
|
}
|
|
|
|
static void history_storage_init(void)
|
|
{
|
|
esp_err_t err = nvs_flash_init();
|
|
if (err == ESP_ERR_NVS_NO_FREE_PAGES ||
|
|
err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
|
|
ESP_ERROR_CHECK(nvs_flash_erase());
|
|
err = nvs_flash_init();
|
|
}
|
|
ESP_ERROR_CHECK(err);
|
|
ESP_ERROR_CHECK(nvs_open(HISTORY_NVS_NAMESPACE, NVS_READWRITE,
|
|
&history_nvs));
|
|
history_nvs_ready = true;
|
|
|
|
history_storage_t storage;
|
|
size_t size = sizeof(storage);
|
|
err = nvs_get_blob(history_nvs, HISTORY_NVS_KEY, &storage, &size);
|
|
if (err == ESP_ERR_NVS_NOT_FOUND)
|
|
return;
|
|
if (err != ESP_OK || size != sizeof(storage) ||
|
|
storage.version != HISTORY_STORAGE_VERSION ||
|
|
storage.count > HISTORY_COUNT || storage.head >= HISTORY_COUNT) {
|
|
ESP_LOGW(TAG, "Saved history is invalid; starting with empty history");
|
|
return;
|
|
}
|
|
|
|
memcpy(history, storage.entries, sizeof(history));
|
|
history_count = storage.count;
|
|
history_head = storage.head;
|
|
for (unsigned i = 0; i < HISTORY_COUNT; i++)
|
|
history[i].text[MESSAGE_SIZE - 1U] = '\0';
|
|
ESP_LOGI(TAG, "Restored %u saved messages", history_count);
|
|
}
|
|
|
|
static void history_add(uint32_t ric, unsigned baud, unsigned function,
|
|
const char *text)
|
|
{
|
|
if (!text || !text[0])
|
|
return;
|
|
if (!monitor_mode && ric != MY_RIC)
|
|
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++;
|
|
|
|
history_cursor = 0;
|
|
history_storage_save();
|
|
ui_note_activity();
|
|
ESP_LOGI(TAG, "PAGER RIC=%lu function=%u baud=%u: %s",
|
|
(unsigned long)ric, function, baud, text);
|
|
ui_render();
|
|
}
|
|
|
|
/* ------------------------------- 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',' ','-','[',']','?'
|
|
};
|
|
|
|
enum {
|
|
UI_LIVE,
|
|
UI_HISTORY,
|
|
UI_MENU,
|
|
UI_TUNE
|
|
};
|
|
|
|
static TickType_t page_alert_until;
|
|
static TickType_t alert_toggle_at;
|
|
static bool alert_led_on;
|
|
static bool alert_output_state;
|
|
static bool alert_output_initialized;
|
|
static unsigned menu_return_screen;
|
|
static uint32_t tune_candidate_hz;
|
|
|
|
typedef enum {
|
|
BUTTON_BOOT,
|
|
BUTTON_UP,
|
|
BUTTON_DOWN,
|
|
BUTTON_SELECT,
|
|
BUTTON_COUNT
|
|
} ui_button_id_t;
|
|
|
|
typedef struct {
|
|
gpio_num_t pin;
|
|
int last_level;
|
|
bool down;
|
|
TickType_t debounce_at;
|
|
TickType_t pressed_at;
|
|
} ui_button_state_t;
|
|
|
|
static ui_button_state_t ui_buttons[BUTTON_COUNT] = {
|
|
[BUTTON_BOOT] = {.pin = PIN_BUTTON_BOOT, .last_level = 1},
|
|
[BUTTON_UP] = {.pin = PIN_BUTTON_UP, .last_level = 1},
|
|
[BUTTON_DOWN] = {.pin = PIN_BUTTON_DOWN, .last_level = 1},
|
|
[BUTTON_SELECT] = {.pin = PIN_BUTTON_SELECT, .last_level = 1},
|
|
};
|
|
|
|
static pager_message_t *history_at_age(unsigned age)
|
|
{
|
|
if (age >= history_count)
|
|
return NULL;
|
|
unsigned index = (history_head + HISTORY_COUNT - 1U - age)
|
|
% HISTORY_COUNT;
|
|
return &history[index];
|
|
}
|
|
|
|
static void ui_note_activity(void)
|
|
{
|
|
ui_last_activity = xTaskGetTickCount();
|
|
oled_power_on();
|
|
}
|
|
|
|
static unsigned text_page_count(size_t length)
|
|
{
|
|
return length ? (unsigned)((length + 83U) / 84U) : 1U;
|
|
}
|
|
|
|
static void oled_draw_text_page(int y, const char *text, unsigned page)
|
|
{
|
|
size_t offset = (size_t)page * 84U;
|
|
size_t length = strlen(text);
|
|
if (offset >= length)
|
|
return;
|
|
|
|
text += offset;
|
|
for (unsigned row = 0; row < 4U && *text; row++) {
|
|
char line[22];
|
|
size_t count = strnlen(text, 21U);
|
|
memcpy(line, text, count);
|
|
line[count] = '\0';
|
|
oled_text(0, y + (int)row * 8, line);
|
|
text += count;
|
|
}
|
|
}
|
|
|
|
static void ui_draw_live(void)
|
|
{
|
|
char line[32];
|
|
oled_text(0, 0, monitor_mode ? "POCSAG MONITOR" : "MY PAGER");
|
|
#if BATTERY_MONITOR_ENABLE
|
|
if (battery_voltage_valid) {
|
|
snprintf(line, sizeof(line), "RIC %lu BAT %u.%02uV",
|
|
(unsigned long)MY_RIC,
|
|
(unsigned)(battery_voltage_mv / 1000U),
|
|
(unsigned)((battery_voltage_mv % 1000U) / 10U));
|
|
} else {
|
|
snprintf(line, sizeof(line), "RIC %lu BAT --",
|
|
(unsigned long)MY_RIC);
|
|
}
|
|
#else
|
|
snprintf(line, sizeof(line), "RIC %lu", (unsigned long)MY_RIC);
|
|
#endif
|
|
oled_text(0, 9, line);
|
|
|
|
if (live_page && message_active) {
|
|
unsigned pages = text_page_count(message_len);
|
|
if (text_page >= pages)
|
|
text_page = 0;
|
|
snprintf(line, sizeof(line), "RX %lu F%u %u/%u",
|
|
(unsigned long)current_ric, current_function,
|
|
text_page + 1U, pages);
|
|
oled_text(0, 18, line);
|
|
oled_draw_text_page(27, message, text_page);
|
|
return;
|
|
}
|
|
|
|
pager_message_t *latest = history_at_age(0);
|
|
if (latest) {
|
|
snprintf(line, sizeof(line), "LAST %lu F%u",
|
|
(unsigned long)latest->ric, latest->function);
|
|
oled_text(0, 20, line);
|
|
unsigned pages = text_page_count(strlen(latest->text));
|
|
if (text_page >= pages)
|
|
text_page = 0;
|
|
snprintf(line, sizeof(line), "PAGE %u/%u", text_page + 1U, pages);
|
|
oled_text(78, 20, line);
|
|
oled_draw_text_page(31, latest->text, text_page);
|
|
} else {
|
|
oled_text(0, 25, display_baud ? "WAITING FOR PAGE" : "WAITING FOR RF");
|
|
}
|
|
}
|
|
|
|
static void ui_draw_history(void)
|
|
{
|
|
char line[24];
|
|
pager_message_t *entry = history_at_age(history_cursor);
|
|
oled_text(0, 0, "MESSAGE HISTORY");
|
|
if (!entry) {
|
|
oled_text(0, 18, "NO SAVED PAGES");
|
|
oled_text(0, 52, "HOLD FOR MENU");
|
|
return;
|
|
}
|
|
|
|
snprintf(line, sizeof(line), "%u/%u RIC %lu", history_cursor + 1U,
|
|
history_count, (unsigned long)entry->ric);
|
|
oled_text(0, 10, line);
|
|
snprintf(line, sizeof(line), "F%u %u BAUD", entry->function, entry->baud);
|
|
oled_text(0, 19, line);
|
|
unsigned pages = text_page_count(strlen(entry->text));
|
|
if (text_page >= pages)
|
|
text_page = 0;
|
|
snprintf(line, sizeof(line), "PAGE %u/%u", text_page + 1U, pages);
|
|
oled_text(78, 19, line);
|
|
oled_draw_text_page(30, entry->text, text_page);
|
|
}
|
|
|
|
static void ui_draw_menu(void)
|
|
{
|
|
static const uint8_t cursor_rows[7] = {
|
|
0x01, 0x02, 0x04, 0x08, 0x04, 0x02, 0x01
|
|
};
|
|
char frequency_item[24];
|
|
snprintf(frequency_item, sizeof(frequency_item), "FREQ %lu.%03lu MHZ",
|
|
(unsigned long)(radio_frequency_hz / 1000000UL),
|
|
(unsigned long)((radio_frequency_hz / 1000UL) % 1000UL));
|
|
const char *items[] = {
|
|
monitor_mode ? "FILTER: ALL RIC" : "FILTER: MY RIC",
|
|
frequency_item,
|
|
"LIVE DISPLAY",
|
|
"MESSAGE HISTORY",
|
|
"RETURN"
|
|
};
|
|
oled_text(0, 0, "PAGER MENU");
|
|
for (unsigned i = 0; i < 5; i++) {
|
|
int y = 8 + (int)i * 8;
|
|
if (i == menu_cursor) {
|
|
for (int row = 0; row < 7; row++) {
|
|
for (int col = 0; col < 5; col++) {
|
|
if (cursor_rows[row] & (1U << col))
|
|
oled_pixel(col, y + row);
|
|
}
|
|
}
|
|
}
|
|
oled_text(8, y, items[i]);
|
|
}
|
|
oled_text(0, 49, "UP/DN MOVE; SEL OK");
|
|
oled_text(0, 57, "BOOT TAP NEXT / HOLD");
|
|
}
|
|
|
|
static void ui_draw_tune(void)
|
|
{
|
|
char line[24];
|
|
oled_text(0, 0, "RECEIVER TUNING");
|
|
snprintf(line, sizeof(line), "%lu.%03lu MHZ",
|
|
(unsigned long)(tune_candidate_hz / 1000000UL),
|
|
(unsigned long)((tune_candidate_hz / 1000UL) % 1000UL));
|
|
oled_text(0, 19, line);
|
|
oled_text(0, 32, "STEP 25 KHZ");
|
|
oled_text(0, 49, "TAP NEXT / HOLD SET");
|
|
}
|
|
|
|
static void ui_render(void)
|
|
{
|
|
if (!oled_is_on)
|
|
oled_power_on();
|
|
oled_clear();
|
|
if (ui_screen == UI_MENU)
|
|
ui_draw_menu();
|
|
else if (ui_screen == UI_HISTORY)
|
|
ui_draw_history();
|
|
else if (ui_screen == UI_TUNE)
|
|
ui_draw_tune();
|
|
else
|
|
ui_draw_live();
|
|
oled_flush();
|
|
}
|
|
|
|
static void oled_draw_history(void)
|
|
{
|
|
ui_render();
|
|
}
|
|
|
|
static void ui_short_press(void)
|
|
{
|
|
ui_note_activity();
|
|
if (ui_screen == UI_MENU) {
|
|
menu_cursor = (menu_cursor + 1U) % 5U;
|
|
} else if (ui_screen == UI_TUNE) {
|
|
tune_candidate_hz += TUNE_STEP_HZ;
|
|
if (tune_candidate_hz > TUNE_MAX_HZ)
|
|
tune_candidate_hz = TUNE_MIN_HZ;
|
|
} else if (ui_screen == UI_LIVE) {
|
|
if (live_page && message_active &&
|
|
text_page + 1U < text_page_count(message_len)) {
|
|
text_page++;
|
|
} else {
|
|
ui_screen = UI_HISTORY;
|
|
history_cursor = 0;
|
|
text_page = 0;
|
|
}
|
|
} else if (history_count) {
|
|
pager_message_t *entry = history_at_age(history_cursor);
|
|
if (entry && text_page + 1U < text_page_count(strlen(entry->text))) {
|
|
text_page++;
|
|
} else {
|
|
history_cursor = (history_cursor + 1U) % history_count;
|
|
text_page = 0;
|
|
}
|
|
} else {
|
|
ui_screen = UI_LIVE;
|
|
}
|
|
ui_render();
|
|
}
|
|
|
|
static void ui_long_press(void)
|
|
{
|
|
ui_note_activity();
|
|
if (ui_screen == UI_TUNE) {
|
|
cc1101_retune(tune_candidate_hz);
|
|
ui_screen = UI_MENU;
|
|
ui_render();
|
|
return;
|
|
}
|
|
if (ui_screen != UI_MENU) {
|
|
menu_return_screen = ui_screen;
|
|
ui_screen = UI_MENU;
|
|
menu_cursor = 0;
|
|
ui_render();
|
|
return;
|
|
}
|
|
|
|
switch (menu_cursor) {
|
|
case 0:
|
|
monitor_mode = !monitor_mode;
|
|
history_count = 0;
|
|
history_head = 0;
|
|
history_cursor = 0;
|
|
text_page = 0;
|
|
history_storage_save();
|
|
break;
|
|
case 1:
|
|
tune_candidate_hz = radio_frequency_hz;
|
|
ui_screen = UI_TUNE;
|
|
break;
|
|
case 2:
|
|
ui_screen = UI_LIVE;
|
|
break;
|
|
case 3:
|
|
ui_screen = UI_HISTORY;
|
|
history_cursor = 0;
|
|
text_page = 0;
|
|
break;
|
|
default:
|
|
ui_screen = menu_return_screen;
|
|
break;
|
|
}
|
|
ui_render();
|
|
}
|
|
|
|
static void ui_handle_button(ui_button_id_t button, bool long_press)
|
|
{
|
|
if (button == BUTTON_BOOT) {
|
|
if (long_press)
|
|
ui_long_press();
|
|
else
|
|
ui_short_press();
|
|
return;
|
|
}
|
|
|
|
if (button == BUTTON_SELECT) {
|
|
if (ui_screen == UI_MENU || ui_screen == UI_TUNE) {
|
|
ui_long_press();
|
|
} else if (ui_screen == UI_HISTORY) {
|
|
ui_screen = UI_LIVE;
|
|
ui_note_activity();
|
|
ui_render();
|
|
} else {
|
|
ui_screen = UI_HISTORY;
|
|
history_cursor = 0;
|
|
text_page = 0;
|
|
ui_note_activity();
|
|
ui_render();
|
|
}
|
|
return;
|
|
}
|
|
|
|
ui_note_activity();
|
|
if (ui_screen == UI_MENU) {
|
|
if (button == BUTTON_UP)
|
|
menu_cursor = (menu_cursor + 4U) % 5U;
|
|
else
|
|
menu_cursor = (menu_cursor + 1U) % 5U;
|
|
} else if (ui_screen == UI_TUNE) {
|
|
if (button == BUTTON_UP) {
|
|
tune_candidate_hz = tune_candidate_hz <= TUNE_MIN_HZ + TUNE_STEP_HZ
|
|
? TUNE_MAX_HZ : tune_candidate_hz - TUNE_STEP_HZ;
|
|
} else {
|
|
tune_candidate_hz = tune_candidate_hz >= TUNE_MAX_HZ
|
|
? TUNE_MIN_HZ : tune_candidate_hz + TUNE_STEP_HZ;
|
|
}
|
|
} else if (history_count) {
|
|
if (ui_screen == UI_LIVE) {
|
|
ui_screen = UI_HISTORY;
|
|
history_cursor = 0;
|
|
} else if (button == BUTTON_UP) {
|
|
history_cursor = (history_cursor + 1U) % history_count;
|
|
} else {
|
|
history_cursor = (history_cursor + history_count - 1U)
|
|
% history_count;
|
|
}
|
|
text_page = 0;
|
|
}
|
|
ui_render();
|
|
}
|
|
|
|
static void ui_poll_button(void)
|
|
{
|
|
TickType_t now = xTaskGetTickCount();
|
|
for (unsigned i = 0; i < BUTTON_COUNT; i++) {
|
|
ui_button_state_t *button = &ui_buttons[i];
|
|
int level = gpio_get_level(button->pin);
|
|
if (level != button->last_level) {
|
|
button->last_level = level;
|
|
button->debounce_at = now;
|
|
continue;
|
|
}
|
|
if (now - button->debounce_at < pdMS_TO_TICKS(30))
|
|
continue;
|
|
|
|
if (level == 0 && !button->down) {
|
|
button->down = true;
|
|
button->pressed_at = now;
|
|
} else if (level != 0 && button->down) {
|
|
button->down = false;
|
|
bool long_press = now - button->pressed_at >= pdMS_TO_TICKS(700);
|
|
ui_handle_button((ui_button_id_t)i, long_press);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ui_idle_power_down(void)
|
|
{
|
|
if (oled_is_on &&
|
|
xTaskGetTickCount() - ui_last_activity >= pdMS_TO_TICKS(OLED_IDLE_OFF_MS))
|
|
oled_power_off();
|
|
}
|
|
|
|
static void ui_start_own_page_alert(void)
|
|
{
|
|
TickType_t now = xTaskGetTickCount();
|
|
page_alert_until = now + pdMS_TO_TICKS(OWN_PAGE_ALERT_MS);
|
|
alert_toggle_at = now;
|
|
alert_led_on = false;
|
|
}
|
|
|
|
static void ui_update_alert(void)
|
|
{
|
|
TickType_t now = xTaskGetTickCount();
|
|
if ((int32_t)(now - page_alert_until) >= 0) {
|
|
alert_led_on = false;
|
|
} else if ((int32_t)(now - alert_toggle_at) >= 0) {
|
|
alert_led_on = !alert_led_on;
|
|
alert_toggle_at = now + pdMS_TO_TICKS(150);
|
|
}
|
|
bool changed = !alert_output_initialized || alert_led_on != alert_output_state;
|
|
if (changed) {
|
|
gpio_set_level(PIN_STATUS_LED, alert_led_on ? 1 : 0);
|
|
if (alert_led_on)
|
|
ESP_ERROR_CHECK(led_strip_set_pixel(neopixel, 0, 255, 24, 0));
|
|
else
|
|
ESP_ERROR_CHECK(led_strip_clear(neopixel));
|
|
ESP_ERROR_CHECK(led_strip_refresh(neopixel));
|
|
alert_output_state = alert_led_on;
|
|
alert_output_initialized = true;
|
|
}
|
|
}
|
|
|
|
static void ui_hardware_init(void)
|
|
{
|
|
gpio_config_t button_cfg = {
|
|
.pin_bit_mask = (1ULL << PIN_BUTTON_BOOT) |
|
|
(1ULL << PIN_BUTTON_UP) |
|
|
(1ULL << PIN_BUTTON_DOWN) |
|
|
(1ULL << PIN_BUTTON_SELECT),
|
|
.mode = GPIO_MODE_INPUT,
|
|
.pull_up_en = GPIO_PULLUP_ENABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&button_cfg));
|
|
|
|
gpio_config_t led_cfg = {
|
|
.pin_bit_mask = 1ULL << PIN_STATUS_LED,
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&led_cfg));
|
|
gpio_set_level(PIN_STATUS_LED, 0);
|
|
|
|
led_strip_config_t strip_cfg = {
|
|
.strip_gpio_num = PIN_NEOPIXEL,
|
|
.max_leds = 1,
|
|
.led_model = LED_MODEL_WS2812,
|
|
.color_component_format = LED_STRIP_COLOR_COMPONENT_FMT_GRB,
|
|
.flags.invert_out = false,
|
|
};
|
|
led_strip_rmt_config_t rmt_cfg = {
|
|
.clk_src = RMT_CLK_SRC_DEFAULT,
|
|
.resolution_hz = 10000000,
|
|
.mem_block_symbols = 64,
|
|
.flags.with_dma = false,
|
|
};
|
|
ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_cfg, &rmt_cfg, &neopixel));
|
|
ESP_ERROR_CHECK(led_strip_clear(neopixel));
|
|
ESP_ERROR_CHECK(led_strip_refresh(neopixel));
|
|
TickType_t now = xTaskGetTickCount();
|
|
for (unsigned i = 0; i < BUTTON_COUNT; i++) {
|
|
ui_buttons[i].last_level = gpio_get_level(ui_buttons[i].pin);
|
|
ui_buttons[i].debounce_at = now;
|
|
}
|
|
ui_last_activity = now;
|
|
}
|
|
|
|
static void battery_adc_init(void)
|
|
{
|
|
#if BATTERY_MONITOR_ENABLE
|
|
adc_unit_t unit;
|
|
ESP_ERROR_CHECK(adc_oneshot_io_to_channel(PIN_BATTERY_ADC,
|
|
&unit,
|
|
&battery_adc_channel));
|
|
|
|
adc_oneshot_unit_init_cfg_t unit_config = {
|
|
.unit_id = unit,
|
|
.ulp_mode = ADC_ULP_MODE_DISABLE,
|
|
};
|
|
ESP_ERROR_CHECK(adc_oneshot_new_unit(&unit_config, &battery_adc_unit));
|
|
|
|
adc_oneshot_chan_cfg_t channel_config = {
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
};
|
|
ESP_ERROR_CHECK(adc_oneshot_config_channel(battery_adc_unit,
|
|
battery_adc_channel,
|
|
&channel_config));
|
|
|
|
adc_cali_curve_fitting_config_t calibration_config = {
|
|
.unit_id = unit,
|
|
.chan = battery_adc_channel,
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
};
|
|
esp_err_t err = adc_cali_create_scheme_curve_fitting(
|
|
&calibration_config, &battery_adc_calibration);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(TAG, "Battery ADC calibration unavailable: %s",
|
|
esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
battery_adc_ready = true;
|
|
#endif
|
|
}
|
|
|
|
static void battery_adc_update(void)
|
|
{
|
|
#if BATTERY_MONITOR_ENABLE
|
|
if (!battery_adc_ready)
|
|
return;
|
|
|
|
int adc_pin_mv;
|
|
esp_err_t err = adc_oneshot_get_calibrated_result(battery_adc_unit,
|
|
battery_adc_calibration,
|
|
battery_adc_channel,
|
|
&adc_pin_mv);
|
|
if (err != ESP_OK)
|
|
return;
|
|
|
|
uint64_t divider_total = (uint64_t)BATTERY_DIVIDER_TOP_OHMS +
|
|
BATTERY_DIVIDER_BOTTOM_OHMS;
|
|
battery_voltage_mv = (uint32_t)(((uint64_t)adc_pin_mv * divider_total +
|
|
BATTERY_DIVIDER_BOTTOM_OHMS / 2U) /
|
|
BATTERY_DIVIDER_BOTTOM_OHMS);
|
|
battery_voltage_valid = true;
|
|
ESP_LOGI(TAG, "Battery: %u mV", (unsigned)battery_voltage_mv);
|
|
if (ui_screen == UI_LIVE)
|
|
ui_render();
|
|
#endif
|
|
}
|
|
|
|
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;
|
|
live_page = false;
|
|
text_page = 0;
|
|
ui_render();
|
|
}
|
|
|
|
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;
|
|
live_page = false;
|
|
}
|
|
|
|
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;
|
|
live_page = monitor_mode || current_ric == MY_RIC;
|
|
text_page = 0;
|
|
if (current_ric == MY_RIC)
|
|
ui_start_own_page_alert();
|
|
if (live_page) {
|
|
ui_screen = UI_LIVE;
|
|
ui_note_activity();
|
|
}
|
|
|
|
if (monitor_mode || current_ric == MY_RIC) {
|
|
ESP_LOGI(TAG, "Address RIC=%lu function=%u",
|
|
(unsigned long)current_ric, current_function);
|
|
}
|
|
if (live_page)
|
|
ui_render();
|
|
} else if (message_active) {
|
|
if (current_function <= 1)
|
|
decode_numeric(payload);
|
|
else
|
|
decode_alpha(payload);
|
|
if (live_page && ui_screen == UI_LIVE) {
|
|
ui_note_activity();
|
|
ui_render();
|
|
}
|
|
}
|
|
}
|
|
|
|
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");
|
|
history_storage_init();
|
|
|
|
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();
|
|
ui_hardware_init();
|
|
battery_adc_init();
|
|
ui_screen = UI_LIVE;
|
|
ui_render();
|
|
|
|
bch_init();
|
|
cc1101_init();
|
|
ui_render();
|
|
|
|
start_sampler();
|
|
|
|
TickType_t last_status = xTaskGetTickCount();
|
|
TickType_t last_battery_read = last_status;
|
|
|
|
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);
|
|
}
|
|
|
|
ui_poll_button();
|
|
ui_update_alert();
|
|
ui_idle_power_down();
|
|
|
|
if (xTaskGetTickCount() - last_battery_read >= pdMS_TO_TICKS(5000)) {
|
|
last_battery_read = xTaskGetTickCount();
|
|
battery_adc_update();
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|