Skip to content

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

22.6 KB
Raw Blame
#pragma once

#include <cstdint>
#include <string>
#include <sstream>
#include "Enums/InfraredProtocolEnum.h"
#include "Enums/ModeEnum.h"
#include "Enums/TerminalTypeEnum.h"

class GlobalState {
private:
    // Version
    const std::string version = "1.4";

    //Pin in use
    std::vector<uint8_t> protectedPins;

    // Builtin
    uint8_t ledPin = 21;

    // SPI
    uint8_t spiCSPin = 12;
    uint8_t spiCLKPin = 40;
    uint8_t spiMISOPin = 39;
    uint8_t spiMOSIPin = 14;
    uint32_t spiFrequency = 20000000;

    // WiFi AP Credentials
    std::string apName = "ESP32-Bus-Pirate";
    std::string apPassword = "readytoboard";

    // NVS
    std::string nvsNamespace = "wifi_settings";
    std::string nvsSsidField = "ssid";
    std::string nvsPasswordField = "pass";

    // Terminal Web UI
    std::string terminalIp = "0.0.0.0";

    // Terminal transmission mode
    TerminalTypeEnum terminalMode = TerminalTypeEnum::Serial;

    //  Current selected mode
    ModeEnum currentMode = ModeEnum::HIZ;

    // PC Terminal Serial Configuration
    unsigned long serialTerminalBaudRate = 115200;

    // OneWire Default Pin
    uint8_t oneWirePin = 1; // pin par défaut

    // TwoWire Default Configuration
    uint8_t twoWireClkPin = 1;
    uint8_t twoWireIoPin = 2;
    uint8_t twoWireRstPin = 3;

    // ThreeWire Default Pins
    uint8_t threeWireCsPin = 5;
    uint8_t threeWireSkPin = 18;
    uint8_t threeWireDiPin = 23;
    uint8_t threeWireDoPin = 19;
    bool threeWireOrg8 = false; // 16-bit organization by default
    uint8_t threeWireeEepromModelIndex = 0; // Default eeprom model index

    // UART Default Configuration
    unsigned long uartBaudRate = 9600;
    uint32_t uartConfig = 0x800001c; // SERIAL_8N1 by default
    bool uartInverted = false;
    uint8_t uartRxPin = 1;
    uint8_t uartTxPin = 2;
    uint8_t uartDataBits = 8;
    std::string uartParity = "None";
    bool uartFlowControl = false;
    uint8_t uartStopBits = 1;

    // HDUART Default Configuration
    unsigned long hdUartBaudRate = 9600;
    uint32_t hdUartConfig = 0x800001c; // SERIAL_8N1
    bool hdUartInverted = false;
    uint8_t hdUartPin = 1;
    uint8_t hdUartDataBits = 8;
    std::string hdUartParity = "N";
    bool hdUartFlowControl = false;
    uint8_t hdUartStopBits = 1;

    // I2C Default Configuration
    uint8_t i2cSclPin = 1;
    uint8_t i2cSdaPin = 2;
    uint32_t i2cFrequency = 100000;

    // Infrared Default Configuration
    uint8_t infraredPin = 44; 
    uint8_t infraredRxPin = 1;
    InfraredProtocolEnum infraredProtocol = InfraredProtocolEnum::_NEC;

    // LED Mode
    uint8_t ledDataPin = 1;
    uint8_t ledClockPin = 2;
    uint16_t ledLength = 1;
    std::string ledProtocol = "ws2812";
    uint8_t ledBrightness = 128;

    // I2S Default Configuration
    uint8_t i2sBclkPin = 41;
    uint8_t i2sLrckPin = 43;
    uint8_t i2sDataPin = 42;
    uint32_t i2sSampleRate = 44100;
    uint8_t i2sBitsPerSample = 16;

    // CAN Default Configuration
    uint8_t canCspin = 1;
    uint8_t canSckPin = 0;
    uint8_t canSiPin = 2;
    uint8_t canSoPin = 3;
    uint32_t canKbps = 120;

