#include "main.h"
#include "fdcan.h"
#include "fdcan_task.h"
#include "HW_Config.h"
#include "W25Qxx.h"
#include "internal_flash.h"
#include "user_norflash.h"
#include "load_gui_lib.h"
#include "uart_printer_drv.h"

#define USER_UART_NUM 	8

extern void MX_FDCAN2_Init(void);

uid_union uid_value;

uart_info_8bit_struct uart_info_8bit[USER_UART_NUM];
//LPUART1--eth 57600,USART1--wifi 115200,USART2--fecbus 9600,USART3--canouter 57600,UART4--linkage 19200,UART5--memory 57600,USART6--print 9600,UART7--switch 57600
unsigned char * const p_user_uart[USER_UART_NUM] = {LPUART1,USART1,USART2,USART3,UART4,UART5,USART6,UART7};
const unsigned int uart_tx_complete_timeup[USER_UART_NUM] = {3,17,17,3,9,3,20,3};//1ms 16bytes FIFO

unsigned int lcd_update_flag = 0;
unsigned int usb_is_host = 0;

//unsigned char TEXT_Buffer[]={"ABC12365478903678913"};
#define SIZE sizeof(TEXT_Buffer)

/**
  * @brief  Perform the SDRAM exernal memory inialization sequence
  * @param  hsdram: SDRAM handle
  * @param  Command: Pointer to SDRAM command structure
  * @retval None
  */
/**
  * @brief  Perform the SDRAM exernal memory inialization sequence
  * @param  hsdram: SDRAM handle
  * @param  Command: Pointer to SDRAM command structure
  * @retval None
  */
void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram, FMC_SDRAM_CommandTypeDef *Command)
{
  __IO uint32_t tmpmrd =0;
  /* Step 1:  Configure a clock configuration enable command */
  Command->CommandMode = FMC_SDRAM_CMD_CLK_ENABLE;
  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
  Command->AutoRefreshNumber = 1;
  Command->ModeRegisterDefinition = 0;

  /* Send the command */
  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);

  /* Step 2: Insert 100 us minimum delay */
  /* Inserted delay is equal to 1 ms due to systick time base unit (ms) */
  HAL_Delay(1);

  /* Step 3: Configure a PALL (precharge all) command */
  Command->CommandMode = FMC_SDRAM_CMD_PALL;
  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
  Command->AutoRefreshNumber = 1;
  Command->ModeRegisterDefinition = 0;

  /* Send the command */
  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);

  /* Step 4 : Configure a Auto-Refresh command */
  Command->CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
  Command->AutoRefreshNumber = 8;
  Command->ModeRegisterDefinition = 0;

  /* Send the command */
  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);

  /* Step 5: Program the external memory mode register */
  tmpmrd = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1          |
                     SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL   |
                     SDRAM_MODEREG_CAS_LATENCY_3           |
                     SDRAM_MODEREG_OPERATING_MODE_STANDARD |
                     SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;

  Command->CommandMode = FMC_SDRAM_CMD_LOAD_MODE;
  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
  Command->AutoRefreshNumber = 1;
  Command->ModeRegisterDefinition = tmpmrd;

  /* Send the command */
  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);

  /* Step 6: Set the refresh rate counter */
  /* Set the device refresh rate */
  HAL_SDRAM_ProgramRefreshRate(hsdram, REFRESH_COUNT); 

}

