mysensors_base.c

Go to the documentation of this file.

/*
 * mysensors_base.c
 *
 *  Created on: 29. 1. 2026
 *      Author: Milan
 */
 
#include "mysensors_base.h"
#include "mysensors.h"
#include "main.h"
#include "se-identity.h"
#include "lora_app.h"
#include "sys_app.h"
#include "utils/mydefs.h"
 
 
 
 
 
systemParams_t _systemParams =  { //
                .Sign = SYSTEMPARAMS_SIGN,  // only sign check
                .AppVersion = {SYSTEMPARAMS_APPVER00, SYSTEMPARAMS_APPVER01},   // application version, SYSTEMPARAMS_APPVER01 - validity
#ifdef DEBUG
                .SensTimeoutMeasure = SYSTEMPARAMS_MINSENSORTIME, //    30sec, sensorsSeq_Init
#else
                .SensTimeoutMeasure = SYSTEMPARAMS_DEFAULTSENSORTIME, //    10min, sensorsSeq_Init
#endif
                .SensAltitude = SYSTEMPARAMS_DEFAULTALTITUDE,           // bar_bmp585_Read, bar_ils22qs_Read, scd41_Init
                .SensSendInOnePacket = 0,
                .SensAvailableSensors = (SYSPARAM_TEMP_HUM | SYSPARAM_BAR), // bit mask of sensors
 
                .MemsStoreSensorData = 1,           // myloraWan_MeasureFinish
                .MemsMaxSensorData = 0,             // mems_WriteToSystemParams, will be updated later, according to memory chip
                .MemsCurrentCountSensorData = 0,    // mems_WriteToSystemParams, will be updated later, according to memory chip
 
 
                .LoRaPort = SYSTEMPARAMS_DEFAULTLORAWANPORT, // myLoraWan_LastDataSend
                .LoRaRepeatTryConnect = 10,         // OnLoRaWanConnected
                .LoRaAdaptiveDataRate = LORAWAN_ADR_STATE,  // systemParams_SetLoRaWanParams
                .LoRaDataRate = LORAWAN_DEFAULT_DATA_RATE,  // systemParams_SetLoRaWanParams
                .LoRaTxPower = LORAWAN_DEFAULT_TX_POWER,    // systemParams_SetLoRaWanParams
                .LoRaClass = LORAWAN_DEFAULT_CLASS,         // systemParams_SetLoRaWanParams
                .LoRaRegion = ACTIVE_REGION,                // systemParams_SetLoRaWanParams
 
 
                .HWBatteryLevelStatus = 0,      // mems_WriteToSystemParams, will be updated later
                .HWBatteryMV = 0,                   // mems_WriteToSystemParams, will be updated later, according to memory chip
                .HWDevEUI = {},                 // default 0, will be updated in getAppDevEUI
                .HWAppEUI = FORMAT32_KEY(SYSTEM_APP_EUI),       // LoRaWAN_Init
                .HWAppKEY = FORMAT_KEY(SYSTEM_APP_KEY),     // LoRaWAN_Init, app KEY
                .HWDevADDR = 0,                 // will be updated in getAppDevEUI
 
                .DevRestart = 0,                    // not ready yet 13.3.2026 - has mean?
                .DevReset = 0,                      // write to NFC wrong data to invoke restart and recreate data
                .DevOnOff = 0,                          // in main()
 
                .Dummy = {},//
                .Crc = 0    //
        };
int8_t _tryInit = 1;            // xxx_Is - try init for ensure....
 
 
static UTIL_TIMER_Object_t _timerToOff = {};    // timer to activate of OFF Mode
static uint32_t _timerTick = 0; // timer tick
 
/**
 * @brief - Dummy function - the timer need empty dummy, cannot be NULL
 */
static void OnTimerToOff(void*)
{
}
 
///////////////////////////////////// public //////////////////////////////////
 
/*
 void boardGetUniqueId(uint8_t *id)
 {
 // Example for STM32L0/WL series
 uint32_t ID_1 = *((uint32_t*) 0x1FFF7580);
 uint32_t ID_2 = *((uint32_t*) 0x1FFF7584);
 uint32_t ID_3 = *((uint32_t*) 0x1FFF7588);
 
 // Mix the 96-bit UID into a 64-bit DevEUI
 uint32_t idL = ID_1 ^ ID_3;
 uint32_t idH = ID_2;
 
 id[7] = (uint8_t) (idL >> 24);
 id[6] = (uint8_t) (idL >> 16);
 id[5] = (uint8_t) (idL >> 8);
 id[4] = (uint8_t) (idL);
 id[3] = (uint8_t) (idH >> 24);
 id[2] = (uint8_t) (idH >> 16);
 id[1] = (uint8_t) (idH >> 8);
 id[0] = (uint8_t) (idH);
 }
 
 
void getDevEuiFromHardware(uint8_t *devEui)
{
    // The STM32WL has a 96-bit Unique ID
    uint32_t uid0 = HAL_GetUIDw0();
    uint32_t uid1 = HAL_GetUIDw1();
    uint32_t uid2 = HAL_GetUIDw2();
 
    // To match the RAK sticker logic (or create a unique 64-bit ID):
    devEui[0] = (uint8_t) (uid0 >> 24);
    devEui[1] = (uint8_t) (uid0 >> 16);
    devEui[2] = (uint8_t) (uid0 >> 8);
    devEui[3] = (uint8_t) (uid0);
    devEui[4] = (uint8_t) (uid1 >> 24);
    devEui[5] = (uint8_t) (uid1 >> 16);
    devEui[6] = (uint8_t) (uid2 >> 8);
    devEui[7] = (uint8_t) (uid2);
}
*/
 
