Cant Join Lorawan TTN Xiao ESP32-S3 + Wio-SX1262 Kit

[rallep71]

Hello, maybe someone can help me, my Xiao ESP32-S3 + Wio-SX1262 Kit can't connect to TTN,
stays still when joining, what am I doing wrong, or what have I forgotten?

The pin assignment is correct, the sx1261 is initialised via spi, it goes via a b2b conector. I'll post my code.

Plattform.ini

[env:seeed_xiao_esp32s3]
platform = espressif32@^6.10.0 ; Verwende eine aktuelle Core-Version
board = seeed_xiao_esp32s3
framework = arduino
monitor_speed = 115200
upload_protocol = esptool
lib_deps =
    beegee-tokyo/SX126x-Arduino@^2.0.30 ; Die Zielbibliothek
build_flags =
    ; Definiere Pinout 3 als Makros
    -D LORA_SCLK_PIN=7
    -D LORA_MISO_PIN=8
    -D LORA_MOSI_PIN=9
    -D LORA_NSS_PIN=41
    -D LORA_RESET_PIN=42
    -D LORA_BUSY_PIN=40
    -D LORA_DIO1_PIN=39
    -D LORA_DIO2_PIN=38 ; Für RF Switch
    ; Konfiguration für die Bibliothek (werden in hw_config verwendet)
    -D SX126X_USE_TCXO=true
    -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_1_8V ; Teste 1.8V zuerst, evtl. 3.0V?
    -D SX126X_USE_LDO=true ; LDO verwenden (laut BSP C-Code)
    ; Einstellen des Log-Levels für Arduino (optional)
    ;-D CORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG

#include <Arduino.h>
#include <SPI.h>
#include <SX126x-Arduino.h>
#include <LoRaWan-Arduino.h> // LoRaWAN helper library

// --- Pinout 3 Definitionen (kommen aus build_flags in platformio.ini) ---
// Beispiel:
// build_flags =
//     -D LORA_SCLK_PIN=7
//     -D LORA_MISO_PIN=8
//     -D LORA_MOSI_PIN=9
//     -D LORA_NSS_PIN=41
//     -D LORA_RESET_PIN=42
//     -D LORA_BUSY_PIN=40
//     -D LORA_DIO1_PIN=39
//     -D LORA_DIO2_PIN=38
//     -D SX126X_USE_TCXO=true
//     -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_1_8V
//     -D SX126X_USE_LDO=true

// --- LoRaWAN Credentials (!!! BITTE DURCH DEINE WERTE ERSETZEN !!!) ---
uint8_t nodeDeviceEUI[8] = {+++key++++};                                               // Dein Device EUI
uint8_t nodeAppEUI[8] = {+++key++++};                                                  // Dein Join EUI (App EUI)
uint8_t nodeAppKey[16] = {+++key+++}; // Dein App Key


// --- LoRaWAN Einstellungen ---
#define LORAWAN_REGION LORAMAC_REGION_EU868
#define LORAWAN_INITIAL_CLASS CLASS_A
#define LORAWAN_TARGET_CLASS CLASS_C
#define LORAWAN_ADR_ON true
#define LORAWAN_PUBLIC_NETWORK true
#define LORAWAN_APP_INTERVAL 60000 // Sendeintervall in ms (60 Sekunden)
#define JOINREQ_NBTRIALS 3
#define LORAWAN_APP_PORT 2
bool doOTAA = true; // Aktiviere OTAA

// --- Globale Variablen ---
bool isJoined = false;
uint32_t uplinkCounter = 0;
uint32_t lastUplinkTime = 0;
bool loraTxDone = true;     // Flag: Bereit für nächsten TX?
bool requestClassC = false; // Flag: Soll Klasse C angefordert werden?

// Buffer für Uplink-Daten
static uint8_t uplink_data_buffer[64];
static lmh_app_data_t uplink_data = {uplink_data_buffer, 0, LORAWAN_APP_PORT, 0, 0};

// --- Board Funktionen (Müssen für die Zielplattform korrekt sein!) ---
/*
uint8_t BoardGetBatteryLevel()
{
    // Implementiere hier deine Batterie-Messung oder gib Dummy zurück
    return 254; // 254 = Max/Unbekannt
}
void BoardGetUniqueId(uint8_t *id)
{
    // Idealerweise ESP32 Chip ID lesen, hier Fallback auf DevEUI
    // uint64_t chipid = ESP.getEfuseMac(); // ESP32 Methode
    // id[0] = (uint8_t)(chipid >> 56); // Beispiel für ESP32, muss angepasst werden!
    // ... (Restliche Bytes) ...
    // Einfacher Fallback:
    memcpy(id, nodeDeviceEUI, 8);
}
uint32_t BoardGetRandomSeed()
{
    // ESP32 Hardware Zufallszahlengenerator nutzen
    return esp_random();
}
*/
// --- Callback Funktionen für LoRaWAN (Angepasst an lmh_callback_t) ---

// Wird aufgerufen, wenn Daten empfangen wurden
void LoraWanRxData(lmh_app_data_t *appdata)
{
    ESP_LOGI("LoRaWAN", "RX data received");
    ESP_LOGI("LoRaWAN", "RSSI: %d, SNR: %d, Port: %d", appdata->rssi, appdata->snr, appdata->port);
    if (appdata->buffsize > 0)
    {
        printf("  Payload: ");
        for (int i = 0; i < appdata->buffsize; i++)
        {
            printf("0x%02X ", appdata->buffer[i]);
        }
        printf("\n");
        // Hier Downlink verarbeiten (z.B. Relais schalten)
        // Beispiel: Wenn erstes Byte 0x01 ist, schalte Relais EIN
        // if (appdata->buffer[0] == 0x01) { digitalWrite(RELAY_PIN, HIGH); }
        // else if (appdata->buffer[0] == 0x00) { digitalWrite(RELAY_PIN, LOW); }
    }
    // Nach Empfang kann Klasse gewechselt werden (nur wenn noch nicht Klasse C)
    DeviceClass_t currentClass;
    lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS))
    {
        ESP_LOGI("LoRaWAN", "Requesting Class C after RX...");
        lmh_error_status status = lmh_class_request(LORAWAN_TARGET_CLASS);
        if (status != LMH_SUCCESS)
        {
            ESP_LOGW("LoRaWAN", "lmh_class_request failed: %d", status);
        }
        // Flag wird erst im ConfirmClass Callback zurückgesetzt
    }
}

// Wird aufgerufen, wenn Join erfolgreich war
void LoraWanHasJoined(void)
{
    ESP_LOGI("LoRaWAN", "OTAA Join successful!");
    isJoined = true;
    requestClassC = true; // Flag setzen, um Klassenwechsel anzufordern
}

// Wird aufgerufen, wenn Join fehlgeschlagen ist
void LoraWanHasJoinedFailed(void)
{
    ESP_LOGW("LoRaWAN", "OTAA Join failed");
    isJoined = false;
    requestClassC = false;
}

// Wird aufgerufen, wenn Klasse erfolgreich gewechselt wurde
void LoraWanConfirmClass(DeviceClass_t Class)
{
    ESP_LOGI("LoRaWAN", "Class switched to: %s", (Class == CLASS_A ? "A" : (Class == CLASS_B ? "B" : "C")));
    if (Class == LORAWAN_TARGET_CLASS)
    {
        requestClassC = false; // Erfolgreich gewechselt
    }
    // Erlaube Senden nach erfolgreichem Wechsel (oder Join)
    lastUplinkTime = millis() - LORAWAN_APP_INTERVAL + 5000; // Starte Uplink-Timer in 5 Sek
    loraTxDone = true;
}

// Wird aufgerufen, wenn unbestätigter Uplink fertig ist
void LoraWanUnconfFinished(void)
{
    ESP_LOGI("LoRaWAN", "Unconfirmed TX finished");
    loraTxDone = true;
    // Nach Senden kann Klasse gewechselt werden (nur wenn noch nicht Klasse C)
    DeviceClass_t currentClass;
    lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS))
    {
        ESP_LOGI("LoRaWAN", "Requesting Class C after TX...");
        lmh_error_status status = lmh_class_request(LORAWAN_TARGET_CLASS);
        if (status != LMH_SUCCESS)
        {
            ESP_LOGW("LoRaWAN", "lmh_class_request failed: %d", status);
        }
    }
}

// Wird aufgerufen, wenn bestätigter Uplink fertig ist
void LoraWanConfResult(bool result)
{
    ESP_LOGI("LoRaWAN", "Confirmed TX finished, ACK received: %s", result ? "YES" : "NO");
    loraTxDone = true;
    // Nach Senden kann Klasse gewechselt werden (nur wenn noch nicht Klasse C)
    DeviceClass_t currentClass;
    lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS))
    {
        ESP_LOGI("LoRaWAN", "Requesting Class C after TX...");
        lmh_error_status status = lmh_class_request(LORAWAN_TARGET_CLASS);
        if (status != LMH_SUCCESS)
        {
            ESP_LOGW("LoRaWAN", "lmh_class_request failed: %d", status);
        }
    }
}

// Callback-Struktur - Initialisierung exakt nach Definition in LoRaMacHelper.h
static lmh_callback_t lmh_callbacks = {
    BoardGetBatteryLevel,
    BoardGetUniqueId,
    BoardGetRandomSeed,
    LoraWanRxData,          // lmh_RxData
    LoraWanHasJoined,       // lmh_has_joined
    LoraWanConfirmClass,    // lmh_ConfirmClass
    LoraWanHasJoinedFailed, // lmh_has_joined_failed
    LoraWanUnconfFinished,  // lmh_unconf_finished
    LoraWanConfResult       // lmh_conf_result
};

// LoRaWAN Parameter Struktur
static lmh_param_t lora_param_init = {LORAWAN_ADR_ON, DR_0, LORAWAN_PUBLIC_NETWORK, JOINREQ_NBTRIALS, TX_POWER_14, false};

// Hardware-Konfiguration
hw_config hwConfig;

// Dummy-Struktur für Radio.Init (wird von lmh überschrieben)
static RadioEvents_t radioEvents = {NULL, NULL, NULL, NULL, NULL, NULL};

void setup()
{
    Serial.begin(115200);
    delay(3000); // Längeres Delay + Warten auf Serial
    long waitSerialStart = millis();
    while (!Serial && (millis() - waitSerialStart < 5000))
    {
        delay(100);
    }
    delay(500);

    Serial.println("\n=====================================");
    Serial.println("PlatformIO beegee-tokyo LoRaWAN OTAA Test v6 (Final Callbacks)");
    Serial.println("Pinout 3, LDO, TCXO 1.8V"); // Annahme Pinout 3 ist korrekt!
    Serial.println("=====================================");

    // Hardware-Konfiguration füllen
    hwConfig.CHIP_TYPE = SX1262_CHIP;
    hwConfig.PIN_LORA_NSS = LORA_NSS_PIN;
    hwConfig.PIN_LORA_RESET = LORA_RESET_PIN;
    hwConfig.PIN_LORA_BUSY = LORA_BUSY_PIN;
    hwConfig.PIN_LORA_DIO_1 = LORA_DIO1_PIN;
    hwConfig.RADIO_TXEN = -1;
    hwConfig.RADIO_RXEN = -1;
    hwConfig.USE_DIO2_ANT_SWITCH = true; // Annahme für Pinout 3 / Wio Modul
    hwConfig.USE_DIO3_TCXO = false;
    hwConfig.USE_DIO3_ANT_SWITCH = false;
#ifdef SX126X_TCXO_VOLTAGE
    hwConfig.TCXO_CTRL_VOLTAGE = SX126X_TCXO_VOLTAGE;
#else
    hwConfig.TCXO_CTRL_VOLTAGE = TCXO_CTRL_1_8V;
#endif

    Serial.println("Hardware Config:");
    Serial.printf("  NSS: %d, RST: %d, BUSY: %d, DIO1: %d\n",
                  hwConfig.PIN_LORA_NSS, hwConfig.PIN_LORA_RESET, hwConfig.PIN_LORA_BUSY,
                  hwConfig.PIN_LORA_DIO_1);
    Serial.printf("  USE_DIO2_ANT_SWITCH: %d\n", hwConfig.USE_DIO2_ANT_SWITCH);
    Serial.printf("  TCXO Voltage Enum: %d\n", hwConfig.TCXO_CTRL_VOLTAGE);

    // SPI Initialisierung
    Serial.print("Initializing SPI...");
    SPI.begin(LORA_SCLK_PIN, LORA_MISO_PIN, LORA_MOSI_PIN);
    SPI.setFrequency(8000000);
    Serial.println(" Done.");

    // LoRa Hardware Initialisierung
    Serial.print("Initializing LoRa Hardware...");
    uint32_t err_code = lora_hardware_init(hwConfig);
    if (err_code != 0)
    {
        Serial.print("\n!!! FAILED lora_hardware_init, Error code: ");
        Serial.println(err_code);
        while (1)
        {
            delay(100);
        }
    }
    Serial.println(" Done.");

    // Radio Initialisierung (wird von lmh_init benötigt)
    Serial.print("Initializing Radio...");
    Radio.Init(&radioEvents); // Leere Events übergeben
    Serial.println(" Done.");

// Setze Regulator Mode explizit
#ifdef SX126X_USE_LDO
    bool use_ldo_flag = SX126X_USE_LDO;
#else
    bool use_ldo_flag = false; // Default DC-DC, aber wir haben LDO im Flag
#endif
    Serial.print("Setting Regulator Mode to ");
    Serial.println(use_ldo_flag ? "LDO" : "DC-DC");
    SX126xSetRegulatorMode(use_ldo_flag ? USE_LDO : USE_DCDC);
    Serial.println("Regulator Mode set.");

    // Setze TCXO Control explizit
    Serial.print("Setting TCXO Control (Voltage Enum ");
    Serial.print(hwConfig.TCXO_CTRL_VOLTAGE);
    Serial.println(")...");
    SX126xSetDio3AsTcxoCtrl((RadioTcxoCtrlVoltage_t)hwConfig.TCXO_CTRL_VOLTAGE, 320);
    Serial.println("TCXO Control set.");
    delay(10);

    // LoRaWAN Stack Initialisierung
    Serial.print("Initializing LoRaWAN Stack...");
    lmh_error_status ret = lmh_init(&lmh_callbacks, lora_param_init, doOTAA, LORAWAN_INITIAL_CLASS, LORAWAN_REGION, false);
    if (ret != LMH_SUCCESS)
    {
        Serial.print("\n!!! FAILED lmh_init, Error code: ");
        Serial.println(ret);
        while (1)
        {
            delay(100);
        }
    }
    Serial.println(" Done.");

    // Setze Keys
    Serial.println("Setting LoRaWAN Keys...");
    lmh_setDevEui(nodeDeviceEUI);
    lmh_setAppEui(nodeAppEUI);
    lmh_setAppKey(nodeAppKey);
    Serial.println("Keys set.");

    // Starte Join Prozess
    Serial.println("Starting LoRaWAN Join procedure...");
    lmh_join();

    Serial.println("Setup complete. Waiting for Join...");
}

