Skip to content

A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol

22.3 KB
Raw Blame
#include "SubGhzService.h"
#include "driver/rmt.h"
#include <sstream>

// Base

bool SubGhzService::configure(SPIClass& spi, uint8_t sck, uint8_t miso, uint8_t mosi, uint8_t ss,
                              uint8_t gdo0, float mhz, int paDbm)
{
    // Value assignment
    sck_ = sck; 
    miso_ = miso; 
    mosi_ = mosi; 
    ss_ = ss;
    gdo0_ = gdo0;
    mhz_ = mhz;
    paDbm_ = paDbm;
    ccMode_ = true;


    // SPI instance
    #ifdef DEVICE_TEMBEDS3CC1101

    initTembed();
    ELECHOUSE_cc1101.setSPIinstance(&spi);

    #elif defined(DEVICE_M5STICK) || defined(DEVICE_CARDPUTER)

    SPI.end();
    delay(10);
    SPI.begin(sck_, miso_, mosi_, ss_);
    ELECHOUSE_cc1101.setSPIinstance(&SPI);

    #else

    ELECHOUSE_cc1101.setSPIinstance(&spi);

    #endif

    // Initialize CC1101
    ELECHOUSE_cc1101.setSpiPin(sck_, miso_, mosi_, ss_);
    ELECHOUSE_cc1101.setGDO0(gdo0_);
    ELECHOUSE_cc1101.Init();
    applyDefaultProfile();

    // Check if CC1101 is configured
    isConfigured_ = ELECHOUSE_cc1101.getCC1101();

    return isConfigured_;
}

void SubGhzService::tune(float mhz)
{
    if (!isConfigured_) return;
    mhz_ = mhz;
    ELECHOUSE_cc1101.SetRx(mhz_);

    #ifdef DEVICE_TEMBEDS3CC1101

    selectRfPathFor(mhz_);

    #endif
 
    delay(2);
}

int SubGhzService::measurePeakRssi(uint32_t holdMs)
{
    if (!isConfigured_) return -127;
    if (holdMs < 1) holdMs = 1;

    const unsigned long t0 = millis();
    int peak = -127;
    while (millis() - t0 < holdMs) {
        int r = ELECHOUSE_cc1101.getRssi();
        if (r > peak) peak = r;
        delay(1);
    }
    return peak;
}

std::vector<std::string> SubGhzService::getSupportedBand() const {
    return std::vector<std::string>(std::begin(kSubGhzScanBandNames), std::end(kSubGhzScanBandNames));
}

std::vector<float> SubGhzService::getSupportedFreq(const std::string& band) const {
    std::vector<float> out;

    int bandIdx = -1;
    for (int i = 0; i < 4; ++i) {
        if (band == kSubGhzScanBandNames[i]) {
            bandIdx = i;
            break;
        }
    }

    if (bandIdx < 0) {
        return out;
    }

    int start = kSubGhzRangeLimits[bandIdx][0];
    int end   = kSubGhzRangeLimits[bandIdx][1];

    out.reserve(static_cast<size_t>(end - start + 1));
    for (int i = start; i <= end; ++i) {
        out.push_back(kSubGhzFreqList[i]);
    }

    return out;
}

void SubGhzService::setScanBand(const std::string& s) {
    for (int i = 0; i < 4; ++i) {
        if (s == kSubGhzScanBandNames[i]) {
            scanBand_ = static_cast<SubGhzScanBand>(i);
            return;
        }
    }

    char* end = nullptr;
    long idx = std::strtol(s.c_str(), &end, 10);
    if (end != s.c_str()) {
        scanBand_ = static_cast<SubGhzScanBand>(idx);
    }
}

// Raw sniffer

bool SubGhzService::startRawSniffer(int pin) {
    // Configure RMT
    rmt_config_t rxconfig;
    rxconfig.rmt_mode = RMT_MODE_RX;
    rxconfig.channel = RMT_RX_CHANNEL;
    rxconfig.gpio_num = (gpio_num_t)pin;
    rxconfig.clk_div = RMT_CLK_DIV;
    rxconfig.mem_block_num = 2;
    rxconfig.flags = 0;
    rxconfig.rx_config.idle_threshold = 3 * RMT_1MS_TICKS,
    rxconfig.rx_config.filter_ticks_thresh = 200 * RMT_1US_TICKS;
    rxconfig.rx_config.filter_en = true;

    // Install RMT driver
    if (rmt_config(&rxconfig) != ESP_OK) return false;
    if (rmt_driver_install(rxconfig.channel, RMT_BUFFER_SIZE, 0) != ESP_OK) return false;

    // Get ring buffer handle
    if (rmt_get_ringbuf_handle(rxconfig.channel, &rb_) != ESP_OK) return false;
    rmt_rx_start(rxconfig.channel, true);

    return true;
}

