#include "interface_uart.h"


#define BUFFER_SIZE 256

#define SBUS_UART UART3


UartFaultInfo uart_fault_info = {
    .remote_count = 0,
    .remote_state = 0,    
};



// 定义并初始化 SBus 解析结构体
typedef struct {
    uint16_t channels[16];  // 存储16个通道的解析结果
    uint8_t flags;          // 标志字节
} SBusData;


SBusData sbus_data = {
    .channels = {0}, 
    .flags = 0
};

///* Buffer used to receive data from the console */
typedef struct user_data {
    uint8_t user_buffer[BUFFER_SIZE];
    uint8_t *buff_ptr;
    uint32_t buff_remain;
} user_data_t;
static user_data_t user_data;
///* Buffer used to transmit welcome message */


sdrv_uart_t uart_ctrl_ptr;

/* uart config structures */    
//sbus 默认为100k  
static sdrv_uart_config_t g_uart_config = {
    .base = DEVICE_BASE(SBUS_UART),
    .irq = DEVICE_INTR(SBUS_UART),
    .baud = 100000,
    .data_bits = SDRV_UART_CHAR_8_BITS,
    .stop_bits = SDRV_UART_STOP_2_BIT,
    .parity = SDRV_UART_EVEN_PARITY,
};


// SBus 数据解析函数
SBusData* parseSBusData(const uint8_t *input_data)
{
    
      for(uint8_t i = 0; i < 25; i++)
      {         
          test_app[i] = input_data[i];
      }
      test_app[25] = 0x44;
    
    float sbus_temp = 0.0;
    // 解析16个通道的数据，每个通道为11位   0xF为帧头，不参与解析
    sbus_data.channels[0]  = (input_data[1]      | input_data[2] << 8) & 0x07FF;
    sbus_data.channels[1]  = (input_data[2] >> 3 | input_data[3] << 5) & 0x07FF;
    sbus_data.channels[2]  = (input_data[3] >> 6 | input_data[4] << 2 | input_data[5] << 10) & 0x07FF;
    sbus_data.channels[3]  = (input_data[5] >> 1 | input_data[6] << 7) & 0x07FF;
    sbus_data.channels[4]  = (input_data[6] >> 4 | input_data[7] << 4) & 0x07FF;
    sbus_data.channels[5]  = (input_data[7] >> 7 | input_data[8] << 1 | input_data[9] << 9) & 0x07FF;
    sbus_data.channels[6]  = (input_data[9] >> 2 | input_data[10] << 6) & 0x07FF;
    sbus_data.channels[7]  = (input_data[10] >> 5 | input_data[11] << 3) & 0x07FF;
    sbus_data.channels[8]  = (input_data[12]     | input_data[13] << 8) & 0x07FF;
    sbus_data.channels[9]  = (input_data[13] >> 3 | input_data[14] << 5) & 0x07FF;
    sbus_data.channels[10] = (input_data[14] >> 6 | input_data[15] << 2 | input_data[16] << 10) & 0x07FF;
    sbus_data.channels[11] = (input_data[16] >> 1 | input_data[17] << 7) & 0x07FF;
    sbus_data.channels[12] = (input_data[17] >> 4 | input_data[18] << 4) & 0x07FF;
    sbus_data.channels[13] = (input_data[18] >> 7 | input_data[19] << 1 | input_data[20] << 9) & 0x07FF;
    sbus_data.channels[14] = (input_data[20] >> 2 | input_data[21] << 6) & 0x07FF;
    sbus_data.channels[15] = (input_data[21] >> 5 | input_data[22] << 3) & 0x07FF;
    
    // 解析标志字节
    sbus_data.flags = input_data[23];

    //转弯
    sbus_temp = (float)(sbus_data.channels[0]);
    sbus_temp = (ZERO_VALUE - sbus_temp)*23;//需要变换一下符号，因为加油是正
    remote_curvature = (uint16_t)((int16_t)sbus_temp);//曲率	
    
    //转速
    sbus_temp = (float)(sbus_data.channels[1]);
    sbus_temp = (ZERO_VALUE - sbus_temp)*2.3;//需要变换一下符号，因为加油是正
    remote_speed = (uint16_t)((int16_t)sbus_temp);//转速
    
    remote_Reserve = sbus_data.channels[7];
      
    //SwA
    if(sbus_data.channels[3] >= 1700)//按下
    {
        emergency_stop = 1;
    }
    else
    {
        emergency_stop = 0;
    }
    
    //SwB
    if(sbus_data.channels[4] >= 1700)//第三档
    {
        remote_switch_b = 2;
    }
    else if(sbus_data.channels[6] <= 250)//第二档
    {
        remote_switch_b = 0;
    }
    else//第一档
    {
        remote_switch_b = 1;
    }	
    
    //SwC
    if(sbus_data.channels[5] >= 1700)//第三档
    {
        remote_switch_c = 2;
    }
    else if(sbus_data.channels[4] <= 250)//第二档
    {
        remote_switch_c = 0;
    }
    else//第一档
    {
        remote_switch_c = 1;
    }		
    
    //SwD
    if(sbus_data.channels[6] >= 1700)//按下
    {
        remote_switch_d = 1;
    }
    else
    {
        remote_switch_d = 0;
    }			
	
    if(0 == sbus_data.flags)//手柄离线故障判断  //通过标志来判断， 为0表示手柄正常连接，否则断线
    {
        remote_enable = 1;//手柄离线
    }
    else
    {
        remote_enable = 0;//手柄在线		
    }        

        ssdk_printf(SSDK_NOTICE, "sta\r\n");
    for(int i=0;i<16;i++)
    {
      ssdk_printf(SSDK_EMERG, "%04x\r\n",sbus_data.channels[i]);
    }
        ssdk_printf(SSDK_NOTICE, "end\r\n");
    return  &sbus_data;  
}


