mysensors.c

Go to the documentation of this file.

/*
 * mysensors.c
 *
 *  Created on: 6. 1. 2026
 *      Author: Milan
 * Pressure: ILS22: 5Ch
 * Pressure: BMP585: 46h(SDO=0) or 47h(SDO=1)
 * Temp&Hum: SHT45: 44h
 * NFC:  st25dv04kc: 53h & 57h
 * Ambient: TSL2591: 29h
 * CO2: SCD41: 62h
 * PM: SPS30: 69h
 
 */
 
 
 
#include "main.h"
#include "mysensors.h"
#include "mysensors_base.h"
#include "i2c.h"
#include "utils/utils.h"
#include "utils/mydefs.h"
 
 
#include "stm32_timer.h"
#include "stm32_seq.h"
#include "adc_if.h"
#include "CayenneLpp.h"
 
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
 
/**
 * @brief sensor groups for reading - the sensors in one group are read together
 * This is necessary to processing of the similar sensors together as tempHum, ambient, barometer etc. depends on their consumption
 * every sensor's group has it own count of measuring, timeout between measure
 * At the end of measure, maybe any sensors need to service, therefor is called method NeedService, which returns 1 - sensor is servicing 0 - not, or
 * service has been finished
 */
typedef enum
{
    SENS_GRP_0 = 0, // group 0 (tempHum, ambient, barometer)
    SENS_GRP_1,     // group 1 (sdc41, sps30)
    SENS_GRP_2,     //
    SENS_GRP_3,
    SENS_GRP_ALL    // all groups - do not use in _sensors
} sens_ReadingGrp_t;
 
/**
 * @brief the definition for group of sensor  sens_ReadingGrp_t
 * the number of readings and timeout for reading data from sensors
 */
#pragma pack(1)
typedef struct
{
    sens_ReadingGrp_t Group;    // group number
    uint8_t MaxReadCount;       // the number of readings data from sensors (0 - no read[temporary off], 255 max)
    uint16_t TimeoutRead;       // timeout between reading from sensor,
} sens_GrpTiming_t;
 
/**
 * @brief sensor definition - interface
 */
typedef struct
{
    sens_GrpTiming_t GroupTiming;
    // follows control methods
    HAL_StatusTypeDef (*Init)(I2C_HandleTypeDef *hi2c);     // sensor initialization
    int8_t (*Is)(I2C_HandleTypeDef *hi2c, int8_t tryInit);  // sensor is/isn't present
    HAL_StatusTypeDef (*On)(I2C_HandleTypeDef *hi2c);       // sensor ON - HAL_OK - sensor can work, other sensor fails or not present
    HAL_StatusTypeDef (*Off)(I2C_HandleTypeDef *hi2c);      // sensor OFF
    HAL_StatusTypeDef (*Read)(I2C_HandleTypeDef *hi2c);     // reads data
    int8_t (*Service)(I2C_HandleTypeDef *hi2c);             // service of sensor, sensors must On, processing of service and Off self
    void (*LogData)(char *buf);                             // optional, write log data to buf
    systemParams_Sensors_t Type;                            // type of sensor
    const char *Name;                                       // the name of sensor
} sens_processing_t;
#pragma pack()
/**
 * @brief definition of sensors group
 */
static const sens_GrpTiming_t _groupTiming[] =
    {
        { SENS_GRP_0, 5, 500 }, // tempHum,barometer,ambient
                { SENS_GRP_1, 3, 5100 },    // scd41 - every 5seconds
                { SENS_GRP_2, 5, 1100 },    // sps30 - every 1second
        //{ SENS_GRP_3, 10, 3000 }  // for debug only - all sensors together
        };
 
// !!! the sensor of tempHum must be before barometer, because the barometer sensors needs value of temperature !!!
 
