mylora_process.c

Go to the documentation of this file.

/*
 * mylora_process.c
 *
 *  Created on: 18. 1. 2026
 *      Author: Milan
 */
 
#include "mylora_process.h"
#include "main.h"
#include "rtc.h"
#include "mysensors.h"
#include "mysensors_base.h"
#include "sys_app.h"
#include "stm32_seq.h"
#include "lora_app.h"
#include "mymems.h"
#include "CayenneLpp.h"
#include "LoRaMac.h"
#include "nfc.h"
#include "i2c.h"
#include "adc_if.h"
#include <stdio.h>
 
#define MAX_NOACKREPEATCOUNT 3 // max, because of bitfield :4
// LoRaWAN data formattin
 
/**
 * @brief anonymous global struct for saving of current mylorawan data flow
 */
static struct
{
    uint8_t MyloraWanAppBit :4; /**< Sequencer bits, CFG_SEQ_Task_MyLora, CFG_SEQ_Task_MyLoraReconect, CFG_SEQ_Task_MyLoraResend - !!! max 4 bits !!! */
    uint8_t ConnectedCount :5; /**< the connection counter for repeating reconnect after NoAckRepeatCount falled on 0 - max 32, _systemParams.LoRaRepeatTryConnect */
    uint8_t NoAckRepeatCount :4; /**< the count of repeating to resend data in case if no ACK comes from gateway - max 16 - default */
    uint8_t IsDataSending :1; /**< data is in process of sending, the memory is blocked, until IsDataSending is ON */
    uint8_t IsMeasureQueued :1; /**< the measure has been finished, but _IsDataSending is ON and memory is blocked, so current measurement is queued */
    uint8_t IsConnected :1; /**< the connection to gateway is ON/OFF */
    uint8_t CurrentSendingDataBuffer[256]; /**< buffer for sending data - max 222, with reserve */
    uint8_t CurrentSendingDataSz; /**< the count of data in buffer */
    int8_t FromEndInx :5; /**< the index from end of memory to send data in case if _systemParams.SendInOnePacket - more data in one pack */
    uint8_t AckFromServer :1; /**< the ACK from server came, data can be processed */
    loraWanPort_t LoraWanPort; /**< the port for data sending */
    // ------ additional data processing of request
    uint16_t DataSendSz; /**< the size of buffer to send, the last buffer is send with port LoraWanPort+1 */
    uint16_t DataSendInx; /**< the index into DataSendBuffer from the context is copying */
    const uint8_t *DataSendBuffer; /**< pointer to data for send - if not null, this buffer is processed */
} _ = {};
 
static void myLoraWan_ResetDataDefault()
{
    _.DataSendBuffer = NULL;
    _.DataSendInx = _.DataSendSz = 0;
    _.LoraWanPort = _systemParams.LoRaPort;
}
 
/**
 * @brief Get the maximum application payload size for the current data rate.
 * Returns 0 if the query fails or channel is not available.
 */
static uint8_t myLoRaWAN_GetMaxPayloadSize(void)
{
    LoRaMacTxInfo_t txInfo;
    LoRaMacStatus_t status = LoRaMacQueryTxPossible(0, &txInfo);
 
    return (status == LORAMAC_STATUS_OK) ? txInfo.MaxPossibleApplicationDataSize : 51;  // 51max
}
 
/**
 * @brief Reconnect to LoRa gateway. In case is measure data are queued, the myloraWan_MeasureFinish is called via sequencer to process current measure data
 */
static void myLoraWan_Reconnect()
{
    _.IsConnected = 0;  // reconnect - the sending has been canceled
    _.IsDataSending = 0;
    _.AckFromServer = 0;
    if (LORAMAC_HANDLER_SUCCESS != LmHandlerStop())
    {
        writeLog("myLoraWan_Reconnect Stop on going ...");
    }
    else
    {
        writeLog("myLoraWan_Reconnect Start join");
        LmHandlerJoin(LORAWAN_DEFAULT_ACTIVATION_TYPE, true);
    }
    if (_.IsMeasureQueued)
        UTIL_SEQ_SetTask(1 << (_.MyloraWanAppBit + 0), CFG_SEQ_Prio_0); // myloraWan_MeasureFinish, the measure is queued, must be finished
}
 
