#include "gd32f30x_libopt.h"
#include "main.h"
#include "SysTick.h"
#include "Relay.h"
#include "Key.h"
#include "Led.h"
#include "Timer.h"
#include "Electricity.h"
#include "Temprature.h"
#include "Beep.h"
#include "Fan.h"
#include "Exti.h"
#include "At24xx.h"
#include "Fwdgt.h"
#include "Mb.h"
#include "R_Led.h"
#include "FreeRTOS.h"
#include "task.h"
#include "lcd.h"
#include "font.h"
#include "menu.h"
#include "timers.h"



#define VERSION  "V1.1.0.0"

#define UNIQU_1                       			0x1FFFF7E8
#define UNIQU_2                       			0x1FFFF7EC
#define UNIQU_3                       			0x1FFFF7F0

sts_data_t  sts_data;


sts_data_t *get_sts(void)
{
	return &sts_data;
}



#define START_TASK_PRIO 1                   
#define START_STK_SIZE  128                 
TaskHandle_t            StartTask_Handler;  
void start_task(void *pvParameters);        


#define TASK1_PRIO      3                  
#define TASK1_STK_SIZE  256                
TaskHandle_t            Task1Task_Handler;  
void task1(void *pvParameters);             

#define TASK2_PRIO      2                  
#define TASK2_STK_SIZE  128                 
TaskHandle_t            Task2Task_Handler;  
void modbus_task(void *pvParameters);       

#define TASK3_PRIO      3                  
#define TASK3_STK_SIZE  256                 
TaskHandle_t            Task3Task_Handler;  
void lcd_task(void *pvParameters);       

#define TASK4_PRIO      4                  
#define TASK4_STK_SIZE  128                 
TaskHandle_t            Task4Task_Handler;  
void task_1s(void *pvParameters);   



TimerHandle_t timer1_handle = 0;
int32_t count = 0;
uint32_t interval = 0;
uint32_t timer_beep_flag = 0;



void beep_timer_start(int cou2,uint32_t inval)
{
	if(timer_beep_flag == 1)
		xTimerStop(timer1_handle,portMAX_DELAY);
	timer_beep_flag = 0;
	count = cou2;
	interval = inval;
	xTimerChangePeriod(timer1_handle,interval,portMAX_DELAY);
	xTimerStart(timer1_handle,portMAX_DELAY);
	timer_beep_flag = 1;
}

void beep_timer_stop()
{
	if(timer_beep_flag == 1)
		xTimerStop(timer1_handle,portMAX_DELAY);
	timer_beep_flag = 0;
}

void timer1_callback( TimerHandle_t pxTimer )
{
	sts_data.beep();
	if(count > 0)
	{
		count--;
	}else if(count == 0)
	{
			sts_data.clear_beep();
			beep_timer_stop();
		timer_beep_flag = 0;
	}else
	{
		
	}
}



extern uint8_t recode_normal_flag;
extern uint8_t  recode_channel;
uint8_t counter = 0;

