batteryTankProbe_temp/Core/Src/freertos.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 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 "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "semphr.h"
#include "i2c.h"
#include "can.h"
#include "usart.h"
#include "gpio.h"
#include "rtc.h"
#include "iwdg.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */


#define MAX_RETRY_COUNT 3
#define ROWS 24  // 温度点矩阵的行数
#define COLS 32  // 温度点矩阵的列数
#define MAX_CAN_MSG_LEN 8
#define NUM_TEMP_DATA 18 // 9 个温度点，每个点两条数据

volatile uint8_t Ambient_temperature;
volatile uint8_t systemlevel = 0;
volatile uint8_t dataReadyFlag = 0;// 标志位或状态

uint8_t canMsgBuffer1[MAX_CAN_MSG_LEN] = {0};  // 第一个 CAN 消息缓冲区
uint8_t canMsgBuffer2[MAX_CAN_MSG_LEN] = {0};  // 第二个 CAN 消息缓冲区
uint8_t summaryBuffer[MAX_CAN_MSG_LEN] = {0};  // 存放最大值、最小值和平均值的缓冲区

uint8_t canMsgBuffer1_tmp[MAX_CAN_MSG_LEN] = {0};  // 第一个 CAN 消息缓冲区
uint8_t canMsgBuffer2_tmp[MAX_CAN_MSG_LEN] = {0};  // 第二个 CAN 消息缓冲区
uint8_t summaryBuffer_tmp[MAX_CAN_MSG_LEN] = {0};  // 存放最大值、最小值和平均值的缓冲区
uint8_t debugBuffer1_tmp[MAX_CAN_MSG_LEN] = {0};  // 包含预警等级加温度的全部数据缓冲区
uint8_t debugBuffer2_tmp[MAX_CAN_MSG_LEN] = {0};  // 包含预警等级加温度的全部数据缓冲区



#define DATA_MOVING   (0)
#define DATA_READY    (1)
#define STOP2_READY   (2)
uint8_t data_Flag = DATA_MOVING;


volatile bool taskEnabled = true; // 任务状态，初始为启动状态

/**
  * @breaf 内部flash参数定义
  */

#define FLASH_LAST_PAGE_ADDR 0x0801FC00 // STM32L431CCT6 内部Flash第127页起始地址
#define FLASH_SECOND_LAST_PAGE_ADDR 0x08018800 // STM32L431CCT6 内部Flash第126页起始地址

uint16_t NODE_ID; // 初始节点ID 01 //温度传感器ID从 16 开始，16 代表 01 号小板



FlashData flash_data = {								
		
    .first_threshold = 60, 					// 一级阈值 60
		.second_threshold = 100, 				// 二级阈值 100
		.delay_receivedValue = 1,				// 初始上报频率 2s
		.Emissivity = 95,								// 初始发射率 0.95（后续除100）
};

extern uint16_t eeMLX90640[832]; 
extern int status;
bool MLX_powered = false;
int failCount = 0;  // 新增失败计数器
extern uint32_t start_tick;
uint32_t end_tick = 0;
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
volatile uint8_t stop2WakeupFlag = 0;// STOP2 唤醒标志
void Configure_GPIOs_For_LowPower(void);
void Enter_LPStop2Mode(void);
void Wakeup_LPStop2Mode(void);
void Enable_RTC_Wakeup(uint16_t delay_time);
void control_MLX90640_power(bool enable) ;
void printCurrentRTCTime(void);
/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */

extern paramsMLX90640 mlx90640;
extern float mlx90640To[768];
extern uint16_t frame[834];
extern uint16_t blockNumber;

