feat: Add NiceRF LoRa2021 (LR2021 Gen 4) variant support

boards/esp32c3_supermini.json

@@ -0,0 +1,44 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32c3_out.ld"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DARDUINO_ESP32C3_SUPERMINI",
+      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_CDC_ON_BOOT=1"
+    ],
+    "f_cpu": "160000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "dio",
+    "hwids": [
+      [
+        "0x303a",
+        "0x1001"
+      ]
+    ],
+    "mcu": "esp32c3",
+    "variant": "esp32c3_supermini"
+  },
+  "connectivity": [
+    "wifi"
+  ],
+  "debug": {
+    "openocd_target": "esp32c3.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "ESP32-C3 SuperMini V1 (Maker go)",
+  "upload": {
+    "flash_size": "4MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 4194304,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://www.aliexpress.com/item/1005006155740481.html",
+  "vendor": "Maker go"
+}

src/helpers/radiolib/CustomLR2021.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <RadioLib.h>
+#include "MeshCore.h"
+
+class CustomLR2021 : public LR2021 {
+  bool _rx_boosted = false;
+
+  public:
+    CustomLR2021(Module *mod) : LR2021(mod) {
+      irqDioNum = LR2021_IRQ_DIO;
+    }
+
+    float getFreqMHz() const { return freqMHz; }
+
+    uint8_t getSpreadingFactor() const { return spreadingFactor; }
+
+    int16_t setRxBoostedGainMode(uint8_t level) {
+      _rx_boosted = (level > 0);
+      return LR2021::setRxBoostedGainMode(level);
+    }
+
+    bool getRxBoostedGainMode() const { return _rx_boosted; }
+
+    bool isReceiving() {
+      uint32_t irq = getIrqStatus();
+      // Use LR2021-specific IRQ flags if available, fall back to LR11x0
+#ifdef RADIOLIB_LR2021_IRQ_PREAMBLE_DETECTED
+      bool detected = (irq & RADIOLIB_LR2021_IRQ_LORA_HEADER_VALID) ||
+                      (irq & RADIOLIB_LR2021_IRQ_PREAMBLE_DETECTED);
+#else
+      bool detected = (irq & RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID) ||
+                      (irq & RADIOLIB_LR11X0_IRQ_PREAMBLE_DETECTED);
+#endif
+      return detected;
+    }
+
+    bool std_init(SPIClass *spi = NULL) {
+      (void)spi;
+
+      int status = begin(LORA_FREQ, LORA_BW, LORA_SF, 5,
+                         RADIOLIB_LR2021_LORA_SYNC_WORD_PRIVATE,
+                         LORA_TX_POWER, 16, 0.0);
+      if (status != RADIOLIB_ERR_NONE) {
+        MESH_DEBUG_PRINTLN("LR2021: radio init failed: %d", status);
+        return false;
+      }
+
+      setCRC(1);
+      return true;
+    }
+};

src/helpers/radiolib/CustomLR2021Wrapper.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "CustomLR2021.h"
+#include "RadioLibWrappers.h"
+
+class CustomLR2021Wrapper : public RadioLibWrapper {
+public:
+  CustomLR2021Wrapper(CustomLR2021 &radio, mesh::MainBoard &board)
+      : RadioLibWrapper(radio, board) {}
+
+  void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
+    ((CustomLR2021 *)_radio)->setFrequency(freq);
+    ((CustomLR2021 *)_radio)->setSpreadingFactor(sf);
+    ((CustomLR2021 *)_radio)->setBandwidth(bw);
+    ((CustomLR2021 *)_radio)->setCodingRate(cr);
+    updatePreamble(sf);
+  }
+
+  bool isReceivingPacket() override {
+    return ((CustomLR2021 *)_radio)->isReceiving();
+  }
+
+  float getCurrentRSSI() override {
+    float rssi = -110;
+    ((CustomLR2021 *)_radio)->getRssiInst(&rssi);
+    return rssi;
+  }
+
+  void onSendFinished() override {
+    RadioLibWrapper::onSendFinished();
+    _radio->setPreambleLength(
+        preambleLengthForSF(getSpreadingFactor()));
+  }
+
+  float getLastRSSI() const override {
+    return ((CustomLR2021 *)_radio)->getRSSI();
+  }
+
+  float getLastSNR() const override {
+    return ((CustomLR2021 *)_radio)->getSNR();
+  }
+
+  uint8_t getSpreadingFactor() const override {
+    return ((CustomLR2021 *)_radio)->getSpreadingFactor();
+  }
+
+  float packetScore(float snr, int packet_len) override {
+    int sf = ((CustomLR2021 *)_radio)->getSpreadingFactor();
+    return packetScoreInt(snr, sf, packet_len);
+  }
+
+  void powerOff() override {
+    ((CustomLR2021 *)_radio)->sleep(false, 0);
+  }
+
+  void doResetAGC() override {
+    CustomLR2021 *r = (CustomLR2021 *)_radio;
+    float freq = r->getFreqMHz();
+    r->sleep(true, 0);
+    r->standby(RADIOLIB_LR2021_STANDBY_RC, true);
+    r->calibrate(RADIOLIB_LR2021_CALIBRATE_ALL);
+    r->setFrequency(freq);
+    r->setRxBoostedGainMode(RADIOLIB_LR2021_RX_BOOST_LF);
+  }
+
+  void setRxBoostedGainMode(bool en) override {
+    ((CustomLR2021 *)_radio)->setRxBoostedGainMode(
+        en ? RADIOLIB_LR2021_RX_BOOST_LF : 0);
+  }
+
+  bool getRxBoostedGainMode() const override {
+    return ((CustomLR2021 *)_radio)->getRxBoostedGainMode();
+  }
+};