bool SubGhzService::isSnifferOverflowing() const {
    if (!rb_) return false;
    size_t freeBytes = xRingbufferGetCurFreeSize(rb_);
    return freeBytes < 128;
}

void SubGhzService::drainSniffer() {
    if (!rb_) return;
    while (true) {
        size_t rx_size = 0;
        rmt_item32_t* item = (rmt_item32_t*) xRingbufferReceive(rb_, &rx_size, 0);
        if (!item) break;
        vRingbufferReturnItem(rb_, (void*)item);
    }
}

void SubGhzService::stopRawSniffer() {
    rmt_rx_stop(RMT_RX_CHANNEL);
    drainSniffer();
    rmt_driver_uninstall(RMT_RX_CHANNEL);
    rb_ = nullptr;
    ELECHOUSE_cc1101.setSidle();
}

std::pair<std::string, size_t> SubGhzService::readRawPulses() {
    if (!rb_) return {"", 0};

    size_t rx_size = 0;
    rmt_item32_t* item = (rmt_item32_t*) xRingbufferReceive(rb_, &rx_size, 0);
    if (!item) return {"", 0};

    size_t n = rx_size / sizeof(rmt_item32_t);
    uint32_t totalDuration = 0;
    for (size_t i = 0; i < n; i++) {
        totalDuration += item[i].duration0;
        totalDuration += item[i].duration1;
    }

    std::ostringstream oss;
    oss << "[raw " << n << " pulses | freq=" << mhz_
        << " MHz | dur=" << totalDuration << " ticks]\r\n";

    int col = 0;
    for (size_t i = 0; i < n; i++) {
        oss << (item[i].level0 ? 'H' : 'L') << ":" << item[i].duration0
            << " | "
            << (item[i].level1 ? 'H' : 'L') << ":" << item[i].duration1
            << "   ";
        if (++col % 4 == 0) oss << "\r\n";
    }
    oss << "\n\r";

    vRingbufferReturnItem(rb_, (void*)item); // Free memory
    return {oss.str(), n};
}

std::vector<rmt_item32_t> SubGhzService::readRawFrame() {
    std::vector<rmt_item32_t> frame;
    if (!rb_) return frame;

    size_t rx_size = 0;
    rmt_item32_t* item = (rmt_item32_t*) xRingbufferReceive(rb_, &rx_size, 0);
    if (!item) return frame;

    size_t n = rx_size / sizeof(rmt_item32_t);
    frame.assign(item, item + n);

    vRingbufferReturnItem(rb_, (void*)item);
    return frame;
}

bool SubGhzService::sendRawFrame(int pin, const std::vector<rmt_item32_t>& items, uint32_t tick_per_us) {
    if (!isConfigured_ || items.empty()) return false;

    // Output
    if (!startTxBitBang()) return false;

    // tick to us
    auto ticks_to_us = [tick_per_us](uint32_t ticks) -> uint32_t {
        if (!tick_per_us) return 0;
        return (ticks + (tick_per_us/2)) / tick_per_us;
    };

    // Bit bang seq
    for (const auto& it : items) {
        gpio_set_level((gpio_num_t)pin, it.level0 ? 1 : 0);
        uint32_t us0 = ticks_to_us(it.duration0);
        if (us0) esp_rom_delay_us(us0);

        gpio_set_level((gpio_num_t)pin, it.level1 ? 1 : 0);
        uint32_t us1 = ticks_to_us(it.duration1);
        if (us1) esp_rom_delay_us(us1);
    }

    // Reset
    gpio_set_level((gpio_num_t)pin, 0);
    return true;
}