/* USER CODE END Variables */
/* Definitions for readTempTask */
osThreadId_t readTempTaskHandle;
const osThreadAttr_t readTempTask_attributes = {
  .name = "readTempTask",
  .stack_size = 256 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for sendTempTask */
osThreadId_t sendTempTaskHandle;
const osThreadAttr_t sendTempTask_attributes = {
  .name = "sendTempTask",
  .stack_size = 256 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for Common */
osThreadId_t CommonHandle;
const osThreadAttr_t Common_attributes = {
  .name = "Common",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityRealtime,
};
/* Definitions for dataMutex */
osMutexId_t dataMutexHandle;
const osMutexAttr_t dataMutex_attributes = {
  .name = "dataMutex"
};
/* Definitions for dataReadySem */
osSemaphoreId_t dataReadySemHandle;
const osSemaphoreAttr_t dataReadySem_attributes = {
  .name = "dataReadySem"
};

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */
void lowpower_wakeup(void);
void lowpower_sleep(void);
void CAN_ErrorHandler(TickType_t *pxPreviousWakeTime, uint32_t *send_interval);
void CAN_TemperatureSend(uint8_t *sequence, uint32_t *send_interval);
int  MLX90640_ReadFrameData(void);
int ProcessTemperatureData(void);
void Read_NODE_ID_From_Flash(void);
void Read_parameter_From_Flash(void);
void Save_NODEID_To_Flash(uint8_t NODE_ID) ;
void Save_parameter_To_Flash(uint8_t first_threshold ,uint8_t second_threshold ,uint8_t delay_receivedValue ,uint8_t Emissivity);
void CAN_Send_Msg(uint8_t *msg,uint8_t len,uint32_t node_id, uint8_t sequence, uint8_t slice_num, uint8_t slice_id);
void CAN_Send_extId(uint16_t *data, uint8_t len, uint32_t node_id, uint8_t sequence, uint8_t slice_num, uint8_t slice_id);
void CAN_Send_Parameter(uint32_t node_id,  uint8_t len, FlashData *flash_data, uint8_t sequence, uint8_t slice_num, uint8_t slice_id) ;
/* USER CODE END FunctionPrototypes */

void ReadTemperatureTask(void *argument);
void SendTemperatureTask(void *argument);
void CommonTask(void *argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/**
  * @brief  FreeRTOS initialization
  * @param  None
  * @retval None
  */
void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */
		
		Read_parameter_From_Flash();
		Read_NODE_ID_From_Flash();
  /* USER CODE END Init */
  /* Create the mutex(es) */
  /* creation of dataMutex */
  dataMutexHandle = osMutexNew(&dataMutex_attributes);

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* Create the semaphores(s) */
  /* creation of dataReadySem */
  dataReadySemHandle = osSemaphoreNew(1, 1, &dataReadySem_attributes);

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */

  /* USER CODE END RTOS_TIMERS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* creation of readTempTask */
  readTempTaskHandle = osThreadNew(ReadTemperatureTask, NULL, &readTempTask_attributes);

  /* creation of sendTempTask */
  sendTempTaskHandle = osThreadNew(SendTemperatureTask, NULL, &sendTempTask_attributes);

  /* creation of Common */
  CommonHandle = osThreadNew(CommonTask, NULL, &Common_attributes);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
	
  /* USER CODE END RTOS_THREADS */

  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */

}

/* USER CODE BEGIN Header_ReadTemperatureTask */
/**
  * @brief  Function implementing the readTempTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_ReadTemperatureTask */
void ReadTemperatureTask(void *argument)
{
  /* USER CODE BEGIN ReadTemperatureTask */
  TickType_t pxPreviousWakeTime = xTaskGetTickCount();
	
	uint8_t sequence =0;
	uint32_t send_interval = 0;
	for(;;)
	{
			
			// 读取并校验有效帧
			if (MLX90640_ReadFrameData())
			{
//					control_MLX90640_power(false);
					int	validData = ProcessTemperatureData();
					if (validData == 1)
					{
							// 1. CAN 错误处理
							CAN_ErrorHandler(&pxPreviousWakeTime, &send_interval);

							// 如果仍然处于 Bus-Off 等待状态，就跳过发送流程
							if (hcan1.Instance->ESR & CAN_ESR_BOFF)
							{
									continue;
							}
							CAN_TemperatureSend(&sequence, &send_interval);			
							send_interval++;
							Enter_LPStop2Mode();
					}
			}
			osDelay(10);	
	}
  /* USER CODE END ReadTemperatureTask */
}

/* USER CODE BEGIN Header_SendTemperatureTask */
/**
* @brief Function implementing the sendTempTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_SendTemperatureTask */
void SendTemperatureTask(void *argument)
{
  /* USER CODE BEGIN SendTemperatureTask */
//  TickType_t pxPreviousWakeTime = xTaskGetTickCount();
//	
//	uint8_t sequence =0;
//	uint32_t send_interval = 0;

  for (;;)
  {
//		// 1. CAN 错误处理
//		CAN_ErrorHandler(&pxPreviousWakeTime, &send_interval);

//		// 如果仍然处于 Bus-Off 等待状态，就跳过发送流程
//		if (hcan1.Instance->ESR & CAN_ESR_BOFF)
//		{
//				continue;
//		}

		osDelay( 100 );  
	}
  /* USER CODE END SendTemperatureTask */
}

/* USER CODE BEGIN Header_CommonTask */
/**
* @brief Function implementing the Common thread.
* @param argument: Not used
* @retval None
*/

/* USER CODE END Header_CommonTask */
void CommonTask(void *argument)
{
  /* USER CODE BEGIN CommonTask */
  /* Infinite loop */
//	uint16_t counter = 0; // LED 闪烁计数器
//	uint16_t led_flash_threshold = 50; // 默认慢闪
	
  for(;;)
  {
		osDelay(10);
//		counter++;
//		// 1. 获取当前 CAN 错误状态
//    uint32_t can_esr = hcan1.Instance->ESR;
//    uint8_t tec = (can_esr >> 16) & 0xFF;
//    uint8_t rec = (can_esr >> 24) & 0xFF;

//    // 2. 判断当前状态并设置 LED 闪烁速度
//    if (can_esr & CAN_ESR_BOFF)
//    {
//      // Bus-Off 快闪 50ms (10ms * 5)
//      led_flash_threshold = 5;
//    }
//    else if (tec >= 128 || rec >= 128)
//    {
//      // Error Passive 中闪 200ms (10ms * 20)
//      led_flash_threshold = 20;
//    }
//    else
//    {
//      // 正常 慢闪 500ms (10ms * 50)
//      led_flash_threshold = 50;
//    }

//    // 3. 按照不同状态执行 LED 闪烁
//    if (counter >= led_flash_threshold)
//    {
//      HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_4); // 切换 LED 状态
//      counter = 0; // 重置计数器
//    }

//    // 4. 喂狗
//    HAL_IWDG_Refresh(&hiwdg);
		
  }
  /* USER CODE END CommonTask */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

void lowpower_wakeup(void)
{
	DEBUG_PRINTF("1\r\n");
	HAL_I2C_DeInit(&hi2c1);
	MX_I2C1_Init(); 
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9|GPIO_PIN_10, GPIO_PIN_SET);
	control_MLX90640_power(true);		
	HAL_Delay(50);
	MLX90640_SetRefreshRate(MLX90640_ADDR, RefreshRate8HZ); // 设置帧率�??0-7对应0.5,1,2,4,8,16,32,64HZ�??
	status = MLX90640_DumpEE(MLX90640_ADDR, eeMLX90640); // 读取像素校正参数
	status = MLX90640_ExtractParameters(eeMLX90640, &mlx90640); // 解析校正参数
}

void lowpower_sleep(void)
{
	control_MLX90640_power(false);
	Configure_GPIOs_For_LowPower();
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9|GPIO_PIN_10, GPIO_PIN_RESET);
}
// CAN 错误状态处理函数
void CAN_ErrorHandler(TickType_t *pxPreviousWakeTime, uint32_t *send_interval)
{
    static uint32_t last_busoff_time = 0;    // 上次 Bus-Off 恢复时间
    static uint8_t  bus_off_flag = 0;        // Bus-Off 状态标志

    uint32_t can_esr = hcan1.Instance->ESR;
    uint8_t tec = (can_esr >> 16) & 0xFF;
    uint8_t rec = (can_esr >> 24) & 0xFF;

    // 1. Bus-Off 状态处理
    if (can_esr & CAN_ESR_BOFF)
    {
        if (bus_off_flag == 0)
        {
            DEBUG_PRINTF(" [CAN ERROR] Bus-Off detected! TEC = %d, REC = %d\n", tec, rec);
            bus_off_flag = 1;
            last_busoff_time = HAL_GetTick();
        }

        // 等待1秒后重启 CAN
        if (HAL_GetTick() - last_busoff_time > 1000)
        {
            DEBUG_PRINTF("[CAN] Restarting CAN after Bus-Off...\n");

            HAL_CAN_Stop(&hcan1);
            HAL_CAN_DeInit(&hcan1);
            MX_CAN1_Init();
            HAL_CAN_Start(&hcan1);

            // 激活中断
            HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING | CAN_IT_BUSOFF);

            DEBUG_PRINTF("[CAN] CAN restarted after Bus-Off\n");

            bus_off_flag = 0;
        }

        // 跳过本次发送，等待恢复
        vTaskDelayUntil(pxPreviousWakeTime, pdMS_TO_TICKS(10));
        (*send_interval)++;
    }

}

