#include "svc_pulse_protocol.h"
#include "../../log/svc/svc_log.h"
#include "svc_pulse.h"
#include "../../flash/svc/svc_flash.h"
#include "../../cloud/svc/svc_cloud.h"
#include "../../util/util_data.h"
#include <string.h>

static S_Pulse_Data s_pulse_data;
static S_Pulse_Data_Ack s_pulse_data_ack;

/**************************************接收数据解析******************************************/

static void Svc_Parse_Cmd_Code(uint8_t *data, uint16_t len);

static void Svc_Cmd41_Query_Device_Para(uint8_t *data, uint16_t len);
static void Svc_FUNC_01_METER_INFO(uint8_t *data);
static void Svc_FUNC_02_COMM_BAUDRATE(uint8_t *data);
static void Svc_FUNC_03_WORK_MODE(uint8_t *data);
static void Svc_FUNC_05_QUERY_RUNTIME(uint8_t *data);

static void Svc_Cmd42_Query_Measure_Para(uint8_t *data, uint16_t len);
static void Svc_FUNC_10_PIPE_PARA(uint8_t *data);
static void Svc_FUNC_11_START_FLOW_SPEED(uint8_t *data);
static void Svc_FUNC_12_ZERO_CORRECT_PARA(uint8_t *data);
static void Svc_FUNC_13_CORRECT_PARA(uint8_t *data);
static void Svc_FUNC_14_ZERO_MODE(uint8_t *data);

static void Svc_CmdC1_Query_Measure_Data(uint8_t *data, uint16_t len);
static void Svc_FUNC_20_QUERY_CURRENT_USAGE(uint8_t *data);

static void Svc_CmdC3_Proprietary_Protocol(uint8_t *data, uint16_t len);
static void Svc_FUNC_A0_DAY_HISTORICAL(uint8_t *data);
static void Svc_FUNC_A1_MONTH_HISTORICAL(uint8_t *data);

/**
 * @brief: 数据帧解析
 * @return {void}
 * @note:
 * @see:
 * @param  {gw_u8*} data 待解析数据
 * @param {gw_u16} u16Len
 */
void Svc_Pulse_Protocol_Parse(gw_u8 *data, gw_u16 len)
{
  gw_u8 u8index = 0;
  gw_u32 u32LeadCode;
  u32LeadCode = ((data[0] & 0x000000FF) << 24 | (data[1] & 0x000000FF) << 16 | (data[2] & 0x000000FF) << 8 | (data[3] & 0x000000FF));
  u8index += 4;
  if (u32LeadCode != PULSE_SLAVE_LEAD_CODE)
  {
    Svc_Log_Printf(LOG_ERROR, "%s : lead code error", __FUNCTION__);
    return;
  }
  if ((data[u8index] != PULSE_FRAME_HEAD) || (data[len - 1]) != PULSE_FRAME_TAIL)
  {
    Svc_Log_Printf(LOG_ERROR, "%s : incomplete data frame", __FUNCTION__);
    return;
  }
  u8index++;
  if (data[u8index] != PULSE_PROTOCOL_VER)
  {
    Svc_Log_Printf(LOG_ERROR, "%s : protocol version error", __FUNCTION__);
    return;
  }
  u8index++;
  if (data[u8index] != len - 7 - 2)
  {
    Svc_Log_Printf(LOG_ERROR, "%s : data len err", __FUNCTION__);
    return;
  }
  u8index++;
  uint8_t u8Sum;
  u8Sum = Util_Data_Check_Sum(&data[u8index], len - 9);
  if (u8Sum != data[len - 2])
  {
    Svc_Log_Printf(LOG_ERROR, "%s : Sum check error: Sum:(0x%04X),Cal_Sum:(0x%04X)", __FUNCTION__);
    return;
  }
  Svc_Parse_Cmd_Code(&data[u8index], len - 7);
  s_pulse_data_ack.u8ack = 0x01;
}