static void getDevEuiFromHardware(uint8_t *devEui)
{
    // --- Prefix: your HW/FW identity (3 bytes) ---
    // Bit 1 of byte[0] set = locally administered (not IEEE-registered)
    devEui[0] = SYSTEM_APP_DevEUI0; // 0x45;  // 0x46 = locally-administered variant of 0x44, or use 0x45 for private network
    devEui[1] = SYSTEM_APP_DevEUI1; // 0x87;
    devEui[2] = SYSTEM_APP_DevEUI2; // 0xF2;
 
    // --- Unique part: 4 bytes derived from STM32 96-bit UID ---
    uint32_t uid0 = HAL_GetUIDw0();
    uint32_t uid2 = HAL_GetUIDw2();
    uint32_t unique = uid0 ^ uid2;  // XOR for better mixing
 
    devEui[3] = (uint8_t)(unique >> 24);
    devEui[4] = (uint8_t)(unique >> 16);
    devEui[5] = (uint8_t)(unique >> 8);
    devEui[6] = (uint8_t)(unique);
 
    // --- Checksum: CRC-8 over bytes [0..6] ---
    devEui[7] = systemParams_CalculateCrc(devEui, 7);
}
 
 
uint8_t* systemParams_getAppDevEUI()
{
    const uint8_t def[8] =
        { 0, 0, 0, 0, 0, 0, 0, 0 };
 
    if (memcmp(_systemParams.HWDevEUI, def, MIN(sizeof(_systemParams.HWDevEUI), sizeof(def))) == 0)
        getDevEuiFromHardware(_systemParams.HWDevEUI);
 
    if (_systemParams.HWDevADDR == 0)
        GetDevAddr(&_systemParams.HWDevADDR);
 
    return _systemParams.HWDevEUI;
}
 
uint8_t* systemParams_getAppEUI()
{
    return _systemParams.HWAppEUI;
}
 
uint8_t* systemParams_getAppKey()
{
    return _systemParams.HWAppKEY;
 
}
 
 
// Internal Helper: CRC-8 Calculation
uint8_t systemParams_CalculateCrc(uint8_t *data, uint8_t len)
{
    uint8_t crc = 0xFF;
    for (uint8_t i = 0; i < len; i++)
    {
        crc ^= data[i];
        for (uint8_t bit = 8; bit > 0; --bit)
        {
            if (crc & 0x80)
                crc = (crc << 1) ^ 0x31;
            else
                crc = (crc << 1);
        }
    }
    return crc;
}
 
void systemParams_SetCRCSystemParams()
{
    _systemParams.Crc = systemParams_CalculateCrc((uint8_t*)&_systemParams, sizeof(_systemParams) - sizeof(_systemParams.Crc));
}
 
uint8_t systemParams_CheckCRC(const systemParams_t* par)
{
    uint8_t crc = systemParams_CalculateCrc((uint8_t*)par, sizeof(*par) - sizeof(par->Crc));
    return crc == par->Crc;
}
 
void sensorsBase_Init()
{
    if (SZ_SYSTEMPARAMS != sizeof(systemParams_t))
    {
        writeLog("The sizeof systemParams_t:%d, expected:%d", sizeof(systemParams_t), SZ_SYSTEMPARAMS);
        Error_Handler();
    }
    systemParams_SetCRCSystemParams();
    systemParams_getAppDevEUI();    // set default setting
}
 
void sensorsBase_StartTimerToOff()
{
    if (_timerToOff.ReloadValue == 0)
        UTIL_TIMER_Create(&_timerToOff, SYSTEMPARAMS_MINTIME2OFF, UTIL_TIMER_ONESHOT, OnTimerToOff, NULL);
    UTIL_TIMER_Start(&_timerToOff);
    _timerTick = HAL_GetTick();
}
 
void sensorsBase_StopTimerToOff()
{
    uint32_t curTick = HAL_GetTick() - _timerTick;
    UTIL_TIMER_Stop(&_timerToOff);
 
    if (curTick >= SYSTEMPARAMS_MINTIME2OFF)
    {
        sensors_Retiming();
        setModeDevice(MODEDEVICE_OFF);
    }
}
 
