SmartPDCode/GD32F427/user/main.c

#include "gd32f4xx_libopt.h"

#include "bsp_enet.h"
#include "bsp_print.h"
#include "bsp_flash.h"
#include "bsp_rtc.h"
#include "bsp_cas.h"
#include "bsp_ctrl.h"
#include "bsp_sensor.h"
#include "bsp_lcd.h"
#include "bsp_watchdog.h"
#include "systick.h"
#include "FreeRTOS.h"
#include "task.h"

#include "arch/netconf.h"
#include "semphr.h"

#include "lfs_file.h"


#include "modbus.h"
#include "power.h"
#include "snmp.h"
#include "paras.h"
#include "sensor.h"
#include "beep.h"
#include "cascade.h"
#include "web.h"
#include "menu.h"
#include "event_groups.h"

typedef uint8_t  u8;






#define START_TASK_PRIO         4         
#define START_STK_SIZE          256    

TCM_DATA static StackType_t   START_Task_Stack[START_STK_SIZE];
TCM_DATA static StaticTask_t 	START_Task_TCB;

TaskHandle_t StartTask_Handler;             
void start_task(void *pvParameters);      




#define LWIP_DMEO_TASK_PRIO     5          
#define LWIP_DMEO_STK_SIZE      2048       
TaskHandle_t LWIP_Task_Handler;            
TCM_DATA static StackType_t   LWIP_Task_Stack[LWIP_DMEO_STK_SIZE];
TCM_DATA static StaticTask_t 	LWIP_Task_TCB;
void lwip_demo_task(void *pvParameters);    




#define CASCADE_TASK_PRIO     6         
#define CASCADE_STK_SIZE     1024       
TaskHandle_t CASCADE_Task_Handler;    
TCM_DATA static StackType_t   CASCADE_Task_Stack[CASCADE_STK_SIZE];
TCM_DATA static StaticTask_t 	CASCADE_Task_TCB;
void cascade_query_task(void *pvParameters);    


#define CASCADE_SCAN_PRIO    				6
#define CASCADE_SCAN_STK_SIZE      512        
TaskHandle_t CASCADE_SCAN_Task_Handler;      
TCM_DATA static StackType_t   CASCADE_SCAN_Task_Stack[CASCADE_SCAN_STK_SIZE];
TCM_DATA static StaticTask_t 	CASCADE_SCAN_Task_TCB;
void cascade_scan_task(void *pvParameters);   



#define POWER_STK_SIZE      1024        
#define POWER_TASK_PRIO     6          
TaskHandle_t POWER_Task_Handler;            
TCM_DATA static StackType_t   POWER_Task_Stack[POWER_STK_SIZE];
TCM_DATA static StaticTask_t 	POWER_Task_TCB;
void power_demo_task(void *pvParameters);    


#define SENSOR_STK_SIZE      1024       
#define SENSOR_TASK_PRIO     8        
TaskHandle_t SENSOR_Task_Handler;             

TCM_DATA static StackType_t   SENSOR_Task_Stack[SENSOR_STK_SIZE];
TCM_DATA static StaticTask_t 	SENSOR_Task_TCB;

void sensor_task(void *pvParameters);    


#define LCD_STK_SIZE      2048        
#define LCD_TASK_PRIO     7      
TaskHandle_t LCD_Task_Handler;             

TCM_DATA static StackType_t   LCD_Task_Stack[LCD_STK_SIZE];
TCM_DATA static StaticTask_t 	LCD_Task_TCB;

void lcd_task(void *pvParameters);    




#define WEB_STK_SIZE      2048       
#define WEB_TASK_PRIO     5          
TaskHandle_t WEB_Task_Handler;   

TCM_DATA static StackType_t   WEB_Task_Stack[WEB_STK_SIZE];
TCM_DATA static StaticTask_t 	WEB_Task_TCB;

void web_task(void *pvParameters);   


#define DEFAULT_DOG  0X3F


__IO uint32_t  ini_flag = 0;
__IO uint32_t  cascade_flag = 0;
__IO uint32_t  lcd_init_flag = 0;

#define TASK_WEB_BIT    		      (1 << 0)
#define TASK_SENSOR_BIT     		  (1 << 1)
#define TASK_CASCADE_SCAN_BIT     (1 << 2)
#define TASK_CASCADE_QUERY_BIT    (1 << 3)
#define TASK_LCD_BIT    					(1 << 4)
#define TASK_POWER_BIT    				(1 << 5)




