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"
#include "utils/utils.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,
                .SensPollSensors = (SYSPARAM_TEMP_HUM | SYSPARAM_BAR),          // bit mask of sensors
 
                .SensExistSensors =
#if defined(SENSOR_SHT45)
                SYSPARAM_TEMP_HUM |
#endif
#if defined(SENSOR_BAR_BMP585) || defined(SENSOR_BAR_ILS22QS)
                SYSPARAM_BAR |
#endif
#if defined(SENSOR_AMB_TSL2591)
                SYSPARAM_AMBIENT |
#endif
#if defined(SENSOR_SCD41)
                SYSPARAM_CO2 |
#endif
#if defined(SENSOR_SPS30)
                SYSPARAM_PARTICULAR |
#endif
                0,
 
                .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 =  LORAWANPORT_DATA_DEFAULT,      // myLoraWan_LastDataSend
                .LoRaRepeatTryConnect = 2,          // 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,                            // the device need to be restarted
                .DevReset = 0,                              // factory reset
                .DevOnOff = 0,                              // in main() - start/stop measuring
 
                .MqttConfirm = 0,
                .MqttTime = 0,
 
                .IntBatTimeSendUNIX = 0,
                .Dummy = {},//
                .Crc = 0    //
        };
 
 
systemParams_t _systemParamsBck = {};   // helper - bckUp buffer for NFC reading and for sending via downlink to server
 
 
// helper -
#ifdef DEBUG
#define SYS_REF(i,f) {.Inx = i, .Size = sizeof(_systemParams.f), .Addr = ((uint8_t*)&_systemParams.f - (uint8_t*)&_systemParams), .Name = #f}
#else
#define SYS_REF(i,f) {.Inx = i, .Size = sizeof(_systemParams.f), .Addr = ((uint8_t*)&_systemParams.f - (uint8_t*)&_systemParams)}
#endif
 
/**
 * @brief - the definition of _systemParams and struct position and sizes
 */
systemParamsRef_t _systemParamRef[] =
        {
                SYS_REF(0, Sign),
                SYS_REF(1, AppVersion),
                SYS_REF(2, SensTimeoutMeasure),
                SYS_REF(3, SensAltitude),
                SYS_REF(4, SensSendInOnePacket),
                SYS_REF(5, SensPollSensors),
                SYS_REF(6, SensExistSensors),
                SYS_REF(7, MemsStoreSensorData),
                SYS_REF(8, MemsMaxSensorData),
                SYS_REF(9, MemsCurrentCountSensorData),
                SYS_REF(10, LoRaPort),
                SYS_REF(11, LoRaRepeatTryConnect),
                SYS_REF(12, LoRaAdaptiveDataRate),
                SYS_REF(13, LoRaDataRate),
                SYS_REF(14, LoRaTxPower),
                SYS_REF(15, LoRaClass),
                SYS_REF(16, LoRaRegion),
                SYS_REF(17, HWBatteryLevelStatus),
                SYS_REF(18, HWBatteryMV),
                SYS_REF(19, HWDevEUI),
                SYS_REF(20, HWAppEUI),
                SYS_REF(21, HWAppKEY),
                SYS_REF(22, HWDevADDR),
                SYS_REF(23, DevRestart),
                SYS_REF(24, DevReset),
                SYS_REF(25, DevOnOff),
                SYS_REF(26, MqttConfirm),
                SYS_REF(27, MqttTime),
                SYS_REF(28, IntBatTimeSendUNIX),
                SYS_REF(29, Dummy),
                SYS_REF(30, Crc)
        };
 
 
int8_t _tryInit = 1;            // xxx_Is - try init for ensure....
measureNFC_t _measureNFC = {};
uint8_t _batPercLevel = 0;      /**< level of battery percentage on start */
 
 
 
static UTIL_TIMER_Object_t _timerToOff = {};    // timer to activate of OFF Mode
static uint32_t _timerTick = 0; // timer tick
 
/**
 * @brief - find the index of field
 * @retval index into _systemParamRef where is found inx param
 * @retval -1 - in case, if specified index not exist
 */