/**
 * @brief StartReconnect - processing of myLoraWan_Reconnect via sequencer in case ConnectedCount is not falled on 0
 */
static void myLoraWan_StartReconnect()
{
    writeLog("myLoraWan_StartReconnect - count:%d", (int) _.ConnectedCount);
    if (_.ConnectedCount)
    {
        UTIL_SEQ_SetTask((1 << (_.MyloraWanAppBit + 1)), CFG_SEQ_Prio_0); // myLoraWan_Reconnect
        _.ConnectedCount--;
    }
}
 
/**
 * @brief Send confirmed data to LoRaWAN network
 *
 * This function sends data that requires acknowledgment from the server.
 * The server must respond with a downlink acknowledgment. This is useful
 * for critical data that must be verified as received.
 *
 * @param data Pointer to the data buffer to send
 * @param dataSize Size of the data in bytes (max 242 bytes)
 * @param port LoRaWAN application port (typically 2)
 * @return LmHandlerErrorStatus_t Status of the send operation
 *         - LORAMAC_HANDLER_SUCCESS: Data queued for transmission with confirmation
 *         - LORAMAC_HANDLER_ERROR: Failed to queue data
 *         - LORAMAC_HANDLER_BUSY_ERROR: MAC layer is busy
 *         - LORAMAC_HANDLER_NO_NETWORK_JOINED: Not connected to network
 */
static LmHandlerErrorStatus_t LoRaWAN_SendConfirmedData(uint8_t *data, uint8_t dataSize, uint8_t port)
{
    LmHandlerAppData_t appData;
    LmHandlerErrorStatus_t status;
 
    _.IsDataSending = 1;    // in OnLoRaWANTxData is reset
    _.AckFromServer = 0;
 
    if (data == NULL || dataSize == 0 || dataSize > 242)
    {
        writeLog("Invalid data parameters");
        return LORAMAC_HANDLER_ERROR;
    }
 
    appData.Buffer = data;
    appData.BufferSize = dataSize;
    appData.Port = port;
 
    writeLog("Sending confirmed data to LoRaWAN: port=%d, size=%d bytes", port, dataSize);
 
    // Send as confirmed message (requires ACK from server)
    status = LmHandlerSend(&appData, LORAMAC_HANDLER_CONFIRMED_MSG, false);
    switch (status)
    {
        case LORAMAC_HANDLER_SUCCESS:
            writeLog("Confirmed data queued for transmission");
        break;
 
        case LORAMAC_HANDLER_NO_NETWORK_JOINED:
            writeLog("Cannot send: Not joined to network");
        break;
 
        case LORAMAC_HANDLER_BUSY_ERROR:
            writeLog("Cannot send: MAC layer busy");
        break;
 
        case LORAMAC_HANDLER_DUTYCYCLE_RESTRICTED:
            //myLoraWan_StartReconnect();   // try reconnect - This is arguably aggressive
            // nothis to do, disconnected, the duty has been reached - defined as 1% from hour - 36seconds
            // see: LORAMAC_STATUS_DUTYCYCLE_RESTRICTED
        break;
 
        default:
            writeLog("Send failed with status: %d", status);
        break;
    }
 
    return status;
}
 
/**
 * @brief the preparing _currentSendingDataBuffer/_currentSendingDataSz from CayennelLpp to send data to LoRaWan gateway
 * @param data - memory data block, sensors measured values
 * @param reset - the sending buffer is reset or not(adding for _systemParams.SendInOnePacket == 1)
 * @param maxSize - the max size of payload for current datarate, 0 - no buffer is checked
 * @param prevMeasureTime - the time of previous block or 0, if time is unknown or is 1st
 * @retval 1 - data stored in _currentSendingDataBuffer for send
 * @retval 0 - not stored, the maximum buffer has been reached
 */
