mymems.c

Go to the documentation of this file.

/*
 * mymems.c
 *
 *  Created on: 22. 1. 2026
 *      Author: Milan
 */
 
#include "mymems.h"
#include "main.h"
#include "flash_at25.h"
#include "spi.h"
#include "rtc.h"
#include "mysensors_base.h"
#include "mysensors.h"
#include "nfc.h"
#include "sys_app.h"
#include "adc_if.h"
#include "utils/mydefs.h"
#include "utils/utils.h"
#include <string.h>
 
 
#define MEMS_SIGN "MTK0001" // sign of main block - version increment
#define MEMS_SIGN_BLOCK "TM" // sign of data block
#define MEMS_MAINBLOCK_ADDR 0
#define MEMS_DATA_BITS_BOUNDARY 5   // Bounder data 5-32, 6-64, 7-128, 8-256
 
 
mems_MainBlock_t _memsMainBlock = {};
 
static flash_at25CS_t _flash =
    { .CSPort = SPI1_CS_GPIO_Port, .CSPin = SPI1_CS_Pin, .Spi = &hspi1, .Is = 0, .Size = 0 }; // spi setting
 
static mems_DataBlock_t _memsDataBlock = {};    // work buffer
 
static void mems_SetCRC()
{
    _memsMainBlock.Crc = calculateCrc((uint8_t*)&_memsMainBlock, sizeof(_memsMainBlock) - sizeof(_memsMainBlock.Crc));
}
 
static uint8_t mems_CheckCRC()
{
    uint8_t crc = calculateCrc((uint8_t*)&_memsMainBlock, sizeof(_memsMainBlock) - sizeof(_memsMainBlock.Crc));
    return crc == _memsMainBlock.Crc;
}
 
static void mens_MainBlockInit()
{
    memset(&_memsMainBlock, 0, sizeof(_memsMainBlock));
    strcpy(_memsMainBlock.Sign, MEMS_SIGN);
    // data setting
    _memsMainBlock.Data_AddrBase = MEMS_MAINBLOCK_ADDR + sizeof(mems_MainBlock_t);
 
    // round to 256 boundery
    _memsMainBlock.Data_AddrBase >>= MEMS_DATA_BITS_BOUNDARY;
    _memsMainBlock.Data_AddrBase = (1 << MEMS_DATA_BITS_BOUNDARY) + (_memsMainBlock.Data_AddrBase << MEMS_DATA_BITS_BOUNDARY);
    _memsMainBlock.Data_Offset = 0;
    _memsMainBlock.Data_CountMax = ((AT25_MEMSIZE / 2) - _memsMainBlock.Data_AddrBase) / sizeof(mems_DataBlock_t);  // only half
    _memsMainBlock.Data_ItemSize = sizeof(mems_DataBlock_t);
    _memsMainBlock.Data_CountCurrent = 0;
    mems_SetCRC();
}
 
/////////////////////////// public /////////////////////////
 
void mems_Init()
{
    HAL_StatusTypeDef status;
    int sz = sizeof(mems_MainBlock_t);
 
    if (sz != SZ_MAINBLOCK)
    {
        writeLog("The sizeof _memMainBlock:%d, expected:%d", sizeof(mems_MainBlock_t), SZ_MAINBLOCK);
        Error_Handler();
    }
 
    sz = sizeof(mems_DataBlock_t);
    if (sz != SZ_DATABLOCK)
    {
        writeLog("The sizeof mems_DataBlock_t:%d, expected:%d", sizeof(mems_DataBlock_t), SZ_DATABLOCK);
        Error_Handler();
    }
 
    // check the senzor data size !!! never exceed 256 - otherwise the type and code must be changed
    if (SZ_DATABLOCK >= 256)
    {
        writeLog("The sizeof data is greate-equal to 256, size:%d", SZ_DATABLOCK);
        Error_Handler();
    }
 
    /*
    // this is necessary, because the flash chip is controlled by 3v3 enb GPIO.
    // I don't know why this is necessary
    int repeat = 5;
    do
    {
        status = flash_at25_Init(&_flash);
        if (status != HAL_OK)
            HAL_Delay(1000);
    } while(status != HAL_OK && --repeat);
     */
 
    status = flash_at25_Init(&_flash);
    writeLog("flash12 data: Init %s", (status == HAL_OK) ? "OK" : "failed");
    if (status == HAL_OK)
    {
        mens_MainBlockInit();
        if (_flash.Size < _memsMainBlock.Data_CountCurrent * _memsMainBlock.Data_ItemSize)
        {
            writeLog("The _flash.Size(%ud) <  _memMainBlock.DataSize(%ud)", _flash.Size, _memsMainBlock.Data_CountCurrent * _memsMainBlock.Data_ItemSize);
            Error_Handler();
        }
 
        status = mems_ReadMainBlock();
        writeLog("flash12 data: MainBlock %s", (status == HAL_OK) ? "OK" : "failed");
    }
}
 