// CAN 温度数据发送函数
void CAN_TemperatureSend(uint8_t *sequence, uint32_t *send_interval)
{
//    if (*send_interval >= 100 * flash_data.delay_receivedValue)
//    {
        CAN_Send_Msg(canMsgBuffer1, 8, NODE_ID, *sequence, 2, 1);
        CAN_Send_Msg(canMsgBuffer2, 8, NODE_ID, *sequence, 2, 2);
				control_MLX90640_power(false);
        (*sequence)++;
        if (*sequence > 0xFF)
        {
            *sequence = 0;
        }

        *send_interval = 0;
				
//        DEBUG_PRINTF("Send Temperature Data - Sequence: %d\n", *sequence);
//        printCurrentRTCTime();
//    }
}

// MLX90640读取温度函数
int MLX90640_ReadFrameData(void)
{
	
    int validFrame = 0;
    while (!validFrame)
    {
				DEBUG_PRINTF("[MLX] Start reading frame data\r\n");
//				control_MLX90640_power(true);
			
        int status = MLX90640_GetFrameData(MLX90640_ADDR, frame);
        
        if (status < 0)
        {
						DEBUG_PRINTF("[MLX] Failed to get frame data, status=%d, retrying...\r\n", status);
						MX_I2C1_Init();
            continue;
        }
        
        float vdd = MLX90640_GetVdd(frame, &mlx90640);
        float Ta = MLX90640_GetTa(frame, &mlx90640);
        Ambient_temperature = (uint8_t)Ta;
        
        DEBUG_PRINTF("vdd %.1f Ta %.1f\r\n", vdd, Ta);
        
        if (vdd < 2.5f || vdd > 5.5f || Ta < -40 || Ta > 85)
        {
            DEBUG_PRINTF("Failed vdd %.1f Ta %.1f\r\n", vdd, Ta);
						failCount++;
            if (failCount >= 5)
            {
								DEBUG_PRINTF("[MLX] Failed 5 times, system resetting\r\n");
                NVIC_SystemReset();  // 软复位
            }
            continue;
        }

        float tr = Ta - TA_SHIFT;
        float emissivity = flash_data.Emissivity / 100.0f;
				
        MLX90640_CalculateTo(frame, &mlx90640, emissivity, tr, mlx90640To);
        MLX90640_BadPixelsCorrection(mlx90640.brokenPixels, mlx90640To, 1, &mlx90640);
        MLX90640_BadPixelsCorrection(mlx90640.outlierPixels, mlx90640To, 1, &mlx90640);
								
        // 数据有效性检查
        int oddSum = 0, evenSum = 0;

        for (int i = 0; i < 768; i++)
        {
            if (mlx90640To[i] < -40 || mlx90640To[i] > 255)
            {
								DEBUG_PRINTF("[MLX] Temperature point[%d] invalid, value=%.1f, retrying...\r\n", i, mlx90640To[i]);              
                validFrame = 0;
                break;
            }

            if (i % 2 == 0)
                evenSum += mlx90640To[i];
            else
                oddSum += mlx90640To[i];
        }

        if (oddSum == 0 || evenSum == 0)
        {
						DEBUG_PRINTF("[MLX] Odd or even sum is zero, invalid data, retrying...\r\n");
            validFrame = 0;
            continue;
        }

        validFrame = 1;
				
				control_MLX90640_power(false);
				end_tick = osKernelGetTickCount();
				DEBUG_PRINTF("MLX_end_tick %lu\r\n",end_tick);
				DEBUG_PRINTF("Elapsed time: %lu ms\r\n", end_tick - start_tick);
    }

    return validFrame;
}

