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 <stdio.h>
 
 
// LoRaWAN data formatting constants
 
static struct tm _localTime = {};
static uint32_t _myloraWanAppBit = 0;   // Sequencer bits
static uint8_t _connectedCount = 0;     // the connection counter for repeating reconnect after timeout duty cycle
static uint8_t _isDataSending = 0;      // data is in process of sending
static uint8_t _isConnected = 0;        // the connect has been done
static uint8_t _currentSendingDataBuffer[256];  // buffer for sending data - current - copy
static uint8_t _currentSendingDataSz = 0;       // the data size in buffer
static uint8_t _fromEndInx = 0;         // the index from end to send (.SendInOnePacket)
 
/**
 * @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);
 
    // Even if status != LORAMAC_STATUS_OK (e.g. duty cycle),
    // txInfo.MaxPossibleApplicationDataSize is still filled in.
    //writeLog("MaxPossibleAppDataSize: %d, CurrentPayloadSize: %d",
    //         txInfo.MaxPossibleApplicationDataSize,
    //         txInfo.CurrentPayloadSize);
 
    return (status == LORAMAC_STATUS_OK) ? txInfo.MaxPossibleApplicationDataSize : 51;  // 51max
}
 
static void myLoraWan_Reconnect()
{
    _isConnected = 0;
    if (LORAMAC_HANDLER_SUCCESS != LmHandlerStop())
    {
        writeLog("myLoraWan_Reconnect Stop on going ...");
    }
    else
    {
        writeLog("myLoraWan_Reconnect Start join");
        LmHandlerJoin(LORAWAN_DEFAULT_ACTIVATION_TYPE, true);
    }
}
 
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;
 
    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
        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
 */
static uint8_t myloraWan_PrepareSendingBuffer(const mems_DataBlock_t *data, uint8_t reset, uint8_t maxSize)
{
    uint8_t *ptr, sz, isOK = 1;
 
    if (reset)
        _currentSendingDataSz = 0;
 
    sensors_ReadToBckFromDataBlock(data);
    ptr = sensors_CayennelFromBckData(&sz);
    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, if no memory is exist or is not storing set
 * _currentSendingDataBuffer - contains data
 * _currentSendingDataSz - size of data in _currentSendingDataBuffer
 * after measure is started myLoraWan_LastDataSend
 */
static void myloraWan_MeasureFinish()
{
    mems_DataBlock_t *memsData;
 
    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
        if (!_systemParams.MemsStoreSensorData || mems_AddData(NULL, 0, 0) != HAL_OK)
            myloraWan_PrepareSendingBuffer(memsData, 1, 0); // reset & no max buffer check
 
        /*
        // 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");
}
 
/**
 * @brief take data from LIFO - last data and send. Cannot be nested
 * only if is LoRa connected
 */
static void myLoraWan_LastDataSend()
{
    if (_isConnected)
    {
        writeLog("myLoraWan_LastDataSend - begin");
 
        if (_isDataSending == 0)
        {
            mems_DataBlock_t *buf = NULL;
            HAL_StatusTypeDef memsStatus;
            const uint8_t maxPayLoad = MIN(CayenneLppMaxBuffer(), myLoRaWAN_GetMaxPayloadSize());   // 5 - ensure... -5 bytes
 
 
            /*
             * the reading one(_systemParams.SendInOnePacket == 0) or more(_systemParams.SendInOnePacket == 1)
             *  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 max
             * _currentSendingDataSz + firstDataSize * 2 < CayenneLppMaxBuffer() - must be 2timer more free space before continue
             *
             *
             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
            {
                _fromEndInx = 0;
                do
                {
                    memsStatus = mems_GetLastData(&buf, _fromEndInx);
                    switch (memsStatus)
                    {
                        case HAL_OK:    // data available
                            if (myloraWan_PrepareSendingBuffer(buf, _fromEndInx == 0, maxPayLoad))  // reset buffer, if 1st is going & max check
                            {
                                writeLog("myLoraWan_LastDataSend - mems sent data, still:%d", (int) _memsMainBlock.Data_CountCurrent - _fromEndInx);
                            }
                            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);
            }
            // data ready to send
            if (_currentSendingDataSz > 0)
            {
                _isDataSending = 1; // in OnLoRaWANTxData is reset
                LoRaWAN_SendConfirmedData(_currentSendingDataBuffer, _currentSendingDataSz, _systemParams.LoRaPort);    // from local buffer
                writeLog("myLoraWan_LastDataSend - sendConfirmedData:%d", (int) _currentSendingDataSz);
            }
            else
            {
                writeLog("myLoraWan_LastDataSend - sendConfirmedData: no data");
            }
        }
        else
            writeLog("myLoraWan_LastDataSend - busy");
        writeLog("myLoraWan_LastDataSend - end");
    }
    else
        writeLog("myLoraWan_LastDataSend - not connected");
}
 
////////////////////////////////// public /////////////////////////////
 
void GetTimeDate()
{
    SysTime_t currentSysTime = SysTimeGet();
    SysTimeLocalTime(currentSysTime.Seconds, &_localTime);
}
 
/**
 * @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;
    _isConnected = 1;
    UTIL_SEQ_SetTask((1 << (_myloraWanAppBit + 2)), CFG_SEQ_Prio_0);    // myLoraWan_LastDataSend, can be send from buffer
    writeLog("Measure done, start myLoraWan_LastDataSend");
}
 
/**
 * @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)
{
    GetTimeDate();
    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);
 
    // 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");
                // last data send OK
                mems_RemoveLastData(_fromEndInx);
                _currentSendingDataSz = 0;
                _fromEndInx = 0;
                _isConnected = 1;   // if ACK - the connetion must be
                UTIL_SEQ_SetTask(1 << (_myloraWanAppBit + 2), CFG_SEQ_Prio_0);  // myLoraWan_LastDataSend
                writeLog("  Status: next data is going to send");
            }
            else
            {
                writeLog("  Status: No ACK received (will retry)");
                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
}
 
void myloraWan_Init(uint32_t myloraWanAppBit)
{
    _myloraWanAppBit = myloraWanAppBit;
    UTIL_SEQ_RegTask((1 << _myloraWanAppBit), UTIL_SEQ_RFU, myloraWan_MeasureFinish);
    UTIL_SEQ_RegTask((1 << (_myloraWanAppBit + 1)), UTIL_SEQ_RFU, myLoraWan_Reconnect);
    UTIL_SEQ_RegTask((1 << (_myloraWanAppBit + 2)), UTIL_SEQ_RFU, myLoraWan_LastDataSend);
}