/**
 * @name: 根据命令码解析数据
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_Parse_Cmd_Code(uint8_t *data, uint16_t len)
{
  uint8_t cmd;
  cmd = data[0];
  memset(&s_pulse_data, 0, sizeof(S_Pulse_Data));
  s_pulse_data_ack.e_comm_result_pulse = COMM_00_PULSE_NORMAL;
  s_pulse_data_ack.e_cmd_code_pulse = (E_Cmd_Code_Pulse)cmd;
  s_pulse_data_ack.e_func_code_pulse = (E_Function_Code_Pulse)data[2];
  /*data[0]:命令码，data[1]:结果码*/
  if (data[1] != COMM_00_PULSE_NORMAL)
  {
    s_pulse_data_ack.e_comm_result_pulse = (E_Comm_Result_Pulse)data[1];
    Svc_Log_Printf(LOG_ERROR, "%s : Pulse_Comm_Result:(0x%04X)", __FUNCTION__, data[1]);
    return;
  }
  switch (cmd)
  {
  case CMD_41_QUERY_DEVICE_INFO:
    Svc_Cmd41_Query_Device_Para(&data[1], len - 1);
    break;
  case CMD_42_QUERY_MEASURE_PARA:
    Svc_Cmd42_Query_Measure_Para(&data[1], len - 1);
    break;
  case CMD_C1_QUERY_USAGE_DATA:
    Svc_CmdC1_Query_Measure_Data(&data[1], len - 1);
    break;
  case CMD_C3_PROPRIETARY_PROTOCOL:
    Svc_CmdC3_Proprietary_Protocol(&data[1], len - 1);
    break;
  default:
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    break;
  }
}