HAL_StatusTypeDef mems_ReadMainBlock()
{
    HAL_StatusTypeDef status;
 
    mens_MainBlockInit(); // initialization
    status = flash_at25_Read(&_flash, MEMS_MAINBLOCK_ADDR, &_memsMainBlock, sizeof(_memsMainBlock));
    if (status == HAL_OK)
    {
        //_memsMainBlock.Sign[0]='x';
        // check of sign
        _memsMainBlock.Data_CountCurrent = CLAMP(_memsMainBlock.Data_CountCurrent, 0, _memsMainBlock.Data_CountMax);
        if (strcmp(_memsMainBlock.Sign, MEMS_SIGN) != 0 || _memsMainBlock.Data_ItemSize != sizeof(mems_DataBlock_t) || !mems_CheckCRC())
        {
            mens_MainBlockInit(); // initialization
            status = mems_WriteMainBlock();
            writeLog("data: MainBlock default write %s", (status == HAL_OK) ? "OK" : "failed");
        }
        else
            mems_Check(1);
    }
    return status;
}
 
HAL_StatusTypeDef mems_WriteMainBlock()
{
    HAL_StatusTypeDef status = HAL_OK;
 
    //writeLog("mems_WriteMainBlock: kokot");
    mems_SetCRC();
    status = flash_at25_Write(&_flash, MEMS_MAINBLOCK_ADDR, &_memsMainBlock, sizeof(_memsMainBlock));
    return status;
}
 
HAL_StatusTypeDef mems_Reset()
{
    HAL_StatusTypeDef status;
    const char buf[] = "XXXX";
 
    status = flash_at25_Write(&_flash, MEMS_MAINBLOCK_ADDR, buf, sizeof(buf));
    return status;
}
 
/**
 * @brief move the offset in circular queue
 */
static uint32_t mems_SetOffset(uint32_t offset, int16_t count)
{
#ifdef DEBUG
    if ((offset % _memsMainBlock.Data_ItemSize) != 0)
    {
        writeLog("mems_MoveAddr: module is not 0!");
        Error_Handler();
    }
#endif
    int32_t inx = offset / _memsMainBlock.Data_ItemSize;
 
    inx += count;
    inx = INX_GET(inx, _memsMainBlock.Data_CountMax);
    offset = inx * _memsMainBlock.Data_ItemSize;
    return offset;
}
 
static uint32_t mems_GetAddr(uint32_t offset)
{
    return _memsMainBlock.Data_AddrBase + offset;
}
 
 
mems_DataBlock_t* mems_InicBuffer(mems_DataType_t type)
{
    memset(&_memsDataBlock, 0, sizeof(_memsDataBlock));
    strcpy(_memsDataBlock.Sign, MEMS_SIGN_BLOCK);
    _memsDataBlock.Type = type;
    return &_memsDataBlock;
}
 