void task_100ms(void *pvParameters)
{
  uint32_t task1_num = 0;
	static uint8_t channel = 0;
	temp_init();
	
	for(uint8_t i = 0; i < 3;i++)
	{
		select_channel(i);
		Init_HLW8110();
	}
	read_config_from_eeprom();
		if(sts_data.switch_status == INPUT_CHANNEL_1 && sts_data.m_data.m_r.r_data.input_status.input_status[INPUT_CHANNEL_1])
		{
			sts_data.choise_input(INPUT_CHANNEL_1);
		}else
		{
			sts_data.choise_input(INPUT_CHANNEL_2);
		}
		if(sts_data.m_data.m_rw.rw_data.md_eep.out_status)
		{
			sts_data.open_output();
		}else
		{
			sts_data.close_output();
		}
    while(1)
    {
			sts_data.read_ele(channel);
			sts_data.check_wanning(channel);
			sts_data.read_temp();
			channel++;	
			if(channel == 3)
			{
				if((sts_data.m_data.m_r.r_data.input_status.input_status[INPUT_CHANNEL_1]) && 
							(sts_data.m_data.m_r.r_data.input_status.input_status[INPUT_CHANNEL_2]))
						{
							sts_data.beep_flag = 0;
							sts_data.input_beep = 0;
							if(recode_normal_flag)
							{
								counter++;
								if(counter>= 3)
								{
									counter = 0;
									recode_normal_flag = 0;
								}
								channel = 0;
								vTaskDelay(100);
								continue;
							}
							if(sts_data.m_data.m_rw.rw_data.chiose_ch == INPUT_CHANNEL_1)
							{
								uint16_t wanning_1 = *(uint16_t*)(&sts_data.m_data.m_r.r_data.input_wanning.in_wan[INPUT_CHANNEL_1]);
								uint16_t wanning_2 = *(uint16_t*)(&sts_data.m_data.m_r.r_data.input_wanning.in_wan[INPUT_CHANNEL_2]);
								if(wanning_1 >> 8)
								{
										if(wanning_2 >> 8 )
										{
											if(sts_data.m_data.m_rw.rw_data.md_eep.out_status == OUT_OPEN) 
												sts_data.close_output();
										}else
										{
											if(!recode_normal_flag)
												sts_data.choise_input(INPUT_CHANNEL_2);
										}
								}
							}else if(sts_data.m_data.m_rw.rw_data.chiose_ch == INPUT_CHANNEL_2)
							{
								uint16_t wanning_2 = *(uint16_t*)(&sts_data.m_data.m_r.r_data.input_wanning.in_wan[INPUT_CHANNEL_2]);
								uint16_t wanning_1 = *(uint16_t*)(&sts_data.m_data.m_r.r_data.input_wanning.in_wan[INPUT_CHANNEL_1]);
								if(wanning_2 >> 8)
								{
										if(wanning_1 >> 8)
										{
											if(sts_data.m_data.m_rw.rw_data.md_eep.out_status == OUT_OPEN) sts_data.close_output();
										}else
										{
											if(!recode_normal_flag)
													sts_data.choise_input(INPUT_CHANNEL_1);
										}
								}
							}else
							{
								;
							}
						}else if((sts_data.m_data.m_r.r_data.input_status.input_status[INPUT_CHANNEL_1]) )
						{
							if(!sts_data.input_beep){
									sts_data.input_beep = 1;
									beep_timer_start(20,300);
							}
							uint16_t wanning_1 = *(uint16_t*)(&sts_data.m_data.m_r.r_data.input_wanning.in_wan[INPUT_CHANNEL_1]);
							if(wanning_1 >> 8)
							{
								if(sts_data.m_data.m_rw.rw_data.md_eep.out_status == OUT_OPEN) sts_data.close_output();
							}
						}else if((sts_data.m_data.m_r.r_data.input_status.input_status[INPUT_CHANNEL_2]) ){
							if(!sts_data.input_beep){
									sts_data.input_beep = 1;
								beep_timer_start(20,300);
							}
							uint16_t wanning_2 = *(uint16_t*)(&sts_data.m_data.m_r.r_data.input_wanning.in_wan[INPUT_CHANNEL_2]);
							if(wanning_2 >> 8)
							{
								if(sts_data.m_data.m_rw.rw_data.md_eep.out_status  == OUT_OPEN) sts_data.close_output();
							}
						}else
						{
							if(!sts_data.input_beep){
									sts_data.input_beep = 1;
//									sts_data.beep_count =sts_data.lost_count;
//									sts_data.beep_flag = 1;
									beep_timer_start(20,300);
							}
						}
				channel = 0;
			}
			vTaskDelay(100);
    }
		vTaskDelete(Task1Task_Handler);
}


void task_10ms(void *pvParameters)
{
		sts_data.addr = ReadKeyValue();
		sts_data.baund = 9600;
		Fwdgt_Init();
		eMBInit(MB_RTU,sts_data.addr,0,sts_data.baund,MB_PAR_NONE);
		
    while(1)
    {  
			Fwdgt_reload();
			if(eMBCheck())
			{
				eMBInit(MB_RTU, sts_data.addr, 0, sts_data.baund, MB_PAR_NONE);
				eMBEnable();
				vTaskDelay(10);
			}			
			eMBPoll();	
//			if(sts_data.beep_flag == 0)
//			{
//				if(sts_data.i_beep_flag[0].beep_waning || sts_data.i_beep_flag[1].beep_waning || sts_data.o_beep_flag.beep_waning)
//				{
//					sts_data.beep_count = sts_data.wanning_count;
//				}else if(sts_data.chiose_flag)
//				{
//				}
//				else
//				{
//					sts_data.clear_beep();
//				}
//			}			
//			if(sts_data.i_beep_flag[0].beep_waning && sts_data.i_beep_flag[1].beep_waning && sts_data.o_beep_flag.beep_waning)
//			{
//				if(sts_data.beep_flag == 1)
//				{
//					sts_data.beep_count = sts_data.lost_count;
//				}else if(sts_data.chiose_flag)
//				{
//				}
//				else
//				{
//					sts_data.clear_beep();
//				}
//			}			
			if(sts_data.m_data.m_r.r_data.temprature_flag == TEMP_ONLINE)
			{
				if(sts_data.m_data.m_rw.rw_data.md_eep.temp_th.max_temp != 0 && sts_data.m_data.m_rw.rw_data.md_eep.temp_th.max_temp != 0)
				{
					if(sts_data.m_data.m_rw.rw_data.md_eep.temp_th.max_temp > sts_data.m_data.m_rw.rw_data.md_eep.temp_th.max_temp)
					{
						if((int16_t)(sts_data.m_data.m_r.r_data.temprature) >= sts_data.m_data.m_rw.rw_data.md_eep.temp_th.max_temp)
						{
							if(sts_data.m_data.m_r.r_data.fans_status != FANS_ON)
							{
								sts_data.fans(FANS_ON);
							}
						}else if((int16_t)(sts_data.m_data.m_r.r_data.temprature) <= sts_data.m_data.m_rw.rw_data.md_eep.temp_th.min_temp)
						{
							if(sts_data.m_data.m_r.r_data.fans_status != FANS_OFF)
							{
								sts_data.fans(FANS_OFF);
							}
						}
					}
				}
			}
			show_wanning_led();
      vTaskDelay(10);                         
    }
		vTaskDelete(Task2Task_Handler);
}