    // Ethernet Default Configuration
    uint8_t ethernetCsPin = 5;
    uint8_t ethernetRstPin = 4;
    uint8_t ethernetSckPin = 18;
    uint8_t ethernetMisoPin = 19;
    uint8_t ethernetMosiPin = 23;
    uint8_t ethernetIrqPin = 39;
    uint32_t ethernetFrequency = 20000000; // 20 MHz
    std::array<uint8_t,6> ethernetMac = { 0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x42 };

    // SubGHz Default Configuration
    uint8_t subGhzSckPin = 12;
    uint8_t subGhzMisoPin = 13;
    uint8_t subGhzMosiPin = 14;
    uint8_t subGhzCsPin = 15;
    uint8_t subGhzGdoPin = 27;
    float subGhzFrequency = 433.92; // mhz
    uint8_t subGhzPower = 10; // dBm
    uint8_t subGhzModulation = 2; // 0=FSK, 1=OOK, 2=ASK
    uint32_t subGhzBandwidth = 125000; // 125 kHz

    // NRF24 Default Configuration
    uint8_t rf24CsnPin = 1;
    uint8_t rf24CePin = 3;
    uint8_t rf24SckPin = 5;
    uint8_t rf24MisoPin = 7;
    uint8_t rf24MosiPin = 9;

    // RFID (I2C PN532)
    uint8_t rfidSdaPin = 1;
    uint8_t rfidSclPin = 2;

    // JTAG Default Pin
    std::vector<uint8_t> jtagScanPins = { 1, 3, 5, 7, 9 };

    // SD Card Default Configuration
    uint8_t sdCardCsPin = 12;
    uint8_t sdCardClkPin = 40;
    uint8_t sdCardMisoPin = 39;
    uint8_t sdCardMosiPin = 14;
    uint32_t sdCardFrequency = 20000000; // 20 MHz
    bool hasInternalSdCard = false;

    // SD Card File Limits
    size_t fileCountLimit = 512;
    size_t fileCacheLimit = 64;

public:
    GlobalState(const GlobalState&) = delete;
    GlobalState& operator=(const GlobalState&) = delete;

    static GlobalState& getInstance() {
        static GlobalState instance;
        return instance;
    }

    // Version
    const std::string& getVersion() const { return version; }

    // Builtin
    uint8_t getLedPin() const { return ledPin; }

    // SPI
    uint8_t getSpiCSPin() const { return spiCSPin; }
    uint8_t getSpiCLKPin() const { return spiCLKPin; }
    uint8_t getSpiMISOPin() const { return spiMISOPin; }
    uint8_t getSpiMOSIPin() const { return spiMOSIPin; }
    uint32_t getSpiFrequency() const { return spiFrequency; }
    
    void setSpiCSPin(uint8_t pin) { spiCSPin = pin; }
    void setSpiCLKPin(uint8_t pin) { spiCLKPin = pin; }
    void setSpiMISOPin(uint8_t pin) { spiMISOPin = pin; }
    void setSpiMOSIPin(uint8_t pin) { spiMOSIPin = pin; }
    void setSpiFrequency(uint32_t freq) { spiFrequency = freq; }

    // AP WiFi
    const std::string& getApName() const { return apName; }
    const std::string& getApPassword() const { return apPassword; }

    void setApName(const std::string& name) { apName = name; }
    void setApPassword(const std::string& pass) { apPassword = pass; }

    // Terminal IP
    const std::string& getTerminalIp() const { return terminalIp; }
    void setTerminalIp(const std::string& ip) { terminalIp = ip; }

    // Terminal transmission mode
    TerminalTypeEnum getTerminalMode() const { return terminalMode; }
    void setTerminalMode(TerminalTypeEnum mode) { terminalMode = mode; }

    // Current Mode
    ModeEnum getCurrentMode() const { return currentMode; }
    void setCurrentMode(ModeEnum mode) { currentMode = mode; }

    // Serial Terminal Baud
    unsigned long getSerialTerminalBaudRate() const { return serialTerminalBaudRate; }
    void setSerialTerminalBaudRate(unsigned long rate) { serialTerminalBaudRate = rate; }

    // OneWire
    uint8_t getOneWirePin() const { return oneWirePin; }
    void setOneWirePin(uint8_t pin) { oneWirePin = pin; }