void FDCAN2_Initialization_Sequence(void)
{
	FDCAN_FilterTypeDef sFilterConfig;
	
	/*##-2- Configure the CAN Filter ###########################################*/
	/* Configure Rx filter */
  sFilterConfig.IdType = FDCAN_EXTENDED_ID;
  sFilterConfig.FilterIndex = 0;
  sFilterConfig.FilterType = FDCAN_FILTER_MASK;
  sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
  sFilterConfig.FilterID1 = 0x0000;
  sFilterConfig.FilterID2 = 0x0000;
	
  if(HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig) != HAL_OK)
  {
    /* Filter configuration Error */
    Error_Handler();
  }
	//HAL_FDCAN_Stop(p_fdcan_handle);
	/*##-3- Start the CAN peripheral ###########################################*/
  if (HAL_FDCAN_Start(&hfdcan2) != HAL_OK)
  {
    /* Start Error */
    //Error_Handler();
		HAL_Delay(100);
		HAL_FDCAN_Start(&hfdcan2);
  }
	
	/*##-4- Activate CAN RX TX notification #######################################*/
  if (HAL_FDCAN_ActivateNotification(&hfdcan2, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0) != HAL_OK)
  {
    /* Notification Error */
    Error_Handler();
  }
	
  if (HAL_FDCAN_ActivateNotification(&hfdcan2, FDCAN_IT_TX_FIFO_EMPTY, 0) != HAL_OK)
  {
    Error_Handler();
  }
}

unsigned int FDCAN2_Reinit(void)
{
	FDCAN_FilterTypeDef sFilterConfig;
	
	MX_FDCAN2_Init();
	
  sFilterConfig.IdType = FDCAN_EXTENDED_ID;
  sFilterConfig.FilterIndex = 0;
  sFilterConfig.FilterType = FDCAN_FILTER_MASK;
  sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
  sFilterConfig.FilterID1 = 0x0000;
  sFilterConfig.FilterID2 = 0x0000;
	
  if(HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig) != HAL_OK)return 2;
  HAL_FDCAN_Start(&hfdcan2);
	HAL_FDCAN_ActivateNotification(&hfdcan2, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0);
	HAL_FDCAN_ActivateNotification(&hfdcan2, FDCAN_IT_TX_FIFO_EMPTY, 0);
	return 0;
}

void get_uuid(void)
{
	uid_value.val_32[0] = LL_GetUID_Word0();
	uid_value.val_32[1] = LL_GetUID_Word1();
	uid_value.val_32[2] = LL_GetUID_Word2();
}

unsigned short get_open_password(void)
{
	unsigned int pwd;
	unsigned short res;
	
	pwd = uid_value.val_32[0];
	pwd^= uid_value.val_32[1];
	pwd^= uid_value.val_32[2];
	
	res = (pwd>>16)&0xFFFF;
	res^= (pwd&0xFFFF);
	
	return res;
}

