main.c

Go to the documentation of this file.

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file           : main.c
 * @brief          : Main program body
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2025 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "dma.h"
#include "i2c.h"
#include "app_lorawan.h"
#include "rtc.h"
#include "spi.h"
#include "usart.h"
#include "gpio.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include "mysensors.h"
#include "mysensors_base.h"
#include "mymems.h"
#include "usart_if.h"
#include "stm32_seq.h"
#include "stm32_lpm.h"
#include "mylora_process.h"
#include "timer_if.h" // #define RTC_BKP_STANDBY   RTC_BKP_DR3  // MT 25.1.2026 - restart register
//#include "stm32_lpm_if.h"
#include "nfc.h"
#include "sys_app.h"
#include "lora_app.h"
/* USER CODE END Includes */
 
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
 
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
 
/* USER CODE BEGIN PV */
static modeDevice_t _modeDevice = MODEDEVICE_SLEEP; // default state
static volatile int _nfcTagged = 0; //counter of NFC tagged
static UTIL_TIMER_Object_t _nfcAfterTrigger;    // after
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
 
#ifdef WRITELOG
void writeLogNL(const char *buf)
{
    Uart_Info(buf);
}
 
void writeLogVA(const char *format, va_list argList)
{
    static char buf[200];
    int len;
 
    vsprintf(buf, format, argList);
    len = strlen(buf);
    if (len > 0 && buf[len - 1] != '\n' && buf[len - 2] != '\r')
        strcat(buf, "\r\n");
    writeLogNL(buf);
}
 
void writeLog(const char *format, ...) //
{
    va_list argList;
    va_start(argList, format);
    writeLogVA(format, argList);
    va_end(argList);
}
 
#endif
 
void I2C_Scan(I2C_HandleTypeDef *hi2c) //
{
    HAL_StatusTypeDef res;
    int8_t found = 0;
 
    HAL_Delay(1500);
    writeLog("Scanning I2C bus...");
    for (uint8_t addr = 1; addr < 127; addr++) //
    {
        res = HAL_I2C_IsDeviceReady(hi2c, addr << 1, 2, 2);
        if (res == HAL_OK) //
        {
            writeLog("Found I2C device at 0x%02X", addr);
            found++;
            HAL_Delay(100);
        }
    }
    if (!found)
        writeLog("no I2C devices");
    else
        HAL_Delay(1500);
}
 
/**
 * @brief called from GPIO interrupt
 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    // Check if the interrupt came from the GPO pin
    if (GPIO_Pin == NFC_INT_Pin)
    {
        UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_NFC_INT), CFG_SEQ_Prio_0);  // start of nfc4_INT
    }
}
 
void uart_Start()
{
    HAL_StatusTypeDef status;
 
    writeLog("start UUART read");
    status = Uart_StartReceving(&huart1);
    writeLog("UART read: %d", (int) status);
}
 
void togle_LedOff(int off)
{
    if (off)
        HAL_GPIO_WritePin(USER_LED_GPIO_Port, USER_LED_Pin, GPIO_PIN_RESET);
    else
        HAL_GPIO_TogglePin(USER_LED_GPIO_Port, USER_LED_Pin);
}
 
void setModeDevice(modeDevice_t mod)
{
    switch (mod)
    {
        case MODEDEVICE_SLEEP:
            UTIL_LPM_SetStopMode((1 << CFG_LPM_APPLI_Id), UTIL_LPM_DISABLE);
            UTIL_LPM_SetOffMode((1 << CFG_LPM_APPLI_Id), UTIL_LPM_DISABLE);
        break;
        case MODEDEVICE_STOP:
            UTIL_LPM_SetStopMode((1 << CFG_LPM_APPLI_Id), UTIL_LPM_ENABLE);
            UTIL_LPM_SetOffMode((1 << CFG_LPM_APPLI_Id), UTIL_LPM_DISABLE);
        break;
        case MODEDEVICE_OFF:
            UTIL_LPM_SetStopMode((1 << CFG_LPM_APPLI_Id), UTIL_LPM_ENABLE);
            UTIL_LPM_SetOffMode((1 << CFG_LPM_APPLI_Id), UTIL_LPM_ENABLE);
        break;
    }
    _modeDevice = mod;
}
 
static void Uart_RxProcessing()
{
//  writeLog("from:%s!", (const char*) uart_req_buf);
    Uart_NextReceving();        // a pokracujeme v citani portu, data su nachystane v uart_req_buf
}
 
/**
 * @brief The interrupt of NFC4 tag
 */
static void sensors_NFCInt()
{
    writeLog("nfc4 tag interrupt"); // don't know what to do with this.... and whether it makes sense
    ++_nfcTagged;
    UTIL_TIMER_Stop(&_nfcAfterTrigger); // restart timer
    UTIL_TIMER_Start(&_nfcAfterTrigger);
}
 