    // TwoWire
    uint8_t getTwoWireClkPin() const { return twoWireClkPin; }
    uint8_t getTwoWireIoPin() const { return twoWireIoPin; }
    uint8_t getTwoWireRstPin() const { return twoWireRstPin; }

    void setTwoWireClkPin(uint8_t pin) { twoWireClkPin = pin; }
    void setTwoWireIoPin(uint8_t pin) { twoWireIoPin = pin; }
    void setTwoWireRstPin(uint8_t pin) { twoWireRstPin = pin; }

    // ThreeWire
    uint8_t getThreeWireCsPin() const { return threeWireCsPin; }
    uint8_t getThreeWireSkPin() const { return threeWireSkPin; }
    uint8_t getThreeWireDiPin() const { return threeWireDiPin; }
    uint8_t getThreeWireDoPin() const { return threeWireDoPin; }
    bool isThreeWireOrg8() const { return threeWireOrg8; }
    uint8_t getThreeWireEepromModelIndex() const { return threeWireeEepromModelIndex; }

    void setThreeWireCsPin(uint8_t pin) { threeWireCsPin = pin; }
    void setThreeWireSkPin(uint8_t pin) { threeWireSkPin = pin ; }
    void setThreeWireDiPin(uint8_t pin) { threeWireDiPin = pin; }
    void setThreeWireDoPin(uint8_t pin) { threeWireDoPin = pin; }
    void setThreeWireOrg8(bool org8) { threeWireOrg8 = org8; }
    void setThreeWireEepromModelIndex(uint8_t index) { threeWireeEepromModelIndex = index; }

    // UART
    unsigned long getUartBaudRate() const { return uartBaudRate; }
    uint32_t getUartConfig() const { return uartConfig; }
    uint8_t getUartRxPin() const { return uartRxPin; }
    uint8_t getUartTxPin() const { return uartTxPin; }
    uint8_t getUartDataBits() const { return uartDataBits; }
    const std::string& getUartParity() const { return uartParity; }
    uint8_t getUartStopBits() const { return uartStopBits; }
    bool isUartInverted() const { return uartInverted; }
    bool isUartFlowControl() const { return uartFlowControl; }

    void setUartBaudRate(unsigned long b) { uartBaudRate = b; }
    void setUartConfig(uint32_t c) { uartConfig = c; }
    void setUartInverted(bool inv) { uartInverted = inv; }
    void setUartRxPin(uint8_t pin) { uartRxPin = pin; }
    void setUartTxPin(uint8_t pin) { uartTxPin = pin; }
    void setUartDataBits(uint8_t bits) { uartDataBits = bits; }
    void setUartParity(const std::string& parityVal) { uartParity = parityVal; }
    void setUartFlowControl(bool enabled) { uartFlowControl = enabled; }
    void setUartStopBits(uint8_t bits) { uartStopBits = bits; }

    // HDUART
    unsigned long getHdUartBaudRate() const { return hdUartBaudRate; }
    uint32_t getHdUartConfig() const { return hdUartConfig; }
    uint8_t getHdUartPin() const { return hdUartPin; }
    uint8_t getHdUartDataBits() const { return hdUartDataBits; }
    const std::string& getHdUartParity() const { return hdUartParity; }
    uint8_t getHdUartStopBits() const { return hdUartStopBits; }
    bool isHdUartInverted() const { return hdUartInverted; }
    bool isHdUartFlowControl() const { return hdUartFlowControl; }

    void setHdUartBaudRate(unsigned long b) { hdUartBaudRate = b; }
    void setHdUartConfig(uint32_t c) { hdUartConfig = c; }
    void setHdUartInverted(bool inv) { hdUartInverted = inv; }
    void setHdUartPin(uint8_t pin) { hdUartPin = pin; }
    void setHdUartDataBits(uint8_t bits) { hdUartDataBits = bits; }
    void setHdUartParity(const std::string& parityVal) { hdUartParity = parityVal; }
    void setHdUartFlowControl(bool enabled) { hdUartFlowControl = enabled; }
    void setHdUartStopBits(uint8_t bits) { hdUartStopBits = bits; }