bool SubGhzService::startTxBitBang() {
    if (!isConfigured_) return false;

    gpio_config_t io{};
    io.pin_bit_mask = (1ULL << gdo0_);
    io.mode = GPIO_MODE_OUTPUT;
    io.pull_up_en = GPIO_PULLUP_DISABLE;
    io.pull_down_en = GPIO_PULLDOWN_DISABLE;
    io.intr_type = GPIO_INTR_DISABLE;
    return gpio_config(&io) == ESP_OK;
}

bool SubGhzService::stopTxBitBang() {
    if (!isConfigured_) return false;

    // Force low
    gpio_set_direction((gpio_num_t)gdo0_, GPIO_MODE_OUTPUT);
    gpio_set_level((gpio_num_t)gdo0_, 0);
    delay(1);

    // Reset to input
    gpio_config_t io{};
    io.pin_bit_mask  = (1ULL << gdo0_);
    io.mode          = GPIO_MODE_INPUT; 
    io.pull_up_en    = GPIO_PULLUP_DISABLE;
    io.pull_down_en  = GPIO_PULLDOWN_ENABLE;
    io.intr_type     = GPIO_INTR_DISABLE;

    ELECHOUSE_cc1101.setSidle();

    return gpio_config(&io) == ESP_OK;
}

bool SubGhzService::sendRawPulse(int pin, int duration) {
    if (!isConfigured_) return false;

    if (duration < 0) {
        gpio_set_level((gpio_num_t)pin, 0);
        delayMicroseconds(-duration);
    } else {
        gpio_set_level((gpio_num_t)pin, 1);
        delayMicroseconds(duration);
    }
    return true;
}

bool SubGhzService::sendRandomBurst(int pin)
{
    if (!isConfigured_) return false;

    constexpr int ITEMS_PER_BURST = 256;   // Number of items
    constexpr int MEAN_US         = 200;   // Mean duration in µs per phase
    constexpr int JITTER_PCT      = 30;    // around the mean

    // Calcul bornes jitter
    int j     = (MEAN_US * JITTER_PCT) / 100;
    int minUs = MEAN_US - j; if (minUs < 1) minUs = 1;
    int maxUs = MEAN_US + j; if (maxUs < minUs) maxUs = minUs;

    auto rnd_between = [&](int lo, int hi) -> uint32_t {
        uint32_t span = static_cast<uint32_t>(hi - lo + 1);
        return static_cast<uint32_t>(lo) + (esp_random() % span);
    };

    // Initial random level
    int level = (esp_random() & 1) ? 1 : 0;

    // Bit-bang
    for (int i = 0; i < ITEMS_PER_BURST; ++i) {
        // phase 0
        gpio_set_level((gpio_num_t)pin, level);
        level ^= 1;
        esp_rom_delay_us(rnd_between(minUs, maxUs));

        // phase 1
        gpio_set_level((gpio_num_t)pin, level);
        level ^= 1;
        esp_rom_delay_us(rnd_between(minUs, maxUs));
    }

    // Reset
    gpio_set_level((gpio_num_t)pin, 0);
    return true;
}

// Profiles

bool SubGhzService::applyScanProfile(float dataRateKbps,
                                  float rxBwKhz,
                                  uint8_t modulation,
                                  bool packetMode)
{
    if (!isConfigured_) return false;
    ELECHOUSE_cc1101.setSidle();
    ELECHOUSE_cc1101.setCCMode(packetMode ? 0 : 1);
    ELECHOUSE_cc1101.setModulation(modulation);
    ELECHOUSE_cc1101.setDRate(dataRateKbps);
    ELECHOUSE_cc1101.setRxBW(rxBwKhz);
    ELECHOUSE_cc1101.setSyncMode(0);
    ELECHOUSE_cc1101.setWhiteData(false);
    ELECHOUSE_cc1101.setCrc(false);
    ELECHOUSE_cc1101.setCRC_AF(false);
    ELECHOUSE_cc1101.setAdrChk(0);
    ELECHOUSE_cc1101.setLengthConfig(1);
    ELECHOUSE_cc1101.setPacketLength(0xFF);
    ELECHOUSE_cc1101.SetRx(mhz_);
    return true;
}