void task_1s(void *pvParameters)
{
	static uint8_t eep_count = 0;
	static uint8_t delay_count = 0;
	while(1)
	{
			if(sts_data.chiose_flag == 1 || sts_data.chiose_flag == 2)
			{
				delay_count++;
				if(delay_count == 3)
				{
					delay_count = 0;
					if(sts_data.chiose_flag == 1)
						sts_data.choise_input(INPUT_CHANNEL_1);
					else
						sts_data.choise_input(INPUT_CHANNEL_2);
					sts_data.chiose_flag = 0;
				}
			}
		eep_count ++;
		if(eep_count >= 10)
		{
			eep_count = 0;
			if(sts_data.kwh.row >= MAX_ROW)
			{
				sts_data.kwh.row  = 0;
			}
			iic_consumer_data_t chache = {0};
			if(sts_data.kwh.index >= UINT64_MAX)
			{
				for(int i = 0 ; i < MAX_ROW;i++){
					sts_data.write_eeprom_page(IIC_CONSUMER_START+(IIC_CONSUMER_PAGE*i),&chache,sizeof(iic_consumer_data_t));
				}
				sts_data.kwh.row = 0;
			}
			chache.iic_consumer = sts_data.iic_consumer;
			chache.recode_index1 = sts_data.kwh.index;;
			sts_data.write_eeprom_page(IIC_CONSUMER_START+(IIC_CONSUMER_PAGE*sts_data.kwh.row),&chache,sizeof(iic_consumer_data_t));
			sts_data.kwh.index++;
			sts_data.kwh.row++;			
		}
		LEDFlicker2();
		vTaskDelay(1000);
	}
	vTaskDelete(Task2Task_Handler);
}

void lcd_task(void *pvParameters)
{
	menu_init();
	int menu = 0;
	int count =0;
	while(1)
	{
		if(count == 6)
		{
			menu++;
			count = 0;
			lcd_fill(COLOR_BLACK);
		}
		if(menu == MENU_MAX )
		{
			menu = 0;
		}
		menu_handle(menu);
		count++;
		vTaskDelay(500);
	}
}

void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();       

    xTaskCreate((TaskFunction_t )task_100ms,
                (const char*    )"task1",
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )configMAX_PRIORITIES-1,
                (TaskHandle_t*  )&Task1Task_Handler);

    xTaskCreate((TaskFunction_t )task_10ms,
                (const char*    )"task2",
                (uint16_t       )TASK2_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler);
#if 0					
    xTaskCreate((TaskFunction_t )lcd_task,
                (const char*    )"task3",
                (uint16_t       )TASK3_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK3_PRIO,
                (TaskHandle_t*  )&Task3Task_Handler);
#endif
    xTaskCreate((TaskFunction_t )task_1s,
                (const char*    )"task4",
                (uint16_t       )TASK4_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK4_PRIO,
                (TaskHandle_t*  )&Task4Task_Handler);
    vTaskDelete(StartTask_Handler); 
    taskEXIT_CRITICAL();            
}



int main()
{
	systick_config();
	InitKey();
	InitLED();
	InitTimer();
	InitRelay();
	fans_init();
	beep_init();
	eeprom_init();
	electricity_init();
	sts_exti_init();
	
	strcpy(sts_data.m_data.m_r.r_data.info.date,__DATE__);
	strcat(sts_data.m_data.m_r.r_data.info.date," ");
	strcat(sts_data.m_data.m_r.r_data.info.date,__TIME__);
	strcpy(sts_data.m_data.m_r.r_data.info.ver,VERSION);
	sts_data.m_data.m_r.r_data.dev |= (STS_TYPE << 8);
	sts_data.m_data.m_r.r_data.dev |= (2 << 6);
	sts_data.m_data.m_r.r_data.dev |= 1;
	sts_data.m_data.m_r.r_data.info.channels = 1;
	sts_data.m_data.m_r.r_data.info.uniq_ID_64_95 						= *(uint32_t*)(UNIQU_3);
	sts_data.m_data.m_r.r_data.info.uniq_ID_32_63 						= *(uint32_t*)(UNIQU_2);
	sts_data.m_data.m_r.r_data.info.uniq_ID_00_31 						= *(uint32_t*)(UNIQU_1);
	
	sts_data.read_switch_level();
	sts_data.lost_count = LOST_COUNT;
	sts_data.wanning_count = WANNING_COUNT;
		
		timer1_handle = xTimerCreate( "timer1", 
                                    1000,
                                    pdTRUE,
                                    (void *)1,
                                    timer1_callback );
																		
	 //xTimerStart(timer1_handle,portMAX_DELAY);
   xTaskCreate((TaskFunction_t )start_task,            
                (const char*    )"start_task",          
                (uint16_t       )START_STK_SIZE,        
                (void*          )NULL,                  
                (UBaseType_t    )START_TASK_PRIO,       
                (TaskHandle_t*  )&StartTask_Handler);   
   vTaskStartScheduler();
	while(1)
	{
		
	}

	return 0;
}