static const sens_processing_t _sensors[] =
{
#ifdef SENSOR_SHT45
        { _groupTiming[0], tmphm_sht45_Init, tmphm_sht45_Is, tmphm_sht45_On, tmphm_sht45_Off, tmphm_sht45_Read, NULL,
                tmphm_sht45_LogData, SYSPARAM_TEMP_HUM, "tempHum sensor" },
#endif
#ifdef SENSOR_BAR_ILS22QS
        { _groupTiming[0], bar_ils22qs_Init, bar_ils22qs_Is, bar_ils22qs_On, bar_ils22qs_Off, bar_ils22qs_Read, NULL,
                bar_ils22qs_LogData, SYSPARAM_BAR, "barometer ILS22 sensor" },
#endif
#ifdef SENSOR_AMB_TSL2591
        { _groupTiming[0], amb_tsl2591_Init, amb_tsl2591_Is, amb_tsl2591_On, amb_tsl2591_Off, amb_tsl2591_Read, NULL,
                amb_tsl2591_LogData, SYSPARAM_AMBIENT, "ambient sensor" },
#endif
#ifdef SENSOR_BAR_BMP585
        { _groupTiming[0], bar_bmp585_Init, bar_bmp585_Is, bar_bmp585_On, bar_bmp585_Off, bar_bmp585_Read, NULL,
                bar_bmp585_LogData, SYSPARAM_BAR, "barometer BMP585 sensor" },
#endif
#ifdef SENSOR_SCD41
        { _groupTiming[1], scd41_Init, scd41_Is, scd41_On, scd41_Off, scd41_Read, NULL,
                scd41_LogData, SYSPARAM_CO2, "scd41 sensor" },
#endif
#ifdef SENSOR_SPS30
        { _groupTiming[2], sps30_Init, sps30_Is, sps30_On, sps30_Off, sps30_Read, sps30_Service,
                sps30_LogData, SYSPARAM_PARTICULAR, "sps30 sensor" },   //
#endif
};
 
/**
 * @brief anonymous global struct for current sensor data flow
 */
static struct
{
    I2C_HandleTypeDef *Hi2c;       /**< current I2C handler */
    sens_ProcessDef_t ProcessDef; /**< process reading sensor data, sensor Reading sequence must start via sensors_Start */
    int8_t GroupInxTiming : 4;    /**< index of current group process - max 7 groups, can be negative */
    sleeper_t ProcessDelay;       /**< global process timing -> _groupTiming */
    uint8_t GroupReadCount;       /**< counter or reading for group -> sens_GrpTiming_t.MaxReadCount */
 
    // for sequencer processing
    UTIL_TIMER_Object_t SensorTimerReading;   /**< semsor timer reading */
    uint8_t SensorSeqID : 4;     /**< bit sequencer for sensor reading CFG_SEQ_Task_Sensors - max 4 bit, CFG_SEQ_Task_Sensors */
    uint8_t MylorawanSeqID : 4;  /**< bit sequencer for mylorawan - the measure is finished, data processing send */
 
    SysTime_t MeasureTime;       /**< time when measure was done */
} _;
 
 
static int getCount_GroupTiming()
{
    return sizeof(_groupTiming) / sizeof(sens_GrpTiming_t);
}
static int getCount_Sensors()
{
    return sizeof(_sensors) / sizeof(sens_processing_t);
}
 
#ifdef WRITELOG
static char _sensBuffer[1024] = {}; // sensor buffer
 
static void sensBuffer_Reset()
{
    _sensBuffer[0] = '\0';
}
 
static void sensBuffer_Add(const char *format, ...)
{
    va_list argList;
    va_start(argList, format);
    int len = strlen(_sensBuffer);
 
    vsprintf(_sensBuffer + len, format, argList);
    va_end(argList);
}
 
static char* sensBuffer_Get()
{
    return _sensBuffer + strlen(_sensBuffer);
}
 
static void sensBuffer_Send()
{
    if (_sensBuffer[0])
    {
        strcat(_sensBuffer, "\r\n");
        writeLogNL(_sensBuffer);
    }
}
#else
#define sensBuffer_Reset()
#define sensBuffer_Add(format, ...)
#define sensBuffer_Get() NULL
#define sensBuffer_Send()
#endif
 