// 处理MLX90640读取到的温度数据
int ProcessTemperatureData(void)
{
		DEBUG_PRINTF("[Process] Start processing temperature data\r\n");
    // 初始化最大值、最小值、平均值、最大值坐标
    float maxTemp = mlx90640To[0];
    float minTemp = mlx90640To[0];
    float sumTemp = 0;
    int maxIndex = 0;
		int minIndex = 0;
	
    for (int i = 0; i < 768; i++)
    {
        if (mlx90640To[i] > maxTemp)
        {
            maxTemp = mlx90640To[i];
            maxIndex = i;
        }
        else if (mlx90640To[i] == maxTemp && i < maxIndex)
        {
            maxIndex = i; // 选择第一个最大值索引
        }

        if (mlx90640To[i] < minTemp)
        {
            minTemp = mlx90640To[i];
						minIndex = i;
        }

        sumTemp += mlx90640To[i];
    }
		DEBUG_PRINTF("[Process] MaxTemp=%.1f maxIndex=%d, MinTemp=%.1f minIndex=%d\r\n", maxTemp, maxIndex, minTemp, minIndex);

    float avgTemp = sumTemp / 768;

    // 判断系统预警等级
    if ((uint8_t)maxTemp <= flash_data.first_threshold)
    {
        systemlevel = 0;
    }
    else if ((uint8_t)maxTemp > flash_data.first_threshold && (uint8_t)maxTemp <= flash_data.second_threshold)
    {
        systemlevel = 1;
    }
    else
    {
        systemlevel = 2;
    }

    // 填充数据
    debugBuffer1_tmp[0] = (uint8_t)systemlevel;
    debugBuffer1_tmp[1] = (uint8_t)maxTemp;
    debugBuffer1_tmp[2] = (uint8_t)minTemp;
    debugBuffer1_tmp[3] = (uint8_t)avgTemp;
    debugBuffer1_tmp[4] = Ambient_temperature;

    // 最大值点坐标
    int maxRow = maxIndex / COLS;
    int maxCol = maxIndex % COLS;

    // 确定九宫格范围
    int startRow = (maxRow > 0) ? maxRow - 1 : 0;
    int endRow = (maxRow < ROWS - 1) ? maxRow + 1 : ROWS - 1;
    int startCol = (maxCol > 0) ? maxCol - 1 : 0;
    int endCol = (maxCol < COLS - 1) ? maxCol + 1 : COLS - 1;

    // 填充九宫格数据
    int dataIndex = 0;
    memset(debugBuffer2_tmp, 0, sizeof(debugBuffer2_tmp));

    for (int r = startRow; r <= endRow; r++)
    {
        for (int c = startCol; c <= endCol; c++)
        {
            int temp = (int)mlx90640To[r * COLS + c]; // 舍去小数部分

            if (dataIndex < 1)
            {
                debugBuffer1_tmp[dataIndex + 7] = (uint8_t)temp;
            }
            else
            {
                debugBuffer2_tmp[dataIndex - 1] = (uint8_t)temp;
            }

            dataIndex++;
        }
    }

    // 填充最大值点坐标
    debugBuffer1_tmp[5] = (uint8_t)maxCol;
    debugBuffer1_tmp[6] = (uint8_t)maxRow;
		
		uint8_t zeroCount = 0;
    // 统计 debugBuffer2_tmp 中 0 的数量
    for (int i = 0; i < sizeof(debugBuffer2_tmp); i++)
    {
        if (debugBuffer2_tmp[i] == 0)
        {
            zeroCount++;
        }
    }
		// 如果 0 的数量在 3 到 6 之间（包含 3 和 6），直接返回 0
    if (zeroCount >= 3 && zeroCount <= 6)
    {
        return 0;
    }
		
		if( (debugBuffer1_tmp[0] == 0 && debugBuffer1_tmp[1] <= flash_data.first_threshold)
			  ||(debugBuffer1_tmp[0] == 1 && (flash_data.first_threshold < debugBuffer1_tmp[1] && debugBuffer1_tmp[1] <= flash_data.second_threshold))
			  ||(debugBuffer1_tmp[0] == 2 && debugBuffer1_tmp[1] > flash_data.second_threshold) )
		{
			
			taskENTER_CRITICAL();
			// CAN 消息打包
			memcpy(canMsgBuffer1, debugBuffer1_tmp, 8);
			memcpy(canMsgBuffer2, debugBuffer2_tmp, 8);
			taskEXIT_CRITICAL();
			return 1;
		}

			return 0;
//    DEBUG_PRINTF("ProcessTemperatureData() complete. MaxCol: %d, MaxRow: %d\r\n", maxCol, maxRow);
}