HAL_StatusTypeDef mems_AddData(const void *data, mems_DataType_t type, uint8_t size)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (size < _memsMainBlock.Data_ItemSize)
    {
        if (data != NULL)
        {
            mems_InicBuffer(type);
            _memsDataBlock.Size = size;
            memcpy(_memsDataBlock.Data, data, size);
        }
        do
        {
            if ((status = flash_at25_Write(&_flash, mems_GetAddr(_memsMainBlock.Data_Offset), &_memsDataBlock, sizeof(_memsDataBlock))) != HAL_OK)
                break;
            _memsMainBlock.Data_Offset = mems_SetOffset(_memsMainBlock.Data_Offset, 1);
            if (_memsMainBlock.Data_CountCurrent < _memsMainBlock.Data_CountMax)
                _memsMainBlock.Data_CountCurrent++;
            if ((status = mems_WriteMainBlock()) != HAL_OK)
                break;
        } while (0);
    }
    return status;
}
 
HAL_StatusTypeDef mems_GetLastData(mems_DataBlock_t **memBlock, uint8_t inxFromEnd)
{
    HAL_StatusTypeDef status = HAL_BUSY;
 
    if (_memsMainBlock.Data_CountCurrent > inxFromEnd)
    {
        uint32_t offset = mems_SetOffset(_memsMainBlock.Data_Offset, -1 - inxFromEnd);
 
        status = HAL_OK;
 
        if (memBlock != NULL)
            if ((status = flash_at25_Read(&_flash, mems_GetAddr(offset), &_memsDataBlock, sizeof(_memsDataBlock))) == HAL_OK)
            {
                *memBlock = &_memsDataBlock;
            }
    }
    return status;
}
 
HAL_StatusTypeDef mems_Check(int8_t correct)
{
    HAL_StatusTypeDef status = HAL_OK;
    uint16_t i;
 
    uint32_t offset = (_memsMainBlock.Data_CountCurrent < _memsMainBlock.Data_CountMax) ? 0 : _memsMainBlock.Data_Offset;
    for (i = 0; i < _memsMainBlock.Data_CountCurrent && HAL_OK == status; i++)
    {
        if ((status = flash_at25_Read(&_flash, mems_GetAddr(offset), &_memsDataBlock, sizeof(_memsDataBlock))) == HAL_OK)
        {
            if (strcmp(_memsDataBlock.Sign, MEMS_SIGN_BLOCK) != 0)
            {
                writeLog("mems_Check: failed, the sign:%s", _memsDataBlock.Sign);
                if (correct)
                {
                    writeLog("mems reset");
                    mens_MainBlockInit();
                    mems_WriteMainBlock();
                    status = HAL_ERROR;
                    break;
                }
                Error_Handler();
            }
            offset = mems_SetOffset(offset, 1);
        }
    }
    return status;
}
 
void mems_RemoveLastData(uint8_t fromEndTo)
{
    if (_memsMainBlock.Data_CountCurrent > 0)
    {
        if (_memsMainBlock.Data_CountCurrent > fromEndTo)
        {
            int16_t count = fromEndTo + 1;
            _memsMainBlock.Data_CountCurrent -= count;
            _memsMainBlock.Data_Offset = mems_SetOffset(_memsMainBlock.Data_Offset, -count);
        }
        else
        {
            _memsMainBlock.Data_CountCurrent = 0;
            _memsMainBlock.Data_Offset = 0;
        }
        mems_WriteMainBlock();
    }
}
 
/**
 *              .MaxSensorData = 0,             // will be updated later, according to memory chip
                .CurrentCountSensorData = 0,    // will be updated later, according to memory chip
                .BatteryLevelStatus = 0,        // will be updated later
                .BatteryMV = 0,                 // will be updated later, according to memory chip
 *
 */