void HW_init(void)
{
	unsigned int addr = 0;
	unsigned int zk_addr = 0;
	unsigned int value = 0;
	unsigned int i = 0,x = 0,y = 0, a = 0;
	
	get_uuid();
	factory_prm.pwr = get_open_password();
	read_factory_prm();
	
	//LCD RST
	LL_GPIO_SetOutputPin(GPIOE,LL_GPIO_PIN_3);//not rst
	
	//TIM2 relay
	LL_TIM_CC_EnableChannel(TIM2,LL_TIM_CHANNEL_CH1);
	LL_TIM_OC_SetCompareCH1(TIM2,0);
	LL_TIM_EnableAllOutputs(TIM2);
	//LL_TIM_EnableIT_UPDATE(TIM2);
	LL_TIM_EnableCounter(TIM2);
	
	//TIM3  LCD_BL
	LL_TIM_CC_EnableChannel(TIM3,LL_TIM_CHANNEL_CH2);
	LL_TIM_OC_SetCompareCH2(TIM3,255);//bl
	LL_TIM_EnableAllOutputs(TIM3);
	LL_TIM_EnableCounter(TIM3);
	
	//TIM7  random
	//LL_TIM_EnableIT_UPDATE(TIM7);
	LL_TIM_EnableCounter(TIM7);
	
	//TIM12 relay
	LL_TIM_CC_EnableChannel(TIM12,LL_TIM_CHANNEL_CH1);
	LL_TIM_OC_SetCompareCH1(TIM12,0);
	LL_TIM_EnableAllOutputs(TIM12);
	//LL_TIM_EnableIT_UPDATE(TIM2);
	LL_TIM_EnableCounter(TIM12);
	
	//LPUART1
	LL_USART_EnableIT_RXNE(LPUART1);
	LL_USART_ClearFlag_IDLE(LPUART1);
	//LL_USART_EnableIT_IDLE(LPUART1);
	uart_info_8bit[0].tx_complete = 1;
	
	//UART1
	LL_USART_EnableIT_RXNE(USART1);
	LL_USART_ClearFlag_IDLE(USART1);
	LL_USART_EnableIT_IDLE(USART1);
	uart_info_8bit[1].tx_complete = 1;
	
	//UART2
	LL_USART_EnableIT_RXNE(USART2);
	LL_USART_ClearFlag_IDLE(USART2);
	//LL_USART_EnableIT_IDLE(USART2);
	uart_info_8bit[2].tx_complete = 1;
	
	//UART3
	LL_USART_EnableIT_RXNE(USART3);
	LL_USART_ClearFlag_IDLE(USART3);
	LL_USART_EnableIT_IDLE(USART3);
	uart_info_8bit[3].tx_complete = 1;
	
	//UART4
	LL_USART_EnableIT_RXNE(UART4);
	LL_USART_ClearFlag_IDLE(UART4);
	//LL_USART_EnableIT_IDLE(UART4);
	uart_info_8bit[4].tx_complete = 1;
	
	//UART5
	LL_USART_EnableIT_RXNE(UART5);
	LL_USART_ClearFlag_IDLE(UART5);
	LL_USART_EnableIT_IDLE(UART5);
	uart_info_8bit[5].tx_complete = 1;
	
	//UART6
	LL_USART_EnableIT_RXNE(USART6);
	uart_info_8bit[6].tx_complete = 1;
	
	//UART7
	LL_USART_EnableIT_RXNE(UART7);
	LL_USART_ClearFlag_IDLE(UART7);
	LL_USART_EnableIT_IDLE(UART7);
	uart_info_8bit[7].tx_complete = 1;
	
	//fdcan2
	FDCAN2_Initialization_Sequence();
	can_prm_init();
	
	//LTDC
	LTDC_Init();
	//LTDC->IER |= LTDC_IER_LIE;
	
	//RTC
	rtc_init();
	
	//I2C
	//write_user_eeprom(0, 0x1005, TEXT_Buffer, 16);
	//write_user_eeprom(1, 0x10001, &TEXT_Buffer[1], 16);
	
	//USBFS
	usb_is_host = 1;
	
	//QSPI-HW 24Mhz
	nor_flash_init();
	//W25QXX_Init();
	//nor_erase_sector(0,0);
	//nor_write_byte(0,0x403,TEXT_Buffer,16);
	//nor_write_byte(1,0x207,TEXT_Buffer,16);
	
	//LCD
	LTDC_Layer_Switch(1,0);
	//LTDC_Layer_Switch(0,1);
	addr = 0xC0000000 + 480*800*4;
	for(y=0;y<480;y++){
		for(x=0;x<800;x++){
			*(unsigned int*)addr = 0;
			addr+=4;
		}
	}
	
	pic_prm_init();
	
	//device_init
	printer_init();
	
	//------------------------test-----------------------------------------
	/*
	for(i=0;i<480;i++){
		addr = 50*4 + 0xC0000000 + (800*i*4);
		*(unsigned int*)addr = 0xFF00FF00;
	}
		*/
	/*
	addr = 0xC0177000 + (10*800*4);
	for(y=0;y<10;y++){
		for(x=0;x<800;x++){
			*(unsigned int*)addr = 0xFF000080;
			addr+=4;
		}
	}
	addr = 0xC0177000 + (20*800*4);
	for(y=0;y<10;y++){
		for(x=0;x<800;x++){
			*(unsigned int*)addr = 0xFF000040;
			addr+=4;
		}
	}
	addr = 0xC0177000 + (30*800*4);
	for(y=0;y<10;y++){
		for(x=0;x<800;x++){
			*(unsigned int*)addr = 0xFF000020;
			addr+=4;
		}
	}
	addr = 0xC0177000 + (40*800*4);
	for(y=0;y<10;y++){
		for(x=0;x<800;x++){
			*(unsigned int*)addr = 0xFF000010;
			addr+=4;
		}
	}
	*/
	/*
	LCD_ShowString(0,240,200,24,24,"SD");
	//while(1);
	
	//erase_internal_one_sector(ADDR_FLASH_SECTOR_6_BANK2);
	//write_internal_flash(ADDR_FLASH_SECTOR_6_BANK2,FlashWord);
	LCD_ShowString(20,200,200,24,24,"SD");
	Show_Str(20,100,720,24,"STM32H7开0123456789abcuodij发111板",24,0);//
	gui_write_string24(20,130,0xFFFF0000,0xFF00FF00,"用户参845数SWEI设aw置");
	
	load_pic_16x16_to_dispaly_layer(100,200,45);
	load_pic_16x16_to_dispaly_layer(140,200,8);
	load_pic_24x24_to_dispaly_layer(100,230,101);
	load_pic_24x24_to_dispaly_layer(140,230,14);
	load_pic_32x32_to_dispaly_layer(100,260,30);
	load_pic_32x32_to_dispaly_layer(140,260,15);
	*/
	//nor_read_byte(0,0x009C0000,TEXT_Buffer,16);
	
	//hw_sdram_test();
	
	gbk_nor_load_to_sdram();
}