/**
  * @breaf 内部flash相关函数
  */

void Read_NODE_ID_From_Flash(void) // 从 Flash 读取 NODE_ID
{
		NODE_ID = *((uint8_t *)FLASH_SECOND_LAST_PAGE_ADDR);
    if (NODE_ID == 0xFF) 
		{
        NODE_ID = 15 + 30 ;
    }else{
				NODE_ID = NODE_ID;
		}
    DEBUG_PRINTF("Loaded data: NODE_ID=%u\n",NODE_ID);
}

void Read_parameter_From_Flash(void) // 从 Flash 读取 parameter
{
		uint8_t *flash_ptr = (uint8_t *)FLASH_LAST_PAGE_ADDR;
	
    if (flash_ptr[0] == 0xFF) {
        flash_data.first_threshold = 60;
    }else{
				flash_data.first_threshold = flash_ptr[0]; 
		}
		if (flash_ptr[1] == 0xFF) {
        flash_data.second_threshold = 100;
    }else{
				flash_data.second_threshold = flash_ptr[1]; 
		}		
		if (flash_ptr[2] == 0xFF) {
        flash_data.delay_receivedValue = 30;
    }else{
				flash_data.delay_receivedValue = flash_ptr[2]; 
		}
		if (flash_ptr[3] == 0xFF) {
        flash_data.Emissivity = 95;
    }else{
				flash_data.Emissivity = flash_ptr[3]; 
		}
    DEBUG_PRINTF("Loaded data: first_threshold=%u, second_threshold=%u , delay_receivedValue=%u ,Emissivity=%u\n",
           flash_data.first_threshold, flash_data.second_threshold, flash_data.delay_receivedValue, flash_data.Emissivity);
}

void Save_NODEID_To_Flash(uint8_t NODE_ID) // 向 Flash 写入 NODE_ID
{
    uint8_t nodeIDData[4] = { NODE_ID, 0, 0, 0 }; 
		uint8_t readnodeIDData[4];
    if (Flash_WriteRead(FLASH_SECOND_LAST_PAGE_ADDR, nodeIDData, sizeof(nodeIDData), readnodeIDData) != SUCCESS) {
        DEBUG_PRINTF("Failed to save NODE_ID to flash\n");
    } else {
        DEBUG_PRINTF("NODE_ID saved to flash: %u\n", nodeIDData[0]);
    }
}

void Save_parameter_To_Flash(uint8_t first_threshold ,uint8_t second_threshold ,uint8_t delay_receivedValue ,uint8_t Emissivity) // 向 Flash 写入 parameter 
{
    uint8_t parameter[4] = {  first_threshold, second_threshold, delay_receivedValue, Emissivity};
		uint8_t readparameterData[4];
    if (Flash_WriteRead(FLASH_LAST_PAGE_ADDR, parameter, sizeof(parameter), readparameterData) != SUCCESS) {
        DEBUG_PRINTF("Failed to save Parameter to flash\n");
    } else {
        DEBUG_PRINTF("Parameter saved to flash: [%u] [%u] [%u]  [%u]\n", parameter[0], parameter[1], parameter[2], parameter[3]);
    }
}

/**
  * @breaf CAN相关函数
  */