#define ALL_TASKS_BITS    (TASK_WEB_BIT | TASK_SENSOR_BIT | TASK_CASCADE_SCAN_BIT | TASK_CASCADE_QUERY_BIT | TASK_LCD_BIT | TASK_POWER_BIT)

EventGroupHandle_t xWatchdogEventGroup;



int main(void)
{
	__IO int i = 0;
	nvic_priority_group_set(NVIC_PRIGROUP_PRE4_SUB0);	
	
	systick_config();
	bsp_print_init(115200);
	bsp_rtc_init();
	bsp_ctrl_init();
	bsp_sensor_init();
	bsp_lcd_init();
	enet_phy_init();
	W25qxx_Init();
	bsp_watchdog_init();
    /* start_taskÈÎÎñ */

	StartTask_Handler = xTaskCreateStatic(	(TaskFunction_t )start_task, 
																					(const char*    )"start_task", 
																					(uint16_t       )START_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )START_TASK_PRIO, 
																					(StackType_t *)START_Task_Stack,
																					(StaticTask_t *)&START_Task_TCB);

    vTaskStartScheduler(); /* ¿ªÆôÈÎÎñµ÷¶È */
	
	while(1)
	{
		i ++;
	}
	

	return 0;
}

void start_task(void *pvParameters)
{
	
	taskENTER_CRITICAL(); 
	
	xWatchdogEventGroup = xEventGroupCreate();
	
	
	POWER_Task_Handler = xTaskCreateStatic(	(TaskFunction_t )power_demo_task, 
																					(const char*    )"power_demo_task", 
																					(uint16_t       )POWER_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )POWER_TASK_PRIO, 
																					(StackType_t *)POWER_Task_Stack,
																					(StaticTask_t *)&POWER_Task_TCB);

	LWIP_Task_Handler = xTaskCreateStatic(	(TaskFunction_t )lwip_demo_task, 
																					(const char*    )"lwip", 
																					(uint16_t       )LWIP_DMEO_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )LWIP_DMEO_TASK_PRIO, 
																					(StackType_t *)LWIP_Task_Stack,
																					(StaticTask_t *)&LWIP_Task_TCB);
	CASCADE_Task_Handler = xTaskCreateStatic(	(TaskFunction_t )cascade_query_task, 
																					(const char*    )"cascade_query_task", 
																					(uint16_t       )CASCADE_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )CASCADE_TASK_PRIO, 
																					(StackType_t *)CASCADE_Task_Stack,
																					(StaticTask_t *)&CASCADE_Task_TCB);
																					
	CASCADE_SCAN_Task_Handler = xTaskCreateStatic(	(TaskFunction_t )cascade_scan_task, 
																					(const char*    )"cascad_scan_task", 
																					(uint16_t       )CASCADE_SCAN_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )CASCADE_SCAN_PRIO, 
																					(StackType_t *)CASCADE_SCAN_Task_Stack,
																					(StaticTask_t *)&CASCADE_SCAN_Task_TCB);
								

	LCD_Task_Handler = xTaskCreateStatic(	(TaskFunction_t )lcd_task, 
																					(const char*    )"lcd_task", 
																					(uint16_t       )LCD_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )LCD_TASK_PRIO, 
																					(StackType_t *)LCD_Task_Stack,
																					(StaticTask_t *)&LCD_Task_TCB);								

	WEB_Task_Handler = xTaskCreateStatic(	(TaskFunction_t )web_task, 
																					(const char*    )"web_task", 
																					(uint16_t       )WEB_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )WEB_TASK_PRIO, 
																					(StackType_t *)WEB_Task_Stack,
																					(StaticTask_t *)&WEB_Task_TCB);				

	SENSOR_Task_Handler = xTaskCreateStatic(	(TaskFunction_t )sensor_task, 
																					(const char*    )"sensor_task", 
																					(uint16_t       )SENSOR_STK_SIZE, 
																					(void*          )NULL,
																					(UBaseType_t    )SENSOR_TASK_PRIO, 
																					(StackType_t *)SENSOR_Task_Stack,
																					(StaticTask_t *)&SENSOR_Task_TCB);																					
								
	vTaskDelete(StartTask_Handler); 
												
	taskEXIT_CRITICAL();  
	
}