bool SubGhzService::applyDefaultProfile(float mhz) {
    if (!isConfigured_) return false;
    ELECHOUSE_cc1101.setSidle();
    ELECHOUSE_cc1101.setPktFormat(0);   // PKT_FORMAT=0 (packet mode normal)
    ELECHOUSE_cc1101.setLengthConfig(1);// 1 = variable length
    ELECHOUSE_cc1101.setPacketLength(0xFF);
    ELECHOUSE_cc1101.setCCMode(0);      // RAW / serial out sur GDO0
    ELECHOUSE_cc1101.setMHZ(mhz);
    ELECHOUSE_cc1101.setModulation(2);  // OOK/ASK
    ELECHOUSE_cc1101.setDRate(4.8f);    // kbps
    ELECHOUSE_cc1101.setRxBW(135.0f);   // kHz
    ELECHOUSE_cc1101.setSyncMode(0);
    ELECHOUSE_cc1101.setWhiteData(false);
    ELECHOUSE_cc1101.setCrc(false);
    ELECHOUSE_cc1101.setCRC_AF(false);
    ELECHOUSE_cc1101.setAdrChk(0);

    return true;
}

bool SubGhzService::applySniffProfile(float mhz) {
    if (!isConfigured_) return false;
    // CC1101 en "raw/async" OOK
    ELECHOUSE_cc1101.setSidle();
    ELECHOUSE_cc1101.setMHZ(mhz);
    ELECHOUSE_cc1101.setModulation(2);      // 2 = ASK/OOK
    ELECHOUSE_cc1101.setDRate(50);         // 50 kbps
    ELECHOUSE_cc1101.setRxBW(135.0f);     // 58–200
    ELECHOUSE_cc1101.setSyncMode(0);     // no sync
    ELECHOUSE_cc1101.setWhiteData(0);
    ELECHOUSE_cc1101.setCrc(0);
    ELECHOUSE_cc1101.setAdrChk(0);
    ELECHOUSE_cc1101.setDcFilterOff(true);
    ELECHOUSE_cc1101.setPktFormat(3);    // *** ASYNCHRONOUS SERIAL MODE ***
    ELECHOUSE_cc1101.SetRx(mhz);
    return true;
}

bool SubGhzService::applyRawSendProfile(float mhz) {
    if (!isConfigured_) return false;
    ELECHOUSE_cc1101.setSidle();
    ELECHOUSE_cc1101.setMHZ(mhz);
    ELECHOUSE_cc1101.setModulation(2);   // OOK/ASK
    ELECHOUSE_cc1101.setDRate(50);
    ELECHOUSE_cc1101.setRxBW(135.0f);
    ELECHOUSE_cc1101.setSyncMode(0);
    ELECHOUSE_cc1101.setWhiteData(0);
    ELECHOUSE_cc1101.setCrc(0);
    ELECHOUSE_cc1101.setAdrChk(0);
    ELECHOUSE_cc1101.setDcFilterOff(true);
    ELECHOUSE_cc1101.setPktFormat(3);    // ASYNC SERIAL MODE (GDO0 = data)
    ELECHOUSE_cc1101.SetTx();
    return true;
}