//主板ID 0x00100000
HAL_StatusTypeDef CAN_FilterInit(void)// 初始化CAN过滤器
{
    CAN_FilterTypeDef CAN_FilterInitStructure;

    // 选择要初始化的过滤器
    CAN_FilterInitStructure.FilterBank = 0;  // 选择过滤器的过滤库，CAN总线支持多个过滤器
    CAN_FilterInitStructure.FilterMode = CAN_FILTERMODE_IDMASK;  // 设置过滤模式为ID掩码模式，即根据ID和掩码进行过滤
    CAN_FilterInitStructure.FilterScale = CAN_FILTERSCALE_32BIT;  // 选择32位的过滤器（过滤器ID + 掩码总共32位）
    CAN_FilterInitStructure.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 指定过滤器分配给FIFO0，用于接收来自CAN总线的消息

    // 配置第一个过滤器接收 0x00100000
    CAN_FilterInitStructure.FilterIdHigh = (0x00100000 >> 13) & 0xFFFF;  // 高 16 位
    CAN_FilterInitStructure.FilterIdLow = ((0x00100000 << 3) & 0xFFFF) | (1 << 2); // 低 16 位 + IDE 位
    CAN_FilterInitStructure.FilterMaskIdHigh = 0xFFFF; // 掩码的高16位设置为全1，表示不对该部分进行匹配过滤
    CAN_FilterInitStructure.FilterMaskIdLow = 0xFFFF; 
		CAN_FilterInitStructure.FilterActivation = CAN_FILTER_ENABLE; // 启用该过滤器，只有符合条件的消息才会通过
		if (HAL_CAN_ConfigFilter(&hcan1, &CAN_FilterInitStructure) != HAL_OK)
    {
        Error_Handler();
        return HAL_ERROR;
    }	
		// 配置第二个过滤器接收 0x00110000
    CAN_FilterInitStructure.FilterBank = 1; // 使用下一个过滤器
    CAN_FilterInitStructure.FilterIdHigh = (0x00110000 >> 13) & 0xFFFF;
    CAN_FilterInitStructure.FilterIdLow = ((0x00110000 << 3) & 0xFFFF) | (1 << 2);
    if (HAL_CAN_ConfigFilter(&hcan1, &CAN_FilterInitStructure) != HAL_OK)
    {
        Error_Handler();
        return HAL_ERROR;
    }
       		    
    if (HAL_CAN_Init(&hcan1) != HAL_OK)// 初始化CAN外设
    {
        // 如果CAN初始化失败，打印错误信息并进入错误处理
        uint32_t can_error = HAL_CAN_GetError(&hcan1);
        DEBUG_PRINTF("CAN Initialization Error: %ld\n", can_error);
        Error_Handler();
        return HAL_ERROR;        
    }

    return HAL_OK;
}

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
    CAN_RxHeaderTypeDef RX_Header;
    uint8_t rxData[8];

    if (HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &RX_Header, rxData) == HAL_OK)
    {
        if (RX_Header.ExtId == 0x00100000 && RX_Header.IDE == CAN_ID_EXT)
        {
            DEBUG_PRINTF("CANID received: 0x%08X\n", RX_Header.ExtId);				
						if (rxData[1] == 0x00)
						{
							CAN_Send_Parameter(NODE_ID, 0, &flash_data, 0xFF, 0xFF, 0xFF);
							return;
						}
						// 更新 NODE_ID
						if (rxData[0] == 0xFF || rxData[0] == (uint8_t)(NODE_ID & 0xFF))
            {
                NODE_ID = rxData[1];
                // 保存到 Flash
                Save_NODEID_To_Flash(NODE_ID);
								// 应答
                CAN_Send_extId(&NODE_ID, 1, NODE_ID, 0xFF, 0xFF, 0xFF);
            }
            else if (rxData[0] != (uint8_t)(NODE_ID & 0xFF))
            {
                // 如果第一个字节和当前全局变量 NODE_ID 不一致，则不执行
                return;
            }
        }
				else if(RX_Header.ExtId == 0x00110000 && RX_Header.IDE == CAN_ID_EXT)
				{
						DEBUG_PRINTF("CANID received: 0x%08X\n", RX_Header.ExtId);
						if(rxData[0]==0 || rxData[1]==0 || rxData[2]==0 || rxData[3]==0 )
						{
							CAN_Send_Parameter(NODE_ID, 0, &flash_data, 0xFF, 0xFF, 0xFF);
							return;
						}
						// 更新 first_threshold 和 delay_receivedValue 和 Emissivity
						flash_data.first_threshold = rxData[0];
						flash_data.second_threshold = rxData[1];
						flash_data.delay_receivedValue = rxData[2];
						flash_data.Emissivity = rxData[3];
						// 保存到 Flash
						Save_parameter_To_Flash(flash_data.first_threshold ,flash_data.second_threshold ,flash_data.delay_receivedValue ,flash_data.Emissivity);
						// 应答
						CAN_Send_Parameter(NODE_ID, 4, &flash_data, 0xFF, 0xFF, 0xFF);
				}
				else
        {
            DEBUG_PRINTF("CANID mismatched!\n");
        }
    }
    else
    {
        DEBUG_PRINTF("CAN receive failed!Error code: 0x%08lX\n", HAL_CAN_GetError(&hcan1));
    }
}