uint8_t mems_WriteToSystemParams()
{
    uint8_t changes = 0;
    uint8_t batLevel = GetBatteryLevel();
    uint16_t batMV = SYS_GetBatteryLevel();
 
    if (_systemParams.MemsMaxSensorData != _memsMainBlock.Data_CountMax)
    {
        ++changes;
        _systemParams.MemsMaxSensorData = _memsMainBlock.Data_CountMax;
    }
    if (_systemParams.MemsCurrentCountSensorData != _memsMainBlock.Data_CountCurrent)
    {
        ++changes;
        _systemParams.MemsCurrentCountSensorData = _memsMainBlock.Data_CountCurrent;
    }
    if (_systemParams.HWBatteryLevelStatus != batLevel)
    {
        ++changes;
        _systemParams.HWBatteryLevelStatus = batLevel;
    }
    if (_systemParams.HWBatteryMV != batMV)
    {
        ++changes;
        _systemParams.HWBatteryMV = batMV;
    }
 
    if (_systemParams.IntBatTimeSendUNIX != _memsMainBlock.Bat_SendTimeSendUNIX)
    {
        ++changes;
        _systemParams.IntBatTimeSendUNIX = _memsMainBlock.Bat_SendTimeSendUNIX;
    }
 
    return changes;
}
 
void mems_ReadFromSystemParams()
{
    _memsMainBlock.Bat_SendTimeSendUNIX = _systemParams.IntBatTimeSendUNIX;
}
 
 
///////////////////////////////////////////////////////////////////////////////////////
// NFC
///////////////////////////////////////////////////////////////////////////////////////
 
 
void nfc_st25r3_OnMailboxData(uint8_t *data, uint16_t len)
{
//  int stop=0;
//  writeLog("mam data");
// this doesn't work, MailBox just doesn't work, giving up on it.....
}
 
/*
 static void nfc_writeBattery(uint16_t addr)
 {
 uint8_t batCurrent = GetBatteryLevel(), batIn = 0;
 
 HAL_StatusTypeDef status = nfc4_ReadEEPROM(_hi2c, addr, &batIn, sizeof(batIn));
 
 if (status == HAL_OK)
 {
 if (batIn != batCurrent)
 nfc4_WriteEEPROM(_hi2c, addr, &batCurrent, sizeof(batCurrent));
 }
 }
 */
 
/**
 * @brief Read a value from an RTC backup register
 * 
 * This function reads a 32-bit value from one of the RTC backup registers.
 * These registers are retained during system standby mode and after system reset
 * (as long as VDD is maintained or VBAT is supplied).
 * 
 * @param backupRegister Backup register index (0-19 for STM32WL).
 *                       Should use RTC_BKP_DRx constants defined in stm32wlxx_hal_rtc_ex.h
 *                       (e.g., RTC_BKP_DR0=0, RTC_BKP_DR1=1, ..., RTC_BKP_DR19=19)
 * @return uint32_t The 32-bit value stored in the backup register
 */
uint32_t getBackUpRegister(uint32_t backupRegister)
{
    return HAL_RTCEx_BKUPRead(&hrtc, backupRegister);
}
 
/**
 * @brief Write a value to an RTC backup register
 * 
 * This function writes a 32-bit value to one of the RTC backup registers.
 * These registers are retained during system standby mode and after system reset
 * (as long as VDD is maintained or VBAT is supplied).
 * 
 * Use this function to save critical data before entering standby mode.
 * On restart, read the values using getBackUpRegister() to check system state
 * and restore necessary information.
 * 
 * do not call HAL_PWR_EnableBkUpAccess and HAL_PWR_DisableBkUpAccess, the HAL_PWR_EnableBkUpAccess is calling in SystemClock_Config
 *
 * @param backupRegister Backup register index (0-19 for STM32WL).
 *                       Should use RTC_BKP_DRx constants defined in stm32wlxx_hal_rtc_ex.h
 *                       (e.g., RTC_BKP_DR0=0, RTC_BKP_DR1=1, ..., RTC_BKP_DR19=19)
 * @param value The 32-bit value to store in the backup register
 */
void setBackUpRegister(uint32_t backupRegister, uint32_t value)
{
    //HAL_PWR_EnableBkUpAccess();
    HAL_RTCEx_BKUPWrite(&hrtc, backupRegister, value);
    //HAL_PWR_DisableBkUpAccess();
}