void callback(sdrv_uart_t *ctrl, sdrv_uart_callback_status_e status,
              void *userData)
{
    uint8_t char_data[25] = {0};//接收一个字节缓存
    static uint8_t cnt_sbus = 0;
    static uint8_t state = 0;
    static uint8_t receive = 0;
    static uint8_t sbus_buff[25];
    SBusData *tmp_sbus_data;   
    
//    user_data_t *user_data = (user_data_t *)userData;
    
//    ssdk_printf(SSDK_NOTICE, "123456789\r\n");

    /* Uart receive data. */
    if (SDRV_UART_RxFWF == status) 
    {          
      uart_fault_info.remote_count ++;  
      
      size_t size = sdrv_uart_get_rxfifodata(ctrl, char_data,1);    
      
//      for(uint8_t i = 0; i < 25; i++)
//      {         
//          test_app[i] = char_data[i];
//
//      }
      
//      sdrv_uart_sync_transmit(&g_console_uart, char_data,
//                        25, NULL,
//                        0Xffff);      
      
//      for(uint8_t i=0;i<25;i++)
//      {
//         ssdk_printf(SSDK_INFO,"char_data: %x \r\n", char_data[i]);
//      }
//      
      
//      for(int i=0;i<size;i++)
//      {
        switch(state)
        {
          case 0:
            if(0x0f == char_data[0])
            {
              receive = 0;
              cnt_sbus = 0;
              sbus_buff[cnt_sbus] = char_data[0];
              cnt_sbus++;
              state = 1;
            }
            else
            {
              state = 0;
            }
            break;
          case 1:
            if(cnt_sbus >= 24)
            {
      for(uint8_t i = 0; i < 25; i++)
      {         
          test_app[i] = sbus_buff[i];
      }
      test_app[25] = 0x55;                
//              ssdk_printf(SSDK_INFO,"char_data24: %x \r\n", char_data[0]);
              if(0x0 == char_data[0])
              {
                cnt_sbus = 0;
                receive = 0;
                sbus_buff[cnt_sbus] = char_data[0];
                state = 0;
                tmp_sbus_data = parseSBusData(sbus_buff);
                
//                sdrv_uart_sync_transmit(ctrl, "AA\r\n", strlen("AA\r\n"), NULL, 0xFFFF);
 
//        sdrv_uart_sync_transmit(ctrl, ( const uint8_t *)&tmp_sbus_data->channels[0],
//                                32, NULL,
//                                0Xffff);                
  //              ssdk_printf(SSDK_EMERG, "AAAr\n");
              }
            }
            else if(0x0f == char_data[0])
            {
              receive = 0;
              cnt_sbus = 0;
              sbus_buff[cnt_sbus] = char_data[0];
              cnt_sbus++;
              state = 1;
            }
            else
            {
              sbus_buff[cnt_sbus] = char_data[0];
              cnt_sbus ++;              
              state = 1;
            }
            break;
          
          default:
            break;
        }
//      }
    } 
    else if (SDRV_UART_RxFifoOverFlow == status) 
    {
//        if (0 != user_data->buff_remain) {
//            size_t size = sdrv_uart_get_rxfifodata(ctrl, user_data->user_buffer,
//                                                   user_data->buff_remain);
//        }
//        sdrv_uart_sync_transmit(ctrl, "\r\n", strlen("\r\n"), NULL, TIMES_OUT);
//        sdrv_uart_sync_transmit(ctrl, user_data->user_buffer,
//                                BUFFER_SIZE - user_data->buff_remain, NULL,
//                                TIMES_OUT);
//        sdrv_uart_sync_transmit(ctrl, "\r\n", strlen("\r\n"), NULL, TIMES_OUT);
//
//        memset(user_data->user_buffer, '\0', BUFFER_SIZE);
//        user_data->buff_ptr = user_data->user_buffer;
//        user_data->buff_remain = BUFFER_SIZE;
//
//        sdrv_uart_sync_transmit(
//            ctrl, "\r\ncallback: SDRV_UART_RxFifoOverFlow!\r\n",
//            strlen("\r\ncallback: SDRV_UART_RxFifoOverFlow!\r\n"), NULL,
//            TIMES_OUT);
//
//        /* User can stop or reset realtime receive if you want, when transfer
//         * occur errors */
//        sdrv_uart_stop_realtime_receive(ctrl);
//        sdrv_uart_start_realtime_receive(ctrl);

    } 
    else if (SDRV_UART_ParityError == status) 
    {
//        sdrv_uart_sync_transmit(
//            ctrl, "\r\ncallback: SDRV_UART_ParityError!\r\n",
//            strlen("\r\ncallback: SDRV_UART_ParityError!\r\n"), NULL,
//            TIMES_OUT);
    } 
    else if (SDRV_UART_BaudrateError == status) 
    {
//        sdrv_uart_sync_transmit(
//            ctrl, "\r\ncallback: SDRV_UART_BaudrateError!\r\n",
//            strlen("\r\ncallback: SDRV_UART_BaudrateError!\r\n"), NULL,
//            TIMES_OUT);
    } 
    else if (SDRV_UART_NoiseError == status) 
    {
//        sdrv_uart_sync_transmit(
//            ctrl, "\r\ncallback: SDRV_UART_NoiseError!\r\n",
//            strlen("\r\ncallback: SDRV_UART_NoiseError!\r\n"), NULL, TIMES_OUT);
    } 
    else if (SDRV_UART_FramingError == status)
    {
//        sdrv_uart_sync_transmit(
//            ctrl, "\r\ncallback: SDRV_UART_FramingError!\r\n",
//            strlen("\r\ncallback: SDRV_UART_FramingError!\r\n"), NULL,
//            TIMES_OUT);
    } 
    else
    {
//        ssdk_printf(SSDK_NOTICE, "234567891\r\n");
    }
}