void CAN_Send_Msg(uint8_t *msg,uint8_t len,uint32_t node_id, uint8_t sequence, uint8_t slice_num, uint8_t slice_id)
{
	CAN_TxHeaderTypeDef Tx_Header;
	uint32_t TxMailBox;	
	uint32_t ret_status = 0;
	
	//	0000   0000 0011    0000 0000   0000   0000   0000
	Tx_Header.ExtId = (1U << 28)                      // 数据标志位 1
                    | ((node_id & 0xFF) << 20)      // 节点 ID，占 8 位
                    | ((sequence & 0xFF) << 12)     // 序列号，占 8 位
                    | ((slice_num & 0xF) << 8)      // 分片总数，占 4 位
                    | ((slice_id & 0xF) << 4);      // 当前分片 ID，占 4 位
	Tx_Header.IDE = CAN_ID_EXT;
	Tx_Header.RTR = CAN_RTR_DATA;
	Tx_Header.DLC = len;
	ret_status = HAL_CAN_AddTxMessage(&hcan1,&Tx_Header,msg,&TxMailBox);	
	
	if(0 != ret_status){
		DEBUG_PRINTF("HAL_CAN_AddTxMessage failed , ret_status:0x%x \r\n", ret_status);
		DEBUG_PRINTF("hcan->ErrorCode: 0x%x \r\n", hcan1.ErrorCode);
	}
}

void CAN_Send_extId(uint16_t *data, uint8_t len, uint32_t node_id, uint8_t sequence, uint8_t slice_num, uint8_t slice_id) 
{
    // 配置 CAN 发送消息结构体
    CAN_TxHeaderTypeDef Tx_Header;
    uint32_t txMailbox;

		Tx_Header.ExtId = (0U << 28)                    	// 指令标志位 0
									| ((node_id & 0xFF) << 20)      // 节点 ID，占 8 位  
									| ((sequence & 0xFF) << 12)     // 序列号，占 8 位  
									| ((slice_num & 0xF) << 8)      // 分片总数，占 4 位  
									| ((slice_id & 0xF) << 4);      // 当前分片 ID，占 4 位	
    Tx_Header.IDE = CAN_ID_EXT;       // 扩展帧
    Tx_Header.RTR = CAN_RTR_DATA;     // 数据帧
    Tx_Header.DLC = len;          		// 数据长度

    if (HAL_CAN_AddTxMessage(&hcan1, &Tx_Header, (uint8_t *)data, &txMailbox) != HAL_OK) {
        DEBUG_PRINTF("CAN message send failed\n");
    } else {
        // 将数据转换为十六进制字符串形式
        char dataStr[len * 3]; // 每字节 3 个字符 (2个字符 + 空格)
        for (uint8_t i = 0; i < len; i++) {
            sprintf(&dataStr[i * 3], "%02X ", data[i]);
        }
        DEBUG_PRINTF("CAN message sent: ID=0x%08X, Data=%s\n", Tx_Header.ExtId, dataStr);
    }
}

void CAN_Send_Parameter(uint32_t node_id, uint8_t len, FlashData *flash_data, uint8_t sequence, uint8_t slice_num, uint8_t slice_id) 
{
	CAN_TxHeaderTypeDef Tx_Header;
	uint32_t TxMailBox;	
	uint32_t ret_status = 0;

	uint8_t msg[8] = {0};  
	msg[0] = flash_data->first_threshold;
	msg[1] = flash_data->second_threshold;
	msg[2] = flash_data->delay_receivedValue;
	msg[3] = flash_data->Emissivity;
	msg[4] = 0;
	msg[5] = 0;
	msg[6] = 0;
	msg[7] = 0;
		
	Tx_Header.ExtId = (0U << 28)                    	// 指令标志位 0
                    | ((node_id & 0xFF) << 20)      // 节点 ID，占 8 位  
                    | ((sequence & 0xFF) << 12)     // 序列号，占 8 位  
                    | ((slice_num & 0xF) << 8)      // 分片总数，占 4 位  
                    | ((slice_id & 0xF) << 4);      // 当前分片 ID，占 4 位	
	Tx_Header.IDE = CAN_ID_EXT;
	Tx_Header.RTR = CAN_RTR_DATA;
	Tx_Header.DLC = len;
	ret_status = HAL_CAN_AddTxMessage(&hcan1,&Tx_Header,msg,&TxMailBox);	
	
	if(0 != ret_status){
		DEBUG_PRINTF("HAL_CAN_AddTxMessage failed , ret_status:0x%x \r\n", ret_status);
		DEBUG_PRINTF("hcan->ErrorCode: 0x%x \r\n", hcan1.ErrorCode);
	}
}

/**
  * @breaf 低功耗相关
  */