    // I2C
    uint8_t getI2cSdaPin() const { return i2cSdaPin; }
    uint8_t getI2cSclPin() const { return i2cSclPin; }
    uint32_t getI2cFrequency() const { return i2cFrequency; }

    void setI2cSdaPin(uint8_t pin) { i2cSdaPin = pin; }
    void setI2cSclPin(uint8_t pin) { i2cSclPin = pin; }
    void setI2cFrequency(uint32_t freq) { i2cFrequency = freq; }

    // Infrared
    uint8_t getInfraredTxPin() const { return infraredPin; }
    uint8_t getInfraredRxPin() const { return infraredRxPin; }
    void setInfraredTxPin(uint8_t pin) { infraredPin = pin; }
    void setInfraredRxPin(uint8_t pin) { infraredRxPin = pin; }
    InfraredProtocolEnum getInfraredProtocol() const { return infraredProtocol ; }
    void setInfraredProtocol(InfraredProtocolEnum prot) {  infraredProtocol = prot; }

    // LED Mode
    uint8_t getLedDataPin() const { return ledDataPin; }
    uint8_t getLedClockPin() const { return ledClockPin; }
    uint16_t getLedLength() const { return ledLength; }
    const std::string& getLedProtocol() const { return ledProtocol; }
    uint8_t getLedBrightness() const { return ledBrightness; }

    void setLedDataPin(uint8_t pin) { ledDataPin = pin; }
    void setLedClockPin(uint8_t pin) { ledClockPin = pin; }
    void setLedLength(uint16_t len) { ledLength = len; }
    void setLedProtocol(const std::string& prot) { ledProtocol = prot; }
    void setLedBrightness(uint8_t brightness) { ledBrightness = brightness; }

    // I2S
    uint8_t getI2sBclkPin() const { return i2sBclkPin; }
    uint8_t getI2sLrckPin() const { return i2sLrckPin; }
    uint8_t getI2sDataPin() const { return i2sDataPin; }
    uint32_t getI2sSampleRate() const { return i2sSampleRate; }
    uint8_t getI2sBitsPerSample() const { return i2sBitsPerSample; }

    void setI2sBclkPin(uint8_t pin) { i2sBclkPin = pin; }
    void setI2sLrckPin(uint8_t pin) { i2sLrckPin = pin; }
    void setI2sDataPin(uint8_t pin) { i2sDataPin = pin; }
    void setI2sSampleRate(uint32_t rate) { i2sSampleRate = rate; }
    void setI2sBitsPerSample(uint8_t bits) { i2sBitsPerSample = bits; }

    // JTAG
    const std::vector<uint8_t>& getJtagScanPins() const { return jtagScanPins; }
    void setJtagScanPins(const std::vector<uint8_t>& pins) { jtagScanPins = pins; }

    // CAN
    uint8_t getCanCspin() const { return canCspin; }
    uint8_t getCanSckPin() const { return canSckPin; }
    uint8_t getCanSiPin() const { return canSiPin; }
    uint8_t getCanSoPin() const { return canSoPin; }
    uint32_t getCanKbps() const { return canKbps; }

    void setCanCspin(uint8_t pin) { canCspin = pin; }
    void setCanSckPin(uint8_t pin) { canSckPin = pin; }
    void setCanSiPin(uint8_t pin) { canSiPin = pin; }
    void setCanSoPin(uint8_t pin) { canSoPin = pin; }
    void setCanKbps(uint32_t kbps) { canKbps = kbps; } 

    // Ethernet
    uint8_t getEthernetCsPin() const { return ethernetCsPin; }
    uint8_t getEthernetRstPin() const { return ethernetRstPin; }
    uint8_t getEthernetSckPin() const { return ethernetSckPin; }
    uint8_t getEthernetMisoPin() const { return ethernetMisoPin; }
    uint8_t getEthernetMosiPin() const { return ethernetMosiPin; }
    uint32_t getEthernetFrequency() const { return ethernetFrequency; }
    uint8_t getEthernetIrqPin() const { return ethernetIrqPin; }
    const std::array<uint8_t,6>& getEthernetMac() const { return ethernetMac; }