static int _i2cOnOff = 1;   // default is ON, 3V3 too, set in CubeMX
void i2c_OnOff(uint8_t onOff)
{
    if (onOff)
    {
        if (_i2cOnOff++ == 0)
        {
            Power3v3_On();  // the peripherials must be ON
            MX_I2C2_Init();     // reinit
        }
    }
    else
        if (_i2cOnOff > 0)
        {
            if (--_i2cOnOff == 0)
            {
                MX_I2C2_DeInit();   // deinit - low power
                Power3v3_Off();     // powering off
            }
        }
}
 
/**
 * @brief On/Off sensors according to group
 * @param grp - specified group, if SENS_GRP_LAST - all sensors
 * @return number of sensors started from group
 */
static int sensors_OnOff(sens_ReadingGrp_t grp, int onOff)
{
    int i, count = getCount_Sensors(), started = 0;
 
    writeLog("Sensors:%s", (onOff ? "On" : "Off"));
    for (i = 0; i < count; i++)
    {
        if (systemParams_IsSensorAvaiable(_sensors[i].Type) && (grp == SENS_GRP_ALL || _sensors[i].GroupTiming.Group == grp))
        {
            if (onOff)
            {
                if (_sensors[i].On != NULL)
                    if (_sensors[i].On(_.Hi2c) == HAL_OK)
                        started++;
            }
            else
            {
                if (_sensors[i].Off != NULL)
                    _sensors[i].Off(_.Hi2c);
            }
        }
    }
    return started;
}
 
/**
 * @brief reading sensor one by one in specified group
 * @param grp specified group, if SENS_GRP_LAST - all sensors
 */
static void sensors_Read(sens_ReadingGrp_t grp)
{
    HAL_StatusTypeDef status;
    int i, count = getCount_Sensors();
 
    sensBuffer_Reset();
    sensBuffer_Add("group:%d ", (int) grp);
    for (i = 0; i < count; i++)
    {
        if (systemParams_IsSensorAvaiable(_sensors[i].Type) && (grp == SENS_GRP_ALL || _sensors[i].GroupTiming.Group == grp))
        {
            if (_sensors[i].Is != NULL && _sensors[i].Is(_.Hi2c, _tryInit) && _sensors[i].Read != NULL)
            {
                status = _sensors[i].Read(_.Hi2c);
                if (status == HAL_OK)
                    if (_sensors[i].LogData != NULL)
                        _sensors[i].LogData(sensBuffer_Get());
            }
        }
    }
    sensBuffer_Send();
}
 
/**
 * @brief Move to next used group in _sensors[]
 */
static uint8_t sensors_NextGroup()
{
    int i, count = getCount_Sensors();
 
    while (++_.GroupInxTiming < getCount_GroupTiming())
        for (i = 0; i < count; i++)
        {
            if (_sensors[i].GroupTiming.Group == _groupTiming[_.GroupInxTiming].Group)
                return 1;   // the group has been found
        }
    return 0;
}
 
static uint8_t sensors_Service()
{
    int i, count = getCount_Sensors();
    uint8_t underService = 0;
 
    for (i = 0; i < count; i++)
        if (systemParams_IsSensorAvaiable(_sensors[i].Type) && _sensors[i].Service != NULL && _sensors[i].Service(_.Hi2c))
            underService++;
    return underService;
}
 
///////////////////////////////////////////////////////////////////
// sequencer
///////////////////////////////////////////////////////////////////
/**
 * @brief task sensor sequencer
 */
static void tasksensors_Work()
{
    sens_ProcessDef_t s = sensors_Work();
 
    switch (s)
    {
        case SENS_DONE:
            // measure is done, system is ready for next measure
            // measure time - time between measure, not time from system is going to sleep
            sensors_Retiming();
        break;
 
        case SENS_DATAREADY:
            //UTIL_SEQ_SetEvt(_.MylorawanSeqID);    // data can be processing, event is fired
            UTIL_SEQ_SetTask((1 << _.MylorawanSeqID), CFG_SEQ_Prio_0);  // the mylorawan processing for send data, better than event? CFG_SEQ_Task_MyLoraSend -> myloraWan_MeasureFinish
            //break; ok, after SENS_DATAREADY, task must be started
        default:
            UTIL_SEQ_SetTask((1 << _.SensorSeqID), CFG_SEQ_Prio_0); // next calling of tasksensors_Work
    }
}
 