static uint8_t myloraWan_PrepareSendingBuffer(const mems_DataBlock_t *data, uint8_t reset, uint8_t maxSize, SysTime_t prevMeasureTime)
{
    uint8_t *ptr, sz, isOK = 1;
 
    if (reset)
        _.CurrentSendingDataSz = 0;
 
    sensors_ReadToBckFromDataBlock(data);
    ptr = sensors_CayennelFromBckData(&sz, &prevMeasureTime);
    isOK = (!maxSize || _.CurrentSendingDataSz + sz <= maxSize);    // buffer cannot be longer than max, maxSize - 0, is not check
    if (ptr != NULL && isOK)
    {
        memcpy(_.CurrentSendingDataBuffer + _.CurrentSendingDataSz, ptr, sz);
        _.CurrentSendingDataSz += sz;
    }
    return isOK;
}
 
/**
 * @brief the measure has been finished, sensor data save to memory or local buffer(in case if no memory is exist or is not storing set)
 * @par
 * <b>_currentSendingDataBuffer</b> - contains data \n
 * <b>_currentSendingDataSz</b> - size of data in _currentSendingDataBuffer
 *
 * the task <b>myLoraWan_LastDataSend</b> is started for start of sending data LIFO direction \n
 */
static void myloraWan_MeasureFinish()
{
    mems_DataBlock_t *memsData;
 
    if (_.IsDataSending)
    {
        writeLog("myloraWan_MeasureFinish - data is in sending, measure is queued...");
        _.IsMeasureQueued = 1;
    }
    else
    {
        writeLog("myloraWan_MeasureFinish - begin, dataCount:%d", (int) _memsMainBlock.Data_CountCurrent);
        //UTIL_SEQ_WaitEvt(_myloraWanAppBit);       // waiting for event - fired from mysensors.c -> tasksensors_Work
        //UTIL_SEQ_ClrEvt(_myloraWanAppBit);
        //UTIL_SEQ_SetTask((1 << _myloraWanAppBit), CFG_SEQ_Prio_0);    // pokracujem
 
        memsData = mems_InicBuffer(MEMS_DATATYPE_SENSOR);   // prepare working memory buffer
        if (memsData != NULL)
        {
            sensors_CopyToBck();                // copy to backup
            sensors_WriteFromBckToDataBlock(memsData);  // write sensors to memory block from backup
            memset(_.CurrentSendingDataBuffer, 0, sizeof(_.CurrentSendingDataBuffer));  // because of sharing - and save to NFC
 
            // buffer sharing pattern
            // current measure data must be saved in NFC EEPROM on address MEASUREDATANFC_ADDR
            // because of save of memory here is used the same buffer(shared buffer) for payload for NFC and payload for LoraWan
            // 1. payload moved on measureDataNFC_t.Data
            measureDataNFC_t *blk = (measureDataNFC_t*) _.CurrentSendingDataBuffer; // shared buffer
 
            SysTime_t tim = {}; // empty time - 0, no time is write in payload for current measuring
 
            // _.CurrentSendingDataBuffer - will be contains:
            //    .UTCMeasureTime - the UTC measure time
            //    .Data - the payload from _.CurrentSendingDataBuffer
 
            uint8_t addOff = blk->Data - (uint8_t*) blk;    // offset address of Data in bytes
 
            _.CurrentSendingDataSz = addOff;                                 // payload is copy on blk->Data position
            blk->UTCMeasureTime = sensors_GetTimeFromBlock(memsData).Seconds;                                 // UTC time from measure data
            myloraWan_PrepareSendingBuffer(memsData, 0, 0, tim);             // no reset, no max buffer check and no time and copy the pyload on blk->Data
 
            // nfc store
            nfc_WriteMeasureData(&hi2c2, blk);  // don't care about result here
 
            // byte size decrees & copy data on valid position in _.CurrentSendingDataBuffer - ready for LoRaWan send or s
            _.CurrentSendingDataSz -= addOff;
            memcpy(_.CurrentSendingDataBuffer, _.CurrentSendingDataBuffer + addOff, _.CurrentSendingDataSz);
 
            // if the save in memory is OK, the reset of sending data, because of packing process in myLoraWan_LastDataSend
            // mems_AddData - is
            if (_systemParams.MemsStoreSensorData && mems_AddData(NULL, 0, 0) == HAL_OK)
                _.CurrentSendingDataSz = 0; // data stored in memory, will be again pickup in myLoraWan_LastDataSend depend on SendInOnePack
 
            /*
             // test only - add next
             if (_memsMainBlock.Data_CountCurrent <= 1 && _systemParams.StoreSensorData)
             {
             int i, m = 10;
             for (i = 0; i < m && mems_AddData(NULL, 0, 0) == HAL_OK; i++)
             ;
 
             writeLog("myloraWan_MeasureFinish - written %dx data, max:%d", i, m);
             } // */
        }
 
        UTIL_SEQ_SetTask(1 << (_.MyloraWanAppBit + 2), CFG_SEQ_Prio_0); // myLoraWan_LastDataSend
        writeLog("myloraWan_MeasureFinish - end");
        _.IsMeasureQueued = 0;
    }
}
 