void loop()
{
    Radio.IrqProcess(); // ESSENTIELL!

    // Sende periodisch einen Uplink
    if (isJoined && loraTxDone && (millis() - lastUplinkTime > LORAWAN_APP_INTERVAL))
    {
        lastUplinkTime = millis();
        uplinkCounter++;

        uplink_data_buffer[0] = highByte(uplinkCounter);
        uplink_data_buffer[1] = lowByte(uplinkCounter);
        uplink_data_buffer[2] = BoardGetBatteryLevel();
        uplink_data.buffsize = 3;
        uplink_data.port = LORAWAN_APP_PORT;
        lmh_confirm confirmed_mode = LMH_UNCONFIRMED_MSG; // Unbestätigt senden

        ESP_LOGI("LoRaWAN", "Requesting Uplink #%lu...", uplinkCounter);
        lmh_error_status tx_status = lmh_send(&uplink_data, confirmed_mode);
        ESP_LOGI("LoRaWAN", "lmh_send returned: %d (0=Success)", tx_status);

        if (tx_status == LMH_SUCCESS)
        {
            ESP_LOGI("LoRaWAN", "Uplink request successful, waiting for Tx Callback...");
            loraTxDone = false; // Warte auf Callback
        }
        else
        {
            ESP_LOGE("LoRaWAN", "Uplink request failed immediately!");
            loraTxDone = true; // Erlaube nächsten Versuch
        }
    }

    delay(10);
}

maybe someone can help me, thanks

[beegee-tokyo]

First try to add build flag for library debug output

-D LIB_DEBUG=1

The output on USB during intialization of the SX1262 should give you first hint if your pin setup is correct.

Not sure if this is the module you use:

If it is, the second RF_SW pin is controlled by the MCU. It does switch on/off the RF antenna switch.
You need to change the hwConfig setup to

    // Hardware-Konfiguration füllen
    hwConfig.CHIP_TYPE = SX1262_CHIP;
    hwConfig.PIN_LORA_NSS = LORA_NSS_PIN;
    hwConfig.PIN_LORA_RESET = LORA_RESET_PIN;
    hwConfig.PIN_LORA_BUSY = LORA_BUSY_PIN;
    hwConfig.PIN_LORA_DIO_1 = LORA_DIO1_PIN;
    hwConfig.RADIO_TXEN = -1;
    // hwConfig.RADIO_RXEN = -1;
    hwConfig.USE_DIO2_ANT_SWITCH = true; // Annahme für Pinout 3 / Wio Modul
    hwConfig.USE_DIO3_TCXO = false;
    hwConfig.USE_DIO3_ANT_SWITCH = false;
#ifdef SX126X_TCXO_VOLTAGE
    hwConfig.TCXO_CTRL_VOLTAGE = SX126X_TCXO_VOLTAGE;
#else
    hwConfig.TCXO_CTRL_VOLTAGE = TCXO_CTRL_1_8V;
#endif

    hwConfig.USE_RXEN_ANT_PWR = true;		  // RXEN used as power for antenna **switch**
    hwConfig.RADIO_RXEN = [[[GPIO_PIN]]];

The last two lines tell the library that RXEN is used to power the RF switch and the GPIO to use as RXEN
Replace [[[GPIO_PIN]]] with the GPIO number that is connected to the RF_SW pin of the module

[rallep71]

Thanks for the hint,
yes, this is the chip, but b2b, I'll post the customised code with debug now. and, although the keys are entered correctly, it only gives me 00 in the dubug, hm, 1 week I'm already working on getting the thing to run ;=

[env:seeed_xiao_esp32s3]
platform = espressif32@^6.10.0
board = seeed_xiao_esp32s3
framework = arduino
monitor_speed = 115200
upload_protocol = esptool
lib_deps =
    beegee-tokyo/SX126x-Arduino@^2.0.30
build_flags =
    ; Pinout 3
    -D LORA_SCLK_PIN=7
    -D LORA_MISO_PIN=8
    -D LORA_MOSI_PIN=9
    -D LORA_NSS_PIN=41
    -D LORA_RESET_PIN=42
    -D LORA_BUSY_PIN=40
    -D LORA_DIO1_PIN=39
    -D LORA_DIO2_PIN=38 ; Für interne RF Switch Steuerung via SX1262 DIO2
    ; === NEU: Pin für externe RF_SW Steuerung (Wio Pin 1) ===
    ; !!! ERSETZE -1 DURCH DEN KORREKTEN GPIO, WENN BEKANNT !!!
    -D LORA_RADIO_RXEN_PIN=-1 ; Vorerst -1, wenn unbekannt
    ; Config
    -D SX126X_USE_TCXO=true
    -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_1_8V
    -D SX126X_USE_LDO=true
    ; === NEU: Debug Flag für die Bibliothek ===
    -D LIB_DEBUG=1

#include <Arduino.h>
#include <SPI.h>
#include <SX126x-Arduino.h>
#include <LoRaWan-Arduino.h>

// Pin-Definitionen kommen aus build_flags in platformio.ini
// Beispiel für platformio.ini (Pinout 3):
// build_flags =
//     -D LORA_SCLK_PIN=7
//     -D LORA_MISO_PIN=8
//     -D LORA_MOSI_PIN=9
//     -D LORA_NSS_PIN=41
//     -D LORA_RESET_PIN=42
//     -D LORA_BUSY_PIN=40
//     -D LORA_DIO1_PIN=39
//     -D LORA_DIO2_PIN=38  // Für interne RF Switch Steuerung via SX1262 DIO2
//     ; === NEU: Pin für externe RF_SW Steuerung (Wio Modul Pin 1) ===
//     ; !!! ERSETZE -1 DURCH DEN KORREKTEN GPIO, WENN BEKANNT !!!
//     -D LORA_RADIO_RXEN_PIN=-1
//     ; Config
//     -D SX126X_USE_TCXO=true
//     -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_1_8V
//     -D SX126X_USE_LDO=true
//     ; === NEU: Debug Flag für die Bibliothek ===
//     -D LIB_DEBUG=1


// --- LoRaWAN Credentials 
uint8_t nodeDeviceEUI[8] = {+++key+++};                                               // Dein Device EUI
uint8_t nodeAppEUI[8] = {+++key+++};                                                  // Dein Join EUI (App EUI)
uint8_t nodeAppKey[16] = {+++key+++}; // Dein App Key
// --- LoRaWAN Einstellungen ---
#define LORAWAN_REGION LORAMAC_REGION_EU868
#define LORAWAN_INITIAL_CLASS CLASS_A
#define LORAWAN_TARGET_CLASS CLASS_C
#define LORAWAN_ADR_ON true
#define LORAWAN_PUBLIC_NETWORK true
#define LORAWAN_APP_INTERVAL 60000 // Sendeintervall in ms (60 Sekunden)
#define JOINREQ_NBTRIALS 3
#define LORAWAN_APP_PORT 2
bool doOTAA = true;

// --- Globale Variablen ---
bool isJoined = false;
uint32_t uplinkCounter = 0;
uint32_t lastUplinkTime = 0;
bool loraTxDone = true;
bool requestClassC = false;

static uint8_t uplink_data_buffer[64];
static lmh_app_data_t uplink_data = {uplink_data_buffer, 0, LORAWAN_APP_PORT, 0, 0};

// --- Board Funktionen (aus der Bibliothek oder Dummy) ---
//uint8_t BoardGetBatteryLevel() { return 254; }
//void BoardGetUniqueId(uint8_t *id) { memcpy(id, nodeDeviceEUI, 8); }
//uint32_t BoardGetRandomSeed() { return esp_random(); }

// --- Callback Funktionen für LoRaWAN ---
void LoraWanRxData(lmh_app_data_t *appdata) {
    Serial.printf("[LoRaWAN][I] RX data received. RSSI: %d, SNR: %d, Port: %d\n", appdata->rssi, appdata->snr, appdata->port);
    if (appdata->buffsize > 0) {
        Serial.print("  Payload: ");
        for (int i = 0; i < appdata->buffsize; i++) { Serial.printf("0x%02X ", appdata->buffer[i]); }
        Serial.println();
        // Hier Downlink-Payload verarbeiten
    }
    DeviceClass_t currentClass; lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS)) {
         Serial.printf("[LoRaWAN][I] Requesting Class C after RX...\n");
         if (lmh_class_request(LORAWAN_TARGET_CLASS) != LMH_SUCCESS) { Serial.printf("[LoRaWAN][W] lmh_class_request failed for Class C\n");}
    }
}
void LoraWanHasJoined(void) { Serial.printf("[LoRaWAN][I] OTAA Join successful!\n"); isJoined = true; requestClassC = true; }
void LoraWanHasJoinedFailed(void) { Serial.printf("[LoRaWAN][W] OTAA Join failed\n"); isJoined = false; requestClassC = false; }
void LoraWanConfirmClass(DeviceClass_t Class) {
    Serial.printf("[LoRaWAN][I] Class switched to: %s\n", (Class == CLASS_A ? "A" : (Class == CLASS_B ? "B" : "C")));
    if (Class == LORAWAN_TARGET_CLASS) { requestClassC = false; }
    lastUplinkTime = millis() - LORAWAN_APP_INTERVAL + 5000; loraTxDone = true;
}
void LoraWanUnconfFinished(void) {
    Serial.printf("[LoRaWAN][I] Unconfirmed TX finished\n"); loraTxDone = true;
    DeviceClass_t currentClass; lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS)) {
         Serial.printf("[LoRaWAN][I] Requesting Class C after Unconf TX...\n");
         if (lmh_class_request(LORAWAN_TARGET_CLASS) != LMH_SUCCESS) { Serial.printf("[LoRaWAN][W] lmh_class_request failed for Class C\n");}
    }
}
void LoraWanConfResult(bool result) {
    Serial.printf("[LoRaWAN][I] Confirmed TX finished, ACK received: %s\n", result ? "YES" : "NO"); loraTxDone = true;
    DeviceClass_t currentClass; lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS)) {
         Serial.printf("[LoRaWAN][I] Requesting Class C after Conf TX...\n");
         if (lmh_class_request(LORAWAN_TARGET_CLASS) != LMH_SUCCESS) { Serial.printf("[LoRaWAN][W] lmh_class_request failed for Class C\n");}
    }
}

static lmh_callback_t lmh_callbacks = {
    BoardGetBatteryLevel, BoardGetUniqueId, BoardGetRandomSeed, LoraWanRxData,
    LoraWanHasJoined, LoraWanConfirmClass, LoraWanHasJoinedFailed,
    LoraWanUnconfFinished, LoraWanConfResult
};
static lmh_param_t lora_param_init = {LORAWAN_ADR_ON, DR_0, LORAWAN_PUBLIC_NETWORK, JOINREQ_NBTRIALS, TX_POWER_14, false};
hw_config hwConfig; // Globale Instanz
static RadioEvents_t radioEvents = { NULL, NULL, NULL, NULL, NULL, NULL };

// Task für Radio.IrqProcess()
TaskHandle_t radioTaskHandle = NULL;
void radioProcessingTask(void *pvParameters) {
    Serial.println("Radio Processing Task started on Core " + String(xPortGetCoreID()));
    while (1) {
        Radio.IrqProcess();
        vTaskDelay(pdMS_TO_TICKS(1)); // Sehr häufig aufrufen
    }
}