/**
 * @bried check the data from NFC. Function is called from timer _nfcAfterTrigger or directly
 */
static void checkResetRestart()
{
    HAL_StatusTypeDef status;
 
    status = nfc_ReadSystemParams(&hi2c2);
    if (status == HAL_OK)
    {
        writeLog("checkResetRestart ok, reset:%d, restart:%d",(int)_systemParams.DevReset, (int)_systemParams.DevRestart);
 
        if (_systemParams.DevReset)
        {
            nfc_FactoryReset(&hi2c2);
            mems_Reset();
            NVIC_SystemReset();
        }
 
        if (_systemParams.DevRestart)
        {
            _systemParams.DevRestart = 0;
            nfc_WriteSystemParams(&hi2c2);
            NVIC_SystemReset();
        }
    }
    else
        writeLog("checkResetRestart failed!, status:%d",(int)status);
}
 
 
 
/* USER CODE END 0 */
 
/**
 * @brief  The application entry point.
 * @retval int
 */
int main(void)
{
    /* USER CODE BEGIN 1 */
    int8_t afterStandby = 0, status;
    uint8_t countChanges;
 
    /* USER CODE END 1 */
 
    /* MCU Configuration--------------------------------------------------------*/
 
    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    HAL_Init();
 
    /* USER CODE BEGIN Init */
    HAL_PWREx_SetRadioBusyTrigger(PWR_RADIO_IRQ_TRIGGER_WU_IT);
    UTIL_SEQ_Init();
    /* USER CODE END Init */
 
    /* Configure the system clock */
    SystemClock_Config();
 
    /* USER CODE BEGIN SysInit */
    afterStandby = (getBackUpRegister(RTC_BKP_STANDBY) == RTC_BKP_STANDBY_SIGN);
    if (afterStandby)
    {
        setBackUpRegister(RTC_BKP_STANDBY, 0);
    }
 
    /*
     * The system_params contains all information about setting the program, included the LoRaWan settings as DEVEUI, APPKEY, APPEUI
     * These values are set from system_params, which can be read from NFC tag - therefore must be suppressed default setting of MX_LoRaWAN_Init
     * The MX_LoRaWAN_Init is below via SystemApp_Init and LoRaWAN_Init
     */
    // default setting of system_params
 
    /* USER CODE END SysInit */
 
    /* Initialize all configured peripherals */
    MX_GPIO_Init();
    MX_DMA_Init();
    MX_USART1_UART_Init();
    MX_I2C2_Init();
    MX_SPI1_Init();
    MX_RTC_Init();
    MX_LoRaWAN_Init();
    /* USER CODE BEGIN 2 */
 
    // MX_LoRaWan_Init() is disable above and is provide here, after NFC has been read - and the begining!!!
    SystemApp_Init();
 
    // pause after start within in 5s
    for (int i = 0; i < 2; i++)
    {
        HAL_GPIO_TogglePin(USER_LED_GPIO_Port, USER_LED_Pin);
        HAL_Delay(500);
    }
 
#ifndef DEBUG
    // !!! this is important !!!
    HAL_DBGMCU_DisableDBGStandbyMode(); // no SWD in release
#endif
 
    // reading comport
    uart_Start();
    UTIL_SEQ_RegTask((1 << CFG_SEQ_Task_Uart_RX), UTIL_SEQ_RFU, Uart_RxProcessing); // repeated v HAL_UART_RxCharMT
    UTIL_SEQ_RegTask((1 << CFG_SEQ_Task_NFC_INT), UTIL_SEQ_RFU, sensors_NFCInt); // repeated v HAL_GPIO_EXTI_Callback
 
    //I2C_Scan(&hi2c2);
 
    sensorsBase_Init();
    mems_Init();
 
    // for debug - log system_params to log - default setting
    //mems_WriteToSystemParams();
    //systemParams_Log("(default)");    // default setting
 
    sensors_Init(&hi2c2);
    status = nfc_Init(&hi2c2);
    writeLog("nfc tag: Init %s", (status == HAL_OK) ? "OK" : "failed");
 
    // for debug - log system_params to log - from NFC
    systemParams_Log("(from NFC + mems)");
    mems_WriteToSystemParams();
 
    // 13.3.2026 - nothing, stop and go to sleep - NFC not present, always ON
    if (_systemParams.DevOnOff || status != HAL_OK)
    {
        writeLog("...ON...");
 
        systemParams_SetLoRaWanParams();
        // MX_LoRaWan_Init() is disable above and is provide here, after NFC has been read
        LoRaWAN_Init();
    }
    else
        writeLog("...OFF...");
 
    // sequencer, added sequencer for sensors
    sensorsSeq_Init(CFG_SEQ_Task_Sensors, CFG_SEQ_Task_MyLoraSend);
    myloraWan_Init(CFG_SEQ_Task_MyLoraSend);
    GetTimeDate();  // 1st initialization
 
 
    checkResetRestart();        // check reset/restart
 
    // create timer for NFC tag detection, 5sec after last
    UTIL_TIMER_Create(&_nfcAfterTrigger, 5000, UTIL_TIMER_ONESHOT, checkResetRestart, NULL);
 
    i2c_OnOff(0);
 
    /*
     {
     // memory test
     int buf = 0, i, j, x;
     char buf1[] = "mala lofasocka", buf2[] = "velka lofasocka", *bufW;
     mems_SensorsDataBlock_t *data;
 
     HAL_StatusTypeDef status;
 
     writeLog("mem test start");
 
     _memsMainBlock.Sens_CountMax = 19;
     if (_memsMainBlock.Sens_CountCurrent > _memsMainBlock.Sens_CountMax)
     _memsMainBlock.Sens_CountCurrent = _memsMainBlock.Sens_CountMax;
 
     mems_WriteMainBlock();
     mems_WriteMainBlock();
 
     for (j = 0; j < 10; j++)
     {
     // precitam prazdny
     //         status = mems_SensorGetLastData(&data);
     //         if (status != HAL_OK && status != HAL_BUSY)
     //             Error_Handler();
 
     // zapis....
     for (i = 0; i < 50; i++)
     {
     bufW = ((buf) ? buf2 : buf1);
     status = mems_SensorAddData(bufW, strlen(bufW)+1);
     if (status != HAL_OK)
     {
     writeLog("err 1");
     Error_Handler();
     }
     // kontrola na posledny
     status = mems_SensorGetLastData(&data, 0); // chcem posledny
     if (status != HAL_OK)
     {
     writeLog("err 2");
     Error_Handler();
     }
     if (strcmp((const char*)data->Data, bufW) != 0)
     {
     Error_Handler();
     writeLog("err 3");
     }
 
     x = _memsMainBlock.Sens_CountCurrent;
     mems_SensorRemoveLastData(2);  // remove last,beforelast,beforebeforelast - 3ps
     mems_SensorCheck(0);
 
     // kontrola
     //if (x != _memsMainBlock.Sens_CountCurrent + 3)
     //{
     // writeLog("err 4");
     // Error_Handler();
     //}
     }
 
 
     mems_SensorCheck(0);
 
     // citanie
     //         status = mems_SensorGetLastData(&data);
     //         if (status != HAL_OK && status != HAL_BUSY)
     //             Error_Handler();
 
     buf = !buf;
     writeLog("check:%d", j);
     }
     writeLog("mem test OK");
     }
     // */
    /* USER CODE END 2 */
 
    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
 
    setModeDevice(MODEDEVICE_STOP); // default stop mode
 
    writeLog("tick:%lu afterStandby:%d", HAL_GetTick(), (int) afterStandby);
 
    while (1) //
    {
        /* USER CODE END WHILE */
        MX_LoRaWAN_Process();
 
        /* USER CODE BEGIN 3 */
 
        if (_modeDevice == MODEDEVICE_OFF)
        {
            if (!_nfcTagged)    // write NFC if was not tagged
            {
                nfc_ReadSystemParams(&hi2c2);   // 1st read from NFC, then write
                if ((countChanges = mems_WriteToSystemParams()) > 0)    // update NFC, before going to OFF mode - if is NFC tagged never write my...
                {
                    status = nfc_WriteSystemParams(&hi2c2);
                    writeLog("nfc_WriteSystemParams: changes:%d status:%s", (int) countChanges, (status == HAL_OK) ? "OK" : "failed");
                }
            }
        }
    }
    /* USER CODE END 3 */
}
 
/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct =
        { 0 };
    RCC_ClkInitTypeDef RCC_ClkInitStruct =
        { 0 };
 
    /** Configure LSE Drive Capability
     */
    HAL_PWR_EnableBkUpAccess();
    __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);
 
    /** Configure the main internal regulator output voltage
     */
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
 
    /** Initializes the CPU, AHB and APB buses clocks
     */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_MSI;
    RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    RCC_OscInitStruct.MSIState = RCC_MSI_ON;
    RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
    RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_8;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    {
        Error_Handler();
    }
 
    /** Configure the SYSCLKSource, HCLK, PCLK1 and PCLK2 clocks dividers
     */
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK3 | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    RCC_ClkInitStruct.AHBCLK3Divider = RCC_SYSCLK_DIV1;
 
    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
    {
        Error_Handler();
    }
}
 
/* USER CODE BEGIN 4 */
 
/* USER CODE END 4 */
 
/**
 * @brief  This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void)
{
    /* USER CODE BEGIN Error_Handler_Debug */
    /* User can add his own implementation to report the HAL error return state */
    //__disable_irq();
    while (1)
    {
        HAL_GPIO_TogglePin(USER_LED_GPIO_Port, USER_LED_Pin);
        HAL_Delay(100);
    }
    /* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */