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 "stm32_timer.h"
#include "stm32_seq.h"
#include "sys_app.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
};
 
static I2C_HandleTypeDef *_hi2c = NULL; // current I2C handler -
 
 
static sens_ProcessDef_t _processDef = SENS_DONE;   // process reading sensor data, sensor Reading sequence must start via sensors_Start
static int _groupInxTiming = 0;                     // index of current group process
static sleeper_t _processDelay = {};                // global process timing -> _groupTiming
static int _groupReadCount = 0;                     // counter or reading for group -> sens_GrpTiming_t.MaxReadCount
 
// for sequencer processing
static UTIL_TIMER_Object_t _sensorTimerReading = {};
static uint32_t _sensorSeqID = 0, _mylorawanSeqID = 0;
 
static uint16_t _sensorMeasureTime = 0; // part of memory to know how was interval
 
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
void i2c_OnOff(uint8_t onOff)
{
    if (onOff)
    {
        if (_i2cOnOff++ == 0)
            MX_I2C2_Init();     // reinit
    }
    else
        if (_i2cOnOff > 0)
        {
            if (--_i2cOnOff == 0)
                MX_I2C2_DeInit();   // deinit - low power
        }
}
 
/**
 * @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:
            UTIL_TIMER_Start(&_sensorTimerReading); // next start, nevertheless data send or not from memory - no, next process to start measure is joined to wakeup - is start sensorsBase_StopTimerToOff -> 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)
    {
        UTIL_TIMER_Stop(&_sensorTimerReading);
        UTIL_TIMER_Start(&_sensorTimerReading);
    }
}
 
/**
 * @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);
    UTIL_TIMER_Create(&_sensorTimerReading, _systemParams.SensTimeoutMeasure, UTIL_TIMER_ONESHOT, tasksensors_OnTimeout, NULL);
    tasksensors_OnTimeout();    // start reading of sensors data and timer after reading
    //UTIL_TIMER_Start(&_sensorTimerReading);
}
 
 
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
}
 
uint8_t* sensors_CayennelFromBckData(uint8_t *sizeOut)
{
    uint8_t sz, channel = 1;
//  float batVoltage = (float) SYS_GetBatteryLevel() / 100.0f;  // abs value of voltage
    float batPerc = ((float) GetBatteryLevel() / 254.0f) * 100.0f;
 
    CayenneLppReset();
#ifdef SENSOR_SHT45
    if (_bck_tmphm_sht45Data.IsDataValid)
    {
        CayenneLppAddTemperature(channel++, _bck_tmphm_sht45Data.Temperature);
        CayenneLppAddRelativeHumidity(channel++, _bck_tmphm_sht45Data.Humidity);
    }
#endif
#ifdef SENSOR_AMB_TSL2591
    if (_bck_amb_tsl2591Data.IsDataValid)
    {
        CayenneLppAddLuminosity(channel++, (uint16_t) _bck_amb_tsl2591Data.Lux);
    }
#endif
#ifdef SENSOR_BAR_ILS22QS
    if (_bck_bar_ils22qsData.IsDataValid)
    {
        //CayenneLppAddTemperature(channel++, _tempBarometerData.Temperature);
        CayenneLppAddBarometricPressure(channel++, _bck_bar_ils22qsData.PressureABS);
    }
#endif
#ifdef SENSOR_BAR_BMP585
    if (_bck_bar_bmp585Data.IsDataValid)
    {
        //CayenneLppAddTemperature(channel++, _tempBarometerData.Temperature);
        CayenneLppAddBarometricPressure(channel++, _bck_bar_bmp585Data.PressureABS);
    }
#endif
#ifdef SENSOR_SCD41
    if (_bck_scd41Data.IsDataValid)
    {
        CayenneLppAddConcentration(channel++, (uint16_t) _bck_scd41Data.Co2);
        CayenneLppAddTemperature(channel++, _bck_scd41Data.Temperature);
        CayenneLppAddRelativeHumidity(channel++, _bck_scd41Data.Humidity);
    }
#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);
    }
#endif
    //CayenneLppAddTimeFromJoin(channel++, 666);
    //  CayenneLppAddVoltage(channel++, batVoltage);
    CayenneLppAddVoltage(channel++, batPerc);
//  CayenneLppAddTimeFromJoin(channel++, SysTimeGet().Seconds); // LINUX time
    CayenneLppAddMeasureInterval(channel++, _sensorMeasureTime);// time of measure - interval in minutes
 
    sz = CayenneLppGetSize();
    if (sizeOut != NULL)
        *sizeOut = sz;
    return (sz) ? CayenneLppGetBuffer() : NULL;
}
 
void sensors_WriteFromBckToDataBlock(mems_DataBlock_t *data)
{
    uint16_t off = 0;
 
    // measure time
    _sensorMeasureTime = (uint16_t)(((float)_systemParams.SensTimeoutMeasure / (1000.0f * 60.0f)) * 10.0f); // from ms to minutes*10
 
    memcpy(data->Data + off, &_sensorMeasureTime, sizeof(_sensorMeasureTime));
    off += sizeof(_sensorMeasureTime);
 
 
 
#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(&_sensorMeasureTime, data->Data + off, sizeof(_sensorMeasureTime));
        off += sizeof(_sensorMeasureTime);
 
#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;
}