void setup() {
    delay(3000); Serial.begin(115200);
    long waitSerialStart = millis(); while (!Serial && (millis() - waitSerialStart < 5000)) { delay(100); } delay(500);
    Serial.println("\n=====================================");
    Serial.println("PlatformIO beegee-tokyo LoRaWAN OTAA Test v8 (RF_SW & LIB_DEBUG)");
    Serial.println("Pinout 3, LDO, TCXO 1.8V");
    Serial.println("=====================================");

    // --- Hardware-Konfiguration füllen ---
    hwConfig.CHIP_TYPE = SX1262_CHIP;
    hwConfig.PIN_LORA_NSS = LORA_NSS_PIN;
    hwConfig.PIN_LORA_RESET = LORA_RESET_PIN;
    hwConfig.PIN_LORA_BUSY = LORA_BUSY_PIN;
    hwConfig.PIN_LORA_DIO_1 = LORA_DIO1_PIN;
    // DIO2 wird von der Bibliothek intern für den RF-Switch verwendet, wenn USE_DIO2_ANT_SWITCH true ist.
    // Der Pin LORA_DIO2_PIN (aus build_flags) wird dann intern zugewiesen.
    hwConfig.RADIO_TXEN = -1;

    // --- Konfiguration für externen RF_SW Pin (Antenna Switch Power/Enable) ---
    #if defined(LORA_RADIO_RXEN_PIN) && (LORA_RADIO_RXEN_PIN != -1)
    hwConfig.RADIO_RXEN = LORA_RADIO_RXEN_PIN;
    hwConfig.USE_RXEN_ANT_PWR = true;
    Serial.printf("INFO: Using GPIO %d (LORA_RADIO_RXEN_PIN) to power/enable antenna switch.\n", LORA_RADIO_RXEN_PIN);
    pinMode(LORA_RADIO_RXEN_PIN, OUTPUT);
    digitalWrite(LORA_RADIO_RXEN_PIN, HIGH); // Antennenschalter EIN
    delay(10);
#else
    hwConfig.RADIO_RXEN = -1;
    hwConfig.USE_RXEN_ANT_PWR = false;
#endif

    hwConfig.USE_DIO2_ANT_SWITCH = true; // Der SX1262 soll seinen DIO2 für die TX/RX Umschaltung nutzen
    hwConfig.USE_DIO3_TCXO = false;      // TCXO wird NICHT über DIO3 gesteuert
    hwConfig.USE_DIO3_ANT_SWITCH = false;
    #ifdef SX126X_TCXO_VOLTAGE
        hwConfig.TCXO_CTRL_VOLTAGE = SX126X_TCXO_VOLTAGE;
    #else
        hwConfig.TCXO_CTRL_VOLTAGE = TCXO_CTRL_1_8V;
    #endif

    Serial.println("Hardware Config:");
    Serial.printf("  NSS: %d, RST: %d, BUSY: %d, DIO1: %d, DIO2 (for SX1262 internal RF SW): %d\n",
                  hwConfig.PIN_LORA_NSS, hwConfig.PIN_LORA_RESET, hwConfig.PIN_LORA_BUSY,
                  hwConfig.PIN_LORA_DIO_1, LORA_DIO2_PIN); // Zeige den DIO2 Pin an
    Serial.printf("  RADIO_RXEN (for ext RF_SW power): %d, USE_RXEN_ANT_PWR: %d\n", hwConfig.RADIO_RXEN, hwConfig.USE_RXEN_ANT_PWR);
    Serial.printf("  USE_DIO2_ANT_SWITCH (SX1262 internal): %d, TCXO Voltage: %d\n", hwConfig.USE_DIO2_ANT_SWITCH, hwConfig.TCXO_CTRL_VOLTAGE);

    Serial.print("Initializing SPI..."); SPI.begin(LORA_SCLK_PIN, LORA_MISO_PIN, LORA_MOSI_PIN); SPI.setFrequency(8000000); Serial.println(" Done.");
    Serial.print("Initializing LoRa Hardware...");
    if (lora_hardware_init(hwConfig) != 0) { Serial.println("\n!!! FAILED lora_hardware_init"); while(1);} Serial.println(" Done.");
    Serial.print("Initializing Radio..."); Radio.Init(&radioEvents); Serial.println(" Done.");

    #ifdef SX126X_USE_LDO
        bool use_ldo_flag = SX126X_USE_LDO;
    #else
        bool use_ldo_flag = false;
    #endif
    Serial.printf("Setting Regulator Mode to %s\n", use_ldo_flag ? "LDO" : "DC-DC");
    SX126xSetRegulatorMode(use_ldo_flag ? USE_LDO : USE_DCDC); Serial.println("Regulator Mode set.");
    Serial.printf("Setting TCXO Control (Voltage %d)...\n", hwConfig.TCXO_CTRL_VOLTAGE);
    SX126xSetDio3AsTcxoCtrl((RadioTcxoCtrlVoltage_t)hwConfig.TCXO_CTRL_VOLTAGE, 320); Serial.println("TCXO Control set."); delay(10);

    // Erstelle den Radio Processing Task auf Core 1
    xTaskCreatePinnedToCore(radioProcessingTask, "RadioTask", 2048, NULL, 5, &radioTaskHandle, 1);
    if (radioTaskHandle == NULL) {
        Serial.println("!!! FAILED to create RadioTask !!!");
        while(1);
    }

    Serial.print("Initializing LoRaWAN Stack...");
    if (lmh_init(&lmh_callbacks, lora_param_init, doOTAA, LORAWAN_INITIAL_CLASS, LORAWAN_REGION, false) != LMH_SUCCESS) {
        Serial.println("\n!!! FAILED lmh_init"); while(1);
    } Serial.println(" Done.");

    Serial.println("Setting LoRaWAN Keys..."); lmh_setDevEui(nodeDeviceEUI); lmh_setAppEui(nodeAppEUI); lmh_setAppKey(nodeAppKey); Serial.println("Keys set.");
    Serial.println("Starting LoRaWAN Join procedure..."); lmh_join();
    Serial.println("Setup complete. Waiting for Join...");
}

void loop() {
    // Radio.IrqProcess() wird jetzt im eigenen Task ausgeführt.
    // Der Hauptloop kann andere Dinge tun oder periodisch Status prüfen.

    lmh_confirm confirmed_mode = LMH_UNCONFIRMED_MSG;
    if (isJoined && loraTxDone && (millis() - lastUplinkTime > LORAWAN_APP_INTERVAL)) {
        lastUplinkTime = millis(); uplinkCounter++;
        uplink_data_buffer[0] = highByte(uplinkCounter); uplink_data_buffer[1] = lowByte(uplinkCounter); uplink_data_buffer[2] = BoardGetBatteryLevel();
        uplink_data.buffsize = 3; uplink_data.port = LORAWAN_APP_PORT;

        Serial.printf("[LoRaWAN][I] Requesting Uplink #%lu...\n", uplinkCounter);
        lmh_error_status tx_status = lmh_send(&uplink_data, confirmed_mode);
        Serial.printf("[LoRaWAN][I] lmh_send returned: %d (0=Success)\n", tx_status);
        if (tx_status == LMH_SUCCESS) {
            Serial.printf("[LoRaWAN][I] Uplink request successful, waiting for Tx Callback...\n");
            loraTxDone = false;
        } else {
            Serial.printf("[LoRaWAN][E] Uplink request failed immediately!\n");
            loraTxDone = true;
        }
    }
    delay(100); // Reduziere CPU-Last im Hauptloop etwas
}

Radio Processing Task started on Core 1
Initializing LoRaWAN Stack...<LMH> OTAA 
                                        DevEui=00-00-00-00-00-00-00-00
                                                                       DevAdd=00000000
           AppEui=00-00-00-00-00-00-00-00
                                         AppKey=2B-7E-15-16-28-AE-D2-A6-AB-F7-15-88-09-CF-4F-3C
                     <LMH> Selected subband 1
                                              Done.
Setting LoRaWAN Keys...
Keys set.
Starting LoRaWAN Join procedure...
<EU868> Channel count ch# 0, freq 868100000
                                           <EU868> Set channel 0, frequency 868100000
            <EU868> Channel count ch# 1, freq 868300000
                                                       <EU868> Set channel 1, frequency 868300000
                        <EU868> Channel count ch# 2, freq 868500000
                                                                   <EU868> Set channel 2, frequency 868500000
                                    <EU868> Channel count ch# 3, freq 0
                                                                       <EU868> Channel count ch# 4, freq 0
                                 <EU868> Channel count ch# 5, freq 0
                                                                    <EU868> Channel count ch# 6, freq 0
                              <EU868> Channel count ch# 7, freq 0
                                                                 <EU868> Using channel 0, frequency 868100000
                                    <LM> dutyCycleTimeOff was = 0
                                                                 <LM> Set send_join_now to false
                       Setup complete. Waiting for Join...
<RADIO> Ti<LM> OnRadioTxTimeout
                               <LM> LoRaMacState = idle
                                                       [LoRaWAN][W] OTAA Join failed

maybe look over it again, i really have no more plan eo i should start, i have already tested so much pin out, public, others etc, with this i get the sheeld addressed at least once. Thanks already

[beegee-tokyo]

You still have

-D LORA_RADIO_RXEN_PIN=-1 ; Vorerst -1, wenn unbekannt

in your platformio.ini.
You have set it to the GPIO that you have connected to the RF_SW pin on the module.

[rallep71]

yes, that's right, only I can't find how to get to the wio 1 pin via b2b, maybe I'm thinking around the corner, I don't know which pin to set there, sorry, I'm stuck, can you tell me the pin? thx

[beegee-tokyo]

Sorry, I don't know this b2b connector of Seeed products.

[rallep71]

ok, thanks. i have tried all possible pins now, 0,4,6, 10, 35,36 37, nothing, hm, i have no idea anymore, in the console it only shows me zeros for the keys, except for appkey, i don't know anymore, maybe not otaa?

=====================================
PlatformIO beegee-tokyo LoRaWAN OTAA Test v12 (Keys Set, No Verify)
Pinout 3, LDO, TCXO 1.8V
=====================================
INFO: Using GPIO 6 (LORA_RADIO_RXEN_PIN) to power/enable antenna switch.
                                                                        Hardware Config:
  NSS: 41, RST: 42, BUSY: 40, DIO1: 39, DIO2 (Pin for SX1262 internal RF SW): 38
        RADIO_RXEN (for ext RF_SW power): 6, USE_RXEN_ANT_PWR: 1
                                                                  USE_DIO2_ANT_SWITCH (SX1262 internal): 1, TCXO Voltage: 2
                                                 Initializing SPI... Done.
Initializing LoRa Hardware...<BRD> SyncWord = 0000
                                                   Done.<BRD> 
LoRa Task started
                 Initializing Radio... Done.
Setting Regulator Mode to LDO
                             Regulator Mode set.
Setting TCXO Control (Voltage 2)...
                                   TCXO Control set.
Radio Processing Task started on Core 1
Initializing LoRaWAN Stack...<LMH> OTAA 
                                        DevEui=00-00-00-00-00-00-00-00
                                                                      DevAdd=00000000
           AppEui=00-00-00-00-00-00-00-00
                                         AppKey=2B-7E-15-16-28-AE-D2-A6-AB-F7-15-88-09-CF-4F-3C
                     <LMH> Selected subband 1
                                              Done.
Setting LoRaWAN Keys (as defined in code)...
Keys set command sent.
Starting LoRaWAN Join procedure...
<EU868> Channel count ch# 0, freq 868100000
                                           <EU868> Set channel 0, frequency 868100000
            <EU868> Channel count ch# 1, freq 868300000
                                                       <EU868> Set channel 1, frequency 868300000
                        <EU868> Channel count ch# 2, freq 868500000
                                                                   <EU868> Set channel 2, frequency 868500000
                                    <EU868> Channel count ch# 3, freq 0
                                                                       <EU868> Channel count ch# 4, freq 0
                                 <EU868> Channel count ch# 5, freq 0
                                                                    <EU868> Channel count ch# 6, freq 0
                              <EU868> Channel count ch# 7, freq 0
                                                                 <EU868> Using channel 0, frequency 868100000
                                    <LM> dutyCycleTimeOff was = 0
                                                                 <LM> Set send_join_now to false
                       Join request sent by lmh_join(). Waiting for network response...
Setup complete. Waiting for Join...
<RAD
    <LM> OnRadioTxTimeout
                         <LM> LoRaMacState = idleN][W] OTAA Join failed

[beegee-tokyo]

I guess you had replaced the fakes here

uint8_t nodeDeviceEUI[8] = {+++key++++};                                               // Dein Device EUI
uint8_t nodeAppEUI[8] = {+++key++++};                                                  // Dein Join EUI (App EUI)
uint8_t nodeAppKey[16] = {+++key+++}; // Dein App Key

with the correct values.

And set the keys before you initialize the stack

    Serial.print("Initializing LoRaWAN Stack...");
    if (lmh_init(&lmh_callbacks, lora_param_init, doOTAA, LORAWAN_INITIAL_CLASS, LORAWAN_REGION, false) != LMH_SUCCESS) {
        Serial.println("\n!!! FAILED lmh_init"); while(1);
    } Serial.println(" Done.");

    Serial.println("Setting LoRaWAN Keys..."); lmh_setDevEui(nodeDeviceEUI); lmh_setAppEui(nodeAppEUI); lmh_setAppKey(nodeAppKey); Serial.println("Keys set.");

should be

    Serial.println("Setting LoRaWAN Keys..."); lmh_setDevEui(nodeDeviceEUI); lmh_setAppEui(nodeAppEUI); lmh_setAppKey(nodeAppKey); Serial.println("Keys set.");

    Serial.print("Initializing LoRaWAN Stack...");
    if (lmh_init(&lmh_callbacks, lora_param_init, doOTAA, LORAWAN_INITIAL_CLASS, LORAWAN_REGION, false) != LMH_SUCCESS) {
        Serial.println("\n!!! FAILED lmh_init"); while(1);
    } Serial.println(" Done.");

[rallep71]

Thanks for the hint, that would be solved, but unfortunately I'm still stuck with the pins, there must be a way to find out. I've searched to the last page of the internet, I can't find it, here's my debug output: (-1 wanted to see if it assigns the pin itself)({+++key++++}; yes, fake)

=====================================
PlatformIO beegee-tokyo LoRaWAN OTAA Test v11 (Keys before Init)
Pinout 3, LDO, TCXO 1.8V
=====================================
INFO: Not using a dedicated RXEN pin for antenna switch power.
Hardware Config:
  NSS: 41, RST: 42, BUSY: 40, DIO1: 39, DIO2 (Pin for SX1262 internal RF SW): 38
        RADIO_RXEN (for ext RF_SW power): -1, USE_RXEN_ANT_PWR: 0
                                                                   USE_DIO2_ANT_SWITCH (SX1262 internal): 1, TCXO Voltage: 2
                                                  Initializing SPI... Done.
Initializing LoRa Hardware...<BRD> SyncWord = 0000
                                                   Done.<BRD> 
LoRa Task started
                 Initializing Radio... Done.
Setting Regulator Mode to LDO
                             Regulator Mode set.
Setting TCXO Control (Voltage 2)...
                                   TCXO Control set.