/**
 * @brief take data from LIFO - last data and send. Cannot be nested
 * only if is LoRa connected
 */
static void myLoraWan_LastDataSend()
{
    if (_.IsConnected)
    {
        if (LoRaMacIsBusy())    // if loramac is busy - repeating, until the MAC is free
            UTIL_SEQ_SetTask(1 << (_.MyloraWanAppBit + 2), CFG_SEQ_Prio_0); // myLoraWan_LastDataSend - but only if the measure is not queued
        else
        {
 
            writeLog("myLoraWan_LastDataSend - begin");
 
            if (_.IsDataSending == 0)
            {
                do  // because of low voltage
                {
                    /*
                     * the reading one(_systemParams.SendInOnePacket == 0) or more(_systemParams.SendInOnePacket == 1) blocks from memory - LIFO
                     *  data from memory a prepare CayenneLppBuffer max to 242 bytes from end to begin of memory
                     * _fromEndInx
                     * _fromEndInx+1
                     * _fromEndInx+2
                     *   .
                     *   .
                     *   .
                     * myloraWan_PrepareSendingBuffer prepare buffer from memory
                     * _systemParams.SendInOnePacket = 0 - one data, = 1 more, until are data or maxPayLoad
                     *
                     *
                     Max payload per DR (EU868 region):
                     Data Rate   Spreading Factor   Max App Payload
                     DR0         SF12 / 125kHz       51 bytes
                     DR1         SF11 / 125kHz       51 bytes
                     DR2         SF10 / 125kHz       51 bytes
                     DR3         SF9 / 125kHz       115 bytes
                     DR4         SF8 / 125kHz       222 bytes
                     DR5         SF7 / 125kHz      222 bytes
                     */
                    if (_.CurrentSendingDataSz == 0)    // data ready in buffer, must be send before reading from memory (e.g. in case if not stored in mem or mem failed)
                    {
                        SysTime_t tim = SysTimeGet();   // current time, when is prepare the buffer
                        mems_DataBlock_t *buf = NULL;
                        HAL_StatusTypeDef memsStatus;
                        const uint8_t maxPayLoad = MIN(CayenneLppMaxBuffer(), myLoRaWAN_GetMaxPayloadSize());
                        uint16_t currentBatVoltage = SYS_GetBatteryLevel();
 
                        _.FromEndInx = 0;
                        // the batter check, if the voltage is lower, no process...
                        if (currentBatVoltage >= SYSTEMPARAMS_BATTMINWORK)
                        {
                            writeLog("myLoraWan_LastDataSend: voltage OK, %dmv", (int) currentBatVoltage);
 
                            // the required data are preferred of measure data from past
                            if (_.DataSendBuffer != NULL && _.DataSendSz > 0)
                            {
                                // the data processed from Data buffer
                                writeLog("DataSendBuffer: sz:%d, inx:%d", (int) _.DataSendSz, (int) _.DataSendInx);
                                _.CurrentSendingDataSz = MIN(maxPayLoad, _.DataSendSz);
                                memcpy(_.CurrentSendingDataBuffer, _.DataSendBuffer + _.DataSendInx, _.CurrentSendingDataSz);
                                _.DataSendSz -= _.CurrentSendingDataSz;
                                _.DataSendInx += _.CurrentSendingDataSz;
                                if (_.DataSendSz == 0)
                                {
                                    // last chunk
                                    _.DataSendInx = 0;
                                    _.DataSendBuffer = NULL;
                                    _.LoraWanPort++;    // last chunk - via port
                                    writeLog("DataSendBuffer last");
                                }
                                else
                                    writeLog("DataSendBuffer still: %d", (int) _.DataSendSz);
                            }
                            else
                            {
                                do
                                {
                                    memsStatus = mems_GetLastData(&buf, _.FromEndInx);
                                    switch (memsStatus)
                                    {
                                        case HAL_OK:    // data available
                                            // change of _currentSendingDataSz
                                            if (myloraWan_PrepareSendingBuffer(buf, _.FromEndInx == 0, maxPayLoad, tim))                // reset buffer, if 1st is going & max check
                                            {
                                                writeLog("myLoraWan_LastDataSend - mems sent data, still:%d", (int) _memsMainBlock.Data_CountCurrent - _.FromEndInx);
                                                tim = sensors_GetTimeFromBlock(buf);    // time for next data in _systemParams.SendInOnePacket
                                            }
                                            else
                                            {
                                                writeLog("myLoraWan_LastDataSend - maximum data payload reached:%d", (int) maxPayLoad);
                                                if (_.FromEndInx)
                                                    --_.FromEndInx;
                                                memsStatus = HAL_BUSY;
                                            }
                                        break;
                                        case HAL_BUSY:  // no more data
                                            writeLog("myLoraWan_LastDataSend - mems no more data");
                                        break;
                                        default:    // error
                                            writeLog("myLoraWan_LastDataSend - mems error");
                                    }
                                } while (_systemParams.SensSendInOnePacket && memsStatus == HAL_OK && ++_.FromEndInx);
                            }
                        }
                        else
                        {
                            writeLog("myLoraWan_LastDataSend - low voltage: %dmV, exit", (int) currentBatVoltage);
                            break;
                        }
                    }
                    // data ready to send
                    if (_.CurrentSendingDataSz > 0)
                    {
                        LoRaWAN_SendConfirmedData(_.CurrentSendingDataBuffer, _.CurrentSendingDataSz, _.LoraWanPort);   // from local buffer
                        writeLog("myLoraWan_LastDataSend - sendConfirmedData:%d", (int) _.CurrentSendingDataSz);
                    }
                    else
                    {
                        writeLog("myLoraWan_LastDataSend - sendConfirmedData: no data");
                    }
                } while (0);
            }
            else
                writeLog("myLoraWan_LastDataSend - busy");
            writeLog("myLoraWan_LastDataSend - end");
        }
    }
    else
        writeLog("myLoraWan_LastDataSend - not connected");
}
 