static int8_t systemParamsRef_Get(uint8_t inx)
{
    int8_t retInx = -1, i;
 
    for (i = 0; i < COUNT_OF(_systemParamRef) && retInx < 0; ++i)
        if (_systemParamRef[i].Inx == inx)
            retInx = i;
    return retInx;
}
 
/**
 * @brief - Dummy function - the timer need empty dummy, cannot be NULL
 */
static void OnTimerToOff(void*)
{
}
 
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] = calculateCrc(devEui, 7);
}
 
///////////////////////////////////// public //////////////////////////////////
 
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;
}
 
 
void systemParams_SetCRCSystemParams()
{
    _systemParams.Crc = calculateCrc((uint8_t*)&_systemParams, sizeof(_systemParams) - sizeof(_systemParams.Crc));
}
 
uint8_t systemParams_CheckCRC(const systemParams_t* par)
{
    uint8_t crc = 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();
    }
 
    if (SZ_MEASURENFC != sizeof(measureNFC_t))
    {
        writeLog("The sizeof measureNFC_t:%d, expected:%d", sizeof(measureNFC_t), SZ_MEASURENFC);
        Error_Handler();
    }
 
    if (sizeof(measureNFC_t) % 4)
    {
        writeLog("The sizeof measureNFC_t:%d is not on boundary 4!", sizeof(measureNFC_t));
        Error_Handler();
    }
    if (sizeof(measureDataNFC_t) % 4)
    {
        writeLog("The sizeof measureDataNFC_t:%d is not on boundary 4!", sizeof(measureDataNFC_t));
        Error_Handler();
 
    }
 
    if (SZ_SYSTEMPARAMS > MEASUREDATANFC_ADDR)
    {
        writeLog("The sizeof systemParams_t:%d overwrite data measure address:%d", SZ_SYSTEMPARAMS, MEASUREDATANFC_ADDR);
        Error_Handler();
    }
 
    // the chec the size of EEPROM a byte address possible
    int eepromDataSize = MEASUEREDATANFC_EEPROMSIZE / sizeof(measureDataNFC_t);
    if (eepromDataSize > 255)
    {
        writeLog("The NFC EEPROM size:%d is too big for BYTE(uint8_t) handling in measureNFC_t", eepromDataSize);
        Error_Handler();
    }
 
    systemParams_SetCRCSystemParams();
    systemParams_getAppDevEUI();    // set default setting
    sensorsBase_MeasureNFCInit();   // 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);  // MCU is ready go to OFF mode
    }
}
 
void systemParams_Correction()
{
    _systemParams.SensTimeoutMeasure = CLAMP(_systemParams.SensTimeoutMeasure, SYSTEMPARAMS_MINSENSORTIME, SYSTEMPARAMS_MAXSENSORTIME); // max 1h
    _systemParams.LoRaRepeatTryConnect = CLAMP(_systemParams.LoRaRepeatTryConnect, 0, 32);
    _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);
    _systemParams.MqttTime &= 0xFFFFFFFF;
 
    // these values ​​cannot be modified
    getDevEuiFromHardware(_systemParams.HWDevEUI);
    GetDevAddr(&_systemParams.HWDevADDR);
}
 
uint8_t systemParams_IsSensorAvaiable(systemParams_Sensors_t sensorType)
{
    return (_systemParams.SensPollSensors & sensorType) != 0;
}
 