Radio Processing Task started on Core 1
Setting LoRaWAN Keys (as defined in code)...
Keys set command sent.
Initializing LoRaWAN Stack...<LMH> OTAA 
                                        DevEui=70-B3-D5-7E-D0-07-08-81
                                                                      DevAdd=00000000
           AppEui=F5-09-56-43-F0-F0-65-98
                                         AppKey=E4-94-39-31-8B-9E-3B-93-63-DF-89-57-B8-5C-76-90
                     <LMH> Selected subband 1
                                              Done.
Starting LoRaWAN Join procedure...
<EU868> Channel count ch# 0, freq 868100000
                                           <EU868> Set channel 0, frequency 868100000
            <EU868> Channel count ch# 1, freq 868300000
                                                       <EU868> Set channel 1, frequency 868300000
                        <EU868> Channel count ch# 2, freq 868500000
                                                                   <EU868> Set channel 2, frequency 868500000
                                    <EU868> Channel count ch# 3, freq 0
                                                                       <EU868> Channel count ch# 4, freq 0
                                 <EU868> Channel count ch# 5, freq 0
                                                                    <EU868> Channel count ch# 6, freq 0
                              <EU868> Channel count ch# 7, freq 0
                                                                 <EU868> Using channel 0, frequency 868100000
                                    <LM> dutyCycleTimeOff was = 0
                                                                 <LM> Set send_join_now to false
                       Join request sent by lmh_join(). Waiting for network response...
Setup complete. Waiting for Join...
<RA
   <LM> OnRadioTxTimeout
                        <LM> LoRaMacState = iJoin failed

[beegee-tokyo]

You have to solve the problem of the RF_SW pin. Or connect it to 3.3V for testing.

[hpssjellis]

I am very interested in everything to do with this kit. Here is the link to seeed about the kit. All LoRa P2P, LoRaWan, both helium and TTN ( in various places around the world, LoRaWan in the USA is different than in Europe or Asia) and Meshtastic working examples should be on this site.

https://wiki.seeedstudio.com/wio_sx1262_with_xiao_esp32s3_kit/

These working examples should be Seeed's responsibility. The B2B connector should mean that all connections are correct and we just need working code examples. Hopefully @rallep71 has two or more of the devices so you can check that your modules are working correctly.

[rallep71]

Unfortunately I only have one device, I have already tested the examples, the binary files work, no question. I have been working through the code for this product for over a week now and have been unsuccessful. I would like to fully utilise this technology and see what works, Lora P2P, Lorawan Class A, B and C. Possibly could be broken, could be, only the binaries work. but I don't want these ready made things because you are limited.

What I am missing here is the direct access to RS_SW2 the other one is internal and works. Unfortunately I have to rely on other libraries for Lorawan Class C, Seed doesn't have one of those. I did a similar project with Healtec V3, they have ready-made libraries for it that also work. here---> https://iot.handwerker.jetzt/

[beegee-tokyo]

@rallep71
If you use @hpssjellis link and check the Hardware Overview you can see that RF_SW is the GPIO5 of the ESP32:

That means the definition for RADIO_RXEN should be:

hwConfig.RADIO_RXEN = 5;

[rallep71]

Thank you, that was an important hint!
I soldered a wire to Wio pin 1 RF_SW, which I connected to seed ESp32S3 on D4, i.e. pin 5.
TimerTxTimeout
OnRadioTxTimeout still comes up, here is my log:

[20218.09h.44m.48s.072] PlatformIO beegee-tokyo LoRaWAN OTAA Test v15 (Corrected Globals)
[20218.09h.44m.48s.072] Pinout 3, LDO, TCXO 1.8V, RF_SW on GPIO 5
[20218.09h.44m.48s.072] =====================================
[20218.09h.44m.48s.072] INFO: Using GPIO 5 (LORA_RADIO_RXEN_PIN) for external RF_SW control.
[20218.09h.44m.48s.078] INFO: LORA_RADIO_RXEN_PIN (GPIO 5) initially set to HIGH (RX mode).
[20218.09h.44m.48s.082] Final Hardware Config:
[20218.09h.44m.48s.082]   NSS: 41, RST: 42, BUSY: 40, DIO1: 39, DIO2 (Pin for SX1262 internal RF SW): 38
[20218.09h.44m.48s.082]   RADIO_RXEN (for ext RF_SW power): 5, USE_RXEN_ANT_PWR: 1
[20218.09h.44m.48s.082]   USE_DIO2_ANT_SWITCH (SX1262 internal): 1, TCXO Voltage: 2
[20218.09h.44m.48s.082] Initializing SPI... Done.
[20218.09h.44m.48s.082] Initializing LoRa Hardware...<BRD> SyncWord = 0000
[20218.09h.44m.48s.113]  Done.<BRD> 
[20218.09h.44m.48s.113] LoRa Task started
[20218.09h.44m.48s.113] Initializing Radio... Done.
[20218.09h.44m.48s.144] Setting Regulator Mode to LDO
[20218.09h.44m.48s.144] Regulator Mode set.
[20218.09h.44m.48s.144] Setting TCXO Control (Voltage 2)...
[20218.09h.44m.48s.144] TCXO Control set.
[20218.09h.44m.48s.154] Radio Processing Task started on Core 1
[20218.09h.44m.48s.154] Setting LoRaWAN Keys (as defined in code)...
[20218.09h.44m.48s.154] Keys set command sent.
[20218.09h.44m.48s.154] Initializing LoRaWAN Stack...<LMH> OTAA 
[20218.09h.44m.48s.154] DevEui=70-B3-D5-7E-D0-07-08-81
[20218.09h.44m.48s.154] DevAdd=00000000
[20218.09h.44m.48s.154] AppEui=F5-09-56-43-F0-F0-65-98
[20218.09h.44m.48s.154] AppKey=E4-94-39-31-8B-9E-3B-93-63-DF-89-57-B8-5C-76-90
[20218.09h.44m.48s.193] <LMH> Selected subband 1
[20218.09h.44m.48s.193]  Done.
[20218.09h.44m.48s.193] [RF_SW] Setting GPIO 5 to LOW (TX Mode)
[20218.09h.44m.48s.193] Starting LoRaWAN Join procedure...
[20218.09h.44m.48s.196] <EU868> Channel count ch# 0, freq 868100000
[20218.09h.44m.48s.196] <EU868> Set channel 0, frequency 868100000
[20218.09h.44m.48s.196] <EU868> Channel count ch# 1, freq 868300000
[20218.09h.44m.48s.196] <EU868> Set channel 1, frequency 868300000
[20218.09h.44m.48s.196] <EU868> Channel count ch# 2, freq 868500000
[20218.09h.44m.48s.196] <EU868> Set channel 2, frequency 868500000
[20218.09h.44m.48s.197] <EU868> Channel count ch# 3, freq 0
[20218.09h.44m.48s.197] <EU868> Channel count ch# 4, freq 0
[20218.09h.44m.48s.197] <EU868> Channel count ch# 5, freq 0
[20218.09h.44m.48s.197] <EU868> Channel count ch# 6, freq 0
[20218.09h.44m.48s.197] <EU868> Channel count ch# 7, freq 0
[20218.09h.44m.48s.197] <EU868> Using channel 0, frequency 868100000
[20218.09h.44m.48s.197] <LM> dutyCycleTimeOff was = 0
[20218.09h.44m.48s.197] <LM> Set send_join_now to false
[20218.09h.44m.48s.198] Join request initiated by lmh_join(). Waiting for network response...
[20218.09h.44m.48s.198] Setup complete. Waiting for Join...
[20218.09h.44m.51s.198] <RADIO> TimerTxTimeout
[20218.09h.44m.51s.198] <LM> OnRadioTxTimeout
[20218.09h.44m.51s.448] <LM> LoRaMacState = idle
[20218.09h.44m.51s.448] [LoRaWAN][W] OTAA Join failed
[20218.09h.44m.51s.448] [RF_SW] Setting GPIO 5 to HIGH (RX Mode)

#include <Arduino.h>
#include <SPI.h>
#include <SX126x-Arduino.h>
#include <LoRaWan-Arduino.h>

// Pin-Definitionen kommen aus build_flags in platformio.ini
// (Stelle sicher, dass LORA_RADIO_RXEN_PIN auf 5 gesetzt ist in platformio.ini)

// --- LoRaWAN Credentials (!!! BITTE ANPASSEN !!!) ---
uint8_t nodeDeviceEUI[8] = {0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x07, 0x08, 0x81};
uint8_t nodeAppEUI[8]    = {0xF5, 0x09, 0x56, 0x43, 0xF0, 0xF0, 0x65, 0x98};
uint8_t nodeAppKey[16]   = {0xE4, 0x94, 0x39, 0x31, 0x8B, 0x9E, 0x3B, 0x93, 0x63, 0xDF, 0x89, 0x57, 0xB8, 0x5C, 0x76, 0x90};

// --- LoRaWAN Einstellungen ---
#define LORAWAN_REGION LORAMAC_REGION_EU868
#define LORAWAN_INITIAL_CLASS CLASS_A
#define LORAWAN_TARGET_CLASS CLASS_C
#define LORAWAN_ADR_ON true
#define LORAWAN_PUBLIC_NETWORK true
#define LORAWAN_APP_INTERVAL 60000
#define JOINREQ_NBTRIALS 3
#define LORAWAN_APP_PORT 2
bool doOTAA = true;

// --- Globale Variablen ---
bool isJoined = false;
uint32_t uplinkCounter = 0;
uint32_t lastUplinkTime = 0;
bool loraTxDone = true;
bool requestClassC = false;
static uint8_t uplink_data_buffer[64];
static lmh_app_data_t uplink_data = {uplink_data_buffer, 0, LORAWAN_APP_PORT, 0, 0};

// === Hardware-Konfiguration (Globale Variable - EINMAL DEKLARIEREN) ===
hw_config hwConfig;

// === RadioEvents Struktur (Globale Variable - EINMAL DEKLARIEREN) ===
static RadioEvents_t radioEvents = { NULL, NULL, NULL, NULL, NULL, NULL };

// --- Board Funktionen ---
//uint8_t BoardGetBatteryLevel() { return 254; }
//void BoardGetUniqueId(uint8_t *id) { memcpy(id, nodeDeviceEUI, 8); }
//uint32_t BoardGetRandomSeed() { return esp_random(); }


// --- Hilfsfunktion zum Setzen des externen RF Switch ---
void setExternalRfSwitch(bool isTx) {
    #if defined(LORA_RADIO_RXEN_PIN) && (LORA_RADIO_RXEN_PIN != -1)
        // Zugriff auf die globale Variable hwConfig
        if (hwConfig.USE_RXEN_ANT_PWR) { // Nur wenn die Logik in hwConfig auch aktiv ist
            if (isTx) {
                Serial.printf("[RF_SW] Setting GPIO %d to LOW (TX Mode)\n", LORA_RADIO_RXEN_PIN);
                digitalWrite(LORA_RADIO_RXEN_PIN, LOW);
            } else {
                Serial.printf("[RF_SW] Setting GPIO %d to HIGH (RX Mode)\n", LORA_RADIO_RXEN_PIN);
                digitalWrite(LORA_RADIO_RXEN_PIN, HIGH);
            }
            delayMicroseconds(100); // Kurze Stabilisierungszeit für den Schalter
        }
    #endif
}

// --- Callback Funktionen für LoRaWAN ---
void LoraWanRxData(lmh_app_data_t *appdata) {
    Serial.printf("[LoRaWAN][I] RX data. RSSI: %d, SNR: %d, Port: %d\n", appdata->rssi, appdata->snr, appdata->port);
    if (appdata->buffsize > 0) {
        Serial.print("  Payload: ");
        for (int i = 0; i < appdata->buffsize; i++) { Serial.printf("0x%02X ", appdata->buffer[i]); }
        Serial.println();
    }
    setExternalRfSwitch(false); // Nach RX sicherstellen, dass RF_SW auf RX steht
    DeviceClass_t currentClass; lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS)) {
         Serial.printf("[LoRaWAN][I] Requesting Class C after RX...\n");
         if (lmh_class_request(LORAWAN_TARGET_CLASS) != LMH_SUCCESS) { Serial.printf("[LoRaWAN][W] lmh_class_request Class C failed\n");}
    }
}
void LoraWanHasJoined(void) {
    Serial.printf("[LoRaWAN][I] OTAA Join successful!\n");
    isJoined = true;
    requestClassC = true;
    setExternalRfSwitch(false); // Nach Join auf RX schalten
}
void LoraWanHasJoinedFailed(void) {
    Serial.printf("[LoRaWAN][W] OTAA Join failed\n");
    isJoined = false;
    requestClassC = false;
    setExternalRfSwitch(false); // Nach fehlgeschlagenem Join auf RX schalten
}
void LoraWanConfirmClass(DeviceClass_t Class) {
    Serial.printf("[LoRaWAN][I] Class switched to: %s\n", (Class == CLASS_A ? "A" : Class == CLASS_C ? "C" : "B"));
    if (Class == LORAWAN_TARGET_CLASS) { requestClassC = false; }
    lastUplinkTime = millis() - LORAWAN_APP_INTERVAL + 5000;
    loraTxDone = true;
    setExternalRfSwitch(false); // Nach Klassenwechsel auf RX schalten
}
void LoraWanUnconfFinished(void) {
    Serial.printf("[LoRaWAN][I] Unconfirmed TX finished\n");
    loraTxDone = true;
    setExternalRfSwitch(false); // Nach TX auf RX schalten
    DeviceClass_t currentClass; lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS)) {
         Serial.printf("[LoRaWAN][I] Requesting Class C after Unconf TX...\n");
         if (lmh_class_request(LORAWAN_TARGET_CLASS) != LMH_SUCCESS) { Serial.printf("[LoRaWAN][W] lmh_class_request Class C failed\n");}
    }
}
void LoraWanConfResult(bool result) {
    Serial.printf("[LoRaWAN][I] Confirmed TX finished, ACK: %s\n", result ? "YES" : "NO");
    loraTxDone = true;
    setExternalRfSwitch(false); // Nach TX auf RX schalten
    DeviceClass_t currentClass; lmh_class_get(&currentClass);
    if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS)) {
         Serial.printf("[LoRaWAN][I] Requesting Class C after Conf TX...\n");
         if (lmh_class_request(LORAWAN_TARGET_CLASS) != LMH_SUCCESS) { Serial.printf("[LoRaWAN][W] lmh_class_request Class C failed\n");}
    }
}