////////////////////////////////// public /////////////////////////////
 
/**
 * @brief Called after LoRaWAN successfully connects to the server
 *
 * This function is called when the LoRaWAN join process completes successfully.
 * It performs time synchronization with the LoRaWAN server by requesting the
 * device time, which updates the RTC with the server's time.
 */
void OnLoRaWanConnected(void)
{
    writeLog("LoRaWAN connected successfully!");
 
    /* Request time synchronization from the LoRaWAN server */
    /* This will trigger the DeviceTimeReq MAC command */
    /* The response will automatically update the system time via OnSysTimeUpdate callback */
    LmHandlerErrorStatus_t status = LmHandlerDeviceTimeReq();
 
    if (status == LORAMAC_HANDLER_SUCCESS)
    {
        writeLog("Time synchronization request sent");
    }
    else
    {
        writeLog("Failed to send time synchronization request");
    }
    _.ConnectedCount = _systemParams.LoRaRepeatTryConnect;
    _.NoAckRepeatCount = MAX_NOACKREPEATCOUNT;
    _.IsConnected = 1;
    _.AckFromServer = 0;
    myLoraWan_ResetDataDefault();   //  _.LoraWanPort = LORAWANPORT_DATA;   // default port NR
    UTIL_SEQ_SetTask((1 << (_.MyloraWanAppBit + 2)), CFG_SEQ_Prio_0);   // myLoraWan_LastDataSend, can be send from buffer, the connection is established
}
 
