modem.setRX2DR(DR_0);
modem.setRX2Freq(869525000);

FPort

#include <Arduino.h>
#include <STM32LoRaWAN.h>
#include <STM32RTC.h>
#include "STM32LowPower.h"

STM32RTC& rtc = STM32RTC::getInstance();
STM32LoRaWAN modem;

void setup() {
    Serial.begin(115200);
    modem.begin(EU868);
    LowPower.begin();
    LowPower.deepSleep();
}

void loop() {
    Serial.begin(115200);
    Serial.println("wakes up");
    delay(1000);
    LowPower.deepSleep();
}

[env:lora_e5_mini]
platform = ststm32
board = lora_e5_mini
framework = arduino
lib_deps = 
    https://github.com/stm32duino/STM32LoRaWAN.git#0.2.0
    https://github.com/stm32duino/STM32RTC.git#1.4.0
    https://github.com/stm32duino/STM32LowPower.git#5ae219c
monitor_speed = 115200
monitor_filters = time
upload_protocol = stlink
debug_tool = stlink

Compiling .pio\build\nucleo_wl55jc\lib114\STM32duinoLoRaWAN\STM32CubeWL\LoRaWAN\Crypto\lorawan_aes.c.o
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\mw_log.cpp: In function 'void MW_LOG(MwLogTimestamp_t, MwLogLevel_t, const char*, ...)':
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\mw_log.cpp:45:5: error: 'vcore_debug' was not declared in this scope; did you mean 'core_debug'?
  45 |     vcore_debug(fmt, ap);
     |     ^~~~~~~~~~~
     |     core_debug
