firmware: SX1262 GFSK wM-Bus C1 repeater, dev tooling, discovery scripts
This commit is contained in:
@@ -0,0 +1,454 @@
|
||||
#include "sx126x.h"
|
||||
#include "board.h"
|
||||
|
||||
#include <string.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "driver/spi_master.h"
|
||||
#include "driver/gpio.h"
|
||||
#include "esp_timer.h"
|
||||
#include "esp_rom_sys.h"
|
||||
|
||||
// ---- opcodes ----
|
||||
#define OP_SET_SLEEP 0x84
|
||||
#define OP_SET_STANDBY 0x80
|
||||
#define OP_SET_FS 0xC1
|
||||
#define OP_SET_TX 0x83
|
||||
#define OP_SET_RX 0x82
|
||||
#define OP_SET_PACKET_TYPE 0x8A
|
||||
#define OP_GET_PACKET_TYPE 0x11
|
||||
#define OP_SET_RF_FREQUENCY 0x86
|
||||
#define OP_SET_PA_CONFIG 0x95
|
||||
#define OP_SET_TX_PARAMS 0x8E
|
||||
#define OP_SET_MODULATION 0x8B
|
||||
#define OP_SET_PACKET_PARAMS 0x8C
|
||||
#define OP_SET_BUFFER_BASE 0x8F
|
||||
#define OP_WRITE_BUFFER 0x0E
|
||||
#define OP_READ_BUFFER 0x1E
|
||||
#define OP_WRITE_REGISTER 0x0D
|
||||
#define OP_READ_REGISTER 0x1D
|
||||
#define OP_SET_DIO_IRQ_PARAMS 0x08
|
||||
#define OP_GET_IRQ_STATUS 0x12
|
||||
#define OP_CLEAR_IRQ_STATUS 0x02
|
||||
#define OP_SET_DIO2_RF_SWITCH 0x9D
|
||||
#define OP_SET_DIO3_TCXO_CTRL 0x97
|
||||
#define OP_CALIBRATE 0x89
|
||||
#define OP_CALIBRATE_IMAGE 0x98
|
||||
#define OP_GET_STATUS 0xC0
|
||||
#define OP_GET_RX_BUFFER_STATUS 0x13
|
||||
#define OP_GET_PACKET_STATUS 0x14
|
||||
#define OP_GET_RSSI_INST 0x15
|
||||
#define OP_GET_DEVICE_ERRORS 0x17
|
||||
#define OP_CLEAR_DEVICE_ERRORS 0x07
|
||||
#define OP_SET_REGULATOR_MODE 0x96
|
||||
#define OP_SET_RXTX_FALLBACK 0x93
|
||||
|
||||
// ---- registers ----
|
||||
#define REG_SYNCWORD_0 0x06C0
|
||||
#define REG_OCP 0x08E7
|
||||
#define REG_RX_GAIN 0x08AC
|
||||
|
||||
#define BUSY_TIMEOUT_US 20000
|
||||
|
||||
static spi_device_handle_t s_spi;
|
||||
static sx126x_irq_cb_t s_irq_cb;
|
||||
static uint8_t s_rx_payload_len = 255;
|
||||
static int8_t s_tx_dbm = -9;
|
||||
static SemaphoreHandle_t s_lock; // serializes SPI access across tasks
|
||||
|
||||
// ---------------------------------------------------------------- low level
|
||||
|
||||
static bool busy_wait(void)
|
||||
{
|
||||
int64_t t0 = esp_timer_get_time();
|
||||
while (gpio_get_level(BOARD_LORA_BUSY)) {
|
||||
if (esp_timer_get_time() - t0 > BUSY_TIMEOUT_US) return false;
|
||||
esp_rom_delay_us(5);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool xfer(const uint8_t *tx, uint8_t *rx, size_t len)
|
||||
{
|
||||
if (s_lock) xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
bool ok = false;
|
||||
if (busy_wait()) {
|
||||
spi_transaction_t t = {
|
||||
.length = len * 8,
|
||||
.tx_buffer = tx,
|
||||
.rx_buffer = rx,
|
||||
};
|
||||
ok = spi_device_polling_transmit(s_spi, &t) == ESP_OK;
|
||||
}
|
||||
if (s_lock) xSemaphoreGive(s_lock);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static bool cmd(uint8_t op, const uint8_t *args, size_t n)
|
||||
{
|
||||
uint8_t buf[16];
|
||||
if (n + 1 > sizeof(buf)) return false;
|
||||
buf[0] = op;
|
||||
if (n) memcpy(buf + 1, args, n);
|
||||
return xfer(buf, NULL, n + 1);
|
||||
}
|
||||
|
||||
static bool cmd_read(uint8_t op, uint8_t *out, size_t n)
|
||||
{
|
||||
// op + status byte + n data
|
||||
uint8_t tx[20] = {0}, rx[20] = {0};
|
||||
if (n + 2 > sizeof(tx)) return false;
|
||||
tx[0] = op;
|
||||
if (!xfer(tx, rx, n + 2)) return false;
|
||||
memcpy(out, rx + 2, n);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool write_regs(uint16_t addr, const uint8_t *data, size_t n)
|
||||
{
|
||||
uint8_t buf[16];
|
||||
if (n + 3 > sizeof(buf)) return false;
|
||||
buf[0] = OP_WRITE_REGISTER;
|
||||
buf[1] = addr >> 8;
|
||||
buf[2] = addr & 0xFF;
|
||||
memcpy(buf + 3, data, n);
|
||||
return xfer(buf, NULL, n + 3);
|
||||
}
|
||||
|
||||
static bool read_regs(uint16_t addr, uint8_t *out, size_t n)
|
||||
{
|
||||
uint8_t tx[20] = {0}, rx[20] = {0};
|
||||
if (n + 4 > sizeof(tx)) return false;
|
||||
tx[0] = OP_READ_REGISTER;
|
||||
tx[1] = addr >> 8;
|
||||
tx[2] = addr & 0xFF;
|
||||
// byte 3 is a NOP/status byte before data
|
||||
if (!xfer(tx, rx, n + 4)) return false;
|
||||
memcpy(out, rx + 4, n);
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- FEM
|
||||
|
||||
void fem_power(bool on)
|
||||
{
|
||||
gpio_set_level(BOARD_FEM_PWR_EN, on);
|
||||
gpio_set_level(BOARD_FEM_CSD, on);
|
||||
if (!on) gpio_set_level(BOARD_FEM_CTX, 0);
|
||||
}
|
||||
|
||||
void fem_set_tx(bool tx)
|
||||
{
|
||||
// KCT8103L: CTX HIGH = TX/PA path, LOW = RX/LNA path. CPS is driven by
|
||||
// SX1262 DIO2 (DIO2-as-RF-switch), which the radio raises during TX.
|
||||
gpio_set_level(BOARD_FEM_CTX, tx);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- IRQ
|
||||
|
||||
static void IRAM_ATTR dio1_isr(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
if (s_irq_cb) s_irq_cb(esp_timer_get_time());
|
||||
}
|
||||
|
||||
void sx126x_set_irq_callback(sx126x_irq_cb_t cb) { s_irq_cb = cb; }
|
||||
|
||||
// ---------------------------------------------------------------- init
|
||||
|
||||
static bool radio_reset(void)
|
||||
{
|
||||
gpio_set_level(BOARD_LORA_RESET, 0);
|
||||
vTaskDelay(pdMS_TO_TICKS(2));
|
||||
gpio_set_level(BOARD_LORA_RESET, 1);
|
||||
vTaskDelay(pdMS_TO_TICKS(5));
|
||||
return busy_wait();
|
||||
}
|
||||
|
||||
bool sx126x_init(sx126x_diag_t *diag)
|
||||
{
|
||||
memset(diag, 0, sizeof(*diag));
|
||||
|
||||
// GPIO setup
|
||||
gpio_config_t out_cfg = {
|
||||
.pin_bit_mask = (1ULL << BOARD_LORA_RESET) | (1ULL << BOARD_FEM_PWR_EN) |
|
||||
(1ULL << BOARD_FEM_CSD) | (1ULL << BOARD_FEM_CTX),
|
||||
.mode = GPIO_MODE_OUTPUT,
|
||||
};
|
||||
gpio_config(&out_cfg);
|
||||
gpio_config_t in_cfg = {
|
||||
.pin_bit_mask = (1ULL << BOARD_LORA_BUSY),
|
||||
.mode = GPIO_MODE_INPUT,
|
||||
};
|
||||
gpio_config(&in_cfg);
|
||||
gpio_config_t irq_cfg = {
|
||||
.pin_bit_mask = (1ULL << BOARD_LORA_DIO1),
|
||||
.mode = GPIO_MODE_INPUT,
|
||||
.intr_type = GPIO_INTR_POSEDGE,
|
||||
};
|
||||
gpio_config(&irq_cfg);
|
||||
gpio_install_isr_service(0);
|
||||
gpio_isr_handler_add(BOARD_LORA_DIO1, dio1_isr, NULL);
|
||||
|
||||
// FEM: power up, enable, RX path
|
||||
gpio_set_level(BOARD_LORA_RESET, 1);
|
||||
fem_power(true);
|
||||
fem_set_tx(false);
|
||||
vTaskDelay(pdMS_TO_TICKS(5));
|
||||
|
||||
// SPI
|
||||
if (!s_lock) s_lock = xSemaphoreCreateMutex();
|
||||
if (!s_spi) {
|
||||
spi_bus_config_t bus = {
|
||||
.sclk_io_num = BOARD_LORA_SCK,
|
||||
.mosi_io_num = BOARD_LORA_MOSI,
|
||||
.miso_io_num = BOARD_LORA_MISO,
|
||||
.quadwp_io_num = -1,
|
||||
.quadhd_io_num = -1,
|
||||
.max_transfer_sz = 300,
|
||||
};
|
||||
if (spi_bus_initialize(SPI2_HOST, &bus, SPI_DMA_CH_AUTO) != ESP_OK) return false;
|
||||
spi_device_interface_config_t dev = {
|
||||
.clock_speed_hz = 8 * 1000 * 1000,
|
||||
.mode = 0,
|
||||
.spics_io_num = BOARD_LORA_NSS,
|
||||
.queue_size = 2,
|
||||
};
|
||||
if (spi_bus_add_device(SPI2_HOST, &dev, &s_spi) != ESP_OK) return false;
|
||||
}
|
||||
|
||||
diag->reset_ok = radio_reset();
|
||||
diag->busy_ok = (gpio_get_level(BOARD_LORA_BUSY) == 0);
|
||||
|
||||
// standby RC
|
||||
uint8_t stdby = 0x00;
|
||||
cmd(OP_SET_STANDBY, &stdby, 1);
|
||||
|
||||
// SPI sanity: write + readback sync word registers
|
||||
uint8_t probe[2] = {0x54, 0x3D}, verify[2] = {0, 0};
|
||||
write_regs(REG_SYNCWORD_0, probe, 2);
|
||||
read_regs(REG_SYNCWORD_0, verify, 2);
|
||||
diag->spi_ok = (verify[0] == 0x54 && verify[1] == 0x3D);
|
||||
|
||||
// TCXO on DIO3 (1.8 V, ~4 ms), then recalibrate everything because
|
||||
// enabling the TCXO invalidates the RC-based calibration.
|
||||
uint8_t tcxo[4] = {BOARD_TCXO_VOLTAGE_CODE, 0x00, 0x00, BOARD_TCXO_DELAY_STEPS};
|
||||
cmd(OP_SET_DIO3_TCXO_CTRL, tcxo, 4);
|
||||
uint8_t calib = 0x7F;
|
||||
cmd(OP_CALIBRATE, &calib, 1);
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
busy_wait();
|
||||
|
||||
uint16_t errs = sx126x_get_device_errors();
|
||||
diag->device_errors = errs;
|
||||
// XOSC_START_ERR (bit 5) would indicate TCXO trouble
|
||||
diag->tcxo_ok = ((errs & 0x20) == 0);
|
||||
if (errs) cmd(OP_CLEAR_DEVICE_ERRORS, (uint8_t[]){0, 0}, 2);
|
||||
|
||||
// DC-DC regulator (Heltec module has the inductor; RNode uses default LDO,
|
||||
// but SX1262 modules from Heltec are DCDC-capable. Use DCDC for lower
|
||||
// current; fall back to LDO if instability is ever observed.)
|
||||
uint8_t reg = 0x01;
|
||||
cmd(OP_SET_REGULATOR_MODE, ®, 1);
|
||||
|
||||
// DIO2 drives the FEM CPS pin
|
||||
uint8_t dio2 = 0x01;
|
||||
cmd(OP_SET_DIO2_RF_SWITCH, &dio2, 1);
|
||||
|
||||
// fallback to STDBY_RC after TX/RX
|
||||
uint8_t fb = 0x20;
|
||||
cmd(OP_SET_RXTX_FALLBACK, &fb, 1);
|
||||
|
||||
diag->chip_mode = (sx126x_get_status() >> 4) & 0x7;
|
||||
return diag->spi_ok && diag->reset_ok && diag->tcxo_ok;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------- wM-Bus C1
|
||||
|
||||
bool sx126x_config_wmbus_c1(uint32_t freq_hz, uint8_t rx_payload_len)
|
||||
{
|
||||
s_rx_payload_len = rx_payload_len;
|
||||
bool ok = true;
|
||||
|
||||
uint8_t pkt_type = 0x00; // GFSK
|
||||
ok &= cmd(OP_SET_PACKET_TYPE, &pkt_type, 1);
|
||||
|
||||
// image calibration for 863-870 MHz band
|
||||
ok &= cmd(OP_CALIBRATE_IMAGE, (uint8_t[]){0xD7, 0xDB}, 2);
|
||||
|
||||
uint32_t frf = (uint32_t)(((uint64_t)freq_hz << 25) / 32000000ULL);
|
||||
uint8_t f[4] = {frf >> 24, frf >> 16, frf >> 8, frf};
|
||||
ok &= cmd(OP_SET_RF_FREQUENCY, f, 4);
|
||||
|
||||
// PA config for SX1262, +14 dBm optimal table (we run far below that)
|
||||
ok &= cmd(OP_SET_PA_CONFIG, (uint8_t[]){0x02, 0x02, 0x00, 0x01}, 4);
|
||||
ok &= sx126x_set_tx_power(s_tx_dbm);
|
||||
|
||||
// OCP
|
||||
uint8_t ocp = BOARD_SX1262_OCP;
|
||||
ok &= write_regs(REG_OCP, &ocp, 1);
|
||||
|
||||
// Boosted RX gain
|
||||
uint8_t gain = 0x96;
|
||||
ok &= write_regs(REG_RX_GAIN, &gain, 1);
|
||||
|
||||
// Modulation: 100 kbps, no shaping (wM-Bus C is plain FSK),
|
||||
// RX BW 234.3 kHz, fdev 45 kHz
|
||||
// br = 32 * 32e6 / 100e3 = 10240 = 0x002800
|
||||
// fdev = 45e3 * 2^25 / 32e6 = 47186 = 0x00B852
|
||||
uint8_t mod[8] = {
|
||||
0x00, 0x28, 0x00, // bitrate
|
||||
0x00, // no pulse shaping
|
||||
0x0A, // RX BW 234.3 kHz
|
||||
0x00, 0xB8, 0x52, // fdev
|
||||
};
|
||||
ok &= cmd(OP_SET_MODULATION, mod, 8);
|
||||
|
||||
// Sync word = wM-Bus T/C access code 0x543D. The two C-mode "mode bytes"
|
||||
// (54CD = frame A, 543D = frame B) are received/sent as payload so that
|
||||
// RX and TX can share one radio configuration.
|
||||
ok &= write_regs(REG_SYNCWORD_0, (uint8_t[]){0x54, 0x3D}, 2);
|
||||
|
||||
ok &= cmd(OP_SET_BUFFER_BASE, (uint8_t[]){0x00, 0x00}, 2);
|
||||
|
||||
// IRQs on DIO1
|
||||
uint16_t irqs = SX126X_IRQ_TX_DONE | SX126X_IRQ_RX_DONE | SX126X_IRQ_TIMEOUT;
|
||||
uint8_t di[8] = {
|
||||
irqs >> 8, irqs & 0xFF, // IRQ mask
|
||||
irqs >> 8, irqs & 0xFF, // DIO1
|
||||
0x00, 0x00, // DIO2 (RF switch)
|
||||
0x00, 0x00, // DIO3 (TCXO)
|
||||
};
|
||||
ok &= cmd(OP_SET_DIO_IRQ_PARAMS, di, 8);
|
||||
|
||||
ok &= sx126x_restore_rx_payload_len();
|
||||
return ok;
|
||||
}
|
||||
|
||||
static bool set_packet_params(uint8_t payload_len)
|
||||
{
|
||||
// preamble 48 bits TX, detector 8 bits, sync 16 bits, fixed length, no
|
||||
// radio CRC (wM-Bus CRC is per-block, validated in software), no whitening
|
||||
uint8_t pp[9] = {
|
||||
0x00, 0x30, // TX preamble length: 48 bits
|
||||
0x04, // preamble detector: 8 bits
|
||||
16, // sync word length in bits
|
||||
0x00, // no address filtering
|
||||
0x00, // fixed length packet
|
||||
payload_len,
|
||||
0x01, // CRC off
|
||||
0x00, // no whitening
|
||||
};
|
||||
return cmd(OP_SET_PACKET_PARAMS, pp, 9);
|
||||
}
|
||||
|
||||
bool sx126x_restore_rx_payload_len(void)
|
||||
{
|
||||
return set_packet_params(s_rx_payload_len);
|
||||
}
|
||||
|
||||
bool sx126x_set_tx_power(int8_t dbm)
|
||||
{
|
||||
if (dbm < -9) dbm = -9;
|
||||
if (dbm > 14) dbm = 14; // deliberately capped: external FEM adds gain
|
||||
s_tx_dbm = dbm;
|
||||
uint8_t tp[2] = {(uint8_t)dbm, 0x02}; // ramp 40 us
|
||||
return cmd(OP_SET_TX_PARAMS, tp, 2);
|
||||
}
|
||||
|
||||
bool sx126x_standby(void)
|
||||
{
|
||||
uint8_t stdby = 0x00;
|
||||
return cmd(OP_SET_STANDBY, &stdby, 1);
|
||||
}
|
||||
|
||||
bool sx126x_set_rx(void)
|
||||
{
|
||||
fem_set_tx(false);
|
||||
sx126x_clear_irq(SX126X_IRQ_ALL);
|
||||
// RX continuous
|
||||
return cmd(OP_SET_RX, (uint8_t[]){0xFF, 0xFF, 0xFF}, 3);
|
||||
}
|
||||
|
||||
bool sx126x_start_tx(const uint8_t *buf, uint8_t len)
|
||||
{
|
||||
if (!sx126x_standby()) return false;
|
||||
sx126x_clear_irq(SX126X_IRQ_ALL);
|
||||
if (!set_packet_params(len)) return false;
|
||||
|
||||
// WriteBuffer needs op + offset + payload in one transaction
|
||||
static uint8_t txbuf[258];
|
||||
txbuf[0] = OP_WRITE_BUFFER;
|
||||
txbuf[1] = 0x00;
|
||||
memcpy(txbuf + 2, buf, len);
|
||||
if (!xfer(txbuf, NULL, (size_t)len + 2)) return false;
|
||||
|
||||
fem_set_tx(true);
|
||||
// TX timeout ~500 ms = 32000 * 15.625 us -> 0x007D00
|
||||
if (!cmd(OP_SET_TX, (uint8_t[]){0x00, 0x7D, 0x00}, 3)) {
|
||||
fem_set_tx(false);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
uint16_t sx126x_get_irq(void)
|
||||
{
|
||||
uint8_t st[2] = {0, 0};
|
||||
if (!cmd_read(OP_GET_IRQ_STATUS, st, 2)) return 0;
|
||||
return ((uint16_t)st[0] << 8) | st[1];
|
||||
}
|
||||
|
||||
bool sx126x_clear_irq(uint16_t mask)
|
||||
{
|
||||
return cmd(OP_CLEAR_IRQ_STATUS, (uint8_t[]){mask >> 8, mask & 0xFF}, 2);
|
||||
}
|
||||
|
||||
int sx126x_read_rx(uint8_t *out, size_t maxlen, int8_t *rssi_dbm)
|
||||
{
|
||||
uint8_t st[2];
|
||||
if (!cmd_read(OP_GET_RX_BUFFER_STATUS, st, 2)) return -1;
|
||||
uint8_t n = st[0], off = st[1];
|
||||
if (n > maxlen) n = maxlen;
|
||||
|
||||
if (rssi_dbm) {
|
||||
uint8_t ps[3] = {0};
|
||||
if (cmd_read(OP_GET_PACKET_STATUS, ps, 3)) {
|
||||
*rssi_dbm = (int8_t)(-(int)ps[1] / 2); // RssiSync
|
||||
} else {
|
||||
*rssi_dbm = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static uint8_t rdbuf_tx[259];
|
||||
static uint8_t rdbuf_rx[259];
|
||||
memset(rdbuf_tx, 0, (size_t)n + 3);
|
||||
rdbuf_tx[0] = OP_READ_BUFFER;
|
||||
rdbuf_tx[1] = off;
|
||||
// byte 2 is status/NOP, data starts at byte 3
|
||||
if (!xfer(rdbuf_tx, rdbuf_rx, (size_t)n + 3)) return -1;
|
||||
memcpy(out, rdbuf_rx + 3, n);
|
||||
return n;
|
||||
}
|
||||
|
||||
int8_t sx126x_get_rssi_inst(void)
|
||||
{
|
||||
uint8_t v = 0;
|
||||
cmd_read(OP_GET_RSSI_INST, &v, 1);
|
||||
return (int8_t)(-(int)v / 2);
|
||||
}
|
||||
|
||||
uint16_t sx126x_get_device_errors(void)
|
||||
{
|
||||
uint8_t e[2] = {0, 0};
|
||||
if (!cmd_read(OP_GET_DEVICE_ERRORS, e, 2)) return 0xFFFF;
|
||||
return ((uint16_t)e[0] << 8) | e[1];
|
||||
}
|
||||
|
||||
uint8_t sx126x_get_status(void)
|
||||
{
|
||||
uint8_t tx[2] = {OP_GET_STATUS, 0}, rx[2] = {0, 0};
|
||||
if (!xfer(tx, rx, 2)) return 0;
|
||||
return rx[1];
|
||||
}
|
||||
Reference in New Issue
Block a user