/*
 * @file: 
 * @Author: Lida
 * @Date: 2023-05-09 14:16:55
 * @LastEditors: LiDa
 * @LastEditTime: 2024-01-10 14:51:35
 */
#include "svc_pulse_usart.h"
#include "../../log/svc/svc_log.h"
#include "../../com/svc/svc_com.h"
#include "../../util/util_data.h"
#include "../../factory/svc/svc_factory.h"
#include "../../ir/svc/svc_ir_protocol.h"
#include "../../timer/svc/svc_timer.h"
static S_Pulse_Uart s_pulse_uart;
static void Pulse_Uart_Quene_Init(void);

/**
 * @brief: 计量模块初始化
 * @return {void}
 * @note: 
 * @see: 
 * @param {void}
 */
void Svc_Pulse_Uart_Init(void)
{
  //Svc_Log_Printf(LOG_INFO,"%s",__FUNCTION__);
  // Bsp_Pulse_Pulse_IN_Mode();
  // Bsp_Pulse_Uart_Config(); 
  Pulse_Uart_Quene_Init();
}

/**
 * @brief: 将1byte的数据存入厂测串口接收队列
 * @return {gw_s8} 存入是否成功状态
 * @note: 
 * @see: 
 * @param {gw_s8} data 待存入数据
 */
gw_s8 Svc_Pulse_Uart_Put_Data_Quene(gw_s8 data)
{
  s_pulse_uart.time_cnt=0;      //队列计数清零
  s_pulse_uart.time_en=1;
  if(((s_pulse_uart.fornt+1)%PULSE_UART_RX_BUF_SIZE)==s_pulse_uart.rear)      //串口队列缓冲区满
  {
    s_pulse_uart.format=1;
    return 1;
  }
  s_pulse_uart.RX_BUF[s_pulse_uart.fornt]=data;
  s_pulse_uart.fornt=(s_pulse_uart.fornt+1)%PULSE_UART_RX_BUF_SIZE;
  return 0;
}

/**
 * @brief: 将厂测串口接收队列中的数据全部返回
 * @param  {gw_s8*} data 返回数据的指针
 * @return {gw_s8} 队列是否存满状态
 * @note: 
 * @see: 
 */
static gw_s8 Pulse_Uart_Out_data_Quene(gw_s8* data)
{
  if(s_pulse_uart.rear==s_pulse_uart.fornt)
  {
    return 1;
  }
  *data=s_pulse_uart.RX_BUF[s_pulse_uart.rear];
  s_pulse_uart.rear=(s_pulse_uart.rear+1)%PULSE_UART_RX_BUF_SIZE;
  return 0;
}

/**
 * @brief: 厂测串口接收队列初始化
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
static void Pulse_Uart_Quene_Init(void)
{
  s_pulse_uart.fornt=0;
  s_pulse_uart.rear=0;
  s_pulse_uart.time_cnt=0;
  s_pulse_uart.format=0;
  memset(s_pulse_uart.RX_BUF,0,sizeof(s_pulse_uart.RX_BUF));
}

/**
 * @brief: 获取当前厂测串口接收队列内的数据长度
 * @param  {void}
 * @return {gw_s16} 数据长度
 * @note: 
 * @see: 
 */
static gw_s16 Get_Buf_Length(void)
{
  if(s_pulse_uart.fornt>=s_pulse_uart.rear)
  {
    return s_pulse_uart.fornt-s_pulse_uart.rear;
  }
  else
  {
    return s_pulse_uart.fornt+PULSE_UART_RX_BUF_SIZE-s_pulse_uart.rear;
  }
}

/**
 * @brief: 从厂测串口接收队列中连续获取指定长度的数据
 * @return {gw_s16} 实际获取的数据长度
 * @note: 
 * @see: 
 * @param {gw_s8} *out_ps8Data 获取数据存放的指针
 * @param {gw_s16} buf_len 获取数据长度
 */
static gw_s16 Get_Pulse_Uart_Bytes(gw_s8 *out_ps8Data,gw_s16 buf_len)
{
  gw_s16 data_len=0;
  gw_s16 i=0;
  gw_s8* ptr=out_ps8Data;
  data_len=Get_Buf_Length();
  s_pulse_uart.time_cnt=0;
  s_pulse_uart.format=0;
  s_pulse_uart.time_en=0;

  if(data_len==0)
  {
    return 0;
  }
  for(i=0;i<data_len&&i<buf_len;i++)
  {
    Pulse_Uart_Out_data_Quene(ptr);
    ptr++;
  }

   return i;
}