void uart_tx_trigger(unsigned int uart_ord)
{
	if(uart_ord > 7)return;
	
	uart_info_8bit[uart_ord].tx_index = 0;
	uart_info_8bit[uart_ord].tx_complete = 0;
	uart_info_8bit[uart_ord].tx_complete_delay_flag = 0;
	uart_info_8bit[uart_ord].tx_complete_delay_tick = 0;
	uart_info_8bit[uart_ord].tx_none_buf = 0;
	
	LL_USART_ClearFlag_TC(p_user_uart[uart_ord]);
	LL_USART_EnableIT_TC(p_user_uart[uart_ord]);
	LL_USART_EnableIT_TXFE(p_user_uart[uart_ord]);
}

void uart_tx_load_data(unsigned int uart_ord, unsigned char * p_data, unsigned int len)
{
	unsigned int i = 0;
	unsigned char * pdata;
	
	if(uart_ord > 7)return;
	
	pdata = p_data;
	
	uart_info_8bit[uart_ord].tx_index = 0;
	uart_info_8bit[uart_ord].tx_complete = 0;
	uart_info_8bit[uart_ord].tx_none_buf = 0;
	uart_info_8bit[uart_ord].tx_len = len;
	
	for(i=0;i<len;i++)
	{
		uart_info_8bit[uart_ord].tx_buf[i] = *pdata;
		pdata++;
	}
}

unsigned int get_uart_tx_complete(unsigned int uart_ord)
{
	if(uart_ord > 7)return 0;
	
	return uart_info_8bit[uart_ord].tx_complete;
}

unsigned int get_uart_tx_complete_delay_flag(unsigned int uart_ord)
{
	if(uart_ord > 7)return 0;
	
	return uart_info_8bit[uart_ord].tx_complete_delay_flag;
}

void uart_tx_complete_delay(void)//1ms
{
	unsigned int i;
	for(i=0;i<USER_UART_NUM;i++){
		if(get_uart_tx_complete(i)){
			if(0 == uart_info_8bit[i].tx_complete_delay_flag){
				uart_info_8bit[i].tx_complete_delay_tick++;
				if(uart_info_8bit[i].tx_complete_delay_tick > uart_tx_complete_timeup[i]){
					uart_info_8bit[i].tx_complete_delay_tick = 0;
					uart_info_8bit[i].tx_complete_delay_flag = 1;
				}
			}
		}
	}
}