static void tasksensors_OnTimeout()
{
    if (_systemParams.DevOnOff)
    {
        sensors_Start();
        UTIL_SEQ_SetTask((1 << _.SensorSeqID), CFG_SEQ_Prio_0); // start of tasksensors_Work
    }
}
 
// ------------- public -----------------------
 
void sensors_Start()
{
    _.ProcessDef = SENS_BEGIN;
    _.GroupInxTiming = -1;
    sensors_NextGroup();
    _.GroupReadCount = 0;
    sleeper_SetSleepMS(&_.ProcessDelay, 0); // no timer at start
}
 
sens_ProcessDef_t sensors_Work()
{
    if (sleeper_IsElapsed(&_.ProcessDelay))
    {
        switch (_.ProcessDef)
        {
            case SENS_BEGIN:
                i2c_OnOff(1);   // I2C on
                sleeper_SetSleepMS(&_.ProcessDelay, 500);   // little pause after init of I2C
                _.ProcessDef = SENS_INIT;
            break;
            case SENS_INIT:
                sensors_Init(NULL);
                sleeper_SetSleepMS(&_.ProcessDelay, 500);   // little pause after init of sensors
                _.ProcessDef = SENS_START;
            break;
            case SENS_START:
                _.GroupReadCount = 0;
                if (sensors_OnOff(_groupTiming[_.GroupInxTiming].Group, 1) > 0) // start sensors for specified group
                {
                    sleeper_SetSleepMS(&_.ProcessDelay, _groupTiming[_.GroupInxTiming].TimeoutRead);    // reading data from sensor every x msseconds for group
                    _.ProcessDef = SENS_READ;
                }
                else
                {
                    _.ProcessDef = SENS_STOP;   // no sensors from group is available
                    _.ProcessDelay.SleepMS = 0; //
                }
            break;
            case SENS_READ:
                if (_groupTiming[_.GroupInxTiming].MaxReadCount)    // is required any reading?
                {
                    sensors_Read(_groupTiming[_.GroupInxTiming].Group);
                    sleeper_Next(&_.ProcessDelay);
                    togle_LedOff(0);
                    _.GroupReadCount++;
                }
                if (_.GroupReadCount >= _groupTiming[_.GroupInxTiming].MaxReadCount)    // maximum read count has been reached
                {
                    _.ProcessDef = SENS_STOP;
                    _.ProcessDelay.SleepMS = 0; // stop timer
                    togle_LedOff(1);
                }
            break;
            case SENS_STOP:
                _.ProcessDelay.SleepMS = 0; // stop timer
                sensors_OnOff(_groupTiming[_.GroupInxTiming].Group, 0); // stop sensors for specified group
                if (sensors_NextGroup())
                    _.ProcessDef = SENS_START;
                else
                    _.ProcessDef = SENS_DATAREADY;  // no more group, data ready
            break;
            case SENS_DATAREADY:
                _.ProcessDef = SENS_SERVICE;
            break;
            case SENS_SERVICE:
                if (!sensors_Service())
                    _.ProcessDef = SENS_END;
            break;
            case SENS_END:
                _.ProcessDef = SENS_DONE;
                i2c_OnOff(0);
            break;
            case SENS_DONE:
                // never reach this line
            break;
        }
    }
    return _.ProcessDef;
}
 
void sensors_Init(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status;
    int i, count = getCount_Sensors();
 
    if (hi2c != NULL)
        _.Hi2c = hi2c;
 
// initialization of individual sensors
    for (i = 0; i < count; i++)
    {
        if (_sensors[i].Init != NULL)
        {
            if (systemParams_IsSensorAvaiable(_sensors[i].Type))
            {
                status = _sensors[i].Init(_.Hi2c);
                writeLog("%d. %s Init %s.", i, ((_sensors[i].Name != NULL) ? _sensors[i].Name : "sensor"), ((status == HAL_OK) ? "OK" : "failed"));
            }
        }
        else
            writeLog("%d. sensor: Init is NULL", i);
    }
    sensors_OnOff(SENS_GRP_ALL, 0); // on start, all sensors OFF
}
 