static lmh_callback_t lmh_callbacks = {
    BoardGetBatteryLevel, BoardGetUniqueId, BoardGetRandomSeed, LoraWanRxData,
    LoraWanHasJoined, LoraWanConfirmClass, LoraWanHasJoinedFailed,
    LoraWanUnconfFinished, LoraWanConfResult
};
static lmh_param_t lora_param_init = {LORAWAN_ADR_ON, DR_0, LORAWAN_PUBLIC_NETWORK, JOINREQ_NBTRIALS, TX_POWER_14, false};
// hwConfig und radioEvents sind jetzt oben global deklariert

TaskHandle_t radioTaskHandle = NULL;
void radioProcessingTask(void *pvParameters) {
    Serial.println("Radio Processing Task started on Core " + String(xPortGetCoreID()));
    while (1) { Radio.IrqProcess(); vTaskDelay(pdMS_TO_TICKS(1)); }
}

void setup() {
    delay(3000); Serial.begin(115200);
    long waitSerialStart = millis(); while (!Serial && (millis() - waitSerialStart < 5000)) { delay(100); } delay(500);
    Serial.println("\n=====================================");
    Serial.println("PlatformIO beegee-tokyo LoRaWAN OTAA Test v15 (Corrected Globals)");
    Serial.println("Pinout 3, LDO, TCXO 1.8V, RF_SW on GPIO 5");
    Serial.println("=====================================");

    // Hardware-Konfiguration füllen
    hwConfig.CHIP_TYPE = SX1262_CHIP;
    hwConfig.PIN_LORA_NSS = LORA_NSS_PIN;
    hwConfig.PIN_LORA_RESET = LORA_RESET_PIN;
    hwConfig.PIN_LORA_BUSY = LORA_BUSY_PIN;
    hwConfig.PIN_LORA_DIO_1 = LORA_DIO1_PIN;
    hwConfig.RADIO_TXEN = -1;

    #if defined(LORA_RADIO_RXEN_PIN) && (LORA_RADIO_RXEN_PIN != -1)
        hwConfig.RADIO_RXEN = LORA_RADIO_RXEN_PIN;
        hwConfig.USE_RXEN_ANT_PWR = true;
        Serial.printf("INFO: Using GPIO %d (LORA_RADIO_RXEN_PIN) for external RF_SW control.\n", LORA_RADIO_RXEN_PIN);
        pinMode(LORA_RADIO_RXEN_PIN, OUTPUT);
        digitalWrite(LORA_RADIO_RXEN_PIN, HIGH); // Initial auf RX (HIGH) setzen
        Serial.printf("INFO: LORA_RADIO_RXEN_PIN (GPIO %d) initially set to HIGH (RX mode).\n", LORA_RADIO_RXEN_PIN);
        delay(10);
    #else
        hwConfig.RADIO_RXEN = -1;
        hwConfig.USE_RXEN_ANT_PWR = false;
        Serial.println("INFO: Not using a dedicated RXEN pin for antenna switch power.");
    #endif

    hwConfig.USE_DIO2_ANT_SWITCH = true;
    hwConfig.USE_DIO3_TCXO = false;
    hwConfig.USE_DIO3_ANT_SWITCH = false;
    #ifdef SX126X_TCXO_VOLTAGE
        hwConfig.TCXO_CTRL_VOLTAGE = SX126X_TCXO_VOLTAGE;
    #else
        hwConfig.TCXO_CTRL_VOLTAGE = TCXO_CTRL_1_8V;
    #endif

    Serial.println("Final Hardware Config:");
    Serial.printf("  NSS: %d, RST: %d, BUSY: %d, DIO1: %d, DIO2 (Pin for SX1262 internal RF SW): %d\n",
                  hwConfig.PIN_LORA_NSS, hwConfig.PIN_LORA_RESET, hwConfig.PIN_LORA_BUSY,
                  hwConfig.PIN_LORA_DIO_1, LORA_DIO2_PIN);
    Serial.printf("  RADIO_RXEN (for ext RF_SW power): %d, USE_RXEN_ANT_PWR: %d\n", hwConfig.RADIO_RXEN, hwConfig.USE_RXEN_ANT_PWR);
    Serial.printf("  USE_DIO2_ANT_SWITCH (SX1262 internal): %d, TCXO Voltage: %d\n", hwConfig.USE_DIO2_ANT_SWITCH, hwConfig.TCXO_CTRL_VOLTAGE);

    Serial.print("Initializing SPI..."); SPI.begin(LORA_SCLK_PIN, LORA_MISO_PIN, LORA_MOSI_PIN); SPI.setFrequency(8000000); Serial.println(" Done.");
    Serial.print("Initializing LoRa Hardware...");
    if (lora_hardware_init(hwConfig) != 0) { Serial.printf("\n!!! FAILED lora_hardware_init\n"); while(1);} Serial.println(" Done.");
    Serial.print("Initializing Radio..."); Radio.Init(&radioEvents); Serial.println(" Done.");

    #ifdef SX126X_USE_LDO
        bool use_ldo_flag = SX126X_USE_LDO;
    #else
        bool use_ldo_flag = false;
    #endif
    Serial.printf("Setting Regulator Mode to %s\n", use_ldo_flag ? "LDO" : "DC-DC");
    SX126xSetRegulatorMode(use_ldo_flag ? USE_LDO : USE_DCDC); Serial.println("Regulator Mode set.");
    Serial.printf("Setting TCXO Control (Voltage %d)...\n", hwConfig.TCXO_CTRL_VOLTAGE);
    SX126xSetDio3AsTcxoCtrl((RadioTcxoCtrlVoltage_t)hwConfig.TCXO_CTRL_VOLTAGE, 320); Serial.println("TCXO Control set."); delay(10);

    xTaskCreatePinnedToCore(radioProcessingTask, "RadioTask", 2048, NULL, 5, &radioTaskHandle, 1);
    if (radioTaskHandle == NULL) { Serial.println("!!! FAILED to create RadioTask !!!"); while(1); }

    // Keys VOR lmh_init setzen
    Serial.println("Setting LoRaWAN Keys (as defined in code)...");
    lmh_setDevEui(nodeDeviceEUI);
    lmh_setAppEui(nodeAppEUI);
    lmh_setAppKey(nodeAppKey);
    Serial.println("Keys set command sent.");

    Serial.print("Initializing LoRaWAN Stack...");
    if (lmh_init(&lmh_callbacks, lora_param_init, doOTAA, LORAWAN_INITIAL_CLASS, LORAWAN_REGION, false) != LMH_SUCCESS) {
        Serial.printf("\n!!! FAILED lmh_init\n"); while(1);
    } Serial.println(" Done.");

    // RF_SW explizit auf TX (LOW) setzen VOR dem Join
    setExternalRfSwitch(true); // true für TX

    Serial.println("Starting LoRaWAN Join procedure...");
    lmh_join();
    Serial.println("Join request initiated by lmh_join(). Waiting for network response...");

    Serial.println("Setup complete. Waiting for Join...");
}

void loop() {
    // Radio.IrqProcess() wird im Task ausgeführt

    lmh_confirm confirmed_mode = LMH_UNCONFIRMED_MSG;
    if (isJoined && loraTxDone && (millis() - lastUplinkTime > LORAWAN_APP_INTERVAL)) {
        lastUplinkTime = millis(); uplinkCounter++;
        uplink_data_buffer[0] = highByte(uplinkCounter);
        uplink_data_buffer[1] = lowByte(uplinkCounter);
        uplink_data_buffer[2] = BoardGetBatteryLevel();
        uplink_data.buffsize = 3;
        uplink_data.port = LORAWAN_APP_PORT;

        // RF_SW auf TX (LOW) setzen VOR dem Senden
        setExternalRfSwitch(true); // true für TX

        Serial.printf("[LoRaWAN][I] Requesting Uplink #%lu...\n", uplinkCounter);
        lmh_error_status tx_status = lmh_send(&uplink_data, confirmed_mode);
        Serial.printf("[LoRaWAN][I] lmh_send returned: %d (0=Success)\n", tx_status);

        if (tx_status == LMH_SUCCESS) {
            Serial.printf("[LoRaWAN][I] Uplink request successful, waiting for Tx Callback...\n");
            loraTxDone = false;
            // RF_SW wird im TxDone-Callback auf RX (HIGH) zurückgesetzt
        } else {
            Serial.printf("[LoRaWAN][E] Uplink request failed immediately!\n");
            loraTxDone = true;
            setExternalRfSwitch(false); // Bei Fehler sofort zurück auf RX
        }
    }
    delay(100);
}

[env:seeed_xiao_esp32s3]
platform = espressif32@^6.10.0
board = seeed_xiao_esp32s3
framework = arduino
monitor_speed = 115200
upload_protocol = esptool
lib_deps =
    beegee-tokyo/SX126x-Arduino@^2.0.30
build_flags =
    ; Pinout 3 - Kernpins
    -D LORA_SCLK_PIN=7
    -D LORA_MISO_PIN=8
    -D LORA_MOSI_PIN=9
    -D LORA_NSS_PIN=41
    -D LORA_RESET_PIN=42
    -D LORA_BUSY_PIN=40
    -D LORA_DIO1_PIN=39
    -D LORA_DIO2_PIN=38  ; Für interne RF Switch Steuerung via SX1262 DIO2
    ; === Externer RF_SW Pin (Wio Pin 1) jetzt auf XIAO GPIO 5 (D4) ===
    -D LORA_RADIO_RXEN_PIN=5
    ; Config
    -D SX126X_USE_TCXO=true
    -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_1_8V
    -D SX126X_USE_LDO=true
    -D LIB_DEBUG=2

[beegee-tokyo]

#define LORAWAN_REGION LORAMAC_REGION_EU868

Is this the region you setup in the gateway and in TTN?

[rallep71]

yes, is the region, why?

[rallep71]

"Yes, LORAMAC_REGION_EU868 is set in my main.cpp and passed to lmh_init().
I have also double-checked my gateway configuration and my device/gateway registration in TTN (or ChirpStack). All are configured for the EU868 frequency plan.
The issue still seems to be the OnRadioTxTimeout occurring before any packet is seen at the gateway."

[beegee-tokyo]

Just verifying.

[20218.09h.44m.51s.448] [RF_SW] Setting GPIO 5 to HIGH (RX Mode)

Why are you controlling this pin from your application. The library controls all of this by itself.
You are interfering with the libraries actions.

Same for lines like

    Serial.printf("Setting Regulator Mode to %s\n", use_ldo_flag ? "LDO" : "DC-DC");
    SX126xSetRegulatorMode(use_ldo_flag ? USE_LDO : USE_DCDC); Serial.println("Regulator Mode set.");
    Serial.printf("Setting TCXO Control (Voltage %d)...\n", hwConfig.TCXO_CTRL_VOLTAGE);
    SX126xSetDio3AsTcxoCtrl((RadioTcxoCtrlVoltage_t)hwConfig.TCXO_CTRL_VOLTAGE, 320); Serial.println("TCXO Control set."); delay(10);

There is no need to do this from application layer. If the settings in hw_config are correct, you should not touch that.

[rallep71]

Thanks for the information, I have changed it,
my log is back to timeout... somehow I don't seem to understand it anymore...