void uart_tx_over(unsigned int uart_ord, unsigned char * p_data, unsigned int len)
{
	unsigned int i = 0;
	unsigned char * pdata;
	
	if(uart_ord > 7)return;
	
	pdata = p_data;
	
	uart_info_8bit[uart_ord].tx_index = 0;
	uart_info_8bit[uart_ord].tx_complete = 0;
	uart_info_8bit[uart_ord].tx_complete_delay_flag = 0;
	uart_info_8bit[uart_ord].tx_complete_delay_tick = 0;
	uart_info_8bit[uart_ord].tx_none_buf = 0;
	uart_info_8bit[uart_ord].tx_len = len;
	
	for(i=0;i<len;i++)
	{
		uart_info_8bit[uart_ord].tx_buf[i] = *pdata;
		pdata++;
	}
	
	uart_tx_trigger(uart_ord);
}

void uart_load_txbuf(unsigned int uart_ord, unsigned char * p_data, unsigned int len)
{
	unsigned int i = 0;
	unsigned char * pdata;
	
	if(uart_ord > 7)return;
	
	pdata = p_data;
	
	uart_info_8bit[uart_ord].tx_index = 0;
	uart_info_8bit[uart_ord].tx_complete = 0;
	uart_info_8bit[uart_ord].tx_complete_delay_flag = 0;
	uart_info_8bit[uart_ord].tx_complete_delay_tick = 0;
	uart_info_8bit[uart_ord].tx_none_buf = 0;
	uart_info_8bit[uart_ord].tx_len = len;
	
	for(i=0;i<len;i++)
	{
		uart_info_8bit[uart_ord].tx_buf[i] = *pdata;
		pdata++;
	}
}

void uart_irq_handle(USART_TypeDef * USARTx)
{
	unsigned short cc;
	unsigned int i;
	
	for(i=0;i<8;i++){
		if(USARTx == p_user_uart[i])break;
	}

	if(LL_USART_IsActiveFlag_RXNE(USARTx))
	{
		cc = LL_USART_ReceiveData8(USARTx);
		
		if(uart_info_8bit[i].rx_index < UART_RX_BUF_MAX)
		{
			uart_info_8bit[i].rx_buf[uart_info_8bit[i].rx_index] = cc;
			uart_info_8bit[i].rx_index++;
		}
	}
	
	if(LL_USART_IsActiveFlag_IDLE(USARTx))
	{
		LL_USART_ClearFlag_IDLE(USARTx);
		if(uart_info_8bit[i].rx_index)
		{
			uart_info_8bit[i].rx_len = uart_info_8bit[i].rx_index;
			uart_info_8bit[i].rx_index = 0;
			uart_info_8bit[i].rx_complete = 1;
		}
	}
	//--------------------------------------------------------------------------------------------------
	if(LL_USART_IsEnabledIT_TC(USARTx))//LL_USART_IsActiveFlag_TC
	{
		LL_USART_ClearFlag_TC(USARTx);
		if(uart_info_8bit[i].tx_index >= uart_info_8bit[i].tx_len)
		{
			LL_USART_DisableIT_TC(USARTx);
			uart_info_8bit[i].tx_complete = 1;
		}
	}
	
	if(LL_USART_IsEnabledIT_TXE_TXFNF(USARTx))//LL_USART_IsActiveFlag_TXE_TXFNF
	{
		if(uart_info_8bit[i].tx_index >= uart_info_8bit[i].tx_len)
		{
			LL_USART_DisableIT_TXE_TXFNF(USARTx);
		}
		else
		{
			LL_USART_TransmitData8(USARTx, uart_info_8bit[i].tx_buf[uart_info_8bit[i].tx_index]);
			uart_info_8bit[i].tx_index++;
		}
	}
	//---------------------------------------------------------------------------
	LL_USART_ClearFlag_ORE(USARTx);
}

unsigned short crc16_data(unsigned char* p_data,unsigned int data_length)
{
	unsigned int x = 0,y = 0;
	unsigned short crc = 0xFFFF;
	unsigned char data = 0;
	
	for(x=0;x<data_length;x++){
		data = (* p_data);
		crc ^= data;
		for(y=0;y<8;y++){
			if(crc & 0x01){
				crc>>=1;
				crc ^= 0xA001;
			}else{
				crc>>=1;
			}
		}
		p_data++;
	}
	return crc;
}

