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

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h" 
#include "event_groups.h"
#include "modbus_deal.h"
#include "global_def.h"
#include "iwdg.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
typedef StaticEventGroup_t osStaticEventGroupDef_t;
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

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

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
#define DEFAULT_TASK_BIT 			( 1UL << 0UL ) /* 事件组位 0 */
#define MODBUS_TASK_BIT 			( 1UL << 1UL ) /* 事件组位 1 */
#define THIRD_TASK_BIT        ( 1UL << 2UL ) /* 事件组位 2 */

/* USER CODE END PM */

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

/* USER CODE END Variables */
/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
  .name = "defaultTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for ModbusTask */
osThreadId_t ModbusTaskHandle;
const osThreadAttr_t ModbusTask_attributes = {
  .name = "ModbusTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for WatchdogTask */
osThreadId_t WatchdogTaskHandle;
const osThreadAttr_t WatchdogTask_attributes = {
  .name = "WatchdogTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityBelowNormal,
};
/* Definitions for taskEvent */
osEventFlagsId_t taskEventHandle;
osStaticEventGroupDef_t taskEventControlBlock;
const osEventFlagsAttr_t taskEvent_attributes = {
  .name = "taskEvent",
  .cb_mem = &taskEventControlBlock,
  .cb_size = sizeof(taskEventControlBlock),
};

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */

/* USER CODE END FunctionPrototypes */

void StartDefaultTask(void *argument);
void StartModbusTask(void *argument);
void StartWatchdogTask(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 */
printf(" MX_FREERTOS_Init  \r\n");
  /* USER CODE END Init */

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

  /* 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 defaultTask */
  defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

  /* creation of ModbusTask */
  ModbusTaskHandle = osThreadNew(StartModbusTask, NULL, &ModbusTask_attributes);

  /* creation of WatchdogTask */
  WatchdogTaskHandle = osThreadNew(StartWatchdogTask, NULL, &WatchdogTask_attributes);

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

  /* Create the event(s) */
  /* creation of taskEvent */
  taskEventHandle = osEventFlagsNew(&taskEvent_attributes);

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

}

/* USER CODE BEGIN Header_StartDefaultTask */
/**
  * @brief  Function implementing the defaultTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
  /* USER CODE BEGIN StartDefaultTask */
	uint32_t count = 0;
	const TickType_t xDelay500ms = pdMS_TO_TICKS(500UL);
  /* Infinite loop */
  for(;;)
  {
    vTaskDelay(xDelay500ms);
		HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);	
		
#ifdef IS_BOOTLOADER
		printf("the boot count: [%d] \r\n", count);
#else
		printf("the app count: [%d] \r\n", count);
#endif
		
		xEventGroupSetBits(taskEventHandle, DEFAULT_TASK_BIT);

		count++;
		
  }
  /* USER CODE END StartDefaultTask */
}

/* USER CODE BEGIN Header_StartModbusTask */
/**
* @brief Function implementing the ModbusTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartModbusTask */
void StartModbusTask(void *argument)
{
  /* USER CODE BEGIN StartModbusTask */
	Modbus_StartReceive();
  /* Infinite loop */
  for(;;)
  {
		Modbus_DataHandle();
		//HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);	
		
    osDelay(50);
		
		xEventGroupSetBits(taskEventHandle, MODBUS_TASK_BIT);
  }
  /* USER CODE END StartModbusTask */
}

/* USER CODE BEGIN Header_StartWatchdogTask */
/**
* @brief Function implementing the WatchdogTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartWatchdogTask */
void StartWatchdogTask(void *argument)
{
  /* USER CODE BEGIN StartWatchdogTask */

	EventBits_t xEventGroupValue;
	const EventBits_t xBitsToWaitFor = (DEFAULT_TASK_BIT |
										MODBUS_TASK_BIT);
	
  /* Infinite loop */
  for(;;)
  {
		xEventGroupValue = xEventGroupWaitBits( 
							taskEventHandle,
							xBitsToWaitFor,
							pdTRUE,
							pdTRUE,
							portMAX_DELAY);
		
		//printf("the task  feed watchdog  \r\n");
		iwdg_feed();
		
    osDelay(100);
  }
  /* USER CODE END StartWatchdogTask */
}

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

/* USER CODE END Application */