void sensors_Retiming()
{
    if (_systemParams.DevOnOff)
    {
        // create timer, if was not created yet
        if (_.SensorTimerReading.ReloadValue == 0)
            UTIL_TIMER_Create(&_.SensorTimerReading, _systemParams.SensTimeoutMeasure, UTIL_TIMER_ONESHOT, tasksensors_OnTimeout, NULL);
        UTIL_TIMER_Stop(&_.SensorTimerReading);
        UTIL_TIMER_Start(&_.SensorTimerReading);    // new time for start
    }
}
 
 
/**
 * @brief task sequencer initialization for sensors reading
 */
void sensorsSeq_Init(uint32_t sensortAppBit, uint32_t mylorawanAppBit)
{
    _.SensorSeqID = sensortAppBit;
    _.MylorawanSeqID = mylorawanAppBit;
    UTIL_SEQ_RegTask((1 << _.SensorSeqID), UTIL_SEQ_RFU, tasksensors_Work);
    tasksensors_OnTimeout();    // start reading of sensors data and timer after reading
}
 
 
void sensors_CopyToBck()
{
#ifdef SENSOR_SHT45
    _bck_tmphm_sht45Data = _tmphm_sht45Data;
#endif
#ifdef SENSOR_AMB_TSL2591
    _bck_amb_tsl2591Data = _amb_tsl2591Data;
#endif
#ifdef SENSOR_BAR_ILS22QS
    _bck_bar_ils22qsData = _bar_ils22qsData;
#endif
#ifdef SENSOR_BAR_BMP585
    _bck_bar_bmp585Data = _bar_bmp585Data;
#endif
#ifdef SENSOR_SCD41
    _bck_scd41Data = _scd41Data;
#endif
#ifdef SENSOR_SPS30
    _bck_sps30Data = _sps30Data;
#endif
}
 
/*
// !!! The adding of more data for Caynnel, check the size of MEASUEREDATANFC_SIZE
 */