void systemParams_Correction()
{
    _systemParams.SensTimeoutMeasure = CLAMP(_systemParams.SensTimeoutMeasure, SYSTEMPARAMS_MINSENSORTIME, SYSTEMPARAMS_MAXSENSORTIME); // max 1h
    _systemParams.LoRaPort = CLAMP(_systemParams.LoRaPort, SYSTEMPARAMS_MINLORAWANPORT, SYSTEMPARAMS_MAXLORAWANPORT);
    _systemParams.LoRaRepeatTryConnect = CLAMP(_systemParams.LoRaRepeatTryConnect, 0, 20);
    _systemParams.LoRaDataRate = CLAMP(_systemParams.LoRaDataRate, DR_0, DR_5);
    _systemParams.LoRaTxPower = CLAMP(_systemParams.LoRaTxPower, TX_POWER_0, TX_POWER_7);
    _systemParams.LoRaClass = CLAMP(_systemParams.LoRaClass, (uint8_t)CLASS_A, (uint8_t)CLASS_C);
    _systemParams.LoRaRegion = CLAMP(_systemParams.LoRaRegion, 0, 9);
}
 
 
uint8_t systemParams_IsSensorAvaiable(systemParams_Sensors_t sensorType)
{
    return (_systemParams.SensAvailableSensors & sensorType) != 0;
}
 
#ifdef WRITELOG
#define SYS_WR(inst, member) \
    writeLog("%03u(%02X) " #member ":%d(%02X)", \
        (unsigned)((uint8_t*)&((inst).member) - (uint8_t*)&(inst)), \
        (unsigned)((uint8_t*)&((inst).member) - (uint8_t*)&(inst)), \
        (int)((inst).member),(int)((inst).member))
 
// Byte array as AA:BB:CC:... — length passed explicitly
#define SYS_WR_ARR(inst, member, len) \
    do { \
        unsigned _off = (unsigned)((uint8_t*)&((inst).member) - (uint8_t*)&(inst)); \
        char _buf[3*(len)]; \
        for (unsigned _i = 0; _i < (unsigned)(len); _i++) { \
            _buf[_i*3+0] = "0123456789ABCDEF"[((inst).member[_i] >> 4) & 0xF]; \
            _buf[_i*3+1] = "0123456789ABCDEF"[ (inst).member[_i]       & 0xF]; \
            _buf[_i*3+2] = (_i < (unsigned)(len)-1) ? ':' : '\0'; \
        } \
        writeLog("%03u(%02X) " #member ":%s", _off, _off, _buf); \
    } while(0)
 
// String field (char array)
#define SYS_WR_STR(inst, member) \
    writeLog("%03u(%02X) " #member ":%s", \
        (unsigned)((uint8_t*)&((inst).member) - (uint8_t*)&(inst)), \
        (unsigned)((uint8_t*)&((inst).member) - (uint8_t*)&(inst)), \
        (inst).member)
 
 
void systemParams_Log(const char* info)
{
    writeLog("=========== systemParams_Log %s =============", info);
    SYS_WR_STR (_systemParams, Sign);
    SYS_WR_ARR (_systemParams, AppVersion, 2);
 
    SYS_WR     (_systemParams, SensTimeoutMeasure);
    SYS_WR     (_systemParams, SensAltitude);
    SYS_WR     (_systemParams, SensSendInOnePacket);
    SYS_WR     (_systemParams, SensAvailableSensors);
 
    SYS_WR     (_systemParams, MemsStoreSensorData);
    SYS_WR     (_systemParams, MemsMaxSensorData);
    SYS_WR     (_systemParams, MemsCurrentCountSensorData);
 
    SYS_WR     (_systemParams, LoRaPort);
    SYS_WR     (_systemParams, LoRaRepeatTryConnect);
    SYS_WR     (_systemParams, LoRaAdaptiveDataRate);
    SYS_WR     (_systemParams, LoRaDataRate);
    SYS_WR     (_systemParams, LoRaTxPower);
    SYS_WR     (_systemParams, LoRaClass);
    SYS_WR     (_systemParams, LoRaRegion);
 
 
    SYS_WR     (_systemParams, HWBatteryLevelStatus);
    SYS_WR     (_systemParams, HWBatteryMV);
    SYS_WR_ARR (_systemParams, HWDevEUI,  8);
    SYS_WR_ARR (_systemParams, HWAppEUI,  8);
    SYS_WR_ARR (_systemParams, HWAppKEY, 16);
    SYS_WR     (_systemParams, HWDevADDR);
 
    SYS_WR     (_systemParams, DevRestart);
    SYS_WR     (_systemParams, DevReset);
    SYS_WR     (_systemParams, DevOnOff);
 
    SYS_WR     (_systemParams, Crc);
    writeLog("==========================================");
}
#endif