bool SubGhzService::applyPresetByName(const std::string& name, float mhz) {
    if (!isConfigured_) return false;
    ELECHOUSE_cc1101.setSidle();
    ELECHOUSE_cc1101.setMHZ(mhz);

    // Default
    ELECHOUSE_cc1101.setWhiteData(0);
    ELECHOUSE_cc1101.setCrc(0);
    ELECHOUSE_cc1101.setCRC_AF(0);
    ELECHOUSE_cc1101.setAdrChk(0);
    ELECHOUSE_cc1101.setSyncMode(0);

    if (name == "FuriHalSubGhzPresetOok270Async") {
        ELECHOUSE_cc1101.setModulation(2); // OOK
        ELECHOUSE_cc1101.setRxBW(270.0f);
        ELECHOUSE_cc1101.setDRate(10.0f);
        ELECHOUSE_cc1101.setPktFormat(3); // async serial
        ELECHOUSE_cc1101.SetTx();
        return true;
    }
    if (name == "FuriHalSubGhzPresetOok650Async") {
        ELECHOUSE_cc1101.setModulation(2);
        ELECHOUSE_cc1101.setRxBW(650.0f);
        ELECHOUSE_cc1101.setDRate(10.0f);
        ELECHOUSE_cc1101.setPktFormat(3);
        ELECHOUSE_cc1101.SetTx();
        return true;
    }
    if (name == "FuriHalSubGhzPreset2FSKDev238Async") {
        ELECHOUSE_cc1101.setModulation(0); // 2-FSK
        ELECHOUSE_cc1101.setDeviation(2.380f);
        ELECHOUSE_cc1101.setRxBW(238.0f);
        ELECHOUSE_cc1101.setPktFormat(3);
        ELECHOUSE_cc1101.SetTx();
        return true;
    }
    if (name == "FuriHalSubGhzPreset2FSKDev476Async") {
        ELECHOUSE_cc1101.setModulation(0);
        ELECHOUSE_cc1101.setDeviation(47.607f);
        ELECHOUSE_cc1101.setRxBW(476.0f);
        ELECHOUSE_cc1101.setPktFormat(3);
        ELECHOUSE_cc1101.SetTx();
        return true;
    }
    if (name == "FuriHalSubGhzPresetMSK99_97KbAsync") {
        ELECHOUSE_cc1101.setModulation(4); // MSK
        ELECHOUSE_cc1101.setDeviation(47.607f);
        ELECHOUSE_cc1101.setDRate(99.97f);
        ELECHOUSE_cc1101.setPktFormat(3);
        ELECHOUSE_cc1101.SetTx();
        return true;
    }
    if (name == "FuriHalSubGhzPresetGFSK9_99KbAsync") {
        ELECHOUSE_cc1101.setModulation(1); // GFSK
        ELECHOUSE_cc1101.setDeviation(19.043f);
        ELECHOUSE_cc1101.setDRate(9.996f);
        ELECHOUSE_cc1101.setPktFormat(3);
        ELECHOUSE_cc1101.SetTx();
        return true;
    }

    // RcSwitch:
    char* end=nullptr;
    long proto = std::strtol(name.c_str(), &end, 10);
    if (end != name.c_str()) {
        ELECHOUSE_cc1101.setModulation(2); // OOK
        ELECHOUSE_cc1101.setRxBW(270.0f);
        ELECHOUSE_cc1101.setDRate(10.0f);
        ELECHOUSE_cc1101.setPktFormat(3);
        ELECHOUSE_cc1101.SetTx();
        return true;
    }

    // Fallback: OOK async
    return applyRawSendProfile(mhz);
}

bool SubGhzService::sendTimingsOOK_(const std::vector<int32_t>& timings) {
    if (!startTxBitBang()) return false;
    int level = 1; // start HIGH
    for (int32_t us : timings) {
        gpio_set_level((gpio_num_t)gdo0_, level);
        if (us > 0) esp_rom_delay_us((uint32_t)us);
        level ^= 1; // alternate
    }
    gpio_set_level((gpio_num_t)gdo0_, 0);
    stopTxBitBang();
    return true;
}

static inline void appendPair(std::vector<int32_t>& v, int hi_us, int lo_us) {
    if (hi_us>0) v.push_back(hi_us);
    if (lo_us>0) v.push_back(lo_us);
}

bool SubGhzService::sendRcSwitch_(uint64_t key, uint16_t bits, int te_us, int proto, int repeat) {
    if (!bits) return false;
    if (te_us <= 0) te_us = 350;      // défaut
    if (repeat <= 0) repeat = 10;

    // Usual protocols
    int sync_hi=0, sync_lo=0, zero_hi=0, zero_lo=0, one_hi=0, one_lo=0;

    if (proto == 1) {            // 350us, sync 1:31, zero 1:3, one 3:1
        sync_hi = te_us * 1;  sync_lo = te_us * 31;
        zero_hi = te_us * 1;  zero_lo = te_us * 3;
        one_hi  = te_us * 3;  one_lo  = te_us * 1;
    } else if (proto == 2) {     // 650us, sync 1:10, zero 1:2, one 2:1
        sync_hi = te_us * 1;  sync_lo = te_us * 10;
        zero_hi = te_us * 1;  zero_lo = te_us * 2;
        one_hi  = te_us * 2;  one_lo  = te_us * 1;
    } else {                     // “11” commonly used: 350us, sync 1:23, zero 1:2, one 2:1
        proto   = 11;
        sync_hi = te_us * 1;  sync_lo = te_us * 23;
        zero_hi = te_us * 1;  zero_lo = te_us * 2;
        one_hi  = te_us * 2;  one_lo  = te_us * 1;
    }

    std::vector<int32_t> timings;
    timings.reserve((bits * 2 + 4) * repeat);

    for (int r = 0; r < repeat; ++r) {
        // sync
        appendPair(timings, sync_hi, sync_lo);

        // bits MSB->LSB
        for (int i = bits - 1; i >= 0; --i) {
            bool b = (key >> i) & 1ULL;
            if (b) appendPair(timings, one_hi, one_lo);
            else   appendPair(timings, zero_hi, zero_lo);
        }
        // inter-frame gap
    }

    return sendTimingsOOK_(timings);
}