//初始化串口
void uart_Initialize(void)
{
    /* Get uart clk Config. */
#if ((CONFIG_E3210) || (CONFIG_E3110))
    if (g_uart_config.irq <= UART8_INTR_NUM) {
        g_uart_config.clk_freq =
            sdrv_ckgen_get_rate(CLK_NODE(g_ckgen_ip_uart_sf_1_to_8));
    } else {
        g_uart_config.clk_freq =
            sdrv_ckgen_get_rate(CLK_NODE(g_ckgen_ip_uart_sf_9_to_16));
    }
#else
    if (g_uart_config.irq <= UART6_INTR_NUM) {
        g_uart_config.clk_freq =
            sdrv_ckgen_get_rate(CLK_NODE(g_ckgen_ip_uart_sf_1_to_6));
    } else {
        g_uart_config.clk_freq =
            sdrv_ckgen_get_rate(CLK_NODE(g_ckgen_ip_uart_sf_7_to_12));
    }
#endif

    /* Initializes sdrv uart controller. */

    user_data.buff_ptr = user_data.user_buffer;
    user_data.buff_remain = BUFFER_SIZE;
    
    ssdk_printf(SSDK_NOTICE, "uart3 init\r\n");
    sdrv_uart_controller_init(&uart_ctrl_ptr, &g_uart_config, callback,
                             &user_data);

    sdrv_uart_start_realtime_receive(&uart_ctrl_ptr);
    
}


void uartTimerProcess(void)
{
    static uint8_t uart_timer = 0;
    static uint8_t uart_temp[1] = {2};//中间判断值
//----------------------------------------------------------------------------    
    uart_timer ++;
    if(uart_timer >= 1)//500ms判断一次
    {
        uart_timer = 0;
        if(uart_fault_info.remote_count == uart_temp[0])//数据一样表示故障
        {                
            uart_fault_info.remote_state = FAULT;							
        }
        else
        {
            uart_fault_info.remote_state = NORMAL;	
            uart_temp[0] = uart_fault_info.remote_count;//数据更新            
        }
        
        if(uart_fault_info.remote_state != uart_temp[1])
        {
//             publishMessage(&uart_fault_info.remote_state, 1);// 状态变化 发送信号
            uart_temp[1] = uart_fault_info.remote_state;
        }          
   }  
}
    
    
    
    
    
    

//Timer uart_timer_interface;

// APP模块的初始化
void uartAppInit(void)
{
    // 初始化定时器，使用 brake_timer 的地址作为信号ID
//    timerInit(&uart_timer_interface, 100);
//    subscribe(&uart_timer_interface, uartTimerProcess);
     
//    timerStart(&uart_timer_interface);
}