/**
 * @brief: 隔1ms检查串口是否有数据
 * @param  {void}
 * @return {void}
 * @note: 需要在1ms定时器终端中调用此函数
 * @see: 
 */
void Svc_Pulse_Uart_Get_Cnt_Add(void)         //隔1ms检查串口是否有数据
{
  if(s_pulse_uart.time_en==1)           //串口有数据
  {
    s_pulse_uart.time_cnt++;
    if(s_pulse_uart.time_cnt>PULSE_UART_CNT_MAX)         //接收自动断帧
    {
      s_pulse_uart.time_cnt=0;
      s_pulse_uart.format++;
      s_pulse_uart.time_en=0;
    }
  }
}

/**
 * @brief: 是否完成自动断帧
 * @param  {void}
 * @return {gw_s8} 完成自动断帧标志 1：此帧已接收完毕，0：正在接收
 * @note: 
 * @see: 
 */
static gw_s8 Pulse_Is_Format(void)
{
  return s_pulse_uart.format;
}

/**
 * @brief: 获取电量模块相关数据结构体
 * @param  {void} 
 * @return {S_Bat} 电量模块相关数据结构体
 * @note: 
 * @see: 
 */
S_Pulse_Uart* Svc_Pulse_Get_Data(void){
    return &s_pulse_uart;
}

/**
 * @brief: 厂测串口接收线程
 * @param  {void}
 * @return {void}
 * @note: 当接收完一帧数据后执行解析操作
 * @see: 
 */
void Svc_Pulse_Uart_Recv(void){
  if(Pulse_Is_Format()>=1){
    gw_u16 recv_len=0;
    gw_u16 buf_len;
    gw_u8 *temp_buf=s_pulse_uart.RX_PULSE_DATA;
    if(temp_buf==NULL){
        return;
    }
    s_pulse_uart.temp_buf=Svc_Com_Get_Buf();
    buf_len=PULSE_UART_RX_BUF_SIZE;
    memset(s_pulse_uart.temp_buf,0,buf_len);
    memset(temp_buf,0,buf_len); 
    recv_len = Get_Pulse_Uart_Bytes((gw_s8*)s_pulse_uart.temp_buf,buf_len);
    #if LOG_FUNC_ENABLE
      if(recv_len<PULSE_UART_RX_BUF_SIZE){
          Svc_Log_Print("\r\n");
          for(int i=0;i<recv_len;i++){
              Svc_Log_Print("%02X ",s_pulse_uart.temp_buf[i]);
          }
    }
    #endif
    if((s_pulse_uart.temp_buf[0] == 0x00 &&  s_pulse_uart.temp_buf[1] == 0x68)){
      memcpy(temp_buf,&s_pulse_uart.temp_buf[1],19);//recv_len-1
      s_pulse_uart.u8PulseN_GetFlag = 1;
    }
    else if((s_pulse_uart.temp_buf[0] == 0x68)){
      memcpy(temp_buf,&s_pulse_uart.temp_buf[0],19);//recv_len
      s_pulse_uart.u8PulseN_GetFlag = 1;        
    }
    else{
        return;
    }
    Bsp_Pulse_Uart_DeInit();
  }
  if(s_pulse_uart.u8PulseN_GetFlag)
  {
    	S_Factory_Data *ps_factory;
	    ps_factory = Svc_Factory_Get_Data();   
      s_pulse_uart.u8PulseN_GetFlag = 0;
      if(ps_factory->u8FactoryTest == 1)
      {
        S_Factory_Data *ps_factory;
        ps_factory = Svc_Factory_Get_Data();
        Svc_Factory_Log_Send_Data(E_IR_Fun_WHOLE,1);
        if(ps_factory->u8PulseTestCnt != 0)
        {
          //为了产测代码执行完该指令后能够进入低功耗
          Svc_Timer_Delay_Ms(3500);
          if(Svc_Ir_Is_Busy()==E_CHECK_OK)
          {
            return;
          }
          ps_factory->u8FactoryLowp = 1;  
        }
      }
      else
      {
        Svc_Pulse_Data_Rsp(&s_pulse_uart.s_ir_pulsedata);
      }

  }  
}