uint8_t* sensors_CayennelFromBckData(uint8_t *sizeOut, SysTime_t* prevMeasureTime)
{
    uint8_t sz, channel = 1;
    SysTime_t currentTime = SysTimeGet();
#ifdef SENSOR_SCD41
    uint8_t isTempHum = 0;
#endif
 
    sensBuffer_Reset();
    sensBuffer_Add("------- ");
    CayenneLppReset();
#ifdef SENSOR_SHT45
    if (_bck_tmphm_sht45Data.IsDataValid)
    {
        CayenneLppAddTemperature(channel++, _bck_tmphm_sht45Data.Temperature);
        CayenneLppAddRelativeHumidity(channel++, _bck_tmphm_sht45Data.Humidity);
#ifdef SENSOR_SCD41
        isTempHum = 1;
#endif
        sensBuffer_Add("tmp:" PRIf_02 " hum:" PRIf_02 " ", PRIf_02D(_bck_tmphm_sht45Data.Temperature), PRIf_02D(_bck_tmphm_sht45Data.Humidity));
    }
#endif
#ifdef SENSOR_AMB_TSL2591
    if (_bck_amb_tsl2591Data.IsDataValid)
    {
        CayenneLppAddLuminosity(channel++, (uint16_t) _bck_amb_tsl2591Data.Lux);
        sensBuffer_Add("amb:" PRIf_02 " ", PRIf_02D(_bck_amb_tsl2591Data.Lux));
    }
#endif
#ifdef SENSOR_BAR_ILS22QS
    if (_bck_bar_ils22qsData.IsDataValid)
    {
        //CayenneLppAddTemperature(channel++, _tempBarometerData.Temperature); if temperature is added, modify SIZE_ILS22QS_NFC also
        CayenneLppAddBarometricPressure(channel++, _bck_bar_ils22qsData.PressureSEA);
        sensBuffer_Add("bar:" PRIf_02 " ", PRIf_02D(_bck_bar_ils22qsData.PressureSEA));
    }
#endif
#ifdef SENSOR_BAR_BMP585
    if (_bck_bar_bmp585Data.IsDataValid)
    {
        //CayenneLppAddTemperature(channel++, _tempBarometerData.Temperature); if temperature is added, modify SIZE_BMP585_NFC also
        CayenneLppAddBarometricPressure(channel++, _bck_bar_bmp585Data.PressureSEA);
        sensBuffer_Add("bar:" PRIf_02 " ", PRIf_02D(_bck_bar_bmp585Data.PressureSEA));
    }
#endif
#ifdef SENSOR_SCD41
    if (_bck_scd41Data.IsDataValid)
    {
        CayenneLppAddConcentration(channel++, (uint16_t) _bck_scd41Data.Co2);
        if (!isTempHum)
        {
            CayenneLppAddTemperature(channel++, _bck_scd41Data.Temperature);
            CayenneLppAddRelativeHumidity(channel++, _bck_scd41Data.Humidity);
        }
        sensBuffer_Add("co2:" PRIf_02 " ", PRIf_02D(_bck_scd41Data.Co2));
    }
#endif
#ifdef SENSOR_SPS30
    if (_bck_sps30Data.IsDataValid)
    {
        CayenneLppAddParticulateMatter_1_0(channel++, _bck_sps30Data.Mass_pm1_0);
        CayenneLppAddParticulateMatter_2_5(channel++, _bck_sps30Data.Mass_pm2_5);
        sensBuffer_Add("part:" PRIf_02 " " PRIf_02 " ",  PRIf_02D(_bck_sps30Data.Mass_pm1_0),  PRIf_02D(_bck_sps30Data.Mass_pm2_5));
    }
#endif
 
    // time check of sending battery level
    if (currentTime.Seconds > _memsMainBlock.Bat_SendTimeSendUNIX + SYSTEMPARAMS_BATTIMESEND)
    {
        uint8_t batPerc = _batPercLevel;
 
        CayenneLppAddBatteryPerc(channel++, batPerc);
        _memsMainBlock.Bat_SendTimeSendUNIX = currentTime.Seconds;
        sensBuffer_Add("bat:%d ", (int)batPerc);
        mems_WriteMainBlock();
    }
 
 
    // is reference time defined?
    if (prevMeasureTime != NULL && prevMeasureTime->Seconds > 0)
    {
        uint32_t timeToBuff = (_.MeasureTime.Seconds >= prevMeasureTime->Seconds) ?
                _.MeasureTime.Seconds - prevMeasureTime->Seconds :
                prevMeasureTime->Seconds - _.MeasureTime.Seconds;
 
        timeToBuff /= 60;   // seconds -> minutes
        if (timeToBuff) // zero - no time
        {
            if (timeToBuff <= 255)
            {
                CayenneLppAddTimeMeasureMIN8(channel++, (uint8_t)timeToBuff);   // value < 255
                sensBuffer_Add("tim8:%dmin ", (int)timeToBuff);
            }
            else
                if (timeToBuff <= 65535)
                {
                    CayenneLppAddTimeMeasureMIN16(channel++, (uint16_t)timeToBuff); // value < 65535
                    sensBuffer_Add("tim16:%dmin ", (int)timeToBuff);
                }
                else
                {
                    CayenneLppAddTimeMeasureABS(channel++, _.MeasureTime.Seconds);  // absolute, UNIX time
                    sensBuffer_Add("timABS ");
                }
        }
    }
    sensBuffer_Add("-------");
    sensBuffer_Send();
    sz = CayenneLppGetSize();
    if (sizeOut != NULL)
        *sizeOut = sz;
    return (sz) ? CayenneLppGetBuffer() : NULL;
}
 
 
 