variants/esp32c3_supermini/pins_arduino.h

@@ -0,0 +1,42 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+
+#define PIN_NEOPIXEL        8
+static const uint8_t LED_BUILTIN = 8;
+#define BUILTIN_LED  LED_BUILTIN
+#define RGB_BUILTIN LED_BUILTIN
+#define RGB_BRIGHTNESS 64
+
+static const uint8_t TX = 21;
+static const uint8_t RX = 20;
+
+static const uint8_t SDA = 8;
+static const uint8_t SCL = 9;
+
+static const uint8_t SS    = 10;
+static const uint8_t MOSI  = 7;
+static const uint8_t MISO  = 2;
+static const uint8_t SCK   = 6;
+
+static const uint8_t A0 = 0;
+static const uint8_t A1 = 1;
+static const uint8_t A2 = 2;
+static const uint8_t A3 = 3;
+static const uint8_t A4 = 4;
+static const uint8_t A5 = 5;
+
+static const uint8_t D0  = 0;
+static const uint8_t D1  = 1;
+static const uint8_t D2  = 2;
+static const uint8_t D3  = 3;
+static const uint8_t D4  = 4;
+static const uint8_t D5  = 5;
+static const uint8_t D6  = 6;
+static const uint8_t D7  = 7;
+static const uint8_t D8  = 8;
+static const uint8_t D9  = 9;
+static const uint8_t D10 = 10;
+
+#endif /* Pins_Arduino_h */

variants/nicerf_lr2021/EspIdfHal.h

