Hi @J-M-L
Thanks for answer, to repeat, this error is coming after months of 24/7 running and working.
Here is where preferences is stored to mem. ref Snippets-r-us
Mem is used in calib function, this function runs only when a) calib button is pressed or
b) if calYesNo == No
(here you see the word 'default', witch is printed on serial mon, I don't know if this is reason for the serial print 'default':
Default is from:
String getResetReason(esp_reset_reason_t reason) {
switch (reason) {
case ESP_RST_UNKNOWN: return "Unknown";
case ESP_RST_POWERON: return "Power On";
case ESP_RST_EXT: return "External Reset";
case ESP_RST_SW: return "Software Reset";
case ESP_RST_PANIC: return "Exception/panic";
case ESP_RST_INT_WDT: return "Watchdog Reset (core)";
case ESP_RST_TASK_WDT: return "Watchdog Reset (task)";
case ESP_RST_WDT: return "Watchdog Reset (other)";
case ESP_RST_DEEPSLEEP: return "Deep Sleep Reset";
case ESP_RST_BROWNOUT: return "Brownout Reset";
case ESP_RST_SDIO: return "Reset over SDIO";
default: return "No Restart Reason";
}
19:07:28.689 -> Kalib-status: default
Yes/No control:
preferences.begin("hiveMon", false);
String calYesNo = preferences.getString("myCalYesNo", "default");
preferences.end();
if (calYesNo == "No") {
functionCalibrate(); // start calibrate
}
functionCalibrate()
code autoCal ---> bla bla bla (this code I cant give, I got it only if I did not share)
// add to mem after autoCal is finished
preferences.begin("hiveMon", false); // my-app = hiveMon
String calYesNo = "Yes";
preferences.putString("myCalYesNo", calYesNo);
preferences.putFloat ("myCal_factor", calibration_factor);
preferences.putFloat ("myZero_factor", zero_factor);
Serial.println("zero_factor and calibration_factor committed to memory: ");
preferences.end();
Main code:
// %%%%%%%%%%%%%%%%%%%%%%%% VIKTIGE INNSTILLINGER %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
int senderVersjonNr = 82;
int kubeNr = 1;
const int sleepTimeSec = 15;
#define sWrite 1
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#include <SPI.h>
#include <SX127XLT.h>
#include "settings.h" // include the setiings file, frequencies, LoRa settings etc
SX127XLT LoRa; // create a library class instance called LoRa - Ai Thinker LoRa 1276 chip
#include <Wire.h> // for å lese I2C, muligens for LoRa
#include "HX711.h" // This library can be obtained here http://librarymanager/All#Avia_HX711 https://github.com/bogde/HX711
#include <DHT.h> // DHT11 aidafruit
#include <OneWire.h> // DS18B20
#include <DallasTemperature.h> // DS18B20
#include <Preferences.h> // Enable lagre til minne
#include <esp32-hal.h> // for å lese reset reson
// Low power libraries
#include <esp_sleep.h> // for å sette i sleep modus
#include <WiFi.h> // for å slå av wifi, batterisparing
#include <BLEDevice.h> // for å slå av BLE, batterisparing. NB!!! tar mye minne
//#include "LowPower.h" // https://loranow.com/lora-and-sleep/
Preferences preferences; // starter opp ESP32 minnet
#define ONE_WIRE_BUS 13 // pin D2 er fra eksempel DS18B20. I2C eller serial, hva er riktig pin? DS18B20 Define to which pin of the Arduino the 1-Wire bus is connected:
OneWire oneWire(ONE_WIRE_BUS); // Create a new instance of the oneWire class to communicate with any OneWire device:
DallasTemperature sensors(&oneWire); // Pass the oneWire reference to DallasTemperature library:
int deviceCount = 0; // antall I2C på bussen
const int buzzerPin = 4; // til høytaler
float battPin = 39; // Voltmeter VN=39 with the actual analog pin number you are using
float zero_factor = 0.0; // vekt avlest ved ingen last
long reading = 0.0; // vekt TRENGS IKKE?
float calibration_factor = 0.0; // Fast cal fakt etter boot, før ev. kalibrering
uint32_t TXPacketCount, startmS, endmS; // positive int 2^32, dette er 3 variabler av samme type
#define DHTPIN 17 // 12 har trøbbel med upload. Digital pin connected to the DHT sensor Pin 12+15 can work but DHT must be disconnected during program upload.
#define DHTTYPE DHT22 // DHT 11 eller 22 (DHT 22 (AM2302) temperature -40~80Celsius)
#define CALWEIGHT 25.3 // kalibreringsvekt, må være kjent vekt, i kg
#define LB2KG 1 // 0.45352 omregningsfaktor, brukes ikke
// skrive til RTC minne ################ Om denne fjernes kompilere ikke koden
RTC_DATA_ATTR int pakkeNr = 1; // i versjon 60 var det kubeNr=1. RTC brukes ikke. Variabelen blir lagret ved deep sleep reset/boot.
// Function calls
void PrintFileNameDateTime();
void sendReadings();
void functionCalibrate();
void alarmWakeUp(); // alarm våkn opp
void playTone();
void printASCIIPacket(const uint8_t* data, size_t length);
void ventKnappTareKalibrer(); // etter reset venter systemet på knappetrykk
// HX711 pins:
const int LOADCELL_DOUT_PIN = 21;
const int LOADCELL_SCK_PIN = 22;
const int switchTare = 34; // ALARM SWITCH select the input pin for the switch
const int switchCalibrate = 35;
const int switchAlarm = 36; // input pin for the alarm switch
const int buttonPressTime = 0; // wait time in milliseconds
const int alarmPressTime = 0;
//const int sleepTimeSecOrg = 0; // brukes ifm å sjekke om serial er koblet til, virker per d.d ikke
float vekt = 0;
float BStempKube = 0;
float BStempUte = 0;
float DHTtempKube = 0;
float DHTfuktKube = 0;
int alarmValue = 0;
float volt = 0;
HX711 scale; // creation of an instance of the HX711 class named scale.
DHT dht(DHTPIN, DHTTYPE); // DHTxx
// ############################# VOID SETUP ########################################
void setup() {
Serial.begin(115200);
// delay(50);
if (sWrite == 1) { // skrives kun ut om sWrite er på
PrintFileNameDateTime();
}
spln("--------------------------------------");
sp("HiveMon 2.0, programvareversjon "); sp(senderVersjonNr); spln(" starter nå opp...");
// skrives ut uansett serial print #def
sp ("sWrite er nå: "); spln(sWrite);
sp("Om sWwrite = 0 skives det ikke ut på serial, om sWrite = 1 skrives det ut");
// Serial.print(" Sov sek: "); Serial.println(sleepTimeSec); // skrives alltid ut
// setup for avlesing av knapper og høytaler
pinMode(switchTare, INPUT); // NO
pinMode(switchCalibrate, INPUT); // NO
pinMode(switchAlarm, INPUT); // NO (NC trekker mer bastteri)
pinMode(buzzerPin, OUTPUT);
esp_reset_reason_t reason = esp_reset_reason(); // Read ESP32 restart reason
sp(F("Restart Reason: ")); spln(getResetReason(reason)); // Print the restart reason
// Denne if setninger gjør at sender etter reset knappetrykk venter 10 sek på tare eller calibrering
if (reason == ESP_RST_POWERON) { // Check if the reset method is from the pin reset and then wait for other switches
scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN); // Starter vekten i tilfelle det skal kalibreres ila 10 sek
ventKnappTareKalibrer(); // funksjon: venter på knappetrykk i 10 sek
}
WiFi.disconnect(true); // Disable Wi-Fi
WiFi.mode(WIFI_OFF); // Disable Wi-Fi
BLEDevice::deinit(true); // Disable BLE
analogReadResolution(12); // 12-bit ADC resolution for ESP32 (batteritest)
// for minnetest og for HA test
//kubeNr = random(1, 4); // Generates a number from 1 to 3 for å teste preferences på mottager siden
//String calYesNo = "nei"; // string som sier om systemet er kalibrer eller ikke, enable vil tvinge kalibrering
// rem ut 8/4 preferences.end(); // TRENGS DENNE
// Starter alle sensorer for å la de få litt tid
scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
scale.set_scale();
sensors.begin(); // DS18B20
sensors.setResolution(12); // Set the DS18B20 resolution to 12 bits
dht.begin();
preferences.begin("hiveMon", false); // false betyr R/W mulig til minnet
String calYesNo = preferences.getString("myCalYesNo", "default"); // leser om vekt er kalibrert eller ikke
preferences.end();
if (calYesNo == "No") { // dersom ikke kalibrert, start kalibrering
functionCalibrate();
}
else { // TRENGS DENNE
//calYesNo = Yes, beholder cal fact innlest for if setningen
}
// delay(50); // 500 litt lenge ift batterisparing, men 500 virker, prøv med 50
deviceCount = sensors.getDeviceCount(); // locate devices on the I2C bus, jeg har 2 stk bs18
sp(F("Antall I2C senorer : ")); spln(deviceCount); // skriver ut hvor mange den fant
SPI.begin();
if (LoRa.begin(NSS, NRESET, DIO0, DIO1, DIO2, LORA_DEVICE)) {
spln(F("LoRa startet"));
} else {
Serial.println(F("Finner ikke LoRa device!"));
}
setupLoRaSettings(LoRa); // Set up LoRa settings in settings.h
sensors.requestTemperatures(); // DS18B20 les temp
float BStempKube = sensors.getTempCByIndex(0); // Celsius. index 0 = temp kube
float BStempUte = sensors.getTempCByIndex(1); // Celsius. index 1 = temp ute
// når BS ikke er koblet til, rem ut de to lnjer over og rem inn de 2 under
// BStempKube = 34;
// BStempUte = 2;
DHTtempKube = dht.readTemperature();
DHTfuktKube = dht.readHumidity();
// Check if any reads failed and exit early (to try again)
if (isnan(DHTtempKube) || isnan(DHTfuktKube)) {
Serial.println("Failed to read from DHT sensor!");
}
// dht11 fysisk merket (S, ingenting, - ) S til DTH, ikke merket til VCC, - til gnd)
// dht22 fra venstre( + signal -)
// når DHT ikke er koblet til, rem ut de to lnjer over og rem inn de 2 under
// DHTtempKube = 12;
// DHTfuktKube = 55;
preferences.begin("hiveMon", false);
calibration_factor = preferences.getFloat("myCal_factor", 0.0);
zero_factor = preferences.getFloat("myZero_factor", 0.0);
preferences.end();
// Batteritest
volt = (float)(analogRead(battPin)) / 4095 * 2 * 3.3 * 1.1;
/* The ADC value is a 12-bit number, so the maximum value is 4095 (counting from 0).
To convert the ADC integer value to a real voltage you’ll need to divide it by the maximum value of 4095,
then double it (note above that Adafruit halves the voltage), then multiply that by the reference voltage of the ESP32 which
is 3.3V and then finally, multiply that again by the ADC Reference Voltage of 1100mV.*/
// les vekt
long vektRaw = scale.get_units(10); // kjører 1 gang for å spare prosesstid
vekt = abs((vektRaw - zero_factor) / calibration_factor); // dette tar ca 0,7 sek
scale.power_down(); // put the ADC in sleep mode
// debug info
sp(" Kalib-status: "); spln(calYesNo);
sp(" Calib factor: "); spln(calibration_factor);
sp(" Vekt raw: "); spln(vektRaw);
sp(" Zero factor: "); spln(zero_factor);
sp(" Vekt raw - zero_f: "); spln(vektRaw - zero_factor);
sp(" Rådata batteri: "); spln(analogRead(battPin));
sp(" Vekt: "); spln(vekt);
/*
if (kubeNr == 2) { // for å skille i HA GUI når bare 1 demokube
vekt = vekt + 1;
}
if (kubeNr == 3) {
vekt = vekt + 2;
}
*/
if (digitalRead(switchAlarm) == LOW) { // check if switchAlarm is pressed // Hva er riktig delay time for alarm?
Serial.println("Alarm trykt");
alarmValue = 1; // setter verdi før myPayload
for (int i = 0; i < 8; i++) {
playTone(1000, 100);
delay(5);
playTone(8000, 300);
} // Denne bør lagres i RTC minne
}
Payload myPayload; // the container for what we want to send over LoRa and store sensor readings into myPayload
myPayload.vekt = vekt;
myPayload.pakkeNr = pakkeNr;
myPayload.BStempKube = BStempKube;
myPayload.BStempUte = BStempUte;
myPayload.DHTtempKube = DHTtempKube;
myPayload.DHTfuktKube = DHTfuktKube;
myPayload.alarmValue = alarmValue;
myPayload.kubeNr = kubeNr;
myPayload.volt = volt;
myPayload.senderVersjonNr = senderVersjonNr;
if ( sWrite == 1) { // skrives kun ut når sWrite er bestemt
sp(" TXpower: "); sp(TXpower); spln(F(" dBm "));
printASCIIPacket(reinterpret_cast<uint8_t*>(&myPayload), sizeof(Payload)); sp("");
}
startmS = millis();
if (LoRa.transmit(reinterpret_cast<uint8_t*>(&myPayload), sizeof(Payload), 10000, TXpower, WAIT_TX)) {
endmS = millis();
TXPacketCount++;
packet_is_OK(myPayload); // overfører myPayload til function
} else {
packet_is_Error();
}
pakkeNr++; // lagres ikke i RTC for hver sleep vakeup
if (pakkeNr == 99999) {
pakkeNr = 1; // tilbakestiller for å ikke få for store tall på OLED, er dette lurt ift HA? Denne nye verdien lagres ikke i RTC, så ved boot starter teller på 1
}
esp_sleep_enable_timer_wakeup(sleepTimeSec * 1000000); // Convert seconds to microseconds
Serial.println(" Sover nå i: " + String(sleepTimeSec) + " sekunder");
spln(F("--------------------------------------"));
esp_deep_sleep_start();
}
void loop() { //loop må være med for å kompilere
}
Functions:
void packet_is_OK(Payload functionPayload) {
uint16_t localCRC;
localCRC = LoRa.CRCCCITT(reinterpret_cast<uint8_t*>(&functionPayload), sizeof(Payload), 0xFFFF);
spln();
sp(" Bytes sent: "); spln(sizeof(Payload));
sp(" TransmitTime: "); sp((endmS - startmS)); spln(F(" mS"));
sp(" PacketsSent: "); spln(TXPacketCount);
sp(" CRC: "); spln(localCRC, HEX); spln();
spln();
spln(F(" Payload sent: "));
Serial.println(" SW og kubeNr: " + String(functionPayload.senderVersjonNr) + " / " + String(functionPayload.kubeNr));
sp(" Vekt: "); spln(functionPayload.vekt);
sp(" PakkeNr: "); spln(functionPayload.pakkeNr);
sp(" BStempKube: "); spln(functionPayload.BStempKube);
sp(" BSStempUte: "); spln(functionPayload.BStempUte);
sp(" DHTtempKube: "); spln(functionPayload.DHTtempKube);
sp(" DHTfuktKube: "); spln(functionPayload.DHTfuktKube);
sp(" Alarm: "); spln(functionPayload.alarmValue);
sp(" Batteri V: "); spln(functionPayload.volt);
spln();
}
/**************************************************************************************************/
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();
}
/**************************************************************************************************/
void printHexBytes(const uint8_t* data, size_t length) {
for (size_t i = 0; i < length; i++) {
if (data[i] < 0x10) {
Serial.print("0");
}
Serial.print(data[i], HEX);
Serial.print(" ");
}
}
/**************************************************************************************************/
void printASCIIPacket(const uint8_t* data, size_t length) {
if (sWrite == 1) {
sp(" Packet: ");
printHexBytes(data, length); // skriver ut pakken i HEX
spln();
}
}
/**************************************************************************************************/
void playTone(int frequency, int duration) {
tone(buzzerPin, frequency, duration);
delay(duration + 20); // Add a small delay to prevent tone overlap
noTone(buzzerPin);
}
/**************************************************************************************************/
void alarmWakeUp() {
// This function will be called when the interrupt is triggered
Serial.println("Alarm");
}
/**************************************************************************************************/
void ventKnappTareKalibrer() { //ESP_RST_POWERON
spln();
spln("-------------------------------------------------------------");
spln(" Reset trykt, restartet");
spln(" Venter på knappetrykk i 10 sek fra tare eller kalibrering");
spln(" NB!!! Gjør dette nå mens det piper!");
spln("-------------------------------------------------------------");
spln();
playTone(10000, 1000);
unsigned long startTime = millis(); // Get the current time
while (millis() - startTime < 5000) { // Run the loop for 10 seconds after reset/boot
if (digitalRead(switchTare) == LOW) { // check if switchTare is pressed
scale.tare();
Serial.println(F("****************************"));
Serial.println(F("* Tare utført! *"));
Serial.println(F("****************************"));
playTone(2000, 1000);
playTone(3000, 1000);
vekt = abs((scale.get_units(10) - zero_factor) / calibration_factor); // dette tar ca 0,7 sek
Serial.print(F(" CalF : ")); Serial.println(calibration_factor);
Serial.print(F(" Vekt raw - zero_f : ")); Serial.println((scale.get_units(10) - zero_factor) / calibration_factor);
Serial.print(F(" Zero factor : ")); Serial.println(zero_factor);
Serial.print(F(" Vekt raw MINUS zero_f : ")); Serial.println(scale.get_units(10) - zero_factor);
Serial.print(F(" Vekt etter tare : ")); Serial.println(vekt);
}
if (digitalRead(switchCalibrate) == LOW) { // check if switchCalibrate is pressed
functionCalibrate();
}
}
}
/**************************************************************************************************/
void functionCalibrate() {
Serial.println("-------------------------------------------------");
Serial.println("Autokalibrering starter!!! ");
scale.power_down(); // slår av hx711 for å lese zero factor
Serial.println("-------------------------------------------------");
Serial.println(" Fjern alt på vekten innen 5 sek");
Serial.println(" NB! Gjør dette før lyden stopper!");
Serial.println("-------------------------------------------------");
scale.power_up();
playTone(300, 5000); // piper i 5 sek, koden fortsette å kjøre
//delay(5000);
long zero_factor = scale.read_average(); //Get a baseline reading after scale power off
Serial.print(" zero_factor ved tom vekt: "); Serial.println(zero_factor); //This can be used to remove the need to tare the scale. Useful in permanent scale projects.
//reading = scale.get_units(10); // trengs denne
scale.tare();
delay(50);
Serial.println(" Tare utført!");
long data = scale.get_units(10); // DENNE SKAL VÆRE CA 0 ETTER TARE
Serial.print(" HX711, etter tare (bør være nær 0): "); Serial.println(data);
Serial.println();
Serial.println("-------------------------------------------------");
Serial.println(" Plasser 25.3 kg på vekten innen 7 sekund");
Serial.println(" NB! Gjør dette før lyden stopper!");
Serial.println("-------------------------------------------------");
Serial.println();
playTone(700, 7000);
boolean done = false;
**"private code"**
else {
Serial.println("Ny zero_factor f = " + String(zero_factor));
Serial.println("Ny calibration_factor f = " + String(calibration_factor));
done = true;
}
} // end while and else
Serial.print (" Vekt etter autokalibrering: "); Serial.println(scale.get_units());
// legg inn i minne
preferences.begin("hiveMon", false); // my-app = hiveMon
String calYesNo = "Yes"; // setter systemet til å være kalibrert
preferences.putString("myCalYesNo", calYesNo);
preferences.putFloat ("myCal_factor", calibration_factor); // max 15 letters NameSpace
preferences.putFloat ("myZero_factor", zero_factor);
Serial.println("zero_factor and calibration_factor committed to memory: ");
preferences.end();
Serial.print("");
Serial.print("calibration_factor: "); Serial.println(calibration_factor);
Serial.print("zero_factor : "); Serial.println(zero_factor);
Serial.print("calYesNo : "); Serial.println(calYesNo);
// Da Dii, Da Dii
playTone(800, 800);
playTone(1500, 1000);
playTone(800, 800);
playTone(1500, 1000);
}
void PrintFileNameDateTime() {
Serial.println( F("Code running comes from file: ") );
Serial.println( F(__FILE__) );
Serial.print( F("Compilert") );
Serial.print( F(__DATE__) );
Serial.print( F(" ") );
Serial.println( F(__TIME__) );
}
Settings:
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 02/03/20
This program is supplied as is, it is up to the user of the program to decide if the program is
suitable for the intended purpose and free from errors.
*******************************************************************************************************/
// serial print macro denne macro kan ta argumenter i parantes, __VA_ARGS__ er en spesiell c++ kode
#if sWrite == 1
#define sp(...) Serial.print(__VA_ARGS__) // Serial.print definert som sp
#define spln(...) Serial.println(__VA_ARGS__) // Serial.println definert som spln
#else
#define sp(...)
#define spln(...)
#endif
//******* Setup hardware pin definitions here ! ***************
//These are the pin definitions for one of my own boards, the Easy Pro Mini,
//be sure to change the definitions to match your own setup. Some pins such as DIO1,
//DIO2, BUZZER are not used by this sketch so they do not need to be connected and
//should be set to -1.
#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 ! ***************
//LoRa Modem Parameters
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
// setup payload as struct
struct __attribute__((packed)) Payload {
float vekt;
int pakkeNr;
float BStempKube;
float BStempUte;
float DHTtempKube;
float DHTfuktKube;
int alarmValue;
int kubeNr;
float volt;
int senderVersjonNr;
};
String getResetReason(esp_reset_reason_t reason) { // kan denne flyttes som en funksjone?
switch (reason) {
case ESP_RST_UNKNOWN: return "Unknown";
case ESP_RST_POWERON: return "Power On";
case ESP_RST_EXT: return "External Reset";
case ESP_RST_SW: return "Software Reset";
case ESP_RST_PANIC: return "Exception/panic";
case ESP_RST_INT_WDT: return "Watchdog Reset (core)";
case ESP_RST_TASK_WDT: return "Watchdog Reset (task)";
case ESP_RST_WDT: return "Watchdog Reset (other)";
case ESP_RST_DEEPSLEEP: return "Deep Sleep Reset";
case ESP_RST_BROWNOUT: return "Brownout Reset";
case ESP_RST_SDIO: return "Reset over SDIO";
default: return "No Restart Reason";
}
}
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);
if (sWrite == 1) { // noen print setninger som ikke er basert på Serial.P
Serial.println("--------------------------------------");
Serial.println(F("ModemSettings: ")); lt.printModemSettings(); Serial.println();
Serial.println(F("OperatingSettings: ")); lt.printOperatingSettings(); Serial.println();
// spln(F("Register: ")); spln(); lt.printRegisters(0x00, 0x4F); // dette er ganske uinteressant
spln(F("LoRa sender klar! "));
}
}
