mymems.h

Go to the documentation of this file.

/*
 * mymems.h
 *
 * Processing of flash & nfc
 *  Created on: 22. 1. 2026
 *      Author: Milan
 */
 
#ifndef INC_MYMEMS_H_
#define INC_MYMEMS_H_
 
#include "stm32wlxx_hal.h"
#include "mysensors_base.h"
 
/**
 * @brief Size in bytes of the mems_MainBlock_t structure written at flash address 0.
 * @warning This value is critical – changing it without resetting the flash will
 *          cause misaligned reads and data corruption.
 */
#define SZ_MAINBLOCK 65
 
/**
 * @brief Size in bytes of one mems_DataBlock_t entry in the circular data queue.
 *        Equals 5 bytes of header plus SENSORS_DATASIZE bytes of payload.
 * @warning This value is critical – any change in the set of active sensors changes
 *          SENSORS_DATASIZE and therefore SZ_DATABLOCK, requiring a memory reset.
 */
#define SZ_DATABLOCK (5+SENSORS_DATASIZE)
 
#pragma pack(1)
/**
 * @brief Master control block stored at flash address 0.
 *
 * Contains the application signature, per-sensor start counters, and all
 * metadata required to manage the circular sensor-data queue in external flash.
 * The structure is exactly SZ_MAINBLOCK (64) bytes.
 *
 * @note The total size MUST remain 64 bytes. Adjust Dummy0/Dummy1 if fields
 *       are added or removed to maintain alignment.
 */
typedef struct
{
    char Sign[8];                    /**< 8-byte signature stamp; checked on boot to validate flash contents 'MTK0001' */
    uint32_t Sens_SPS30Start :24;    /**< Cumulative number of SPS30 fan-start events (used to schedule auto-cleaning) */
    uint32_t Sens_SCD41Start :24;    /**< Cumulative number of SCD41 measurement starts */
    uint32_t Sens_BarometerStart :24;/**< Cumulative number of barometer (ILPS22QS / BMP585) measurement starts */
    uint32_t Sens_TempHumStart :24;  /**< Cumulative number of SHT45 measurement starts */
    uint32_t Sens_AmbientStart :24;  /**< Cumulative number of TSL2591 measurement starts */
    uint32_t Bat_SendTimeSendUNIX;   /**< the time, when was send the battery level to LoRa */
 
    uint8_t Dummy0[6];               /**< Reserved for future use */
    /* Circular queue metadata (added MT 23.2.2026) */
    uint32_t Data_AddrBase : 24;     /**< Flash address of the first mems_DataBlock_t element in the queue */
    uint32_t Data_Offset : 24;       /**< Byte offset from Data_AddrBase pointing to the next write slot */
    uint8_t Data_ItemSize;           /**< Size of one queue element in bytes (== SZ_DATABLOCK) */
    uint16_t Data_CountMax;          /**< Maximum number of records the queue can hold */
    uint16_t Data_CountCurrent;      /**< Number of valid records currently stored in the queue */
    uint8_t Dummy1[20];              /**< Reserved for future use */
    // ------ CRC covers all fields above; Crc itself is excluded from the calculation
    uint8_t Crc;
} mems_MainBlock_t;
 
/**
 * @brief Type tag stored in each mems_DataBlock_t to identify the payload format.
 *        Used when reading back blocks from the circular queue so the caller
 *        knows how to interpret the Data[] field.
 */
typedef enum
{
    MEMS_DATATYPE_NON,    /**< Unspecified / uninitialised block – should not appear in valid data */
    MEMS_DATATYPE_SENSOR  /**< Payload contains a packed sensor data record (all active sensors) */
} mems_DataType_t;
/**
 * @brief Sensor data record stored as one element in the flash circular queue.
 *
 * New sensor readings are appended at the tail; when the queue is full the
 * oldest records are silently overwritten (circular / ring-buffer behaviour).
 * The total size of one record is fixed at SZ_DATABLOCK bytes; changing the
 * set of active sensors changes this size and forces a memory reset.
 */
typedef struct
{
    char Sign[3];                    /**< 3-byte signature 'TM'; checked when reading back to verify block integrity */
    mems_DataType_t Type;            /**< Payload type identifier (see mems_DataType_t) */
    uint8_t Size;                    /**< Number of valid bytes written into Data[] (≤ SENSORS_DATASIZE) */
    uint8_t Data[SENSORS_DATASIZE];  /**< Packed sensor payload; layout depends on which sensors are enabled */
} mems_DataBlock_t;
 
#pragma pack()
 
/** @brief Global instance of the main flash control block; loaded by mems_ReadMainBlock(). */
extern mems_MainBlock_t _memsMainBlock;
 
/**
 * @brief Initialise NFC and external flash; load the main block and system parameters.
 *        Verifies the flash signature and resets the queue if the block size has changed.
 */
void mems_Init();
 
/**
 * @brief - reading of main block from flash. If there is not valid MEMS_SIGN, the structure is initialize to 0
 * The main block it stored on address 0
 * @retval HAL_OK or error
 */
HAL_StatusTypeDef mems_ReadMainBlock();
 
/**
 * @brief writing the main block on flash. The main block is stored on address 0
 * @retval HAL_OK or error
 */
HAL_StatusTypeDef mems_WriteMainBlock();
 
/**
 * @brief memory reset - remove sign from chip
 *  * @retval status
 *
 */
HAL_StatusTypeDef mems_Reset();
 
/**
 * @brief Initialize the work buffer - _memsDataBlock
 * @retval return pointer to buffer
 */
mems_DataBlock_t* mems_InicBuffer(mems_DataType_t type);
 
 
/**
 * @brief write new data of sensor at the end of queue, if is no space, the most older data start to rewrites
 * @param data - the buffer for save, NULL(other parameter are ignored, if used the main default work buffer - _memsDataBlock)
 * @param type - type of data, optional
 * @param size - buffer, must be <= to SENSORS_DATASIZE (_memsMainBlock.Sens_ItemSize)
 * @retval HAL_OK or error
 */
HAL_StatusTypeDef mems_AddData(const void *data, mems_DataType_t type, uint8_t size);
 
/**
 * @brief Get the last sensor data if exists. The data and mem block is stored in work buffer, which can be modify by
 * other mems_xxxx function, temporary valid only
 * @param memBlock - pointer to mem block with data
 * @param inxFromEnd - the index from end of memory, which is reading to buffer (0 - last, 1 - before last, etc)
 * @retval HAL_OK or error, HAL_BUSY no more data
 */
HAL_StatusTypeDef mems_GetLastData(mems_DataBlock_t **memBlock, uint8_t inxFromEnd);
 
/**
 * @brief Check the memory consist
 * @param correct - correct - means to reset all sensor data
 * @retval HAL_OK - memory is OK, HAL_ERROR - error
 */
HAL_StatusTypeDef mems_Check(int8_t correct);
 
/**
 * @brief remove last data
 * @param fromEndTo remove from last to index, 0 - last, 1 - last&before last, etc
 */
void mems_RemoveLastData(uint8_t fromEndTo);
 
/**
 * @brief write data from memory to systemParams
 * @retval 0 - data same-no changes, number is count of different changes
 */
uint8_t mems_WriteToSystemParams();
 
/**
 * @brief read data from NFC to mems block
 */
void mems_ReadFromSystemParams();
 
 
 
 
 
/**
 * @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);
 
/**
 * @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.
 * 
 * @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);
 
#endif /* INC_MYMEMS_H_ */