void Configure_GPIOs_For_LowPower(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // 启用承朿 GPIO 端口的时钿
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
		
		__HAL_RCC_RTC_ENABLE();
		__HAL_RCC_USART2_CLK_ENABLE();
		
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;// 配置为模拟模式，禁用上拉/下拉
    GPIO_InitStruct.Pull = GPIO_NOPULL;
  
    GPIO_InitStruct.Pin = GPIO_PIN_All; 
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);// 配置 GPIOA
   
    GPIO_InitStruct.Pin = GPIO_PIN_All& ~(GPIO_PIN_15);// 配置 GPIOB
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

		// 9 10 是IIC，11 12是CAN		
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_SET);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0|GPIO_PIN_15, GPIO_PIN_SET);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET);
		
    __HAL_RCC_GPIOA_CLK_DISABLE();
    __HAL_RCC_GPIOB_CLK_DISABLE();
		
		// 关闭外设时钟
		__HAL_RCC_USART2_CLK_DISABLE();
		__HAL_RCC_I2C1_CLK_DISABLE();
		__HAL_RCC_CAN1_CLK_DISABLE();
}

void Enter_LPStop2Mode(void)
{
    DEBUG_PRINTF("Entering Stop2\n");
    Configure_GPIOs_For_LowPower();
	
		// 使能 RTC 唤醒
    Enable_RTC_Wakeup(flash_data.delay_receivedValue);
	HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE2); // 配置调压器为低功耗模式   
    HAL_PWREx_EnterSTOP2Mode(PWR_STOPENTRY_WFI);// 进入 STOP2 低功耗模式
//    // 重新初始化 CAN
//    MX_CAN1_Init();

//    // 重新启动 CAN
//    HAL_CAN_Start(&hcan1);
//    HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);
//		HAL_Delay(50);
//		SystemClock_Config();
//		HAL_I2C_DeInit(&hi2c1);
//		MX_I2C1_Init();
//		MX_CAN1_Init();        // 重新初始化 CAN
//    HAL_CAN_Start(&hcan1);
//    HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);
//		DEBUG_PRINTF("Stop2 wakeup\n");
}
void Wakeup_LPStop2Mode(void)
{
    // 重新初始化系统时钟
    SystemClock_Config();
		NVIC_SystemReset();    // 直接执行软件复位
    
//		// 重新初始化 CAN
//    MX_CAN1_Init();
//    // 重新启动 CAN
//    HAL_CAN_Start(&hcan1);
//    HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);
//		HAL_Delay(50);
//		SystemClock_Config();
//		HAL_I2C_DeInit(&hi2c1);
//		MX_I2C1_Init();
//		MX_CAN1_Init();        // 重新初始化 CAN
//    HAL_CAN_Start(&hcan1);
//    HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);

}
void Enable_RTC_Wakeup(uint16_t delay_time)
{
    HAL_RTCEx_DeactivateWakeUpTimer(&hrtc); // 先关闭 RTC 唤醒，防止冲突

    // 计算唤醒时间
	uint32_t wakeup_counter = delay_time - 9;

    // 设置 RTC 唤醒
    HAL_RTCEx_SetWakeUpTimer_IT(&hrtc, delay_time, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);

    DEBUG_PRINTF("RTC Wakeup Timer set for %d s\n", wakeup_counter);
}

void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
{
		DEBUG_PRINTF("RTC callback\n");
		control_MLX90640_power(true);
		HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1); // 配置调压器为正常模式
    NVIC_SystemReset();  // RTC 唤醒后执行软件复位
}

void control_MLX90640_power(bool enable)  // 三极管 徐
{
    // 低电平 供电，高电平 断电。
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, enable ? GPIO_PIN_RESET : GPIO_PIN_SET);	
}

//void control_MLX90640_power(bool enable) // 跳线 邢
//{
//		// 高电平 供电，低电平 断电。
//    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, enable ? GPIO_PIN_SET : GPIO_PIN_RESET);
//}
void printCurrentRTCTime(void)
{
    RTC_TimeTypeDef sTime = {0};
    RTC_DateTypeDef sDate = {0};
    char timeString[20];  // 用于存储格式化的时间字符串
		char dataString[20];  // 用于存储格式化的时间字符串

    // 获取当前时间
    HAL_RTC_GetTime(&hrtc, &sTime, RTC_FORMAT_BIN);
    
    // 获取当前日期
    HAL_RTC_GetDate(&hrtc, &sDate, RTC_FORMAT_BIN);

    // 格式化时间为字符串 "HH:MM:SS"
    snprintf(timeString, sizeof(timeString), "%02d:%02d:%02d", 
             sTime.Hours, sTime.Minutes, sTime.Seconds); 
    // 格式化日期为字符串 "YYYY/MM/DD"
    snprintf(dataString, sizeof(dataString), "20%02d/%02d/%02d", 
             sDate.Year, sDate.Month, sDate.Date);

    // 打印日期
    DEBUG_PRINTF("CurrentBeijingDateTime: %s-%s\n", dataString, timeString);
}

/* USER CODE END Application */