    void setEthernetCsPin(uint8_t pin) { ethernetCsPin = pin; }
    void setEthernetRstPin(uint8_t pin) { ethernetRstPin = pin; }
    void setEthernetSckPin(uint8_t pin) { ethernetSckPin = pin; }
    void setEthernetMisoPin(uint8_t pin) { ethernetMisoPin = pin; }
    void setEthernetMosiPin(uint8_t pin) { ethernetMosiPin = pin; }
    void setEthernetFrequency(uint32_t freq) { ethernetFrequency = freq; }
    void setEthernetIrqPin(uint8_t pin) { ethernetIrqPin = pin; }
    void setEthernetMac(const std::array<uint8_t,6>& mac) { ethernetMac = mac; }

    // SubGHz
    uint8_t getSubGhzSckPin() const { return subGhzSckPin; }
    uint8_t getSubGhzMisoPin() const { return subGhzMisoPin; }
    uint8_t getSubGhzMosiPin() const { return subGhzMosiPin; }
    uint8_t getSubGhzCsPin() const { return subGhzCsPin; }
    uint8_t getSubGhzGdoPin() const { return subGhzGdoPin; }
    float getSubGhzFrequency() const { return subGhzFrequency; }

    void setSubGhzSckPin(uint8_t pin) { subGhzSckPin = pin; }
    void setSubGhzMisoPin(uint8_t pin) { subGhzMisoPin = pin; }
    void setSubGhzMosiPin(uint8_t pin) { subGhzMosiPin = pin; }
    void setSubGhzCsPin(uint8_t pin) { subGhzCsPin = pin; }
    void setSubGhzGdoPin(uint8_t pin) { subGhzGdoPin = pin; }
    void setSubGhzFrequency(float freq) { subGhzFrequency = freq; }

    // NRF24
    uint8_t getRf24CsnPin() const { return rf24CsnPin; }
    uint8_t getRf24CePin() const { return rf24CePin; }
    uint8_t getRf24SckPin() const { return rf24SckPin; }
    uint8_t getRf24MisoPin() const { return rf24MisoPin; }
    uint8_t getRf24MosiPin() const { return rf24MosiPin; }

    void setRf24CsnPin(uint8_t pin) { rf24CsnPin = pin; }
    void setRf24CePin(uint8_t pin) { rf24CePin = pin; }
    void setRf24SckPin(uint8_t pin) { rf24SckPin = pin; }
    void setRf24MisoPin(uint8_t pin) { rf24MisoPin = pin; }
    void setRf24MosiPin(uint8_t pin) { rf24MosiPin = pin; }

    // RFID (I2C PN532)
    uint8_t getRfidSdaPin() const { return rfidSdaPin; }
    uint8_t getRfidSclPin() const { return rfidSclPin; }

    void setRfidSdaPin(uint8_t pin) { rfidSdaPin = pin; }
    void setRfidSclPin(uint8_t pin) { rfidSclPin = pin; }

    // SD Card
    uint8_t getSdCardCsPin() const { return sdCardCsPin; }
    uint8_t getSdCardClkPin() const { return sdCardClkPin; }
    uint8_t getSdCardMisoPin() const { return sdCardMisoPin; }
    uint8_t getSdCardMosiPin() const { return sdCardMosiPin; }
    uint32_t getSdCardFrequency() const { return sdCardFrequency; }
    bool getHasInternalSdCard() const { return hasInternalSdCard; }

    void setSdCardCsPin(uint8_t pin) { sdCardCsPin = pin; }
    void setSdCardClkPin(uint8_t pin) { sdCardClkPin = pin; }
    void setSdCardMisoPin(uint8_t pin) { sdCardMisoPin = pin; }
    void setSdCardMosiPin(uint8_t pin) { sdCardMosiPin = pin; }
    void setSdCardFrequency(uint32_t freq) { sdCardFrequency = freq; }

    // SD File Limits
    size_t getFileCountLimit() const { return fileCountLimit; }
    size_t getFileCacheLimit() const { return fileCacheLimit; }

    void setFileCountLimit(size_t count) { fileCountLimit = count; }
    void setFileCacheLimit(size_t cache) { fileCacheLimit = cache; }

    // NVS
    const std::string& getNvsNamespace() const { return nvsNamespace; }
    void setNvsNamespace(const std::string& ns) { nvsNamespace = ns; }