`#include <Arduino.h>
#include <SPI.h>
#include <SX126x-Arduino.h>
#include <LoRaWan-Arduino.h>

// Pin-Definitionen kommen aus build_flags in platformio.ini
// platformio.ini sollte enthalten:
// -D LORA_SCLK_PIN=7
// -D LORA_MISO_PIN=8
// -D LORA_MOSI_PIN=9
// -D LORA_NSS_PIN=41
// -D LORA_RESET_PIN=42
// -D LORA_BUSY_PIN=40
// -D LORA_DIO1_PIN=39
// -D LORA_DIO2_PIN=38
// -D LORA_RADIO_RXEN_PIN=5 // GPIO 5 für externen RF_SW
// -D SX126X_USE_TCXO=true
// -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_1_8V
// -D SX126X_USE_LDO=true
// -D LIB_DEBUG=1

// --- LoRaWAN Credentials (!!! ANPASSEN !!!) ---
uint8_t nodeDeviceEUI[8] = {0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x07, 0x08, 0x81};
uint8_t nodeAppEUI[8] = {0xF5, 0x09, 0x56, 0x43, 0xF0, 0xF0, 0x65, 0x98};
uint8_t nodeAppKey[16] = {0xE4, 0x94, 0x39, 0x31, 0x8B, 0x9E, 0x3B, 0x93, 0x63, 0xDF, 0x89, 0x57, 0xB8, 0x5C, 0x76, 0x90};

// --- LoRaWAN Einstellungen ---
#define LORAWAN_REGION LORAMAC_REGION_EU868
#define LORAWAN_INITIAL_CLASS CLASS_A
#define LORAWAN_TARGET_CLASS CLASS_C
#define LORAWAN_ADR_ON true
#define LORAWAN_PUBLIC_NETWORK true
#define LORAWAN_APP_INTERVAL 60000
#define JOINREQ_NBTRIALS 3
#define LORAWAN_APP_PORT 2
bool doOTAA = true;

// --- Globale Variablen ---
bool isJoined = false;
uint32_t uplinkCounter = 0;
uint32_t lastUplinkTime = 0;
bool loraTxDone = true;
bool requestClassC = false;
static uint8_t uplink_data_buffer[64];
static lmh_app_data_t uplink_data = {uplink_data_buffer, 0, LORAWAN_APP_PORT, 0, 0};

// --- Board Funktionen ---
//uint8_t BoardGetBatteryLevel() { return 254; }
//void BoardGetUniqueId(uint8_t *id) { memcpy(id, nodeDeviceEUI, 8); }
//uint32_t BoardGetRandomSeed() { return esp_random(); }

// --- Callback Funktionen ---
void LoraWanRxData(lmh_app_data_t appdata) {
Serial.printf("[LoRaWAN][I] RX data. RSSI: %d, SNR: %d, Port: %d\n", appdata->rssi, appdata->snr, appdata->port);
if (appdata->buffsize > 0) { / ... Payload ... / }
DeviceClass_t currentClass; lmh_class_get(&currentClass);
if (requestClassC && isJoined && (currentClass != LORAWAN_TARGET_CLASS)) { / ... Class C ... / }
}
void LoraWanHasJoined(void) { Serial.printf("[LoRaWAN][I] OTAA Join successful!\n"); isJoined = true; requestClassC = true; }
void LoraWanHasJoinedFailed(void) { Serial.printf("[LoRaWAN][W] OTAA Join failed\n"); isJoined = false; requestClassC = false; }
void LoraWanConfirmClass(DeviceClass_t Class) { / ... Class C confirm ... / }
void LoraWanUnconfFinished(void) { Serial.printf("[LoRaWAN][I] Unconfirmed TX finished\n"); loraTxDone = true; / ... Class C ... / }
void LoraWanConfResult(bool result) { Serial.printf("[LoRaWAN][I] Confirmed TX finished, ACK: %s\n", result ? "YES" : "NO"); loraTxDone = true; / ... Class C ... */ }

static lmh_callback_t lmh_callbacks = {
BoardGetBatteryLevel, BoardGetUniqueId, BoardGetRandomSeed, LoraWanRxData,
LoraWanHasJoined, LoraWanConfirmClass, LoraWanHasJoinedFailed,
LoraWanUnconfFinished, LoraWanConfResult
};
static lmh_param_t lora_param_init = {LORAWAN_ADR_ON, DR_0, LORAWAN_PUBLIC_NETWORK, JOINREQ_NBTRIALS, TX_POWER_14, false};
hw_config hwConfig;
static RadioEvents_t radioEvents = { NULL, NULL, NULL, NULL, NULL, NULL };

TaskHandle_t radioTaskHandle = NULL;
void radioProcessingTask(void *pvParameters) {
Serial.println("Radio Processing Task started on Core " + String(xPortGetCoreID()));
while (1) { Radio.IrqProcess(); vTaskDelay(pdMS_TO_TICKS(1)); }
}

void setup() {
delay(3000); Serial.begin(115200);
long waitSerialStart = millis(); while (!Serial && (millis() - waitSerialStart < 5000)) { delay(100); } delay(500);
Serial.println("\n=====================================");
Serial.println("PlatformIO beegee-tokyo LoRaWAN OTAA Test v13 (Library Control)");
Serial.println("Pinout 3, LDO, TCXO 1.8V, RF_SW on GPIO 5 via Lib");
Serial.println("=====================================");

// --- Hardware-Konfiguration füllen ---
hwConfig.CHIP_TYPE = SX1262_CHIP;
hwConfig.PIN_LORA_NSS = LORA_NSS_PIN;
hwConfig.PIN_LORA_RESET = LORA_RESET_PIN;
hwConfig.PIN_LORA_BUSY = LORA_BUSY_PIN;
hwConfig.PIN_LORA_DIO_1 = LORA_DIO1_PIN;
hwConfig.RADIO_TXEN = -1;

// Konfiguration für externen RF_SW Pin (gesteuert durch Bibliothek)
#if defined(LORA_RADIO_RXEN_PIN) && (LORA_RADIO_RXEN_PIN != -1)
    hwConfig.RADIO_RXEN = LORA_RADIO_RXEN_PIN; // Wird 5 sein
    hwConfig.USE_RXEN_ANT_PWR = true;          // Bibliothek anweisen, diesen Pin zu nutzen
    Serial.printf("INFO: GPIO %d (LORA_RADIO_RXEN_PIN) assigned for library RF_SW control.\n", LORA_RADIO_RXEN_PIN);
    // KEIN pinMode oder digitalWrite hier! Das macht die Bibliothek in lora_hardware_init.
#else
    hwConfig.RADIO_RXEN = -1;
    hwConfig.USE_RXEN_ANT_PWR = false;
    Serial.println("INFO: Not using a dedicated RXEN pin for antenna switch power.");
#endif

hwConfig.USE_DIO2_ANT_SWITCH = true; // SX1262 soll seinen internen DIO2 für TX/RX Umschaltung nutzen
hwConfig.USE_DIO3_TCXO = false;      // TCXO wird NICHT über DIO3 gesteuert (Spannung wird in hwConfig gesetzt)
hwConfig.USE_DIO3_ANT_SWITCH = false;
#ifdef SX126X_TCXO_VOLTAGE
    hwConfig.TCXO_CTRL_VOLTAGE = SX126X_TCXO_VOLTAGE; // Aus build_flags
#else
    hwConfig.TCXO_CTRL_VOLTAGE = TCXO_CTRL_1_8V;      // Fallback
#endif
// LDO/DC-DC wird durch das Build-Flag SX126X_USE_LDO gesteuert,
// das die Bibliothek intern bei lora_hardware_init und SX126xSetRegulatorMode berücksichtigt.

Serial.println("Final Hardware Config (to be used by lora_hardware_init):");
Serial.printf("  NSS: %d, RST: %d, BUSY: %d, DIO1: %d, LORA_DIO2_PIN_DEF: %d\n",
              hwConfig.PIN_LORA_NSS, hwConfig.PIN_LORA_RESET, hwConfig.PIN_LORA_BUSY,
              hwConfig.PIN_LORA_DIO_1, LORA_DIO2_PIN); // LORA_DIO2_PIN für Info
Serial.printf("  RADIO_RXEN: %d, USE_RXEN_ANT_PWR: %d\n", hwConfig.RADIO_RXEN, hwConfig.USE_RXEN_ANT_PWR);
Serial.printf("  USE_DIO2_ANT_SWITCH: %d, TCXO_CTRL_VOLTAGE: %d\n", hwConfig.USE_DIO2_ANT_SWITCH, hwConfig.TCXO_CTRL_VOLTAGE);
#ifdef SX126X_USE_LDO
  Serial.printf("  SX126X_USE_LDO (from build_flag): %s\n", SX126X_USE_LDO ? "true (LDO)" : "false (DC-DC)");
#else
  Serial.println("  SX126X_USE_LDO (from build_flag): not defined (defaulting to DC-DC in lib)");
#endif


Serial.print("Initializing SPI..."); SPI.begin(LORA_SCLK_PIN, LORA_MISO_PIN, LORA_MOSI_PIN); SPI.setFrequency(8000000); Serial.println(" Done.");

// LoRa Hardware Initialisierung - SOLLTE JETZT ALLES INTERN MACHEN
Serial.print("Initializing LoRa Hardware (lora_hardware_init)...");
if (lora_hardware_init(hwConfig) != 0) { Serial.printf("\n!!! FAILED lora_hardware_init\n"); while(1);} Serial.println(" Done.");

// Radio Initialisierung
Serial.print("Initializing Radio (Radio.Init)..."); Radio.Init(&radioEvents); Serial.println(" Done.");

// KEINE expliziten Aufrufe mehr für SX126xSetRegulatorMode und SX126xSetDio3AsTcxoCtrl
// Die Bibliothek sollte das basierend auf hwConfig und Build-Flags in lora_hardware_init erledigen.
Serial.println("Regulator mode and TCXO control should be set by lora_hardware_init via hwConfig/build_flags.");


xTaskCreatePinnedToCore(radioProcessingTask, "RadioTask", 2048, NULL, 5, &radioTaskHandle, 1);
if (radioTaskHandle == NULL) { Serial.println("!!! FAILED to create RadioTask !!!"); while(1); }

// Keys VOR lmh_init setzen
Serial.println("Setting LoRaWAN Keys...");
lmh_setDevEui(nodeDeviceEUI);
lmh_setAppEui(nodeAppEUI);
lmh_setAppKey(nodeAppKey);
Serial.println("Keys set.");

Serial.print("Initializing LoRaWAN Stack...");
if (lmh_init(&lmh_callbacks, lora_param_init, doOTAA, LORAWAN_INITIAL_CLASS, LORAWAN_REGION, false) != LMH_SUCCESS) {
    Serial.printf("\n!!! FAILED lmh_init\n"); while(1);
} Serial.println(" Done.");

// KEINE manuelle RF_SW-Steuerung hier vor lmh_join() mehr.
Serial.println("Starting LoRaWAN Join procedure...");
lmh_join();
Serial.println("Join request initiated by lmh_join(). Waiting for network response...");

Serial.println("Setup complete. Waiting for Join...");

}

void loop() {
// Radio.IrqProcess() wird im Task ausgeführt
lmh_confirm confirmed_mode = LMH_UNCONFIRMED_MSG;
if (isJoined && loraTxDone && (millis() - lastUplinkTime > LORAWAN_APP_INTERVAL)) {
lastUplinkTime = millis(); uplinkCounter++;
uplink_data_buffer[0] = highByte(uplinkCounter);
uplink_data_buffer[1] = lowByte(uplinkCounter);
uplink_data_buffer[2] = BoardGetBatteryLevel();
uplink_data.buffsize = 3;
uplink_data.port = LORAWAN_APP_PORT;

    // KEINE manuelle RF_SW-Steuerung hier vor lmh_send() mehr.
    Serial.printf("[LoRaWAN][I] Requesting Uplink #%lu...\n", uplinkCounter);
    lmh_error_status tx_status = lmh_send(&uplink_data, confirmed_mode);
    Serial.printf("[LoRaWAN][I] lmh_send returned: %d (0=Success)\n", tx_status);

    if (tx_status == LMH_SUCCESS) {
        Serial.printf("[LoRaWAN][I] Uplink request successful, waiting for Tx Callback...\n");
        loraTxDone = false;
    } else {
        Serial.printf("[LoRaWAN][E] Uplink request failed immediately!\n");
        loraTxDone = true;
    }
}
delay(100);

}`

[20218.10h.35m.35s.002] =====================================
[20218.10h.35m.35s.002] PlatformIO beegee-tokyo LoRaWAN OTAA Test v13 (Library Control)
[20218.10h.35m.35s.002] Pinout 3, LDO, TCXO 1.8V, RF_SW on GPIO 5 via Lib
[20218.10h.35m.35s.002] =====================================
[20218.10h.35m.35s.002] INFO: GPIO 5 (LORA_RADIO_RXEN_PIN) assigned for library RF_SW control.
[20218.10h.35m.35s.002] Final Hardware Config (to be used by lora_hardware_init):
[20218.10h.35m.35s.002]   NSS: 41, RST: 42, BUSY: 40, DIO1: 39, LORA_DIO2_PIN_DEF: 38
[20218.10h.35m.35s.009]   RADIO_RXEN: 5, USE_RXEN_ANT_PWR: 1
[20218.10h.35m.35s.009]   USE_DIO2_ANT_SWITCH: 1, TCXO_CTRL_VOLTAGE: 2
[20218.10h.35m.35s.009]   SX126X_USE_LDO (from build_flag): true (LDO)
[20218.10h.35m.35s.009] Initializing SPI... Done.
[20218.10h.35m.35s.009] Initializing LoRa Hardware (lora_hardware_init)...<BRD> SyncWord = 0000
[20218.10h.35m.35s.033]  Done.<BRD> 
[20218.10h.35m.35s.033] LoRa Task started
[20218.10h.35m.35s.033] Initializing Radio (Radio.Init)... Done.
[20218.10h.35m.35s.064] Regulator mode and TCXO control should be set by lora_hardware_init via hwConfig/build_flags.
[20218.10h.35m.35s.064] Radio Processing Task started on Core 1
[20218.10h.35m.35s.064] Setting LoRaWAN Keys...
[20218.10h.35m.35s.064] Keys set.
[20218.10h.35m.35s.064] Initializing LoRaWAN Stack...<LMH> OTAA 
[20218.10h.35m.35s.064] DevEui=70-B3-D5-7E-D0-07-08-81
[20218.10h.35m.35s.064] DevAdd=00000000
[20218.10h.35m.35s.064] AppEui=F5-09-56-43-F0-F0-65-98
[20218.10h.35m.35s.064] AppKey=E4-94-39-31-8B-9E-3B-93-63-DF-89-57-B8-5C-76-90
[20218.10h.35m.35s.102] <LMH> Selected subband 1
[20218.10h.35m.35s.102]  Done.
[20218.10h.35m.35s.102] Starting LoRaWAN Join procedure...
[20218.10h.35m.35s.106] <EU868> Channel count ch# 0, freq 868100000
[20218.10h.35m.35s.106] <EU868> Set channel 0, frequency 868100000
[20218.10h.35m.35s.106] <EU868> Channel count ch# 1, freq 868300000
[20218.10h.35m.35s.106] <EU868> Set channel 1, frequency 868300000
[20218.10h.35m.35s.106] <EU868> Channel count ch# 2, freq 868500000
[20218.10h.35m.35s.106] <EU868> Set channel 2, frequency 868500000
[20218.10h.35m.35s.106] <EU868> Channel count ch# 3, freq 0
[20218.10h.35m.35s.106] <EU868> Channel count ch# 4, freq 0
[20218.10h.35m.35s.106] <EU868> Channel count ch# 5, freq 0
[20218.10h.35m.35s.106] <EU868> Channel count ch# 6, freq 0
[20218.10h.35m.35s.106] <EU868> Channel count ch# 7, freq 0
[20218.10h.35m.35s.106] <EU868> Using channel 0, frequency 868100000
[20218.10h.35m.35s.106] <LM> dutyCycleTimeOff was = 0
[20218.10h.35m.35s.106] <LM> Set send_join_now to false
[20218.10h.35m.35s.107] Join request initiated by lmh_join(). Waiting for network response...
[20218.10h.35m.35s.107] Setup complete. Waiting for Join...
[20218.10h.35m.38s.107] <RADIO> TimerTxTimeoutOnRadioTxTimeout
[20218.10h.35m.38s.357] 
                        [20218.10h.35m.38s.357] [LoRaWAN][W] OTAA Join failed