void sensors_WriteFromBckToDataBlock(mems_DataBlock_t *data)
{
    uint16_t off = 0;
 
    // measure time - must be 1st, because of sensors_GetTimeFromBlock
    _.MeasureTime = SysTimeGet();
    memcpy(data->Data + off, &_.MeasureTime, sizeof(_.MeasureTime));
    off += sizeof(_.MeasureTime);
 
#ifdef SENSOR_SHT45
    memcpy(data->Data + off, &_bck_tmphm_sht45Data, sizeof(_bck_tmphm_sht45Data));
    off += sizeof(_bck_tmphm_sht45Data);
#endif
#ifdef SENSOR_AMB_TSL2591
    memcpy(data->Data + off, &_bck_amb_tsl2591Data, sizeof(_bck_amb_tsl2591Data));
    off += sizeof(_bck_amb_tsl2591Data);
#endif
#ifdef SENSOR_BAR_ILS22QS
    memcpy(data->Data + off, &_bck_bar_ils22qsData, sizeof(_bck_bar_ils22qsData));
    off += sizeof(_bck_bar_ils22qsData);
#endif
#ifdef SENSOR_BAR_BMP585
    memcpy(data->Data + off, &_bck_bar_bmp585Data, sizeof(_bck_bar_bmp585Data));
    off += sizeof(_bck_bar_bmp585Data);
#endif
#ifdef SENSOR_SCD41
    memcpy(data->Data + off, &_bck_scd41Data, sizeof(_bck_scd41Data));
    off += sizeof(_bck_scd41Data);
#endif
#ifdef SENSOR_SPS30
    memcpy(data->Data + off, &_bck_sps30Data, sizeof(_bck_sps30Data));
    off += sizeof(_bck_sps30Data);
#endif
    if (off > SENSORS_DATASIZE)
    {
        writeLog("The sensors_FillDataBlock %d>=SENSORS_DATASIZE(%d)!", (int)off, (int)SENSORS_DATASIZE);
        Error_Handler();
    }
    data->Type = MEMS_DATATYPE_SENSOR;
    data->Size = (uint8_t)off;
}
 
uint8_t sensors_ReadToBckFromDataBlock(const mems_DataBlock_t *data)
{
    uint8_t off = 0;
    if (data->Type == MEMS_DATATYPE_SENSOR)
    {
        // measure time
        memcpy(&_.MeasureTime, data->Data + off, sizeof(_.MeasureTime));
        off += sizeof(_.MeasureTime);
 
#ifdef SENSOR_SHT45
        memcpy(&_bck_tmphm_sht45Data, data->Data + off, sizeof(_bck_tmphm_sht45Data));
        off += sizeof(_bck_tmphm_sht45Data);
#endif
#ifdef SENSOR_AMB_TSL2591
        memcpy(&_bck_amb_tsl2591Data, data->Data + off, sizeof(_bck_amb_tsl2591Data));
        off += sizeof(_bck_amb_tsl2591Data);
#endif
#ifdef SENSOR_BAR_ILS22QS
        memcpy(&_bck_bar_ils22qsData, data->Data + off, sizeof(_bck_bar_ils22qsData));
        off += sizeof(_bck_bar_ils22qsData);
#endif
#ifdef SENSOR_BAR_BMP585
        memcpy(&_bck_bar_bmp585Data, data->Data + off, sizeof(_bck_bar_bmp585Data));
        off += sizeof(_bck_bar_bmp585Data);
#endif
#ifdef SENSOR_SCD41
        memcpy(&_bck_scd41Data, data->Data + off, sizeof(_bck_scd41Data));
        off += sizeof(_bck_scd41Data);
#endif
#ifdef SENSOR_SPS30
        memcpy(&_bck_sps30Data, data->Data + off, sizeof(_bck_sps30Data));
        off += sizeof(_bck_sps30Data);
#endif
    }
    return off;
}
 
SysTime_t sensors_GetTimeFromBlock(const mems_DataBlock_t *data)
{
    SysTime_t ss;
 
    memcpy(&ss, data->Data, sizeof(ss));
    return ss;
}