bool SubGhzService::sendPrinceton_(uint64_t key, uint16_t bits, int te_us) {
    // Canon PT2262: TE≈350us, 1=1h3l, 0=3h1l, sync=1h31l
    return sendRcSwitch_(key, bits, te_us>0?te_us:350, /*proto*/1, /*repeat*/10);
}

bool SubGhzService::sendBinRaw_(const std::vector<uint8_t>& bytes,
                                int te_us,
                                int bits /*ignored in ref mode*/,
                                bool /*msb_first unused in ref mode*/,
                                bool /*invert unused in ref mode*/) {
    if (bytes.empty()) return false;
    if (te_us <= 0) te_us = 100;

    // Impl. de référence : idle LOW, envoi depuis la FIN de la chaîne binaire,
    // donc: parcourir les octets à rebours, et dans chaque octet LSB->MSB.
    const int total_bits = int(bytes.size()) * 8;
    // // Si tu veux respecter "Bit:", décommente:
    // int limit_bits = (bits > 0 && bits < total_bits) ? bits : total_bits;
    const int limit_bits = total_bits; // référence = envoie tout

    if (!startTxBitBang()) return false;

    // Idle bas
    gpio_set_level((gpio_num_t)gdo0_, 0);

    int sent = 0;

    // Octets depuis la fin
    for (int bi = int(bytes.size()) - 1; bi >= 0 && sent < limit_bits; --bi) {
        uint8_t b = bytes[bi];

        // Bits LSB -> MSB
        for (int i = 0; i < 8 && sent < limit_bits; ++i, ++sent) {
            bool one = (b >> i) & 0x01; // LSB-first
            gpio_set_level((gpio_num_t)gdo0_, one ? 1 : 0);
            esp_rom_delay_us((uint32_t)te_us);
        }
    }

    // Idle bas en fin de trame
    gpio_set_level((gpio_num_t)gdo0_, 0);

    stopTxBitBang();
    return true;
}

bool SubGhzService::sendRawTimings(const std::vector<int32_t>& timings) {
    return sendTimingsRawSigned_(timings);
}

bool SubGhzService::sendTimingsRawSigned_(const std::vector<int32_t>& timings) {
    if (!startTxBitBang()) return false;

    // Idle LOW
    gpio_set_level((gpio_num_t)gdo0_, 0);

    for (int32_t t : timings) {
        if (t == 0) continue;
        bool high = (t > 0);
        uint32_t us = (uint32_t)(high ? t : -t);
        gpio_set_level((gpio_num_t)gdo0_, high ? 1 : 0);
        if (us) esp_rom_delay_us(us);
    }

    // Return to idle LOW
    gpio_set_level((gpio_num_t)gdo0_, 0);
    stopTxBitBang();
    return true;
}

bool SubGhzService::send(const SubGhzFileCommand& cmd) {
    if (!isConfigured_) return false;

    float mhz = cmd.frequency_hz ? (cmd.frequency_hz / 1e6f) : mhz_;
    tune(mhz);  // update antenna (selectRfPathFor) and RX

    if (!applyPresetByName(cmd.preset, mhz)) {
        // fallback async OOK TX
        if (!applyRawSendProfile(mhz)) return false;
    }

    // IMPORTANT: in async TX mode, GDO0 = data input -> we bit-bang on gdo0_
    switch (cmd.protocol) {
        case SubGhzProtocolEnum::RAW:
            return sendRawTimings(cmd.raw_timings);

        case SubGhzProtocolEnum::BinRAW: {
            const int te = cmd.te_us ? cmd.te_us : 100;
            const int total_bits = int(cmd.bitstream_bytes.size()) * 8;
            return sendBinRaw_(cmd.bitstream_bytes, te, total_bits,
                            /*msb_first*/false, /*invert*/false);
        }

        case SubGhzProtocolEnum::RcSwitch: {
            int proto = 11;
            char* end=nullptr;
            long p = std::strtol(cmd.preset.c_str(), &end, 10);
            if (end != cmd.preset.c_str()) proto = (int)p;
            int te = cmd.te_us ? cmd.te_us : ((proto==2)?650:350);
            return sendRcSwitch_(cmd.key, cmd.bits ? cmd.bits : 24, te, proto, /*repeat*/10);
        }

        case SubGhzProtocolEnum::Princeton:
            return sendPrinceton_(cmd.key, cmd.bits ? cmd.bits : 24, cmd.te_us ? cmd.te_us : 350);

        default: {
            // Fallback CAME/HOLTEK/NICE/unk like RcSwitch(11)
            // TE 270 µs, 10 rep
            if (!cmd.key) return false;
            const int te   = cmd.te_us ? cmd.te_us : 270;
            const int bits = cmd.bits  ? cmd.bits  : 24;
            return sendRcSwitch_(cmd.key, bits, te, /*proto*/11, /*repeat*/10);
        }
    }
}