[beegee-tokyo]

I can't debug your code.
Here is a project I setup from an old example, tested with a hardware I have (ESP32 + SX1262) and it works.

LoRaWanPio.zip
I changed the pin assignments to what I read from the the Hardware Overview

I still think your pin definitions are mixed up and you are calling functions in the library that you do not have to touch.

[rallep71]

thank you very much for your help, i'll post my configuration again now, i'm a bit further, but i'll give up soon and throw the part on the scrap heap. One more question, can I use the wio sx1262 also separately b2b, because I can solder, then the part is connected to another esp.

[env:seeed_xiao_esp32s3]
platform = espressif32@^6.10.0
board = seeed_xiao_esp32s3
framework = arduino
monitor_speed = 115200
lib_deps =
    beegee-tokyo/SX126x-Arduino@^2.0.30
build_flags =
    ; Bernds Pinout für XIAO ESP32-S3
    -D S_PIN_LORA_RESET=3
    -D S_PIN_LORA_NSS=4
    -D S_PIN_LORA_SCLK=7
    -D S_PIN_LORA_MISO=8
    -D S_PIN_LORA_DIO_1=1
    -D S_PIN_LORA_BUSY=2
    -D S_PIN_LORA_MOSI=9
    -D S_RADIO_TXEN=-1
    -D S_RADIO_RXEN=5
    ; Zusätzliche Flags
    -D SX126X_CHIP_TYPE=SX1262_CHIP
    -D SX126X_USE_DIO2_ANT_SWITCH=true
    -D SX126X_USE_TCXO=true
    -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_1_8V
    -D SX126X_USE_LDO=true
    -D SX126X_USE_RXEN_ANT_PWR=true
    -D LIB_DEBUG=1
    ; Arduino spezifische Defines
    -D LORAWAN_PUBLIC_NETWORK=true
    -D LORAWAN_ADR_ON=true
   ; -D LORAWAN_DUTYCYCLE_OFF=true ; <<< HIER ENTSCHEIDEN: true für AUS, false für AN

`#include <Arduino.h>
#include <LoRaWan-Arduino.h> // Stellt sicher, dass alle nötigen LoRaMac und Board Header inkludiert werden
#include <SPI.h> // Obwohl von der Lib verwaltet, schadet der Include nicht

// Pin-Definitionen kommen aus build_flags (S_PIN_LORA_... und S_RADIO_...)

// --- LoRaWAN Credentials (!!! BITTE DURCH DEINE WERTE ERSETZEN !!!) ---
uint8_t nodeDeviceEUI[8] = {0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x07, 0x08, 0x81};
uint8_t nodeAppEUI[8] = {0xF5, 0x09, 0x56, 0x43, 0xF0, 0xF0, 0x65, 0x98};
uint8_t nodeAppKey[16] = {0xE4, 0x94, 0x39, 0x31, 0x8B, 0x9E, 0x3B, 0x93, 0x63, 0xDF, 0x89, 0x57, 0xB8, 0x5C, 0x76, 0x90};

// --- LoRaWAN Einstellungen ---
#define LORAWAN_REGION_DEFINE LORAMAC_REGION_EU868 // Für g_CurrentRegion
#define LORAWAN_INITIAL_CLASS CLASS_A
// #define LORAWAN_TARGET_CLASS CLASS_C // Vorerst nicht aktiv genutzt für Klassenwechsel-Logik
#define LORAWAN_ADR_ON true // Wird in g_lora_param_init verwendet
#define LORAWAN_PUBLIC_NETWORK true // Wird in g_lora_param_init verwendet
#define LORAWAN_APP_INTERVAL 20000 // Sendeintervall wie in Bernds Beispiel
#define JOINREQ_NBTRIALS 3 // Wird in g_lora_param_init verwendet
#define LORAWAN_APP_PORT 2
#define LORAWAN_APP_DATA_BUFF_SIZE 64 // Buffergröße für Sendedaten
#define LORAWAN_DATERATE DR_0 // Wird in g_lora_param_init verwendet
#define LORAWAN_TX_POWER TX_POWER_14 // Wird in g_lora_param_init verwendet

bool doOTAA = true;
DeviceClass_t g_CurrentClass = LORAWAN_INITIAL_CLASS; // Startklasse
LoRaMacRegion_t g_CurrentRegion = LORAWAN_REGION_DEFINE; // <<<<===== KORREKTE GLOBALE DEKLARATION
lmh_confirm g_CurrentConfirm = LMH_UNCONFIRMED_MSG; // Sendeart
uint8_t gAppPort = LORAWAN_APP_PORT; // Port für Anwendungsdaten

// --- Globale Variablen ---
bool isJoined = false;
uint32_t uplinkCounter = 0;
TimerEvent_t appTimer;
bool send_packet_flag = false;

// --- Board Funktionen (Werden von der Bibliothek bereitgestellt) ---
// uint8_t BoardGetBatteryLevel() { return 254; } // Auskommentiert, da Lib sie bereitstellt
// void BoardGetUniqueId(uint8_t *id) { memcpy(id, nodeDeviceEUI, 8); } // Auskommentiert
// uint32_t BoardGetRandomSeed() { return esp_random(); } // Auskommentiert

// --- Callback Funktionen für LoRaWAN ---
void lorawan_rx_handler(lmh_app_data_t *app_data) {
Serial.printf("LoRa Packet received on port %d, size:%d, rssi:%d, snr:%d\n",
app_data->port, app_data->buffsize, app_data->rssi, app_data->snr);
if (app_data->buffsize > 0) {
Serial.print(" Payload: ");
for (int i = 0; i < app_data->buffsize; i++) { Serial.printf("%02X ", app_data->buffer[i]); }
Serial.println();
}
}

void lorawan_has_joined_handler(void) {
Serial.println("OTAA Network Joined!");
isJoined = true;
TimerSetValue(&appTimer, LORAWAN_APP_INTERVAL);
TimerStart(&appTimer);
}

void lorawan_join_failed_handler(void) {
Serial.println("OTAA join failed!");
isJoined = false;
}

void lorawan_confirm_class_handler(DeviceClass_t Class) {
Serial.printf("Class switched to %c done\n", "ABC"[Class]);
// Hier keine automatische Nachricht senden, um Komplexität zu reduzieren
}

// Callback-Struktur (Angepasst an die 7 Member, wie in Bernds Beispiel)
static lmh_callback_t g_lora_callbacks = {
BoardGetBatteryLevel, // Diese müssen von der Bibliothek bereitgestellt werden
BoardGetUniqueId, // oder wir müssen sie wieder einkommentieren, falls Linker-Fehler
BoardGetRandomSeed,
lorawan_rx_handler,
lorawan_has_joined_handler,
lorawan_confirm_class_handler,
lorawan_join_failed_handler
};

// LoRaWAN Parameter Struktur
static lmh_param_t g_lora_param_init = {
LORAWAN_ADR_ON,
LORAWAN_DATERATE,
LORAWAN_PUBLIC_NETWORK,
JOINREQ_NBTRIALS,
LORAWAN_TX_POWER,
true // <--- Setzt Duty Cycle auf AUS
};

hw_config hwConfig;

// Timer Callback für periodisches Senden
void tx_lora_periodic_handler(void) {
TimerSetValue(&appTimer, LORAWAN_APP_INTERVAL);
TimerStart(&appTimer);
send_packet_flag = true;
}

// Funktion zum Senden eines LoRa-Frames
void send_lora_frame(void) {
if (lmh_join_status_get() != LMH_SET) {
Serial.println("Not joined, cannot send frame.");
return;
}

static uint8_t m_lora_app_data_buffer[LORAWAN_APP_DATA_BUFF_SIZE];
static lmh_app_data_t m_lora_app_data = {m_lora_app_data_buffer, 0, 0, 0, 0};

m_lora_app_data.port = gAppPort;
m_lora_app_data.buffer[0] = 'P';
m_lora_app_data.buffer[1] = 'I';
m_lora_app_data.buffer[2] = 'N';
m_lora_app_data.buffer[3] = 'G';
uplinkCounter++;
m_lora_app_data.buffer[4] = uplinkCounter;
m_lora_app_data.buffsize = 5;

Serial.printf("Sending Uplink #%lu (Port %d): ", uplinkCounter, m_lora_app_data.port);
for(int i=0; i<m_lora_app_data.buffsize; i++) Serial.printf("%02X ", m_lora_app_data.buffer[i]);
Serial.println();

lmh_error_status error = lmh_send(&m_lora_app_data, g_CurrentConfirm);
if (error == LMH_SUCCESS) {
    Serial.printf("lmh_send ok count %lu\n", uplinkCounter);
} else {
    Serial.printf("lmh_send fail error %d\n", error);
}

}

void setup() {
delay(3000); Serial.begin(115200);
long waitSerialStart = millis(); while (!Serial && (millis() - waitSerialStart < 5000)) { delay(100); } delay(500);

Serial.println("\n=====================================");
Serial.println("XIAO ESP32-S3 LoRaWAN Test (Adapted v10 - Corrected Globals)");
Serial.println("Using Pinout from platformio.ini");
Serial.println("=====================================");

// Hardware-Konfiguration füllen
hwConfig.CHIP_TYPE = SX126X_CHIP_TYPE;
hwConfig.PIN_LORA_RESET = S_PIN_LORA_RESET;
hwConfig.PIN_LORA_NSS = S_PIN_LORA_NSS;
hwConfig.PIN_LORA_SCLK = S_PIN_LORA_SCLK;
hwConfig.PIN_LORA_MISO = S_PIN_LORA_MISO;
hwConfig.PIN_LORA_DIO_1 = S_PIN_LORA_DIO_1;
hwConfig.PIN_LORA_BUSY = S_PIN_LORA_BUSY;
hwConfig.PIN_LORA_MOSI = S_PIN_LORA_MOSI;
hwConfig.RADIO_TXEN = S_RADIO_TXEN;
hwConfig.RADIO_RXEN = S_RADIO_RXEN;

#ifdef SX126X_USE_DIO2_ANT_SWITCH
  hwConfig.USE_DIO2_ANT_SWITCH = SX126X_USE_DIO2_ANT_SWITCH;
#else
  hwConfig.USE_DIO2_ANT_SWITCH = true;
#endif
#ifdef SX126X_USE_TCXO
  hwConfig.USE_DIO3_TCXO = SX126X_USE_TCXO;
#else
  hwConfig.USE_DIO3_TCXO = true;
#endif
hwConfig.USE_DIO3_ANT_SWITCH = false;
#ifdef SX126X_USE_RXEN_ANT_PWR
  hwConfig.USE_RXEN_ANT_PWR = SX126X_USE_RXEN_ANT_PWR;
#else
  hwConfig.USE_RXEN_ANT_PWR = (S_RADIO_RXEN != -1);
#endif
#ifdef SX126X_TCXO_VOLTAGE
    hwConfig.TCXO_CTRL_VOLTAGE = SX126X_TCXO_VOLTAGE;
#else
    hwConfig.TCXO_CTRL_VOLTAGE = TCXO_CTRL_1_8V;
#endif

Serial.println("Hardware Config (from build_flags):");
Serial.printf("  NSS: %d, RST: %d, BUSY: %d, DIO1: %d\n", hwConfig.PIN_LORA_NSS, hwConfig.PIN_LORA_RESET, hwConfig.PIN_LORA_BUSY, hwConfig.PIN_LORA_DIO_1);
Serial.printf("  SCLK: %d, MISO: %d, MOSI: %d\n", hwConfig.PIN_LORA_SCLK, hwConfig.PIN_LORA_MISO, hwConfig.PIN_LORA_MOSI);
Serial.printf("  RADIO_RXEN: %d, RADIO_TXEN: %d, USE_RXEN_ANT_PWR: %d\n", hwConfig.RADIO_RXEN, hwConfig.RADIO_TXEN, hwConfig.USE_RXEN_ANT_PWR);
Serial.printf("  USE_DIO2_ANT_SWITCH: %d, USE_DIO3_TCXO: %d, TCXO_VOLTAGE: %d\n", hwConfig.USE_DIO2_ANT_SWITCH, hwConfig.USE_DIO3_TCXO, hwConfig.TCXO_CTRL_VOLTAGE);

Serial.println("Initializing LoRa Hardware...");
uint32_t err_code = lora_hardware_init(hwConfig);
if (err_code != 0) {
    Serial.printf("lora_hardware_init failed - %lu\n", err_code);
    while(1);
}
Serial.println("LoRa Hardware Initialized.");

TimerInit(&appTimer, tx_lora_periodic_handler);
Serial.println("Timer Initialized.");

Serial.println("Setting LoRaWAN Keys...");
if (doOTAA) {
    lmh_setDevEui(nodeDeviceEUI);
    lmh_setAppEui(nodeAppEUI);
    lmh_setAppKey(nodeAppKey);
} else {
    // ABP Code auskommentiert
}
Serial.println("Keys set.");

Serial.println("Initializing LoRaWAN Stack...");
// Verwende die globale g_CurrentRegion und g_CurrentClass
err_code = lmh_init(&g_lora_callbacks, g_lora_param_init, doOTAA, g_CurrentClass, g_CurrentRegion);
if (err_code != 0) {
    Serial.printf("lmh_init failed - %lu\n", err_code);
    while(1);
}
Serial.println("LoRaWAN Stack Initialized.");

Serial.println("Starting Join procedure...");
lmh_join();
Serial.println("Join request initiated.");

}

void loop() {
Radio.IrqProcess();

if (send_packet_flag) {
    send_packet_flag = false;
    // Serial.println("Timer triggered sending frame..."); // Reduziert für weniger Logs
    send_lora_frame();
}
delay(10);

}`