Compiling .pio\build\nucleo_wl55jc\lib114\STM32duinoLoRaWAN\STM32CubeWL\LoRaWAN\Crypto\soft-se.c.o
*** [.pio\build\nucleo_wl55jc\lib114\STM32duinoLoRaWAN\BSP\mw_log.cpp.o] Error 1
In file included from .pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:41:
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.h:50:8: error: unknown type name 'SUBGHZ_HandleTypeDef'
  50 | extern SUBGHZ_HandleTypeDef hsubghz;
     |        ^~~~~~~~~~~~~~~~~~~~
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:43:1: error: unknown type name 'SUBGHZ_HandleTypeDef'; did you mean 'UART_HandleTypeDef'?
  43 | SUBGHZ_HandleTypeDef hsubghz;
     | ^~~~~~~~~~~~~~~~~~~~
     | UART_HandleTypeDef
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c: In function 'MX_SUBGHZ_Init':
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:47:10: error: request for member 'Init' in something not a structure or union
  47 |   hsubghz.Init.BaudratePrescaler = SUBGHZSPI_BAUDRATEPRESCALER_4;
     |          ^
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:47:36: error: 'SUBGHZSPI_BAUDRATEPRESCALER_4' undeclared (first use in this function); did you mean 'SPI_BAUDRATEPRESCALER_4'?
  47 |   hsubghz.Init.BaudratePrescaler = SUBGHZSPI_BAUDRATEPRESCALER_4;
     |                                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     |                                    SPI_BAUDRATEPRESCALER_4
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:47:36: note: each undeclared identifier is reported only once for each function it appears in
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:48:7: warning: implicit declaration of function 'HAL_SUBGHZ_Init'; did you mean 'MX_SUBGHZ_Init'? [-Wimplicit-function-declaration]
  48 |   if (HAL_SUBGHZ_Init(&hsubghz) != HAL_OK) {
     |       ^~~~~~~~~~~~~~~
     |       MX_SUBGHZ_Init
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c: At top level:
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:54:25: error: unknown type name 'SUBGHZ_HandleTypeDef'; did you mean 'UART_HandleTypeDef'?
  54 | void HAL_SUBGHZ_MspInit(SUBGHZ_HandleTypeDef *subghzHandle)
     |                         ^~~~~~~~~~~~~~~~~~~~
     |                         UART_HandleTypeDef
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:65:27: error: unknown type name 'SUBGHZ_HandleTypeDef'; did you mean 'UART_HandleTypeDef'?
  65 | void HAL_SUBGHZ_MspDeInit(SUBGHZ_HandleTypeDef *subghzHandle)
     |                           ^~~~~~~~~~~~~~~~~~~~
     |                           UART_HandleTypeDef
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c: In function 'SUBGHZ_Radio_IRQHandler':
.pio\libdeps\nucleo_wl55jc\STM32duinoLoRaWAN\src\BSP\subghz.c:78:3: warning: implicit declaration of function 'HAL_SUBGHZ_IRQHandler'; did you mean 'HAL_UART_IRQHandler'? [-Wimplicit-function-declaration]
  78 |   HAL_SUBGHZ_IRQHandler(&hsubghz);
     |   ^~~~~~~~~~~~~~~~~~~~~
     |   HAL_UART_IRQHandler
*** [.pio\build\nucleo_wl55jc\lib114\STM32duinoLoRaWAN\BSP\subghz.c.o] Error 1

LoRaMacProcess 1
LoRaMacHandleIrqEvents 1
LoRaMacHandleIrqEvents 2
ProcessRadioTxDone
...
TIMER_IF_StartTimer Start timer: time=4154841, alarm=4156109
GetTimerTicks 1
GetTimerTicks 2: -4154845, 4154844
TIMER_IF_GetTimerElapsedTime: 6
TIMER_IF_GetTime
GetTimerTicks 1
GetTimerTicks 2: -4154847, 4154846
TIMER_IF_BkUp_Read_MSBticks
LoRaMacProcess 2
LoRaMacProcess 3
LoRaMacProcess 13
LoRaMacProcess 14

TIMER_IF_SetTimerContext
GetTimerTicks 1
GetTimerTicks 2: -4156110, 4156109
OnRxWindow1TimerEvent
RxWindowSetup 1
RxWindowSetup 2
RxWindowSetup 3
GetTimerTicks 1
GetTimerTicks 2: -4156114, 4156113
TIMER_IF_GetTimerElapsedTime: 4
GetTimerTicks 1
GetTimerTicks 2: -4156116, 4156115
TIMER_IF_GetTimerElapsedTime: 6
GetTimerTicks 1
GetTimerTicks 2: -4156118, 4156117
TIMER_IF_GetTimerElapsedTime: 8
GetTimerTicks 1
GetTimerTicks 2: -4156120, 4156119
TIMER_IF_StartTimer Start timer: time=4156119, alarm=4156371
OnRadioRxTimeout
OnMacProcessNotify
... [logs continue]

LoRaMacProcess 1
LoRaMacHandleIrqEvents 1
LoRaMacHandleIrqEvents 2
ProcessRadioTxDone
...
TIMER_IF_StartTimer Start timer: time=4308483, alarm=4309750
GetTimerTicks 1
GetTimerTicks 2: -4308487, 4308486
TIMER_IF_GetTimerElapsedTime: 6
TIMER_IF_GetTime
GetTimerTicks 1
GetTimerTicks 2: -4308489, 4308488
TIMER_IF_BkUp_Read_MSBticks
LoRaMacProcess 2
LoRaMacProcess 3
LoRaMacProcess 13
LoRaMacProcess 14
[logs stopped]

String setAppEuiString;
String setAppKeyString;
String setDevEuiString;

  setAppEuiString="0000000000000099";
  setAppKeyString="FF9F138B40180AA45D6846E0A0146954";
  setDevEuiString="XX80E115051XX80A";
  modem.setAppEui(setAppEuiString); //@
  modem.setAppKey(setAppKeyString); //#
  modem.setDevEui(setDevEuiString); //$

  modem.setAppEui("0000000000000099"); //@
  modem.setAppKey("FF9F138B40180AA45D6846E0A0146954"); //#
  modem.setDevEui("0080E115051FD80A"); //$

.: ../../../..\libraries\STM32duino_RTC\rtc.c.o: in function `HAL_RTC_AlarmAEventCallback':
rtc.c:(.text.HAL_RTC_AlarmAEventCallback+0x0): multiple definition of `HAL_RTC_AlarmAEventCallback'; ..\..\..\.\libraries\STM32duino_RTC\rtc.c.o: in function `RTC_Alarm_IRQHandler':
rtc.c:(.text.RTC_Alarm_IRQHandler+0x0): multiple definition of `RTC_Alarm_IRQHandler'; 
..\..\..\.\libraries\STM32LoRaWAN-main\BSP\rtc.c.o:rtc.c:(.text.RTC_Alarm_IRQHandler+0x0): first defined here
collect2.exe: error: ld returned 1 exit status

Start
Error: d:\Arduino\libraries\STM32LoRaWAN\src\BSP\rtc.c (56)

/**
 * This is a more complex asynchronous sketch that shows how the
 * asynchronous code could be used in a sketch that uses a scheduler of
 * some sort to decide what code to run when.
 *
 * This sketch defines its own very, very simple scheduler that is not
 * suggested to be used directly, but just serves to show how a sketch
 * that uses some scheduling mechanism can be used with the
 * asynchronous STM32LoRaWAN API and the MaintainNeeded callback.
 *
 * The behavior of the sketch is simple, it just blinks a LED
 * (asynchronously) and at the same time joins the network and transmit
 * a packet periodically.
 *
 * Revised BSD License - https://spdx.org/licenses/BSD-3-Clause.html
 */
#include <STM32LoRaWAN.h>

STM32LoRaWAN modem;

/*********************************************************************
 * This part of the sketch defines a very simple scheduler and defines
 * two tasks that handle the actual work.
 *********************************************************************/
struct Task {
  unsigned long time; /* When to run, 0 == never */
  void (*callback)();
};

enum Tasks {
  BLINK_TASK,
  LORA_WORK_TASK,
  LORA_MAINTAIN_TASK,
  NUM_TASKS,
};

void do_blink();
void do_lora_maintain();
void do_lora_work();
void maintain_needed_callback();

Task tasks[NUM_TASKS] = {
  [BLINK_TASK] = {0, do_blink},
  [LORA_WORK_TASK] = {0, do_lora_work},
  [LORA_MAINTAIN_TASK] = {0, do_lora_maintain},
};


void run_scheduler()
{
  // Super-simple scheduler that just checks all tasks and runs
  // any that are due.
  for (size_t i = 0; i < NUM_TASKS; ++i) {
    if (tasks[i].time != 0 && (int)(millis() - tasks[i].time) >= 0) {
      tasks[i].time = 0;
      tasks[i].callback();
    }
  }
}

/*********************************************************************
 * This part of the sketch defines the blink task, which just toggles
 * a LED whenever it is called.
 * And this is the entry points of the sketch.
 *********************************************************************/
static const unsigned long BLINK_TASK_TIME = 1000; /* ms */

void do_blink()
{
  digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  tasks[BLINK_TASK].time = millis() + BLINK_TASK_TIME;
}

/*********************************************************************
 * This part of the sketch defines the lora work task, which initiates
 * new work and the lora_done() function that processes the results.
 *********************************************************************/

static const unsigned long TX_INTERVAL = 60000; /* ms */
static const unsigned long RETRY_JOIN_INTERVAL = 5000; /* ms */

enum LoraState {
  IDLE,
  JOINING,
  TRANSMITTING,
};
LoraState lora_state;

void start_join()
{
  // Configure join method by (un)commenting the right method
  // call, and fill in credentials in that method call.
  modem.setAppEui("0000000000000000");
  modem.setAppKey("00000000000000000000000000000000");
  modem.setDevEui("0000000000000000");
  modem.joinOTAAAsync();
  //modem.setDevAddr("00000000");
  //modem.setNwkSKey("00000000000000000000000000000000");
  //modem.setAppSKey("00000000000000000000000000000000");
  //modem.joinABP();

  lora_state = JOINING;
}

void send_packet()
{
  uint8_t payload[] = {0xde, 0xad, 0xbe, 0xef};
  modem.setPort(10);
  modem.beginPacket();
  modem.write(payload, sizeof(payload));
  if (modem.endPacketAsync() == sizeof(payload)) {
    Serial.println("Queued packet");
  } else {
    Serial.println("Failed to queue packet");
  }
  lora_state = TRANSMITTING;
}

void process_rx()
{
  if (modem.available()) {
    Serial.print("Received packet on port ");
    Serial.print(modem.getDownlinkPort());
    Serial.print(":");
    while (modem.available()) {
      uint8_t b = modem.read();
      Serial.print(" ");
      Serial.print(b >> 4, HEX);
      Serial.print(b & 0xF, HEX);
    }
    Serial.println();
  }
}

void do_lora_work()
{
  // Time to start new work
  if (!modem.connected()) {
    start_join();
  } else {
    send_packet();
  }
}

void lora_done()
{
  // If, after calling maintain() the library is no longer
  // busy, then the asynchronous operation has completed,
  // so check its results.
  if (lora_state == TRANSMITTING) {
    Serial.println("Sent packet");
    // Done transmitting
    process_rx();
    lora_state = IDLE;
    // Schedule transmission of next packet
    tasks[LORA_WORK_TASK].time = millis() + TX_INTERVAL;
  } else if (lora_state == JOINING) {
    if (modem.connected()) {
      Serial.println("Joined");
      send_packet();
    } else {
      Serial.println("Join failed");
      lora_state = IDLE;
      tasks[LORA_WORK_TASK].time = millis() + RETRY_JOIN_INTERVAL;
    }
  }
}

/*********************************************************************
 * This part of the sketch defines the lora maintain task, which calls
 * maintain() to let the lora library do any background work that it
 * needs to do. It is called whenever request by the callback.
 *********************************************************************/

void do_lora_maintain()
{
  modem.maintain();

  // If, after calling maintain() the library is no longer
  // busy, then the asynchronous operation has completed,
  // so check its results.
  if (!modem.busy()) {
    lora_done();
  }
}

void maintain_needed_callback()
{
  // This is called from interrupt context, so this must *not*
  // call maintain() directly and return as fast as possible.
  // So just schedule the maintain task to run ASAP.
  tasks[LORA_MAINTAIN_TASK].time = millis();
}

/*********************************************************************
 * And this is the entry points of the sketch.
 *********************************************************************/

void setup()
{
  Serial.begin(115200);
  Serial.println("Start");
  modem.begin(EU868);
  modem.setMaintainNeededCallback(maintain_needed_callback);

  pinMode(LED_BUILTIN, OUTPUT);

  do_blink();
  do_lora_work();
}

void loop()
{
  run_scheduler();

}