uint8_t systemParams_CorrectSystemTime()
{
    uint8_t ret = 0;
    SysTime_t sysTime = SysTimeGet(), mqttTime = {.Seconds = _systemParams.MqttTime & 0xFFFFFFFF, .SubSeconds = 0};
 
    if (mqttTime.Seconds >= sysTime.Seconds)    // the system time is lower, is updated
    {
        SysTimeSet(mqttTime);
        ret = 1;    // system time has been changed, system Time is incorrect
    }
    else
    {
        _systemParams.MqttTime = sysTime.Seconds;
        ret = 2;    // mqtt time has been changed
    }
    return ret;
}
 
 
void systemParams_SetFromPart(const uint8_t* buffer, uint8_t bufSize)
{
    uint8_t pos = 0;
    while (buffer != NULL && bufSize)
    {
        // 1. read index
        uint8_t inx = *(buffer + pos);    // index of field in _systemParams
        const uint8_t *data = buffer + pos + 1; // data for field
        int8_t inxRef = systemParamsRef_Get(inx); // trying to fine the address and size for specified inx
 
        if (inxRef < 0)
        {
            writeLog("systemParams_SetFromPart: Incorrect INX:%d on position in buffer:%d", (int)inx, (int)pos);
            break;
        }
 
        // 2. minimum size of rest must be .Size + 1(byte of Inx)
        if (bufSize < _systemParamRef[inxRef].Size + 1)
        {
            writeLog("systemParams_SetFromPart: few bytes in buffer. Position:%d, required:%d, in buffer:%d", (int)pos,  (int)_systemParamRef[inxRef].Size, (int)bufSize);
            break;
        }
 
        // copy data to _systemParam struct
        memcpy((uint8_t*)&_systemParams +  _systemParamRef[inxRef].Addr, data, _systemParamRef[inxRef].Size);
        pos += (1 + _systemParamRef[inxRef].Size);      // next position
        bufSize -= (1 + _systemParamRef[inxRef].Size);  // decrement size
        writeLog("systemParams_SetFromPart: write on _systemParams, Addr:%d, Size:%d", (int) _systemParamRef[inxRef].Addr,  _systemParamRef[inxRef].Size);
    }
    systemParams_SetCRCSystemParams();
}
 
 
void sensorsBase_MeasureNFCInit()
{
    _measureNFC.Count = 0;
    _measureNFC.MaxCount = (MEASUEREDATANFC_EEPROMSIZE - MEASUREDATANFC_ADDR - sizeof(measureNFC_t)) / sizeof(measureDataNFC_t);    // byte border
    _measureNFC.Inx = 0;
    _measureNFC.Size = sizeof(measureDataNFC_t);
    memset(_measureNFC.Dummy, 0, sizeof(_measureNFC.Dummy));
    sensorsBase_SetCRCMeasureNFC();
}
 
void sensorsBase_SetCRCMeasureNFC()
{
    _measureNFC.Crc = calculateCrc((uint8_t*)&_measureNFC, sizeof(_measureNFC) - sizeof(_measureNFC.Crc));
}
 
uint8_t sensorsBase_CheckCRCMeasureNFC()
{
    uint8_t crc = calculateCrc((uint8_t*)&_measureNFC, sizeof(_measureNFC) - sizeof(_measureNFC.Crc));
    uint8_t isOK = (crc == _measureNFC.Crc);
 
    if (isOK)
    {
        // 1. check the count - correction
        _measureNFC.Count = CLAMP(_measureNFC.Count, 0, _measureNFC.MaxCount);
        // 2. check the INX - correcton
        _measureNFC.Inx = CLAMP(_measureNFC.Inx, 0, _measureNFC.Count);
        sensorsBase_SetCRCMeasureNFC();
        // 3. the checking of size - not correction possible
        isOK = (_measureNFC.Size == sizeof(measureDataNFC_t));
    }
    return isOK;
}
 
#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)
 
// uint64_t Unix timestamp field — logs offset, raw value (dec hi:lo and hex hi:lo) and human-readable UTC date/time
#define SYS_WR_TIME(inst, member) \
    do { \
        unsigned _off = (unsigned)((uint8_t*)&((inst).member) - (uint8_t*)&(inst)); \
        uint64_t _t = (uint64_t)((inst).member); \
        uint32_t _thi = (uint32_t)((_t >> 32) & 0xFFFFFFFFUL); \
        uint32_t _tlo = (uint32_t)(_t & 0xFFFFFFFFUL); \
        if (_t == 0ULL) { \
            writeLog("%03u(%02X) " #member ":%lu%08lu(%08lX%08lX) (not set)", \
                _off, _off, 0UL, 0UL, 0UL, 0UL); \
        } else { \
            uint16_t _yr; uint8_t _mo, _dy, _hh, _mm, _ss; \
            _systemParams_unixToDateTime(_t, &_yr, &_mo, &_dy, &_hh, &_mm, &_ss); \
            writeLog("%03u(%02X) " #member ":%lu%08lu(%08lX%08lX) %04u-%02u-%02u %02u:%02u:%02u UTC", \
                _off, _off, \
                (unsigned long)_thi, (unsigned long)_tlo, \
                (unsigned long)_thi, (unsigned long)_tlo, \
                (unsigned)_yr, (unsigned)_mo, (unsigned)_dy, \
                (unsigned)_hh, (unsigned)_mm, (unsigned)_ss); \
        } \
    } while(0)
 