[20218.18h.31m.20s.268] XIAO ESP32-S3 LoRaWAN Test (Adapted v10 - Corrected Globals)
[20218.18h.31m.20s.268] Using Pinout from platformio.ini
[20218.18h.31m.20s.268] =====================================
[20218.18h.31m.20s.268] Hardware Config (from build_flags):
[20218.18h.31m.20s.268]   NSS: 4, RST: 3, BUSY: 2, DIO1: 1
[20218.18h.31m.20s.268]   SCLK: 7, MISO: 8, MOSI: 9
[20218.18h.31m.20s.268]   RADIO_RXEN: 5, RADIO_TXEN: -1, USE_RXEN_ANT_PWR: 1
[20218.18h.31m.20s.268]   USE_DIO2_ANT_SWITCH: 1, USE_DIO3_TCXO: 1, TCXO_VOLTAGE: 2
[20218.18h.31m.20s.268] Initializing LoRa Hardware...
[20218.18h.31m.20s.299] <BRD> SyncWord = 2A2A
[20218.18h.31m.20s.299] LoRa Hardware Initialized<BRD>
[20218.18h.31m.20s.299] LoRa Task startedTimer Initialized.
[20218.18h.31m.20s.299]
[20218.18h.31m.20s.299] Setting LoRaWAN Keys...
[20218.18h.31m.20s.299] Keys set.
[20218.18h.31m.20s.299] Initializing LoRaWAN Stack...
[20218.18h.31m.20s.299] <LMH> OTAA
[20218.18h.31m.20s.299] DevEui=70-B3-D5-7E-D0-07-08-81
[20218.18h.31m.20s.299] DevAdd=00000000
[20218.18h.31m.20s.299] AppEui=F5-09-56-43-F0-F0-65-98
[20218.18h.31m.20s.299] AppKey=E4-94-39-31-8B-9E-3B-93-63-DF-89-57-B8-5C-76-90
[20218.18h.31m.20s.338] <LMH> Selected subband 1
[20218.18h.31m.20s.338] LoRaWAN Stack Initialized.
[20218.18h.31m.20s.338] Starting Join procedure...
[20218.18h.31m.20s.344] <EU868> Channel count ch# 0, freq 868100000
[20218.18h.31m.20s.344] <EU868> Channel count ch# 1, freq 868300000
[20218.18h.31m.20s.344] <EU868> Channel count ch# 2, freq 868500000
[20218.18h.31m.20s.344] <EU868> Channel count ch# 3, freq 0
[20218.18h.31m.20s.344] <EU868> Channel count ch# 4, freq 0
[20218.18h.31m.20s.344] <EU868> Channel count ch# 5, freq 0
[20218.18h.31m.20s.344] <EU868> Channel count ch# 6, freq 0
[20218.18h.31m.20s.344] <EU868> Channel count ch# 7, freq 0
[20218.18h.31m.20s.344] <LM> dutyCycleTimeOff was = 61939
[20218.18h.31m.20s.344] <LM> Set send_join_now to false
[20218.18h.31m.20s.344] Join request initiated.
[20218.18h.31m.23s.343] <RADIO> TimerTxTimeou
[20218.18h.31m.23s.343] <LM> OnRadioTxT
[20218.18h.31m.23s.592] OTAA join failed!

[beegee-tokyo]

Can't help anymore here.
Did you try the code I sent you?

[rallep71]

Now I have taken your code, thanks again for that, I just adjusted the region. in the ini set to seeed_xiao_esp32s3 with your pin layout. it compiled and uploaded without a problem. and then the log:

=====================================
Welcome to Xiao LoRaWan!!!
Type: OTAA
Region: EU868
=====================================
Guru Meditation Error: Core  1 panic'ed (LoadStoreError). Exception was unhandled.

Core  1 register dump:
PC      : 0x42002052  PS      : 0x00060430  A0      : 0x82010130  A1      : 0x3fcebe70  
A2      : 0x40000744  A3      : 0x3fc95be4  A4      : 0x00000000  A5      : 0x00000001  
A6      : 0x3fcec004  A7      : 0x80000001  A8      : 0x82002047  A9      : 0x3fcebdf0  
A10     : 0x3fc95d7a  A11     : 0xd4ffb50b  A12     : 0xd4ffb50b  A13     : 0x00000000  
A14     : 0x00000000  A15     : 0x3fc95d7c  SAR     : 0x0000001b  EXCCAUSE: 0x00000003  
EXCVADDR: 0x40000744  LBEG    : 0x400570e8  LEND    : 0x400570f3  LCOUNT  : 0x00000000  


Backtrace: 0x4200204f:0x3fcebe70 0x4201012d:0x3fcebe90

[rallep71]

I have searched further on the internet and found the following, this is a pin assignment ubr b2b, what would this pin layout mean for your sketch?

const smtc_shield_sx126x_xosc_cfg_t smtc_shield_xiao_esp32s3_devkit_sx1262_xosc_cfg = {
    .tcxo_is_radio_controlled = true,
    .supply_voltage           = SX126X_TCXO_CTRL_3_0V,
    .startup_time_in_tick     = 300,
};

/**
 * @brief GPIO configuration
 */
const smtc_shield_sx126x_pinout_t smtc_shield_xiao_esp32s3_devkit_sx1262_pinout = {
    .nss   = 41,  /* GPIO4 */
    .sclk  = 7,  /* GPIO7 */
    .mosi  = 9, /* GPIO9 */
    .miso  = 8, /* GPIO8 */
    .reset = 42, /* GPIO3 */
    .busy  = 40, /* GPIO2 */
    .irq   = 39, /* DIO1 */
    .antenna_sw = 38, /* GPIO5 */
    .led_tx     = 0xFF, /* NC */
    .led_rx     = 0xFF, /* NC */
};

/**
 * @brief Board capabilities
 */
const smtc_shield_sx126x_capabilities_t smtc_shield_xiao_esp32s3_devkit_sx1262_capabilities = {
    .freq_hz_min   = SMTC_SHIELD_SX126X_FREQ_MIN,
    .freq_hz_max   = SMTC_SHIELD_SX126X_FREQ_MAX,
    .power_dbm_min = SMTC_SHIELD_SX1262_MIN_PWR,
    .power_dbm_max = SMTC_SHIELD_SX1262_MAX_PWR,
};

[beegee-tokyo]

Interesting, the pin out does not match their pin description.

}You can try with that.

I can't help much anymore.

[hpssjellis]

Can you post what is your final working demo code? @rallep71

[rallep71]

Yes, I'll publish that on my website when I'm finished with the project.

There are, I think, according to my current research, which was very extensive, only two libraries that support Lorawan Class C, and that is the one from Bernd, which offers support for corresponding chipsets, and then the one from Heltec for their own customised hardware, nothing else. neither Lmic or Radiolib!

There are enough products to play with, but nothing more. There are professional products, but the prices are very high and they don't disclose the code.

What I'm trying to say is that I haven't found a complete code for something like this anywhere on the Internet. What use is Class A if I only get data and can't change anything online? For example, I can query the time of a sensor or switch a pump....nothing, exactly. That's why it's Class C.

And TTN, well, the focus is on business. People always talk about IoT, of course, for companies, but not for private users.

For example, Seed Studio writes that Lorawan can also be used...and sells the product, but does not write anywhere that you have to solder a wire from Wio pin 1 to ESP32S3 DO4 which is pin 5, so? how is that supposed to work then?

[rallep71]

@hpssjellis Here is something important for you,
that was actually the hardest task, with the settings and the library of Beegee you can do everything your heart desires, I can confirm that this library with Lorawan A and C works great and stable.

[env:seeed_xiao_esp32s3]
platform = espressif32@^6.10.0
board = seeed_xiao_esp32s3
framework = arduino
monitor_speed = 115200
lib_deps =
    beegee-tokyo/SX126x-Arduino@^2.0.30
build_flags =
    ; === Pinout 3 (aus seeed_xiao_esp32s3_devkit_sx1262.c) ===
    -D S_PIN_LORA_SCLK=7
    -D S_PIN_LORA_MISO=8
    -D S_PIN_LORA_MOSI=9
    -D S_PIN_LORA_NSS=41
    -D S_PIN_LORA_RESET=42
    -D S_PIN_LORA_BUSY=40
    -D S_PIN_LORA_DIO_1=39
    -D S_PIN_LORA_DIO_2=38    ; Für internen RF Switch (antenna_sw aus Pinout-Struktur)

    ; === Externer RF_SW (Wio Pin 1 an XIAO GPIO 5) ===
    -D S_RADIO_RXEN=5  ; gelötet von wio sx1262 pin 1 auf esp32s3 DO4=GPIO5
    -D SX126X_USE_RXEN_ANT_PWR=true

    -D S_RADIO_TXEN=-1 ; Nicht verwendet

    ; Config basierend auf seeed_xiao_esp32s3_devkit_sx1262.c
    -D SX126X_CHIP_TYPE=SX1262_CHIP
    -D SX126X_USE_DIO2_ANT_SWITCH=true   ; Da antenna_sw = 38 im Pinout definiert ist
    -D SX126X_USE_TCXO=true             ; Da tcxo_is_radio_controlled = true
    -D SX126X_TCXO_VOLTAGE=TCXO_CTRL_3_0V ; <<<=== WICHTIGE ÄNDERUNG!
    -D SX126X_USE_LDO=true              ; Da _get_reg_mode() LDO zurückgibt

    -D LIB_DEBUG=1
    ;-D LORAWAN_PUBLIC_NETWORK=true
    ;-D LORAWAN_ADR_ON=true
    ; Board Xiao ESP32-S3 + Wio-SX1262 Kit with B2B Connector

[StevenCellist]

RadioLib now offers Class C if you check out the open Pull Request.

[rallep71]

Thanks for the hint, I will do it.

[rallep71]

@beegee-tokyo,

I'm following up on our previous discussion (discussion #148 regarding class C with the ESP32-S3 and the Wio-SX1262 module). After a lot of further debugging and testing, I've come across a solution that now reliably enables OTAA joins and subsequent switch to class C for me. There were a few subtle issues that prevented this.

The core problem and the solution:

The main issue was that key timers (RxWindowTimer1, RxWindowTimer2, AckTimeoutTimer) within the LoRaMacInitialization() function (in LoRaMac.cpp) were not being initialised correctly. This happened because the code block that performs these initialisations and depends on the condition if (!region_change) was skipped. The region_change parameter was apparently passed true to LoRaMacInitialisation().
The solution was to make sure that this region_change parameter is false when LoRaMacInitialisation() is called (from lmh_init() in LoRaMacHelper.cpp) at first startup.

In my sketch (main.cpp) I have explicitly set the last parameter of the lmh_init() call to false:

// In main.cpp
// LoRaMacRegion_t region_val = LORAMAC_REGION_EU868; // Beispiel
// bool request_c = true; // Für Klasse C nach Join
// bool region_has_changed = false; // <<< Dieser Wert ist entscheidend

err_code = lmh_init(&lmh_callbacks, lora_param_init, doOTAA, 
                    LORAWAN_INITIAL_CLASS_VAL, // z.B. CLASS_A
                    LORAWAN_REGION_VAL,        // z.B. LORAMAC_REGION_EU868
                    false); // <<< Dieser Parameter (region_change) wurde auf false gesetzt
                    // Der Parameter für "request_class_c_at_start" ist in meiner lmh_init-Version anscheinend nicht der letzte.

After this parameter has been set to false in main.cpp:
The if (!region_change) block in LoRaMacInitialisation is executed.

All timers (MacStateCheckTimer, TxDelayedTimer, RxWindowTimer1, RxWindowTimer2, AckTimeoutTimer) are initialised correctly with TimerInit() and receive unique ticker indices and their respective callback functions.

In OnRadioTxDone, RxWindowTimer1 and RxWindowTimer2 are then started with the correct, initialised values (in particular valid callback pointers).
The timer callbacks OnRxWindow1TimerEvent (or OnRxWindow2TimerEvent) are triggered.
Radio.Rx() is called, the radio switches to receive mode.

The Join Accept is received (IRQ_RX_DONE is triggered and processed).
The LpwanHasJoined callback in my sketch is called.

The automatic switch to class C (triggered by lmh_init with request_class_c_at_start = true - this parameter must be in the correct place in the lmh_init signature of your library if it is to be used, or the switch must be made manually after the join) now also works, and LpwanConfirmClass reports the successful switch.

Additional observation on the SX126xWaitOnBusy timeout:
In sx126x-board.cpp there was the message [SX126xWaitOnBusy] Timeout waiting for BUSY low. Increasing the timeout_counter in this function from 1000 to 5000 (in the implementation with delay(1)) prevented this message. The time measurement with millis() within this loop in combination with delay(1) seemed to be inaccurate, as often many iterations (e.g. >300) supposedly lasted only 0-1 ms. Removing delay(1) and replacing it with yield() resulted in watchdog timeouts, suggesting that the BUSY pin can indeed be HIGH for significant periods of time. The version with delay(1) and a higher counter seems to be a stable compromise.

In summary:
The crucial point for the successful join and subsequent class C switch was the correct initialisation of all timers in LoRaMacInitialization, which was achieved by correctly passing the region_change parameter (as false at first start) to lmh_init.
I hope these detailed observations are helpful. It's been a long road, but it seems to work now.
Best regards,
Ralf

[rallep71]

@beegee-tokyo Hallo Bernd,
Quick question regarding your SX126x-Arduino library:
Is there a straightforward way for an application using the lmh_... API to get the GPS time (seconds since epoch) that the MAC layer might have received via a DeviceTimeAns command, so it can be used to set the ESP32's system RTC (e.g., with settimeofday())?

I see LoRaMacDeviceTimeAnsHandler() is currently empty. My goal is to sync the application's clock after a join and periodically without relying solely on an application-layer downlink for the timestamp.
Thanks for your great work!

[beegee-tokyo]

Unfortunately that is not implemented.