/**
 * @brief Called after date/time has been synchronized from LoRaWAN
 *
 * This function is called when the device receives a time synchronization
 * response (DeviceTimeAns) from the LoRaWAN server. The RTC has already
 * been updated with the server's time when this function is called.
 *
 * Add your custom code here to perform actions after time synchronization,
 * such as updating time-dependent schedules, logging the sync event, or
 * triggering time-based operations.
 */
void OnTimeSynchronized(void)
{
    // 1st must be check, if time is valid
    uint8_t timeSync = systemParams_CorrectSystemTime();
 
    writeLog("Time synchronized: systemParams_CorrectSystemTime returns: %d", (int) timeSync);
 
    SysTime_t sysTime = SysTimeGet();
    struct tm localTime;
 
    SysTimeLocalTime(sysTime.Seconds, &localTime);
    writeLog("Time synchronized: %04d-%02d-%02d %02d:%02d:%02d", localTime.tm_year + 1900, localTime.tm_mon + 1, localTime.tm_mday, localTime.tm_hour, localTime.tm_min,
            localTime.tm_sec);
}
 
/**
 * @brief Handle received downlink data from LoRaWAN server
 *
 * This callback function is triggered when the device receives data from the
 * LoRaWAN server. This can be a response to a confirmed uplink or an
 * application-level downlink message.
 *
 * @param appData Received application data including buffer and port
 * @param params Receive parameters including RSSI, SNR, and downlink counter
 */
void OnLoRaWANRxData(LmHandlerAppData_t *appData, LmHandlerRxParams_t *params)
{
    if (appData == NULL || params == NULL)
    {
        writeLog("Invalid RX data parameters");
        return;
    }
 
    writeLog("Received data from server:");
    writeLog("  Port: %d", appData->Port);
    writeLog("  Size: %d bytes", appData->BufferSize);
    writeLog("  RSSI: %d dBm", params->Rssi);
    writeLog("  SNR: %d dB", params->Snr);
    writeLog("  Downlink Counter: %lu", params->DownlinkCounter);
 
    if (_.AckFromServer)
    {
        // last data send OK
        mems_RemoveLastData(_.FromEndInx);
        _.CurrentSendingDataSz = 0;
        _.FromEndInx = 0;
        _.IsConnected = 1;  // if ACK - the connetion must be
        if (_.IsMeasureQueued)
            UTIL_SEQ_SetTask(1 << (_.MyloraWanAppBit + 0), CFG_SEQ_Prio_0); // myloraWan_MeasureFinish, the measure is queued, must be finished before myLoraWan_LastDataSend
        else
            UTIL_SEQ_SetTask(1 << (_.MyloraWanAppBit + 2), CFG_SEQ_Prio_0); // myLoraWan_LastDataSend - but only if the measure is not queued
        writeLog("  Status: next data is going to send");
        _.AckFromServer = 0;
    }
 
    switch (appData->Port)
    {
        case 0:
        break;
 
        case LORAWANPORT_CONFIG_GET:
        {
            // the system params is required
            systemParams_SetCRCSystemParams();
 
            writeLog("LORAWANPORT_CONFIG_GET: crc:%d %s", (int)_systemParams.Crc, (systemParams_CheckCRC(&_systemParams) ? "ok" : "failed"));
 
            _systemParamsBck = _systemParams;   // copy to backup to no change
            _.DataSendBuffer = (const uint8_t*) &_systemParamsBck;
            _.DataSendSz = sizeof(_systemParamsBck);
            _.DataSendInx = 0;
            _.LoraWanPort = appData->Port;
            UTIL_SEQ_SetTask(1 << (_.MyloraWanAppBit + 2), CFG_SEQ_Prio_0); // myLoraWan_LastDataSend - but only if the measure is not queued
        }
        break;
        case LORAWANPORT_CONFIG_GET_LAST:
        break;
 
        case LORAWANPORT_CONFIG_SET_PART:
            systemParams_SetFromPart(appData->Buffer, appData->BufferSize); // setting of new params
            break;
    }
 
    /*
     // Process received data based on port
     if (appData->BufferSize > 0)
     {
     // Handle specific commands from server
     switch (appData->Port)
     {
     case 2: // Application data port
     // Process application-specific commands
     if (appData->BufferSize >= 1)
     {
     uint8_t command = appData->Buffer[0];
     writeLog("  Command received: 0x%02X", command);
 
     // Example: handle different commands
     switch (command)
     {
     case 0x01:
     writeLog("  -> Command: Request immediate sensor reading");
     // Trigger immediate sensor read
     break;
     case 0x02:
     writeLog("  -> Command: Change reporting interval");
     if (appData->BufferSize >= 3)
     {
     uint16_t interval = (appData->Buffer[1] << 8) | appData->Buffer[2];
     writeLog("  -> New interval: %d seconds", interval);
     }
     break;
     default:
     writeLog("  -> Unknown command");
     break;
     }
     }
     break;
 
     case 3: // Configuration port
     writeLog("  Configuration data received");
     break;
 
     default:
     writeLog("  Data on unknown port");
     break;
     }
     } */
 
    // Check if this was an ACK for a confirmed uplink
    // IsMcpsIndication == 0 means this is a MAC layer response (ACK), not an application data indication
    if (params->IsMcpsIndication == 0)
    {
        writeLog("  This is an ACK for confirmed uplink");
    }
}
 