/**
 * @brief Convert a Unix UTC timestamp (seconds since 1970-01-01 00:00:00) to
 *        broken-down calendar fields.
 *
 * Uses Howard Hinnant's pure-integer civil-from-days Gregorian algorithm
 * (no libc time functions required), correct for any 64-bit Unix timestamp
 * including leap years and century / 400-year boundaries.
 *
 * @param t     Seconds since the Unix epoch (UTC).
 * @param year  Output: full calendar year (e.g. 2026).
 * @param month Output: month 1–12.
 * @param day   Output: day-of-month 1–31.
 * @param hour  Output: hours 0–23.
 * @param min   Output: minutes 0–59.
 * @param sec   Output: seconds 0–59.
 */
static void _systemParams_unixToDateTime(uint64_t t,
    uint16_t *year, uint8_t *month, uint8_t *day,
    uint8_t *hour, uint8_t *min, uint8_t *sec)
{
    *sec  = (uint8_t)(t % 60u);
    t    /= 60u;
    *min  = (uint8_t)(t % 60u);
    t    /= 60u;
    *hour = (uint8_t)(t % 24u);
    t    /= 24u;
 
    // Shift epoch from 1970-01-01 to 0000-03-01 for the era-based Gregorian algorithm
    uint32_t z   = (uint32_t)t + 719468u;
    uint32_t era = z / 146097u;
    uint32_t doe = z - era * 146097u;                                   /* [0, 146096] */
    uint32_t yoe = (doe - doe/1460u + doe/36524u - doe/146096u) / 365u; /* [0, 399]    */
    uint32_t y   = yoe + era * 400u;
    uint32_t doy = doe - (365u * yoe + yoe/4u - yoe/100u);             /* [0, 365]    */
    uint32_t mp  = (5u * doy + 2u) / 153u;                             /* [0, 11]     */
    uint32_t d   = doy - (153u * mp + 2u) / 5u + 1u;                  /* [1, 31]     */
    uint32_t m   = mp + (mp < 10u ? 3u : -9u);                         /* [1, 12]     */
    y           += (m <= 2u ? 1u : 0u);
 
    *year  = (uint16_t)y;
    *month = (uint8_t)m;
    *day   = (uint8_t)d;
}
 
 
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, SensPollSensors);
    SYS_WR     (_systemParams, SensExistSensors);
 
    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, MqttConfirm);
    SYS_WR_TIME(_systemParams, MqttTime);
 
    SYS_WR_TIME(_systemParams, IntBatTimeSendUNIX);
 
    SYS_WR     (_systemParams, Crc);
 
    writeLog("================ NFC measure info ========");
    SYS_WR(_measureNFC, Count);
    SYS_WR(_measureNFC, MaxCount);
    SYS_WR(_measureNFC, Size);
    SYS_WR(_measureNFC, Inx);
    SYS_WR(_measureNFC, Crc);
 
#ifdef DEBUG
    writeLog("======_systemParamRef only for Tamas =======");
    for(int i = 0; i < COUNT_OF(_systemParamRef); ++i)
    {
        writeLog("Inx:%02d Size:%02d Addr:%02d Name:%s", (int)_systemParamRef[i].Inx, (int)_systemParamRef[i].Size, (int)_systemParamRef[i].Addr, _systemParamRef[i].Name);
    }
#endif
    writeLog("==========================================");
 
}
#endif