void web_task(void *pvParameters)
{
	while(ini_flag == 0)
	{
		vTaskDelay(10);
	}
	web_init();
	web_query();
	vTaskDelete( WEB_Task_Handler );
	
}



void lcd_task(void *pvParameters)
{
	while(ini_flag == 0)
	{
		vTaskDelay(10);
	}
	menu_init();
	lcd_init_flag = 1;
	int i = 0;
	while(1)
	{
		menu_handle();
		xEventGroupSetBits(xWatchdogEventGroup, TASK_LCD_BIT);
		vTaskDelay(100);
	}
	vTaskDelete(LCD_Task_Handler);
}



void sensor_task(void *pvParameters)
{
	while(ini_flag == 0 || lcd_init_flag == 0)
	{
		vTaskDelay(10);
	}
	sensor_init();
	while(1)
	{
		
		sensor_query();
		xEventGroupSetBits(xWatchdogEventGroup, TASK_SENSOR_BIT);
		vTaskDelay(1000);
	}
	vTaskDelete(SENSOR_Task_Handler);
}


void cascade_scan_task(void *pvParameters)
{
	while(ini_flag == 0 || cascade_flag == 0)
	{
		vTaskDelay(10);
	}
	while(1)
	{
		cas_scan_query();
		xEventGroupSetBits(xWatchdogEventGroup, TASK_CASCADE_SCAN_BIT);
		vTaskDelay(1000);
	}
	vTaskDelete(CASCADE_SCAN_Task_Handler);
}


void cascade_query_task(void *pvParameters)
{
	while(ini_flag == 0)
	{
		vTaskDelay(10);
	}
	cascade_init();
	cascade_flag = 1;
	while(1)
	{
		cas_query();
		xEventGroupSetBits(xWatchdogEventGroup, TASK_CASCADE_QUERY_BIT);
		vTaskDelay(10);
	}
	vTaskDelete(CASCADE_Task_Handler);
}

void power_demo_task(void *pvParameters)
{
	while(ini_flag == 0 || lcd_init_flag == 0)
	{
		vTaskDelay(10);
	}
	power_init();
	while(1)
	{
		power_thread();
		xEventGroupSetBits(xWatchdogEventGroup, TASK_POWER_BIT);
		vTaskDelay(200);
	}
	vTaskDelete(POWER_Task_Handler);
}


void print_freertos_heap(void) {
//    size_t total = configTOTAL_HEAP_SIZE;
//    size_t free_now = xPortGetFreeHeapSize();
//    size_t min_ever = xPortGetMinimumEverFreeHeapSize();
//    size_t used = total - free_now;
//    size_t peak_used = total - min_ever;

//    fr_printf("========== FreeRTOS HEAP ==========\r\n");
//    fr_printf("Total size:   %u bytes (%u KB)\r\n", total, total / 1024);
//    fr_printf("Free now:     %u bytes (%u KB)\r\n", free_now, free_now / 1024);
//    fr_printf("Used now:     %u bytes (%u KB)\r\n", used, used / 1024);
//    fr_printf("Peak used:    %u bytes (%u KB)\r\n", peak_used, peak_used / 1024);
//    fr_printf("Min ever free:%u bytes (%u KB)\r\n", min_ever, min_ever / 1024);
//    fr_printf("===================================\r\n");
}





void lwip_demo_task(void *pvParameters)
{
	int i = 0;
	EventBits_t  uxBits;
	uint8_t addr[6] = {0};
	l_file_init();
	paras_init();
	lwip_stack_init();
	ini_flag = 1;
	snmp2_init();
	
	while(1)
	{
		enet_mac_address_get(ENET_MAC_ADDRESS0,addr);
//		fr_printf("\r\n");
//		for(i=0;i < 6;i++)
//		{
//			fr_printf("0x%02X ",addr[i]);
//		}
//		fr_printf("\r\n");
		print_freertos_heap();
		lwip_check();
		uxBits = xEventGroupWaitBits(xWatchdogEventGroup, ALL_TASKS_BITS, pdFALSE, pdTRUE, pdMS_TO_TICKS(10));  
		if ((uxBits & ALL_TASKS_BITS) == ALL_TASKS_BITS) {
        bsp_watchdog_feed();
				xEventGroupClearBits(xWatchdogEventGroup, ALL_TASKS_BITS);
    } 
		vTaskDelay(1000);
	}
	vTaskDelete( LWIP_Task_Handler );
}