/**
 * @brief Handle transmission event callback
 *
 * This callback is triggered after a transmission attempt, whether successful or not.
 * It provides information about whether an ACK was received for confirmed messages.
 *
 * @param params Transmission parameters including status and ACK received flag
 */
void OnLoRaWANTxData(LmHandlerTxParams_t *params)
{
    if (_.CurrentSendingDataSz > 0 && params != NULL)
    {
        writeLog("Transmission completed:");
        writeLog("  Uplink Counter: %lu", params->UplinkCounter);
        writeLog("  Datarate: DR%d", params->Datarate);
        writeLog("  TX Power: %d dBm", params->TxPower);
        writeLog("  Channel: %d", params->Channel);
 
        if (params->MsgType == LORAMAC_HANDLER_CONFIRMED_MSG)
        {
            if (params->AckReceived)
            {
                writeLog("  Status: ACK received from server");
                _.AckFromServer = 1;    // we have ACK
                _.NoAckRepeatCount = MAX_NOACKREPEATCOUNT;
                if (_.DataSendBuffer == NULL)
                    myLoraWan_ResetDataDefault();   // _.LoraWanPort = LORAWANPORT_DATA;    // no data send -> back to measure data
            }
            else
            {
                writeLog("  Status: No ACK received (will retry)");
                if (_.NoAckRepeatCount)
                {
                    writeLog("  Retrying send, retries left: %d", (int) _.NoAckRepeatCount);
                    UTIL_SEQ_SetTask(1 << (_.MyloraWanAppBit + 2), CFG_SEQ_Prio_0); // myLoraWan_LastDataSend
                    --_.NoAckRepeatCount;
                }
                else
                {
                    writeLog("  All retries exhausted, reconnecting...");
                    myLoraWan_StartReconnect();
                }
            }
        }
        else
        {
            writeLog("  Status: Unconfirmed message sent");
        }
 
        if (params->Status != LORAMAC_EVENT_INFO_STATUS_OK)
        {
            writeLog("  TX Error: %d", params->Status);
        }
    }
    _.IsDataSending = 0;    // sending has been finished - confirmed or not
}
 
void myloraWan_Init(uint8_t myloraWanAppBit)
{
    _.MyloraWanAppBit = myloraWanAppBit;
    UTIL_SEQ_RegTask((1 << (_.MyloraWanAppBit + 0)), UTIL_SEQ_RFU, myloraWan_MeasureFinish); // CFG_SEQ_Task_MyLora
    UTIL_SEQ_RegTask((1 << (_.MyloraWanAppBit + 1)), UTIL_SEQ_RFU, myLoraWan_Reconnect);     // CFG_SEQ_Task_MyLora + 1
    UTIL_SEQ_RegTask((1 << (_.MyloraWanAppBit + 2)), UTIL_SEQ_RFU, myLoraWan_LastDataSend);  // CFG_SEQ_Task_MyLora + 2
}