Hi
I have used hours trying to find my mistake.
The main part of this code is used in another project, that did work. So maybe I have missed something (previous use of code was on same hardware, V2. This is V3, has same chip/pin layout ESP32Wroom, LoRA, buzzer.
Now I have a PCB I need to test, and to get info from it when not connected to PC I need to send LoRa messages.
This is the error message
SendError:
Length: 15 IRQreg: 57F, IRQ_CAD_ACTIVITY_DETECTED, IRQ_FSHS_CHANGE_CHANNEL,IRQ_CAD_DONE, IRQ_TX_DONE, IRQ_HEADER_VALID, IRQ_CRC_ERROR, IRQ_RX_DONE, TX_TIMEOUT, NO_PACKET_CRC
Hope I can get some help with my code:.
Serial Output:
Kompileringsinformasjon:
Filnavn kode:D:\Arduino2024\HiveMon\PCB3_test_flip_flopp_sleep_v8_LoRa\functions.ino
Kompileringsdato: Dec 28 2024
Klokkeslett: 11:06:08
No LoRa start!
ModemSettings:
SX1278_PABOOST,0hz,SF0,BW7800,CR4:4,LDRO_Off,SyncWord_0x0,IQNormal,Preamble_0
OperatingSettings:
SX1278_PABOOST,SLEEP,Version_0,PacketMode_FSK,Explicit,CRC_Off,AGCauto_Off,LNAgain_0
LoRa start
3.3 AND 5V IS NOW SWITCHED ON, DEFAULT IS floating
Choose:
'1' B_C_Sel Default LOW=superC Trigger (veksle mellom Bat/Cap) B_C_Sel HIGH - LOW
'2' EN_B_CH Default LOW=LiPo no charge Activate/deactivate LiPo charging
'3' EN_SLP Default LOW= 3.3 and 5V Off 3.3v on/off sensors
'x' ESP Sleep + 3.3 OG 5 v OFF
sCap ADC Value raw: 3261
sCap voltage Out (ADC): 2.628
sCap Voltage In (Real): 5.450
Status now:
'1' Pulse B_C_Sel_Status (bat or cap) : 1 = Lipo power 0 = SuperCap: 0
'2' Pulse EN_B_CH_Status (LiPo charge): 1 = LiPo charge ON, 0 = Off: 0
'3' EN_SLP_Status (volt on / off) : 1 = 3.3 og 5V ON 0 = Off: 1
------------------------------------------------------------------------------------------------
sCap ADC Value raw: 3248
sCap voltage Out (ADC): 2.617
sCap Voltage In (Real): 5.429
Status now:
'1' Pulse B_C_Sel_Status (bat or cap) : 1 = Lipo power 0 = SuperCap: 0
'2' Pulse EN_B_CH_Status (LiPo charge): 1 = LiPo charge ON, 0 = Off: 0
'3' EN_SLP_Status (volt on / off) : 1 = 3.3 og 5V ON 0 = Off: 1
------------------------------------------------------------------------------------------------
sCapADCRaw: 3245
sCapVoltageOut: 2.62
sCapVoltageIn: 5.42
B_C_Sel_Status: 0
EN_B_CH_Status: 0
EN_SLP_Status: 1
Packet:
AD 0C 00 00 76 5C 27 40 B5 8D AD 40 00 00 01
SendError: Length: 15 IRQreg: 57F,IRQ_CAD_ACTIVITY_DETECTED,IRQ_FSHS_CHANGE_CHANNEL,IRQ_CAD_DONE,IRQ_TX_DONE,IRQ_HEADER_VALID,IRQ_CRC_ERROR,IRQ_RX_DONE,TX_TIMEOUT,NO_PACKET_CRC
// functions
void packet_is_OK();
void packet_is_Error();
void readVoltToSerial();
void PrintFileInfoAndVersion();
void setupLoRaSettings();
void PrintFileInfoAndVersion();
void handleButtonPress();
void printASCIIPacket(const uint8_t* data, size_t length);
// Include necessary LoRa library
#include <SPI.h>
#include <SX127XLT.h>
#include "settings.h"
#include <Wire.h>
SX127XLT LoRa; // create a library class instance called LoRa - Ai Thinker LoRa 1276 chip
// for å lese 2 siffer i filnavn (versjonsnr) + funksjon PrintFileInfoAndVersion()
#include <cstring> #include <cstdlib> #include <iostream>
#include <esp_sleep.h> // for å sette i sleep modus
uint64_t resultSleepTime = 0LL; // Variabel som holder faktisk sleep time
uint64_t sov15sek = 15LL * 1000000LL; // Første tall er sekund sov
uint64_t sov60sek = 60LL * 1000000LL; // Første tall er sekund sov
unsigned long startTid;
bool recivedInput = false;
//unsigned long startmS = 0; // lora variabel
//unsigned long endmS = 0; // lora variabel
uint32_t TXPacketCount, startmS, endmS; // lora variabel positive int 2^32, dette er 3 variabler av samme type
// Debounce-parametre for tare/calibrate
unsigned long lastDebounceTimeTare = 0;
unsigned long lastDebounceTimeCalibrate = 0;
const unsigned long debounceDelay = 400; // 200 ms debounce
// Trigger and battery options
// ==============================================================================================
// EN_B_CH : DEFAULT LOW ---> CHARGE DISABLE
// FIRST HIGH TO LOW PULSE : BATTERY CHARGE
const int EN_B_CH = 26; // EN_B_CH slår på og av LiPo lading
// Default LOW ---> CAP OUTPU
// FIRST HIGH TO LOW PULSE : BATTERY AS POWER
// SECOND HIGH TO LOW PULSE : CAPACITOR AS POWER and so on...
const int B_C_Sel = 32; // B_C_Sel, velge energikilde puls høy til lav
const int EN_SLP = 27; // EN_SLP slår av 3.3 og 5 V unntatt ESP32
// ==============================================================================================
const int buzzerPin = 4; // til buzzer
const int solPin = 33; // adc volt solar
const int sCapPin = 36; // adc volt sCap VP=36 sCap test med LiPo
const int LiPoPin = 39; // adc volt LiPo VN=39 Voltmeter LiPo with the actual analog pin number you are using
int sCapADCRaw = 0;
float sCapVoltageOut = 0.0;
float sCapVoltageIn = 0.0;
const int switchTare = 34;
const int switchCalibrate = 35;
const int switchAlarm = 25;
bool B_C_Sel_Status = LOW; // Default low -> Cap On. Variabel for å holde tilstanden til energikilde B_C_Sel
bool EN_B_CH_Status = LOW; // Default low -> No charge. Variabel for å holde tilstanden til volt rail EN_B_CH
bool EN_SLP_Status = LOW; // Starts low to save power. Slår av 3.3 og 5 V, Variabel for å holde tilstanden til power On/Off
#define ADC_MAX 4095 // 12-bit ADC
#define ADC_REF 3.3 // Referansespenning for ESP32
#define sCapScaleFactor 2.074 // OK Kalibrert faktor basert på faktisk måling: scap 5,502, scapin 2,665 v
const float solDividerFactor = 6.2 / 3.3; // For solPin (1:0.53)
const float sCapDividerFactor = 5.7 / 3.3; // For sCapPin (1:0.579)
const float LiPoDividerFactor = 4.2 / 3.3; // For LiPoPin (1:0.785)
// Definer Payload-struct for å sende data over LoRa
//struct Payload {
// setup payload as struct Må være identisk på mottagerside
struct __attribute__((packed)) Payload {
int PsCapADCRaw; // Rå ADC-verdi fra supercapacitor
float PsCapVoltageOut; // Spenning ut fra ADC (0-3.3V)
float PsCapVoltageIn; // Faktisk spenning etter skaleringsfaktor
bool PB_C_Sel_Status; // Status for energikilde (Bat/Cap)
bool PEN_B_CH_Status; // Status for LiPo-lading (aktivert/deaktivert)
bool PEN_SLP_Status; // Status for sensorstrøm (3.3V/5V)
};
// ############################# VOID SETUP ########################################
void setup() {
Serial.begin(115200);
delay(1000);
PrintFileInfoAndVersion();
SPI.begin();
delay(100);
if (LoRa.begin(NSS, NRESET, DIO0, DIO1, DIO2, LORA_DEVICE)) {
Serial.println("LoRa start");
} else {
Serial.println(F("No LoRa start!"));
}
setupLoRaSettings(LoRa); // Set up LoRa settings in settings.h
Payload myPayload; // de fleste variabler må være klare før de pakkes i myPayload som skal sendes over LoRa
analogReadResolution(12);
// dette ga ikke utslag når scap var fulladet. analogSetPinAttenuation(sCapPin, ADC_11db); // Tillater opptil ~3.9V
// *********************************************************************
// cgatgpt foreslo dette:
// analogSetAttenuation(ADC_2_5db); // For 1V til 2.5V område
// *********************************************************************
pinMode(B_C_Sel, OUTPUT); // 1 input serial
pinMode(EN_B_CH, OUTPUT); // 2 input serial
pinMode(EN_SLP, OUTPUT); // 3 input serial
pinMode(buzzerPin, OUTPUT);
pinMode(switchTare, INPUT);
pinMode(switchCalibrate, INPUT);
digitalWrite(EN_SLP, HIGH); // switch on 3,3 + 5Vv
EN_SLP_Status = !EN_SLP_Status; // togle status value from default LOW (0) to HIGH (1)
Serial.println(" 3.3 AND 5V IS NOW SWITCHED ON, DEFAULT IS floating");
//FIRST HIGH TO LOW PULSE : BATTERY AS POWER
Serial.println("Choose:");
Serial.println(" '1' B_C_Sel Default LOW=superC Trigger (veksle mellom Bat/Cap) B_C_Sel HIGH - LOW");
Serial.println(" '2' EN_B_CH Default LOW=LiPo no charge Activate/deactivate LiPo charging");
Serial.println(" '3' EN_SLP Default LOW= 3.3 and 5V Off 3.3v on/off sensors");
Serial.println(" 'x' ESP Sleep + 3.3 OG 5 v OFF");
readVoltToSerial();
tone(buzzerPin, 800, 100);
}
void loop() {
if (Serial.available() > 0) {
char input = Serial.read();
if (input == '1') {
Serial.println("1 -> B_C_Sel -> Bat connected/ not disconnect. Triggering B_C_Sel HIGH - LOW.");
B_C_Sel_Status = !B_C_Sel_Status;
tone(buzzerPin, 400, 100);
delay(500);
digitalWrite(B_C_Sel, HIGH);
delay(20);
digitalWrite(B_C_Sel, LOW);
readVoltToSerial();
}
else if (input == '2') { // EN_B_CH
Serial.println("2 -> Activate/deactivate LiPo charging - Spiller 2 toner (400 Hz)");
for (int i = 0; i < 2; i++) {
tone(buzzerPin, 400, 100);
delay(500);
}
// Bytt status og kjør HIGH-LOW puls
EN_B_CH_Status = !EN_B_CH_Status; // Veksler mellom true (1) og false (0)
// Trigge HIGH-LOW puls for LiPo-lading
digitalWrite(EN_B_CH, HIGH);
delay(20);
digitalWrite(EN_B_CH, LOW);
// Vis status som 1 eller 0 i Serial
Serial.print("LiPo-lading status: ");
Serial.println(EN_B_CH_Status ? "1" : "0");
// Les spenninger etter endring
readVoltToSerial();
}
else if (input == '3') { // Slår av sensorer
Serial.println("3 -> Switch on/off 3.3v sensors");
EN_SLP_Status = !EN_SLP_Status;
digitalWrite(EN_SLP, EN_SLP_Status);
Serial.println(EN_SLP_Status ? "Sensorer aktivert." : "Sensorer deaktivert.");
Serial.println("Spiller 3 toner om 3.3 er på, ellers stille");
for (int i = 0; i < 3; i++) {
tone(buzzerPin, 400, 100);
delay(500);
}
readVoltToSerial();
}
else if (input == 'x') {
Serial.println("x -> sleep - Spiller 4 toner (600 Hz)");
for (int i = 0; i < 4; i++) {
tone(buzzerPin, 400, 100);
delay(500);
}
readVoltToSerial();
digitalWrite(EN_SLP, LOW); // Switch off 3.3 and 5v when sleep
resultSleepTime = sov15sek;
esp_sleep_enable_timer_wakeup(resultSleepTime);
Serial.println("Sleep: " + String((unsigned long)(resultSleepTime / 1000000UL)) + " sec");
Serial.println("--------------------------------------");
esp_deep_sleep_start();
}
}
// Hent nåværende tid for debounce tare og calibrate
unsigned long currentMillis = millis();
// *******************************************************************************************
// 1 - Tare-knapp (B_C_Sel) Veksle mellom Bat/Cap
if (digitalRead(switchTare) == HIGH) {
if (currentMillis - lastDebounceTimeTare > debounceDelay) {
lastDebounceTimeTare = currentMillis; // Oppdater debounce-tid
Serial.println("1 - B_C_Sel - Tare pressed. (Veksle mellom Bat/Cap)");
B_C_Sel_Status = !B_C_Sel_Status;
tone(buzzerPin, 400, 100);
delay(500);
digitalWrite(B_C_Sel, HIGH);
delay(20);
digitalWrite(B_C_Sel, LOW);
readVoltToSerial();
}
}
if (digitalRead(switchCalibrate) == HIGH) {
if (currentMillis - lastDebounceTimeCalibrate > debounceDelay) {
lastDebounceTimeCalibrate = currentMillis; // Oppdater debounce-tid
Serial.println("2-> EN_B_CH Default LOW=LiPo no charge");
// Bytt status og kjør HIGH-LOW puls
EN_B_CH_Status = !EN_B_CH_Status; // Veksler mellom true (1) og false (0)
// Trigge HIGH-LOW puls for LiPo-lading
digitalWrite(EN_B_CH, HIGH);
delay(20);
digitalWrite(EN_B_CH, LOW);
// Vis status som 1 eller 0 i Serial
Serial.print("LiPo-lading status: ");
Serial.println(EN_B_CH_Status ? "1" : "0");
tone(buzzerPin, 400, 1000);
// Les spenninger etter endring
readVoltToSerial();
}
}
readVoltToSerial();
int sCapADCRaw = analogRead(sCapPin);
float sCapVoltageOut = (sCapADCRaw / (float)ADC_MAX) * ADC_REF; // OK Konverter til spenning (0-3.3V)
float sCapVoltageIn = sCapVoltageOut * sCapScaleFactor; // OK Kompenser for spenningsdeleren
// Fyller myPayload med data
Payload myPayload;
myPayload.PsCapADCRaw = sCapADCRaw;
myPayload.PsCapVoltageOut = sCapVoltageOut;
myPayload.PsCapVoltageIn = sCapVoltageIn;
myPayload.PB_C_Sel_Status = B_C_Sel_Status;
myPayload.PEN_B_CH_Status = EN_B_CH_Status;
myPayload.PEN_SLP_Status = EN_SLP_Status;
Serial.print("sCapADCRaw: "); Serial.println(myPayload.PsCapADCRaw);
Serial.print("sCapVoltageOut: "); Serial.println(myPayload.PsCapVoltageOut);
Serial.print("sCapVoltageIn: "); Serial.println(myPayload.PsCapVoltageIn);
Serial.print("B_C_Sel_Status: "); Serial.println(myPayload.PB_C_Sel_Status);
Serial.print("EN_B_CH_Status: "); Serial.println(myPayload.PEN_B_CH_Status);
Serial.print("EN_SLP_Status: "); Serial.println(myPayload.PEN_SLP_Status);
printASCIIPacket(reinterpret_cast<uint8_t*>(&myPayload), sizeof(Payload));
startmS = millis(); // Starttidspunkt settes til nåværende tid i millisekunder
// her sjekkes og sendes pakken
if (LoRa.transmit(reinterpret_cast<uint8_t*>(&myPayload), sizeof(Payload), 10000, TXpower, 5000)) {
endmS = millis();
TXPacketCount++;
packet_is_OK(myPayload); // overfører myPayload til function
} else {
packet_is_Error();
}
delay(5000);
}
// ******************************************************************************
// FUNCTIONS
// ******************************************************************************
void packet_is_OK(Payload functionPayload) { // Sender pakken om den er OK
//3.3 og 5V må være på for å sende pakke
uint16_t localCRC;
localCRC = LoRa.CRCCCITT(reinterpret_cast<uint8_t*>(&functionPayload), sizeof(Payload), 0xFFFF);
Serial.println();
Serial.print(" Bytes sent: "); Serial.println(sizeof(Payload));
Serial.print(" TransmitTime: "); Serial.print((endmS - startmS)); Serial.println(" mS");
Serial.print(" PacketsSent: "); Serial.println(TXPacketCount);
Serial.print(" CRC: "); Serial.println(localCRC, HEX); Serial.println();
Serial.println();
/* Serial.println(" Payload sent: ");
Serial.print(" sCapADCRaw: "); Serial.println(myPayload.PsCapADCRaw);
Serial.print(" sCapVoltageOut: "); Serial.println(myPayload.PsCapVoltageOut, 2); // To desimaler for nøyaktig spenning
Serial.print(" sCapVoltageIn: "); Serial.println(myPayload.PsCapVoltageIn, 2); // To desimaler for nøyaktig spenning
Serial.print(" B_C_Sel_Status: "); Serial.println(myPayload.PB_C_Sel_Status ? "True" : "False");
Serial.print(" EN_B_CH_Status: "); Serial.println(myPayload.PEN_B_CH_Status ? "True" : "False");
Serial.print(" EN_SLP_Status: "); Serial.println(myPayload.PEN_SLP_Status ? "True" : "False");
Serial.println();
*/
Serial.println("Pakken ble sendt OK!");
Serial.print("sCapADCRaw: "); Serial.println(functionPayload.PsCapADCRaw);
Serial.print("sCapVoltageOut: "); Serial.println(functionPayload.PsCapVoltageOut);
Serial.print("sCapVoltageIn: "); Serial.println(functionPayload.PsCapVoltageIn);
Serial.print("B_C_Sel_Status: "); Serial.println(functionPayload.PB_C_Sel_Status);
Serial.print("EN_B_CH_Status: "); Serial.println(functionPayload.PEN_B_CH_Status);
Serial.print("EN_SLP_Status: "); Serial.println(functionPayload.PEN_SLP_Status);
}
/**************************************************************************************************/
void packet_is_Error() {
uint16_t IRQStatus;
IRQStatus = LoRa.readIrqStatus();
Serial.print(F(" SendError: "));
Serial.print(F(" Length: "));
Serial.print(sizeof(Payload));
Serial.print(F(" IRQreg: "));
Serial.print(IRQStatus, HEX);
LoRa.printIrqStatus();
Serial.println();
}
/**************************************************************************************************/
void readVoltToSerial() {
int solVerdi = analogRead(solPin);
int sCapADCRaw = analogRead(sCapPin);
int LiPoVerdi = analogRead(LiPoPin);
// float solSpenning = (solVerdi / 4095.0) * referanseSpenning * solDividerFactor;
// float sCapSpenning = (sCapVerdi / 4095.0) * referanseSpenning * sCapDividerFactor;
// float LiPoSpenning = (LiPoVerdi / 4095.0) * referanseSpenning * LiPoDividerFactor;
float sCapVoltageOut = (sCapADCRaw / (float)ADC_MAX) * ADC_REF; // OK Konverter til spenning (0-3.3V)
// float sCapVoltageIn = sCapVoltageOut * 60.6; // OK Kompenser for spenningsdeleren. For å beregne tilbake til inngangsspenningen
float sCapVoltageIn = sCapVoltageOut * sCapScaleFactor; // OK Kompenser for spenningsdeleren
Serial.println();
Serial.print("sCap ADC Value raw: "); Serial.println(sCapADCRaw);
Serial.print("sCap voltage Out (ADC): "); Serial.println(sCapVoltageOut, 3);
Serial.print("sCap Voltage In (Real): "); Serial.println(sCapVoltageIn, 3);
Serial.println();
Serial.println("Status now: ");
Serial.println("'1' Pulse B_C_Sel_Status (bat or cap) : 1 = Lipo power 0 = SuperCap: " + String(B_C_Sel_Status));
Serial.println("'2' Pulse EN_B_CH_Status (LiPo charge): 1 = LiPo charge ON, 0 = Off: " + String(EN_B_CH_Status));
Serial.println("'3' EN_SLP_Status (volt on / off) : 1 = 3.3 og 5V ON 0 = Off: " + String(EN_SLP_Status));
/* Serial.println("Volt meassure: ");
Serial.println("Source;Volt;raw");
Serial.print("sCap;"); Serial.print(sCapSpenning); Serial.print(";"); Serial.print(sCapVerdi); Serial.println(";");
Serial.print("lipo;"); Serial.print(LiPoSpenning); Serial.print(";"); Serial.print(LiPoVerdi); Serial.println(";");
Serial.print("sol ;"); Serial.print(solSpenning); Serial.print(";"); Serial.print(solVerdi); Serial.println(";");
*/
Serial.println("------------------------------------------------------------------------------------------------");
Serial.println();
}
// Håndter knappetrykk generelt
void handleButtonPress(int buttonPin, bool & buttonState, unsigned long & lastDebounceTime, const unsigned long debounceDelay, const char* actionMessage, int triggerPin) {
bool currentButtonState = digitalRead(buttonPin);
if (currentButtonState == HIGH && !buttonState && (millis() - lastDebounceTime > debounceDelay)) {
buttonState = true;
lastDebounceTime = millis();
Serial.println(actionMessage);
}
if (currentButtonState == LOW && buttonState) {
buttonState = false;
}
}
void PrintFileInfoAndVersion() {
Serial.println(" Kompileringsinformasjon:");
Serial.print (" Filnavn kode: "); Serial.println(__FILE__); // Makroer
Serial.print (" Kompileringsdato: "); Serial.println(__DATE__);
Serial.print (" Klokkeslett: "); Serial.println(__TIME__);
// Hent versjonsnummer direkte
const char* dotPos = strrchr(__FILE__, '.'); // Finn posisjonen til siste punktum i filbanen
int mottagerVersjon = 0;
if (dotPos != nullptr && (dotPos - __FILE__) >= 2) { // Sjekk at det finnes minst 2 tegn før punktum
char versionStr[3]; // To siffer + nullterminator
versionStr[0] = *(dotPos - 2);
versionStr[1] = *(dotPos - 1);
versionStr[2] = '\0';
mottagerVersjon = atoi(versionStr); // Konverter til heltall
}
Serial.println("------------------------------------------------------");
}
/**************************************************************************************************/
void printASCIIPacket(const uint8_t* data, size_t length) {
Serial.println(" Packet: ");
printHexBytes(data, length); // skriver ut pakken i HEX
Serial.println();
}
/**************************************************************************************************/
void printHexBytes(const uint8_t* data, size_t length) {
for (size_t i = 0; i < length; i++) {
if (data[i] < 0x10) {
Serial.print(F("0"));
}
Serial.print(data[i], HEX);
Serial.print(F(" "));
}
}
settings.h
//******* Setup hardware pin definitions here ! ***************
// LoRa
#define NSS 5 // select pin on LoRa device
#define NRESET 14 // reset pin on LoRa device
#define LED1 -1 // on board LED, high for on
#define DIO0 16 // DIO0 pin on LoRa device, used for RX and TX done
#define DIO1 -1 // DIO1 pin on LoRa device, normally not used so set to -1
#define DIO2 -1 // DIO2 pin on LoRa device, normally not used so set to -1
#define LORA_DEVICE DEVICE_SX1278 // we need to define the device we are using
// ***************************************************************
//******* Setup LoRa Parameters Here ! ***************
const uint32_t Frequency = 868000000; // frequency of transmissions in hertz
const uint32_t Offset = 0; // offset frequency for calibration purposes
const uint8_t Bandwidth = LORA_BW_125; // LoRa bandwidth
const uint8_t SpreadingFactor = LORA_SF7; // LoRa spreading factor
const uint8_t CodeRate = LORA_CR_4_5; // LoRa coding rate
const uint8_t Optimisation = LDRO_AUTO; // low data rate optimisation setting, normally set to auto
const int8_t TXpower = 10; // LoRa transmit power in dBm
const uint16_t packet_delay = 10000; // mS delay between packets
void setupLoRaSettings(SX127XLT <) {
lt.setMode(MODE_STDBY_RC);
lt.setPacketType(PACKET_TYPE_LORA);
lt.setRfFrequency(Frequency, Offset);
lt.calibrateImage(0);
lt.setModulationParams(SpreadingFactor, Bandwidth, CodeRate, LDRO_AUTO);
lt.setBufferBaseAddress(0x00, 0x00);
lt.setPacketParams(8, LORA_PACKET_VARIABLE_LENGTH, 255, LORA_CRC_ON, LORA_IQ_NORMAL);
lt.setSyncWord(LORA_MAC_PRIVATE_SYNCWORD);
lt.setHighSensitivity();
lt.setDioIrqParams(IRQ_RADIO_ALL, IRQ_TX_DONE, 0, 0);
Serial.println(F("--------------------------------------"));
Serial.println(F("ModemSettings: ")); lt.printModemSettings(); Serial.println();
Serial.println(F("OperatingSettings: ")); lt.printOperatingSettings(); Serial.println();
Serial.println("LoRa sender klar! ");
}