unsigned int check_crc(unsigned char* p_data,unsigned int data_length)
{
	uint16_t crc_data = 0;
	
	if(data_length < 2)return 0;
		
	crc_data = *(p_data + data_length - 1);
	crc_data<<=8;
	crc_data |= *(p_data + data_length - 2);
	
	if(crc_data == crc16_data(p_data,(data_length - 2))){
		return 0;
	}
	return 1;
}

unsigned char sum8_data(unsigned char* p_data,unsigned int data_length)
{
	unsigned int x = 0;
	unsigned char sum = 0;
	
	for(x=0;x<data_length;x++){
		sum+= (* p_data);
		p_data++;
	}
	return sum;
}

unsigned int check_sum8(unsigned char* p_data,unsigned int data_length)
{
	uint8_t sum = 0;
	
	sum = *(p_data + data_length);
	
	if(sum == sum8_data(p_data,data_length)){
		return 0;
	}
	return 1;
}

unsigned int check_open_password(unsigned int check_value)
{
	if(check_value == factory_prm.pwr){
		return 1;
	}
	return 0;
}

unsigned int check_open_password_isenable(void)
{
	return factory_prm.open_password_isenable;
}

unsigned int check_auth_function_isenable(void)
{
	return factory_prm.auth_function_isenable;
}

void set_open_password_isover(void)
{
	factory_prm.open_password_isenable = 0;
	write_factory_prm();
}

void set_auth_function_able(unsigned int able)
{
	if(able > 1)return;
	factory_prm.auth_function_isenable = able;
	write_factory_prm();
}

void HAL_LTDC_LineEventCallback(LTDC_HandleTypeDef *hltdc)
{
	lcd_update_flag = 1;
	__HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_LI);
}

/*******************************************************************************
* Function Name  : Crc32Cal
* Description    : CRC
* Input          : SourceData,Length
* Output         : None
* Return         : none
*******************************************************************************/
unsigned int  Crc32Cal(unsigned int * SourceData, unsigned int Length)
{ 
    unsigned int i;
    
    CRC->CR |= CRC_CR_RESET;
  
    for (i = 0; i < Length; ++i)
    {
        CRC->DR = *SourceData;
        SourceData++;
    }
    return CRC->DR; 
}

void Crc32Reset(void)
{ 
    CRC->CR |= CRC_CR_RESET;
}

void Crc32Feed(unsigned int aVal)
{ 
    CRC->DR = aVal;
}

unsigned int  Crc32GetResult()
{
	return CRC->DR;
}

void usb_host_to_device(void)
{
	if(usb_is_host){
		MX_FATFS_DeInit();
		HAL_Delay(5);
		HAL_NVIC_ClearPendingIRQ(OTG_FS_IRQn);
		HAL_NVIC_DisableIRQ(OTG_FS_IRQn);
		MX_USB_HOST_DeInit();
		HAL_Delay(10);
		
		MX_USB_DEVICE_Init();
		HAL_Delay(5);
		
		usb_is_host = 0;
		
		UsbConfigSetState(0);
	}
}

void usb_device_to_host(void)
{
	if(0 == usb_is_host){
		HAL_NVIC_ClearPendingIRQ(OTG_FS_IRQn);
		HAL_NVIC_DisableIRQ(OTG_FS_IRQn);
		MX_USB_DEVICE_DeInit();
		HAL_Delay(5);
		
		UsbConfigSetState(0);
		
		__HAL_RCC_USB_OTG_FS_CLK_ENABLE();
		HAL_NVIC_ClearPendingIRQ(OTG_FS_IRQn);
		HAL_NVIC_EnableIRQ(OTG_FS_IRQn);
		
		MX_USB_HOST_Init();
		MX_FATFS_Init();
		HAL_Delay(5);
		
		usb_is_host = 1;
	}
}