/**
 * @name: 查询设备信息
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_Cmd41_Query_Device_Para(uint8_t *data, uint16_t len)
{
  uint8_t u8FuncCode;
  u8FuncCode = data[1]; // 功能片段
  switch (u8FuncCode)
  {
  case FUNC_01_METER_INFO:
    Svc_FUNC_01_METER_INFO(&data[1]);
    break;
  case FUNC_02_COMM_BAUDRATE:
    Svc_FUNC_02_COMM_BAUDRATE(&data[1]);
    break;
  case FUNC_03_WORK_MODE:
    Svc_FUNC_03_WORK_MODE(&data[1]);
    break;
  case FUNC_05_RUN_TIME:
    Svc_FUNC_05_QUERY_RUNTIME(&data[1]);
    break;
  default:
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    break;
  }
}

/**
 * @name: 设备信息
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_01_METER_INFO(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x0D)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  memcpy(ps_pulse->s_pulse_para.pu8Pulse_Devic_Id, &data[index], 4);
  index += 4;
  memcpy(ps_pulse->s_pulse_para.pu8Pulse_Manufac_Id, &data[index], 4);
  index += 4;
  ps_pulse->s_pulse_para.u8Pulse_Devic_Type = data[index];
  index++;
  ps_pulse->s_pulse_para.u16Pulse_Sw_Ver = (((data[index] & 0x00FF) << 8) | data[index + 1] & 0x00FF);
  index += 2;
  ps_pulse->s_pulse_para.u16Pulse_Hw_Ver = (((data[index] & 0x00FF) << 8) | data[index + 1] & 0x00FF);
  index += 2;
}

/**
 * @name: 通信波特率
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_02_COMM_BAUDRATE(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x01)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  switch (data[index])
  {
  case 0xBB:
    ps_pulse->s_pulse_para.u16Baudrate = 2400;
    break;
  case 0xBC:
    ps_pulse->s_pulse_para.u16Baudrate = 4800;
    break;
  case 0xBD:
    ps_pulse->s_pulse_para.u16Baudrate = 9600;
    break;
  default:
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    break;
  }
  index++;
}

/**
 * @name: 工作模式
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_03_WORK_MODE(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x01)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  ps_pulse->s_pulse_para.ePulseMode = (E_Pulse_Mode)data[index];
  index++;
}

/**
 * @name: 设备运行时间
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_05_QUERY_RUNTIME(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  gw_u32 u32Pulse_Runtime;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x04)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  u32Pulse_Runtime = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
  index += 4;
  ps_pulse->s_pulse_para.u32Runtime = u32Pulse_Runtime;
}

/**
 * @name: 查询测量参数
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_Cmd42_Query_Measure_Para(uint8_t *data, uint16_t len)
{
  uint8_t u8FuncCode;
  u8FuncCode = data[1]; // 功能片段
  switch (u8FuncCode)
  {
  case FUNC_10_PIPE_PARA:
    Svc_FUNC_10_PIPE_PARA(&data[1]);
    break;
  case FUNC_11_START_FLOW_SPEED:
    Svc_FUNC_11_START_FLOW_SPEED(&data[1]);
    break;
  case FUNC_12_ZERO_CORRECT_PARA:
    Svc_FUNC_12_ZERO_CORRECT_PARA(&data[1]);
    break;
  case FUNC_13_CORRECT_PARA:
    Svc_FUNC_13_CORRECT_PARA(&data[1]);
    break;
  case FUNC_14_ZERO_MODE:
    Svc_FUNC_14_ZERO_MODE(&data[1]);
    break;
  default:
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    break;
  }
}

/**
 * @name: 管段参数
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_10_PIPE_PARA(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x07)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  ps_pulse->s_pulse_para.u8PipeMode = data[index];
  index++;
  ps_pulse->s_pulse_para.u16SonicLength = (((data[index] & 0x00FF) << 8) | (data[index + 1] & 0x00FF));
  index += 2;
  ps_pulse->s_pulse_para.u16ActiveSonicLength = (((data[index] & 0x00FF) << 8) | (data[index + 1] & 0x00FF));
  index += 2;
  ps_pulse->s_pulse_para.u16Diameter = (((data[index] & 0x00FF) << 8) | (data[index + 1] & 0x00FF));
  index += 2;
}

/**
 * @name: 始动流量
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_11_START_FLOW_SPEED(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x02)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  ps_pulse->s_pulse_para.u16SatrtSpeed = (((data[index] & 0x00FF) << 8) | (data[index + 1] & 0x00FF));
  index += 2;
}

/**
 * @name: 零点校准参数
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_12_ZERO_CORRECT_PARA(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x04)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  ps_pulse->s_pulse_para.u32ZeroPara = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
  index += 4;
}

/**
 * @name: 修正系数
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_13_CORRECT_PARA(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1; // 片段长度
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  index++;
  ps_pulse->s_pulse_para.u8CorrPointNum = data[index];
  index++;
  for (gw_u8 i = 0; i < ps_pulse->s_pulse_para.u8CorrPointNum; i++)
  {
    ps_pulse->s_pulse_para.s32CorrPoint[i][0] = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s_pulse_para.s32CorrPoint[i][1] = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
  }
}

/**
 * @name: 零点测试模式
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_14_ZERO_MODE(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  if (data[index] != 0x04)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  if (data[index] == 0x00) // 退出零点测试模式
  {
    ps_pulse->s_pulse_para.u8ZeroModeEn = 0;
    ps_pulse->s_pulse_para.u32ZeroPara = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
  }
  else if (data[index] == 0x01)
  {
    ps_pulse->s_pulse_para.u8ZeroModeEn = 1;
  }
}

/**
 * @name: 读取计量数据
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_CmdC1_Query_Measure_Data(uint8_t *data, uint16_t len)
{
  uint8_t u8FuncCode;
  u8FuncCode = data[1];
  switch (u8FuncCode)
  {
  case FUNC_20_QUERY_CURRENT_USAGE:
    Svc_FUNC_20_QUERY_CURRENT_USAGE(&data[1]);
    break;
  case FUNC_2A_CLEAR_CORRECT_DATA:
    break;
  case FUNC_2C_CLEAR_ALL_DATA:
    break;
  default:
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    break;
  }
}

/**
 * @name: 用量信息
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_20_QUERY_CURRENT_USAGE(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  E_Pulse_Mode eWorkMode;
  S_Flash_Data *ps_flash_data;
  ps_flash_data = Svc_Flash_Get_Data();
  if (data[index] < 0x08)
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    return;
  }
  index++;
  eWorkMode = (E_Pulse_Mode)data[index];
  index++;
  ps_pulse->s_pulse_para.ePulseMode = eWorkMode;

  /*同步工作模式*/
  if (eWorkMode == E_Pulse_Mode_Calibra)
  {
    ps_flash_data->s_other.e_work_mode = E_Mode_Calibration;
  }
  else if (eWorkMode == E_Pulse_Mode_Calibra)
  {
    ps_flash_data->s_other.e_work_mode = E_Pulse_Mode_Sleep;
  }

  float ftemp;
  switch (eWorkMode)
  {
  case E_Pulse_Mode_Normal: // 正常测量模式
    ps_pulse->u32Usage = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s32Usage_mL = ps_pulse->u32Usage * 1000;
    ps_pulse->s32Flow = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s32Flow_mL = ps_pulse->s32Flow * 1000;
    break;
  case E_Pulse_Mode_Usage: // 累计流量模式
    ps_pulse->s32Usage_mL = (gw_s32)((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ftemp = (float)ps_pulse->s32Usage_mL;
    ps_pulse->u32Usage = Util_Data_Round(ftemp / 1000);
    ps_pulse->s32Flow_mL = (gw_s32)((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ftemp = (float)ps_pulse->s32Flow_mL;
    ps_pulse->s32Flow = Util_Data_Round(ftemp / 1000);
    break;
  case E_Pulse_Mode_Calculte: // 流量计算模式
    ps_pulse->u32Usage = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s32Usage_mL = ps_pulse->u32Usage * 1000;
    ps_pulse->u32UsageRe = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s32Flow = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s32Flow_mL = ps_pulse->s32Flow * 1000;
    break;
  case E_Pulse_Mode_Calibra: // 流量校准模式
    ps_pulse->s32CalibraUsage = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s32Flow_mL = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    ps_pulse->s32TimeDiffC = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
    break;
  default:
    s_pulse_data_ack.e_comm_result_pulse = COMM_01_PULSE_ERROR_PARA;
    Svc_Log_Printf(LOG_ERROR, "This mode should not return usage information!");
    break;
  }
  ps_pulse->s16WaterTemp = (((data[index] & 0x00FF) << 8) | (data[index + 1] & 0xFF));
  index += 2;
  ps_pulse->u8PulseAlarm = data[index];
  index++;
  if (ps_pulse->s32Flow_mL > 0)
    ps_pulse->s8FlowDir = 1;
  else if (ps_pulse->s32Flow_mL < 0)
    ps_pulse->s8FlowDir = -1;
  else
    ps_pulse->s8FlowDir = 0;
}

/**
 * @name: 查询历史数据
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_CmdC3_Proprietary_Protocol(uint8_t *data, uint16_t len)
{
  uint8_t u8FuncCode;
  u8FuncCode = data[1];
  switch (u8FuncCode)
  {
  case FUNC_A0_DAY_HISTORICAL:
    Svc_FUNC_A0_DAY_HISTORICAL(&data[1]);
    break;
  case FUNC_A1_MONTH_HISTORICAL:
    Svc_FUNC_A1_MONTH_HISTORICAL(&data[1]);
    break;
  case FUNC_A2_CLOSE_SERIAL_PORT:
    break;
  default:
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    break;
  }
}

/**
 * @name: 查询100日内的日流量数据
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_A0_DAY_HISTORICAL(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1; // 片段长度
  index++;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  memcpy(ps_pulse->s_pulse_para.s_pulse_day_history.pu8Query_StartDay, &data[index], 3);
  index += 3;
  ps_pulse->s_pulse_para.s_pulse_day_history.u8Query_DayNum = data[index];
  index++;
  if (strlen((const char *)data) < 1 + 1 + 3 + 1 + ps_pulse->s_pulse_para.s_pulse_day_history.u8Query_DayNum) // 功能码+片段长度+起始日+查询天数+日流量数据
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    Svc_Log_Printf(LOG_ERROR, "query day num wrong!");
    return;
  }
  for (gw_u8 i = 0; i < ps_pulse->s_pulse_para.s_pulse_day_history.u8Query_DayNum; i++)
  {
    ps_pulse->s_pulse_para.s_pulse_day_history.pu8Day_Usage[i] = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
  }
}

/**
 * @name: 查询 60个月内月流量数据
 * @param {gw_u8*} data
 * @param {gw_u16} len
 * @return {*}
 * @note:
 */
static void Svc_FUNC_A1_MONTH_HISTORICAL(uint8_t *data)
{
  /*data[0]:功能片段*/
  gw_u8 index = 1; // 片段长度
  index++;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  memcpy(ps_pulse->s_pulse_para.s_pulse_month_history.pu8Query_StartMonth, &data[index], 2);
  index += 3;
  ps_pulse->s_pulse_para.s_pulse_month_history.u8Query_MonthNum = data[index];
  index++;
  if (strlen((const char *)data) < 1 + 1 + 2 + 1 + ps_pulse->s_pulse_para.s_pulse_month_history.u8Query_MonthNum) // 功能码+片段长度+起始月+查询月数+月流量数据
  {
    s_pulse_data_ack.e_comm_result_pulse = COMM_FF_PULSE_ERROR_SYS;
    Svc_Log_Printf(LOG_ERROR, "query numth num wrong!");
    return;
  }
  for (gw_u8 i = 0; i < ps_pulse->s_pulse_para.s_pulse_month_history.u8Query_MonthNum; i++)
  {
    ps_pulse->s_pulse_para.s_pulse_month_history.puMonth_Usage[i] = ((data[index] & 0x000000FF) << 24 | (data[index + 1] & 0x000000FF) << 16 | (data[index + 2] & 0x000000FF) << 8 | (data[index + 3] & 0x000000FF));
    index += 4;
  }
}

S_Pulse_Data_Ack *Svc_Get_Pulse_Protocol_Ack(void)
{
  return &s_pulse_data_ack;
}

/***********************************************************************命令发送*******************************************************************************/

static E_Result_State Svc_Creat_Pulse_Frame(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Head_Field(S_Pulse_Data *s_pulse_data);
static E_Result_State Svc_Creat_Data_Field(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_User_Data(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func02_COMM_BAUDRATE(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func03_WORK_MODE(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func04_CORRECT_TIME(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func10_PIPE_PARA(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func11_START_FLOW_SPEED(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func12_ZERO_CORRECT_PARA(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func13_CORRECT_PARA(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func14_ZERO_MODE(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_Func15_SET_USAGE(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_FuncA0_DAY_HISTORICAL(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_FuncA1_MONTH_HISTORICAL(S_Pulse_Data *s_pulse_data);
static void Svc_Creat_FuncA2_CLOSE_SERIAL_PORT(S_Pulse_Data *s_pulse_data);
/**
 * @brief: 发送数据帧
 * @param:{E_Cmd_Code_Pulse}Cmd_Code命令码，{E_Function_Code_Pulse}Function_code片段码
 * @return {void}
 * @note:
 * @see:
 */
void Svc_Pulse_Protocol_Send_Cmd(E_Cmd_Code_Pulse e_cmd_code, E_Function_Code_Pulse e_func_code)
{
  s_pulse_data.e_cmd_code_pulse = e_cmd_code;
  s_pulse_data.e_func_code_pulse = e_func_code;
  if (Svc_Creat_Pulse_Frame(&s_pulse_data) == E_STATE_SUCCESS)
  {
    Svc_Pulse_Uart_Send((gw_s8 *)s_pulse_data.pu8Buff, s_pulse_data.u16BuffLen);
    //    Svc_Log_Printf(LOG_INFO, "Pulse Send: ");
    //    gw_u16 i = 0;
    //    for (i = 0; i < s_pulse_data.u16BuffLen; i++)
    //    {
    //      Svc_Log_Print("%02X ", s_pulse_data.pu8Buff[i]);
    //    }
    //    Svc_Log_Print("\r\n");
  }
}

/**
 * @brief: 生成整个数据帧
 * @param：
 * @return {void}
 * @note:
 * @see:
 */
static E_Result_State Svc_Creat_Pulse_Frame(S_Pulse_Data *s_pulse_data)
{
  memset(&s_pulse_data->pu8Buff, 0, sizeof(s_pulse_data->pu8Buff));

  Svc_Creat_Head_Field(s_pulse_data);
  if (Svc_Creat_Data_Field(s_pulse_data) == E_STATE_ERROR)
  {
    return E_STATE_ERROR;
  }
  return E_STATE_SUCCESS;
}

/**
 * @brief: 生成数据帧帧头部分
 * @param：
 * @return {void}
 * @note: 引导码、帧头、版本号、数据长度、产品序列号
 * @see:
 */
static void Svc_Creat_Head_Field(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = 0;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  buff[index] = (PULSE_MAIN_LEAD_CODE & 0xFF000000) >> 24;
  buff[index + 1] = (PULSE_MAIN_LEAD_CODE & 0x00FF0000) >> 16;
  buff[index + 2] = (PULSE_MAIN_LEAD_CODE & 0x0000FF00) >> 8;
  buff[index + 3] = PULSE_MAIN_LEAD_CODE & 0x000000FF; // 引导码
  index = index + 4;
  buff[index] = PULSE_FRAME_HEAD;       // 帧头
  buff[index + 1] = PULSE_PROTOCOL_VER; // 协议版本号
  index = index + 2;
  s_pulse_data->s_data_index.u16DataLenIndex = index; // 记录数据长度所在位置
  index = index + 1;                                  // 数据长度

  s_pulse_data->s_data_index.u16DataFieldIndex = index; // 数据域起始位置
  s_pulse_data->u16BuffLen = index;                     // 即当前数据帧长度
}

/**
 * @brief: 生成数据域部分
 * @param：
 * @return {void}
 * @note: 命令码、功能片段、校验和、帧尾
 * @see:
 */
static E_Result_State Svc_Creat_Data_Field(S_Pulse_Data *s_pulse_data)
{
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u16 index = s_pulse_data->s_data_index.u16DataFieldIndex; // 数据域起始位置
  buff[index] = s_pulse_data->e_cmd_code_pulse;                // 命令码
  index++;
  s_pulse_data->u16BuffLen = index; // 记录目前数据帧长度
  if ((s_pulse_data->e_cmd_code_pulse == CMD_41_QUERY_DEVICE_INFO) || (s_pulse_data->e_cmd_code_pulse == CMD_42_QUERY_MEASURE_PARA) || (s_pulse_data->e_cmd_code_pulse == CMD_C1_QUERY_USAGE_DATA))
  {                                                // 不需要带数据，直接发送
    buff[index] = s_pulse_data->e_func_code_pulse; // 功能码
    index = index + 1;
    s_pulse_data->u16BuffLen = index;
  }
  else if ((s_pulse_data->e_cmd_code_pulse == CMD_81_SET_DEVICE_INFO) || (s_pulse_data->e_cmd_code_pulse == CMD_82_SET_MEASURE_PARA) || (s_pulse_data->e_cmd_code_pulse == CMD_C3_PROPRIETARY_PROTOCOL))
  { // 需要带数据发送
    Svc_Creat_User_Data(s_pulse_data);
  }
  gw_u16 u16Sumlen = s_pulse_data->u16BuffLen - s_pulse_data->s_data_index.u16DataFieldIndex; // 需要校验的数据为数据域，校验之前的长度-数据域之前的长度
  buff[s_pulse_data->s_data_index.u16DataLenIndex] = u16Sumlen;
  s_pulse_data->u8Sum_Check = Util_Data_Check_Sum(&s_pulse_data->pu8Buff[s_pulse_data->s_data_index.u16DataFieldIndex], u16Sumlen);
  buff[index] = s_pulse_data->u8Sum_Check;
  index++;
  buff[index] = PULSE_FRAME_TAIL;
  index++;
  s_pulse_data->u16BuffLen = index;
  return E_STATE_SUCCESS;
}

/**
 * @brief: 根据功能码生成功能片段
 * @param
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_User_Data(S_Pulse_Data *s_pulse_data)
{
  E_Function_Code_Pulse function_code;
  function_code = s_pulse_data->e_func_code_pulse;
  switch (function_code)
  {
  case FUNC_02_COMM_BAUDRATE:
    Svc_Creat_Func02_COMM_BAUDRATE(s_pulse_data);
    break;
  case FUNC_03_WORK_MODE:
    Svc_Creat_Func03_WORK_MODE(s_pulse_data);
    break;
  case FUNC_04_CORRECT_TIME:
    Svc_Creat_Func04_CORRECT_TIME(s_pulse_data);
    break;
  case FUNC_10_PIPE_PARA:
    Svc_Creat_Func10_PIPE_PARA(s_pulse_data);
    break;
  case FUNC_11_START_FLOW_SPEED:
    Svc_Creat_Func11_START_FLOW_SPEED(s_pulse_data);
    break;
  case FUNC_12_ZERO_CORRECT_PARA:
    Svc_Creat_Func12_ZERO_CORRECT_PARA(s_pulse_data);
    break;
  case FUNC_13_CORRECT_PARA:
    Svc_Creat_Func13_CORRECT_PARA(s_pulse_data);
    break;
  case FUNC_14_ZERO_MODE:
    Svc_Creat_Func14_ZERO_MODE(s_pulse_data);
    break;
  case FUNC_15_SET_USAGE:
    Svc_Creat_Func15_SET_USAGE(s_pulse_data);
    break;
  case FUNC_A0_DAY_HISTORICAL:
    Svc_Creat_FuncA0_DAY_HISTORICAL(s_pulse_data);
    break;
  case FUNC_A1_MONTH_HISTORICAL:
    Svc_Creat_FuncA1_MONTH_HISTORICAL(s_pulse_data);
    break;
  case FUNC_A2_CLOSE_SERIAL_PORT:
    Svc_Creat_FuncA2_CLOSE_SERIAL_PORT(s_pulse_data);
    break;
  default:
    break;
  }
}

/**
 * @brief: 生成功能片段02-通信波特率设置
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func02_COMM_BAUDRATE(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen; // 起始长度为前面记录的总长
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_02_COMM_BAUDRATE; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  // 波特率
  switch (ps_pulse->s_pulse_para.u16Baudrate)
  {
  case 9600:
    buff[index] = 0xBD;
    break;
  case 4800:
    buff[index] = 0xBC;
    break;
  case 2400:
    buff[index] = 0xBB;
    break;
  default:
    break;
  }
  index = index + 1;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段03-工作模式设置
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func03_WORK_MODE(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_03_WORK_MODE; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  // 工作模式
  buff[index] = ps_pulse->s_pulse_para.ePulseMode;
  index = index + 1;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段04-时间校准
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func04_CORRECT_TIME(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Cloud *ps_cloud;
  ps_cloud = Svc_Cloud_Get_Data();

  buff[index] = FUNC_04_CORRECT_TIME; // 功能片段码
  index++;
  u8LenIndex = index; // 记录片段长度位置
  index++;
  memcpy(&buff[u8LenIndex], ps_cloud->s_manage.pu8CurTime, 6);
  index = index + 6;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段10-管段参数设置
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func10_PIPE_PARA(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_10_PIPE_PARA; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  // 管段代码
  buff[index] = ps_pulse->s_pulse_para.u8PipeMode;
  index = index + 1;
  if (ps_pulse->s_pulse_para.u8PipeMode == 0xFF)
  {
    // 声路总长
    buff[index] = (ps_pulse->s_pulse_para.u16SonicLength & 0xFF00) >> 8;
    buff[index + 1] = ps_pulse->s_pulse_para.u16SonicLength & 0x00FF;
    index = index + 2;
    // 有效声路长度
    buff[index] = (ps_pulse->s_pulse_para.u16ActiveSonicLength & 0xFF00) >> 8;
    buff[index + 1] = ps_pulse->s_pulse_para.u16ActiveSonicLength & 0x00FF;
    index = index + 2;
    // 有效内径
    buff[index] = (ps_pulse->s_pulse_para.u16Diameter & 0xFF00) >> 8;
    buff[index + 1] = ps_pulse->s_pulse_para.u16Diameter & 0x00FF;
    index = index + 2;
  }
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段11-始动流速设置
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func11_START_FLOW_SPEED(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_11_START_FLOW_SPEED; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  // 始动流速
  buff[index] = (ps_pulse->s_pulse_para.u16SatrtSpeed & 0xFF00) >> 8;
  buff[index + 1] = ps_pulse->s_pulse_para.u16SatrtSpeed & 0x00FF;
  index = index + 2;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段12-零点校准参数
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func12_ZERO_CORRECT_PARA(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_12_ZERO_CORRECT_PARA; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  // 零点参数
  buff[index] = (ps_pulse->s_pulse_para.u32ZeroPara & 0xFF000000) >> 24;
  buff[index + 1] = (ps_pulse->s_pulse_para.u32ZeroPara & 0x00FF0000) >> 16;
  buff[index + 2] = (ps_pulse->s_pulse_para.u32ZeroPara & 0x0000FF00) >> 8;
  buff[index + 3] = ps_pulse->s_pulse_para.u32ZeroPara & 0x000000FF;
  index = index + 4;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段13-修正系数设置
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func13_CORRECT_PARA(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_13_CORRECT_PARA; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  /*流量点个数*/
  buff[index] = ps_pulse->s_pulse_para.u8CorrPointNum;
  index++;
  /*修正系数*/
  for (gw_u8 i = 0; i < ps_pulse->s_pulse_para.u8CorrPointNum; i++)
  {
    buff[index] = (ps_pulse->s_pulse_para.s32CorrPoint[i][0] & 0xFF000000) >> 24;
    buff[index + 1] = (ps_pulse->s_pulse_para.s32CorrPoint[i][0] & 0x00FF0000) >> 16;
    buff[index + 2] = (ps_pulse->s_pulse_para.s32CorrPoint[i][0] & 0x0000FF00) >> 8;
    buff[index + 3] = ps_pulse->s_pulse_para.s32CorrPoint[i][0] & 0x000000FF;
    index += 4;
    buff[index] = (ps_pulse->s_pulse_para.s32CorrPoint[i][1] & 0xFF000000) >> 24;
    buff[index + 1] = (ps_pulse->s_pulse_para.s32CorrPoint[i][1] & 0x00FF0000) >> 16;
    buff[index + 2] = (ps_pulse->s_pulse_para.s32CorrPoint[i][1] & 0x0000FF00) >> 8;
    buff[index + 3] = ps_pulse->s_pulse_para.s32CorrPoint[i][1] & 0x000000FF;
    index += 4;
  }
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段14-零点测试模式
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func14_ZERO_MODE(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_14_ZERO_MODE; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  buff[index] = ps_pulse->s_pulse_para.u8ZeroModeEn;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段15-设置累积量
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_Func15_SET_USAGE(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_15_SET_USAGE; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  buff[index] = (ps_pulse->u32BaseUsage & 0xFF000000) >> 24;
  buff[index + 1] = (ps_pulse->u32BaseUsage & 0x00FF0000) >> 16;
  buff[index + 2] = (ps_pulse->u32BaseUsage & 0x0000FF00) >> 8;
  buff[index + 3] = ps_pulse->u32BaseUsage & 0x000000FF;
  index += 4;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段A0-查询100日内的日流量数据
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_FuncA0_DAY_HISTORICAL(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_A0_DAY_HISTORICAL; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  memcpy(&buff[index], ps_pulse->s_pulse_para.s_pulse_day_history.pu8Query_StartDay, 3);
  index += 3;
  buff[index] = ps_pulse->s_pulse_para.s_pulse_day_history.u8Query_DayNum;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段A1-查询 60个月内月流量数据
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_FuncA1_MONTH_HISTORICAL(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_A1_MONTH_HISTORICAL; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  memcpy(&buff[index], ps_pulse->s_pulse_para.s_pulse_month_history.pu8Query_StartMonth, 2);
  index += 2;
  buff[index] = ps_pulse->s_pulse_para.s_pulse_month_history.u8Query_MonthNum;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}

/**
 * @brief: 生成功能片段A2-开启/关闭调试串口
 * @param:
 * @return {void}
 * @note:
 * @see:
 */
static void Svc_Creat_FuncA2_CLOSE_SERIAL_PORT(S_Pulse_Data *s_pulse_data)
{
  gw_u16 index = s_pulse_data->u16BuffLen;
  gw_u8 *buff = s_pulse_data->pu8Buff;
  gw_u8 u8LenIndex = 0;
  gw_u16 u16Len = 0;
  S_Pulse *ps_pulse;
  ps_pulse = Svc_Pulse_Get_Data();
  buff[index] = FUNC_A2_CLOSE_SERIAL_PORT; // 功能片段码
  index = index + 1;
  u8LenIndex = index; // 记录片段长度位置
  index = index + 1;
  buff[index] = ps_pulse->s_pulse_para.u8DebugEn;
  index++;
  u16Len = index - u8LenIndex - 1;
  buff[u8LenIndex] = u16Len;
  s_pulse_data->u16BuffLen = index;
}