@@ -0,0 +1,174 @@
+#pragma once
+
+#include <RadioLib.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "driver/gpio.h"
+#include "driver/spi_master.h"
+#include "esp_timer.h"
+
+#define HAL_LOW (0x0)
+#define HAL_HIGH (0x1)
+#define HAL_INPUT (0x01)
+#define HAL_OUTPUT (0x03)
+#define HAL_RISING (0x01)
+#define HAL_FALLING (0x02)
+#define NOP() asm volatile("nop")
+
+class EspIdfHal : public RadioLibHal {
+public:
+  EspIdfHal(int8_t sck, int8_t miso, int8_t mosi)
+      : RadioLibHal(HAL_INPUT, HAL_OUTPUT, HAL_LOW, HAL_HIGH, HAL_RISING,
+                    HAL_FALLING),
+        spiSCK(sck), spiMISO(miso), spiMOSI(mosi), spiDev(nullptr),
+        spiInitialized(false) {}
+
+  void init() override { spiBegin(); }
+
+  void term() override { spiEnd(); }
+
+  void pinMode(uint32_t pin, uint32_t mode) override {
+    if (pin == RADIOLIB_NC)
+      return;
+    gpio_config_t conf = {};
+    conf.pin_bit_mask = (1ULL << pin);
+    conf.mode = (gpio_mode_t)mode;
+    conf.pull_up_en = GPIO_PULLUP_DISABLE;
+    conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
+    conf.intr_type = GPIO_INTR_DISABLE;
+    gpio_config(&conf);
+  }
+
+  void digitalWrite(uint32_t pin, uint32_t value) override {
+    if (pin == RADIOLIB_NC)
+      return;
+    gpio_set_level((gpio_num_t)pin, value);
+  }
+
+  uint32_t digitalRead(uint32_t pin) override {
+    if (pin == RADIOLIB_NC)
+      return (0);
+    return (gpio_get_level((gpio_num_t)pin));
+  }
+
+  void attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void),
+                       uint32_t mode) override {
+    if (interruptNum == RADIOLIB_NC)
+      return;
+    gpio_install_isr_service((int)ESP_INTR_FLAG_IRAM);
+    gpio_set_intr_type((gpio_num_t)interruptNum,
+                       (gpio_int_type_t)(mode & 0x7));
+    gpio_isr_handler_add((gpio_num_t)interruptNum,
+                         (void (*)(void *))interruptCb, NULL);
+  }
+
+  void detachInterrupt(uint32_t interruptNum) override {
+    if (interruptNum == RADIOLIB_NC)
+      return;
+    gpio_isr_handler_remove((gpio_num_t)interruptNum);
+    gpio_set_intr_type((gpio_num_t)interruptNum, GPIO_INTR_DISABLE);
+  }
+
+  void delay(unsigned long ms) override {
+    vTaskDelay(ms / portTICK_PERIOD_MS);
+  }
+
+  void delayMicroseconds(unsigned long us) override {
+    uint64_t m = (uint64_t)esp_timer_get_time();
+    if (us) {
+      uint64_t e = (m + us);
+      if (m > e) {
+        while ((uint64_t)esp_timer_get_time() > e) {
+          NOP();
+        }
+      }
+      while ((uint64_t)esp_timer_get_time() < e) {
+        NOP();
+      }
+    }
+  }
+
+  unsigned long millis() override {
+    return ((unsigned long)(esp_timer_get_time() / 1000ULL));
+  }
+
+  unsigned long micros() override {
+    return ((unsigned long)(esp_timer_get_time()));
+  }
+
+  long pulseIn(uint32_t pin, uint32_t state, unsigned long timeout) override {
+    if (pin == RADIOLIB_NC)
+      return (0);
+    this->pinMode(pin, HAL_INPUT);
+    uint32_t start = this->micros();
+    uint32_t curtick = this->micros();
+    while (this->digitalRead(pin) == state) {
+      if ((this->micros() - curtick) > timeout)
+        return (0);
+    }
+    return (this->micros() - start);
+  }
+
+  void spiBegin() override {
+    if (spiInitialized)
+      return;
+    spi_bus_config_t bus_cfg = {};
+    bus_cfg.mosi_io_num = this->spiMOSI;
+    bus_cfg.miso_io_num = this->spiMISO;
+    bus_cfg.sclk_io_num = this->spiSCK;
+    bus_cfg.quadwp_io_num = -1;
+    bus_cfg.quadhd_io_num = -1;
+    bus_cfg.max_transfer_sz = 256;
+    esp_err_t ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
+    if (ret != ESP_OK && ret != ESP_ERR_INVALID_STATE) {
+      return;
+    }
+
+    spi_device_interface_config_t dev_cfg = {};
+    dev_cfg.mode = 0;
+    dev_cfg.clock_speed_hz = 2000000;
+    dev_cfg.spics_io_num = -1;
+    dev_cfg.queue_size = 1;
+    ret = spi_bus_add_device(SPI2_HOST, &dev_cfg, &this->spiDev);
+    if (ret != ESP_OK) {
+      return;
+    }
+    this->spiInitialized = true;
+  }
+
+  void spiBeginTransaction() override {}
+
+  void spiTransfer(uint8_t *out, size_t len, uint8_t *in) override {
+    uint8_t *buf = out;
+    for (size_t i = 0; i < len; i++) {
+      spi_transaction_t trans = {};
+      trans.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_USE_RXDATA;
+      trans.length = 8;
+      trans.tx_data[0] = buf[i];
+      esp_err_t ret = spi_device_polling_transmit(this->spiDev, &trans);
+      if (ret != ESP_OK) {
+        in[i] = 0xFF;
+      } else {
+        in[i] = trans.rx_data[0];
+      }
+    }
+  }
+
+  void spiEndTransaction() override {}
+
+  void spiEnd() override {
+    if (this->spiDev) {
+      spi_bus_remove_device(this->spiDev);
+      this->spiDev = nullptr;
+    }
+    spi_bus_free(SPI2_HOST);
+    this->spiInitialized = false;
+  }
+
+private:
+  int8_t spiSCK;
+  int8_t spiMISO;
+  int8_t spiMOSI;
+  spi_device_handle_t spiDev;
+  bool spiInitialized;
+};