    const std::string& getNvsPasswordField() const { return nvsPasswordField; }
    void setNvsPasswordField(const std::string& f) { nvsPasswordField = f; }

    const std::string& getNvsSsidField() const { return nvsSsidField; }
    void setNvsSsidField(const std::string& f) { nvsSsidField = f; }

    // Protected
    const std::vector<uint8_t>& getProtectedPins() const {
        return protectedPins;
    }

    bool isPinProtected(uint8_t pin) const {
        return std::find(protectedPins.begin(), protectedPins.end(), pin) != protectedPins.end();
    }

    bool isPinAnalog(uint8_t pin) const {
        return ((pin > 0) && (pin < 19));
    }

    // Constructor
    GlobalState() {
        #ifdef LED_PIN
            ledPin = LED_PIN;
        #endif
        #ifdef SPI_CS_PIN
            spiCSPin = SPI_CS_PIN;
        #endif
        #ifdef SPI_CLK_PIN
            spiCLKPin = SPI_CLK_PIN;
        #endif
        #ifdef SPI_MISO_PIN
            spiMISOPin = SPI_MISO_PIN;
        #endif
        #ifdef SPI_MOSI_PIN
            spiMOSIPin = SPI_MOSI_PIN;
        #endif
        #ifdef ONEWIRE_PIN
            oneWirePin = ONEWIRE_PIN;
        #endif
        #ifdef UART_BAUD
            uartBaudRate = UART_BAUD;
        #endif
        #ifdef UART_RX_PIN
            uartRxPin = UART_RX_PIN;
        #endif
        #ifdef UART_TX_PIN
            uartTxPin = UART_TX_PIN;
        #endif
        #ifdef HDUART_BAUD
            hdUartBaudRate = HDUART_BAUD;
        #endif
        #ifdef HDUART_PIN
            hdUartPin = HDUART_PIN;
        #endif
        #ifdef I2C_SCL_PIN
            i2cSclPin = I2C_SCL_PIN;
        #endif
        #ifdef I2C_SDA_PIN
            i2cSdaPin = I2C_SDA_PIN;
        #endif
        #ifdef I2C_FREQ
            i2cFrequency = I2C_FREQ;
        #endif
        #ifdef IR_TX_PIN
            infraredPin = IR_TX_PIN;
        #endif
        #ifdef IR_RX_PIN
            infraredRxPin = IR_RX_PIN;
        #endif
        #ifdef I2S_BCLK_PIN
            i2sBclkPin = I2S_BCLK_PIN;
        #endif
        #ifdef I2S_LRCK_PIN
            i2sLrckPin = I2S_LRCK_PIN;
        #endif
        #ifdef I2S_DATA_PIN
            i2sDataPin = I2S_DATA_PIN;
        #endif
        #ifdef I2S_SAMPLE_RATE
            i2sSampleRate = I2S_SAMPLE_RATE;
        #endif
        #ifdef I2S_BITS
            i2sBitsPerSample = I2S_BITS;
        #endif
        #ifdef TWOWIRE_CLK_PIN
            twoWireClkPin = TWOWIRE_CLK_PIN;
        #endif
        #ifdef TWOWIRE_IO_PIN
            twoWireIoPin = TWOWIRE_IO_PIN;
        #endif
        #ifdef TWOWIRE_RST_PIN
            twoWireRstPin = TWOWIRE_RST_PIN;
        #endif
        #ifdef THREEWIRE_CS_PIN
            threeWireCsPin = THREEWIRE_CS_PIN;
        #endif
        #ifdef THREEWIRE_SK_PIN
            threeWireSkPin = THREEWIRE_SK_PIN;
        #endif
        #ifdef THREEWIRE_DI_PIN 
            threeWireDiPin = THREEWIRE_DI_PIN;
        #endif
        #ifdef THREEWIRE_DO_PIN 
            threeWireDoPin = THREEWIRE_DO_PIN;
        #endif
        #ifdef LED_DATA_PIN
            ledDataPin = LED_DATA_PIN;
        #endif
        #ifdef LED_CLOCK_PIN
            ledClockPin = LED_CLOCK_PIN;
        #endif
        #ifdef CAN_CS_PIN
            canCspin = CAN_CS_PIN;
        #endif
        #ifdef CAN_SCK_PIN
            canSckPin = CAN_SCK_PIN;
        #endif
        #ifdef CAN_SI_PIN
            canSiPin = CAN_SI_PIN;
        #endif
        #ifdef CAN_SO_PIN
            canSoPin = CAN_SO_PIN;
        #endif
        #ifdef CAN_KBPS
            canKbps = CAN_KBPS;
        #endif
        #ifdef ETHERNET_CS_PIN
            ethernetCsPin = ETHERNET_CS_PIN;
        #endif
        #ifdef ETHERNET_CLK_PIN
            ethernetSckPin = ETHERNET_CLK_PIN;
        #endif
        #ifdef ETHERNET_MISO_PIN
            ethernetMisoPin = ETHERNET_MISO_PIN;
        #endif
        #ifdef ETHERNET_MOSI_PIN
            ethernetMosiPin = ETHERNET_MOSI_PIN;
        #endif
        #ifdef ETHERNET_IRQ_PIN
            ethernetIrqPin = ETHERNET_IRQ_PIN;
        #endif
        #ifdef SUBGHZ_SCK_PIN
            subGhzSckPin = SUBGHZ_SCK_PIN;
        #endif
        #ifdef SUBGHZ_SO_PIN
            subGhzMisoPin = SUBGHZ_SO_PIN;
        #endif
        #ifdef SUBGHZ_SI_PIN
            subGhzMosiPin = SUBGHZ_SI_PIN;
        #endif
        #ifdef SUBGHZ_CS_PIN
            subGhzCsPin = SUBGHZ_CS_PIN;
        #endif
        #ifdef SUBGHZ_GDO_PIN
            subGhzGdoPin = SUBGHZ_GDO_PIN;
        #endif
        #ifdef I2C_SCL_PIN
            rfidSclPin = I2C_SCL_PIN;
        #endif
        #ifdef I2C_SDA_PIN
            rfidSdaPin = I2C_SDA_PIN;
        #endif
        #ifdef SUBGHZ_CS_PIN
            rf24CsnPin = SUBGHZ_CS_PIN;
        #endif
        #ifdef SUBGHZ_GDO_PIN
            rf24CePin = SUBGHZ_GDO_PIN;
        #endif
        #ifdef SUBGHZ_SCK_PIN
            rf24SckPin = SUBGHZ_SCK_PIN;
        #endif
        #ifdef SUBGHZ_SO_PIN
            rf24MisoPin = SUBGHZ_SO_PIN;
        #endif
        #ifdef SUBGHZ_SI_PIN
            rf24MosiPin = SUBGHZ_SI_PIN;
        #endif
        #ifdef SDCARD_CS_PIN
            hasInternalSdCard = true;
            sdCardCsPin = SDCARD_CS_PIN;
        #else 
            sdCardCsPin = spiCSPin;
        #endif
        #ifdef SDCARD_CLK_PIN
            sdCardClkPin = SDCARD_CLK_PIN;
        #else 
            sdCardClkPin = spiCLKPin;
        #endif
        #ifdef SDCARD_MISO_PIN
            sdCardMisoPin = SDCARD_MISO_PIN;
        #else
            sdCardMisoPin = spiMISOPin;
        #endif
        #ifdef SDCARD_MOSI_PIN
            sdCardMosiPin = SDCARD_MOSI_PIN;
        #else
            sdCardMosiPin = spiMOSIPin;
        #endif

        #ifdef PROTECTED_PINS
        {
            protectedPins.clear();
            std::string pinsStr = PROTECTED_PINS;
            std::stringstream ss(pinsStr);
            std::string item;
            while (std::getline(ss, item, ',')) {
                protectedPins.push_back(std::stoi(item));
            }
        }
        #endif

        #ifdef JTAG_SCAN_PINS
        {
            jtagScanPins.clear();
            std::string pinsStr = JTAG_SCAN_PINS;
            std::stringstream ss(pinsStr);
            std::string item;
            while (std::getline(ss, item, ',')) {
                jtagScanPins.push_back((std::stoi(item)));
            }
        }
        #endif
    }
};