// Tembed S3 CC1101 specific

void SubGhzService::initTembed() {
    // POWER
    const int BOARD_PWR_EN   = 15;

    // I2C
    const int BOARD_SDA_PIN  = 18;
    const int BOARD_SCL_PIN  = 8;

    // TFT
    const int BOARD_TFT_CS   = 41;

    // --------- SPI bus ---------
    const int BOARD_SPI_SCK  = 11;
    const int BOARD_SPI_MOSI = 9;
    const int BOARD_SPI_MISO = 10;

    // TF card
    const int BOARD_SD_CS    = 13;
    const int BOARD_SD_SCK   = BOARD_SPI_SCK;
    const int BOARD_SD_MOSI  = BOARD_SPI_MOSI;
    const int BOARD_SD_MISO  = BOARD_SPI_MISO;

    // LoRa / CC1101 front-end
    const int BOARD_LORA_CS  = 12;
    const int BOARD_LORA_SCK = BOARD_SPI_SCK;
    const int BOARD_LORA_MOSI= BOARD_SPI_MOSI;
    const int BOARD_LORA_MISO= BOARD_SPI_MISO;
    const int BOARD_LORA_IO2 = 38;
    const int BOARD_LORA_IO0 = 3;

    // Disable others spi devices
    pinMode(41, OUTPUT);
    digitalWrite(41, HIGH);
    pinMode(BOARD_SD_CS, OUTPUT);
    digitalWrite(BOARD_SD_CS, HIGH);
    pinMode(BOARD_LORA_CS, OUTPUT);
    digitalWrite(BOARD_LORA_CS, HIGH);

    // Set antenna frequency range, 433 (H/H) as default
    pinMode(rfSw1_, OUTPUT);
    pinMode(rfSw0_, OUTPUT);
    digitalWrite(rfSw1_, HIGH);
    digitalWrite(rfSw0_, HIGH);

    // Power the CC1101
    pinMode(BOARD_PWR_EN, OUTPUT);
    digitalWrite(BOARD_PWR_EN, HIGH);
}

void SubGhzService::selectRfPathFor(float mhz) {
    if (rfSw0_ < 0 || rfSw1_ < 0) return;

    // Map CC1101 antenna to bands

    uint8_t sel; // 0=315, 1=868/915, 2=433
    if (mhz >= 300.0f && mhz <= 348.0f) {
        sel = 0; // 315
    } else if ((mhz >= 387.0f && mhz <= 464.0f)) {
        sel = 2; // 433
    } else if (mhz >= 779.0f && mhz <= 928.0f) {
        sel = 1; // 868/915
    } else {
        // fallback
        sel = 2;
    }

    if (sel == rfSel_) return; // no change
    rfSel_ = sel;

    switch (sel) {
        case 0: // 315 MHz: SW1=1, SW0=0
            digitalWrite(rfSw1_, HIGH);
            digitalWrite(rfSw0_, LOW);
            break;
        case 1: // 868/915 MHz: SW1=0, SW0=1
            digitalWrite(rfSw1_, LOW);
            digitalWrite(rfSw0_, HIGH);
            break;
        case 2: // 433 MHz: SW1=1, SW0=1
        default:
            digitalWrite(rfSw1_, HIGH);
            digitalWrite(rfSw0_, HIGH);
            break;
    }
}