Init
This commit is contained in:
No files matched your search
@@ -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"]
|
||||
@@ -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"]
|
||||
}
|
||||
+78
@@ -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
|
||||
Vendored
+20
@@ -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
|
||||
}
|
||||
Vendored
+10
@@ -0,0 +1,10 @@
|
||||
{
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"type": "gdbtarget",
|
||||
"request": "attach",
|
||||
"name": "Eclipse CDT GDB Adapter"
|
||||
}
|
||||
]
|
||||
}
|
||||
Vendored
+31
@@ -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"
|
||||
}
|
||||
@@ -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)
|
||||
@@ -0,0 +1,2 @@
|
||||
idf_component_register(SRCS "main.c"
|
||||
INCLUDE_DIRS ".")
|
||||
+950
@@ -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 <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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user