motor_ctl-1/3.BasicFunction/Source/usart.c

/**
  ******************************************************************************
  * @file    uart.c
  * @author  
  * @version V1.0.0
  * @date    23-12-2015
  * @brief  usart function.
  ******************************************************************************
  *
  * COPYRIGHT(c) 2015 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* Includes ------------------------------------------------------------------*/
#include "usart.h"
#include "can.h"
#include "string.h"
#include "canAppl.h"
#include "CodePara.h"
#include "flash_master.h"
#include "i2c_master.h"
#include "power.h"
#include "torquesensor.h"
#include "FuncLayerAPI.h"
#include "MosResCalib.h"
#include "syspar.h"
#include "uart_Lidian2.h"
#include "uart_gainianzhihui.h"
#include "ti_msp_dl_config.h"
#include "uart_bafang.h"
#include "uart_lanfeng.h"
#include "uart_lanfeng9.h"
#include "uart_J.h"
#include "hwsetup.h"
#include "UserGpio_Config.h"
#include "FuncLayerAPI.h"
//#include "api.h"
//#include "board_config.h"
/* Private variables ---------------接收缓存区------------------------------------------*/

UBYTE UART_RxBuff_OBC[UART_BUFF_SIZE];
 USART_Buf_TypeDef UART_RxBuff_Struct_OBC = {UART_BUFF_SIZE,0,0,0,0,UART_RxBuff_OBC,0,0};
UBYTE UART_TxBuff_OBC[UART_BUFF_SIZE];
 USART_Buf_TypeDef UART_TxBuff_Struct_OBC = {UART_BUFF_SIZE,0,0,0,0,UART_TxBuff_OBC,0,0};

UBYTE UART_RxBuff_BMS[UART_BUFF_SIZE];
USART_Buf_TypeDef UART_RxBuff_Struct_BMS = {UART_BUFF_SIZE,0,0,0,0,UART_RxBuff_BMS,0,0};
UBYTE UART_TxBuff_BMS[UART_BUFF_SIZE];
USART_Buf_TypeDef UART_TxBuff_Struct_BMS = {UART_BUFF_SIZE,0,0,0,0,UART_TxBuff_BMS,0,0};
USART_FrameBuf_TypeDef stUSART_FrameBuf_OBC;
USART_FrameBuf_TypeDef stUSART_FrameBuf_BMS;

OBC_RunInfo_Struct_t stOBC_RunInfo;
OBC_SetInfo_Struct_t stOBC_SetInfo;
MC2OBC_RunInfo_Struct_t stMC2OBC_RRunInfo;

UBYTE ucUartAnalyseID = 0;
UBYTE ucCommType = 0;//0-Both,1-CAN,2-UART
/* Private variables ---------------------------------------------------------*/
const UBYTE ucOBC_password[64]=
{137,159,134,249,88,11,250,61,33,150,3,193,118,141,209,94,
226,68,146,158,145,127,216,62,116,230,101,211,251,54,229,247,
20,222,59,63,35,252,142,238,23,197,84,77,147,173,210,57,
142,223,157,97,36,160,229,237,75,80,37,113,154,88,23,120};

/* Private function prototypes -----------------------------------------------*/
// CAN数据解任务，定时执行
void UsartRx_Process(USART_Buf_TypeDef *USARTx_RxBuf_Struct, USART_Buf_TypeDef *USARTx_TxBuf_Struct, USART_FrameBuf_TypeDef *USART_RxFrameBuf_Struct)
{ 
    if((USARTx_RxBuf_Struct->ul_UartComTimeOutCount > FRAMETIMEOUT_Count) && (USART_RxFrameBuf_Struct->uwDataCount[USART_RxFrameBuf_Struct->ucBufWrIndex] > 0))
    {
     //   usart_interrupt_enable(USARTx_RxBuf_Struct->usart_periph, USART_RDBF_INT, FALSE);
        DL_UART_Main_disableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
        //(*USART_FrameBuf_Struct).uartframebuf[(*USART_FrameBuf_Struct).ucBufWrIndex].uwDataCount = 0;
        USART_RxFrameBuf_Struct->ucBufWrIndex++;
        if(USART_RxFrameBuf_Struct->ucBufWrIndex >= FRAME_SIZE)
        {
            USART_RxFrameBuf_Struct->ucBufWrIndex = 0;
        }
        
      //  usart_interrupt_enable(USARTx_RxBuf_Struct->usart_periph, USART_RDBF_INT, TRUE);
        DL_UART_Main_enableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
        USART_RxFrameBuf_Struct->uwFramecount++;
        USARTx_RxBuf_Struct->ul_UartComTimeOutCount = 0;
    }
    
    if(USART_RxFrameBuf_Struct->uwFramecount > 0)
    {
        UBYTE data[255];
        UBYTE datacount;

        datacount = USART_RxFrameBuf_Struct->uwDataCount[USART_RxFrameBuf_Struct->ucBufRdIndex];
        for(int i=0;i<datacount;i++)
        {
            data[i] = UART_ReadChar(USARTx_RxBuf_Struct,i);
        }
        UART_DelChar(USARTx_RxBuf_Struct,datacount);
        //UART_PutChar(&UART_TxBuff_Struct_OBC,datacount);
        /*解析1*/
        KM5S_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
        /*解析2*/
        Lidian2_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
        GNZH_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
#if (UART_ID == 3)
        Bafang_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
#endif
        Lanfeng_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
        J_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
        Lanfeng9_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
        TORG4BB_USART_RxData_Process(USARTx_TxBuf_Struct, data, datacount);
        /*clear*/
        if(USARTx_RxBuf_Struct->ucBufRdInde!=USARTx_RxBuf_Struct->ucBufWrInde)
        USARTx_RxBuf_Struct->ucBufRdInde=USARTx_RxBuf_Struct->ucBufWrInde;

        USART_RxFrameBuf_Struct->uwDataCount[USART_RxFrameBuf_Struct->ucBufRdIndex] = 0;
        USART_RxFrameBuf_Struct->uwFramecount--;
        USART_RxFrameBuf_Struct->ucBufRdIndex++;
        if(USART_RxFrameBuf_Struct->ucBufRdIndex>=FRAME_SIZE)
        {
            USART_RxFrameBuf_Struct->ucBufRdIndex = 0;
        }
    }
}

void KM5S_USART_RxData_Process(USART_Buf_TypeDef* ptUartTx, UBYTE* buf, UWORD dataCount)
{
    UBYTE Mode, DataLength, Addr;
    static UBYTE Data[255];
    //UWORD Cmd, ID;
    UWORD i;
    UWORD CheckSumResult=0, CheckSumData=0;
    UBYTE FrameBegin, FrameEnd1, FrameEnd2;
	
    if(dataCount >= 8)
    {
        //帧头
        FrameBegin = buf[0];

        if(FrameBegin == UARTFRAME_BEGIN)
        {
            //地址
            Addr = buf[1];

            //if(Addr == UARTID_MC_TO_CDL)
            {
                 //模式
                Mode = buf[2];
                
                //if((Mode == UARTMODE_READ) || (Mode == UARTMODE_WRITE) || (Mode == UARTMODE_REPORT))
                {
                    //长度
                    DataLength = buf[3];
                    
                    if(dataCount == (DataLength + 8))
                    {           
                        for(i=0; i<(DataLength+4); i++)//数据
                        {
                            Data[i] = buf[i];
                        }
                        CheckSumData = (UWORD)(buf[4 + DataLength] + (buf[5 + DataLength] << 8));
                        for(i = 1; i<(DataLength+4); i++)
                        {
                            CheckSumResult = (UWORD)(Data[i] + CheckSumResult);
                        }
                        
                        FrameEnd1 = buf[6 + DataLength];
                        FrameEnd2 = buf[7 + DataLength];

                        if((CheckSumData == CheckSumResult) && (FrameEnd1 == UARTFRAME_END1) && (FrameEnd2 == UARTFRAME_END2))// 校验和帧尾正常
                        {                          
                            KM5S_USART_DataProcess(ptUartTx, Addr, Mode, DataLength, &Data[0]);
                        }
                    }
                }
            }
        }
    }
}
void KM5S_MingruiTxErrorCodeUpdata(void)
{
#if(MINGRUI_ENABLE == 1)
    if(1 == MC_ErrorCode.ERROR_Bit.Protect_OverVoltage)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x26;//过压保护
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Protect_UnderVoltage)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x11;//欠压保护
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Protect_LockRotor)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x29;//电机堵转保护
    }
    else if((1 == MC_ErrorCode.ERROR_Bit.Protect_OverTemp) || (1 == MC_ErrorCode.ERROR_Bit.Protect_MotorOverTemp))
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x13;//控制器或电机过温
    }
    /*else if(0)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x17;//飞车保护
    }*/
    else if(1 == MC_ErrorCode.ERROR_Bit.Fault_CadenceSensor)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x18;//踏频传感器故障
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Fault_BikeSpdSensor)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x19;//电机测速传感器故障
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Protect_OverCurrent)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x21;//控制器过流
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Fault_Throttle)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x22;//转把故障
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Fault_HallSensor)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x24;//电机霍尔故障
    }
    else if(1 == alm_unBikeCode.bit.Brake)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x25;//刹车异常
    }
    else
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x00;
    }
#endif
}
void KM5S_MingruiRxGearStUpdata(void)
{
#if(MINGRUI_ENABLE == 1)
    if(stOBC_RunInfo.ucWalk == 1)
    {
        MC_ControlCode.GearSt = MC_GearSt_WALK;
    }
    else if(stOBC_RunInfo.ucPWM == 0x11)
    {
        MC_ControlCode.GearSt = MC_GearSt_Torque_ECO;
    }
    else if(stOBC_RunInfo.ucPWM == 0x22)
    {
        MC_ControlCode.GearSt = MC_GearSt_Torque_NORM;
    }
    else if(stOBC_RunInfo.ucPWM == 0x33)
    {
        MC_ControlCode.GearSt = MC_GearSt_Torque_SPORT;
    }
    else if(stOBC_RunInfo.ucPWM == 0x44)
    {
        MC_ControlCode.GearSt = MC_GearSt_Torque_TURBO;
    }
    else if(stOBC_RunInfo.ucPWM == 0x55)
    {
        MC_ControlCode.GearSt = MC_GearSt_SMART;
    }
    else
    {
        MC_ControlCode.GearSt = MC_GearSt_OFF;
    }
#endif
}
void KM5S_USART_DataProcess(USART_Buf_TypeDef* ptUartTx, UWORD Addr, UBYTE Mode, UBYTE Length, UBYTE* Data)
{
    UWORD uwCmd,uwID;
    if(Addr == UARTADDR_CDL)
    {
        if((Mode == UARTMODE_READ) || (Mode == UARTMODE_WRITE) || (Mode == UARTMODE_REPORT))
        {
            if(Length >= 4)
            {
                uwID = (UWORD)((Data[4]<<8) + Data[5]);
                uwCmd = (UWORD)((Data[6]<<8) + Data[7]);
                ucCommType = 2;
                DataProcess(ptUartTx, uwID, Mode, uwCmd, &Data[8]);
            }
        }
    }
    else if(Addr == UARTADDR_OBC)
    {
        if((Mode == 0x52) && (Length == 0x02))              //运行信息
        {
            /*数据获取*/
            stOBC_RunInfo.ucPWM = Data[4];
            stOBC_RunInfo.ucLightSwitch = ((Data[5] & 0x80)>>7);//大灯
            stOBC_RunInfo.ucLowPower = ((Data[5] & 0x20)>>5);//电池容量低
            stOBC_RunInfo.ucWalk = ((Data[5] & 0x10)>>4);//6km/h 推行功能
            stOBC_RunInfo.ucCruise = ((Data[5] & 0x04)>>2);//巡航
            stOBC_RunInfo.ucOverSpeed = (Data[5] & 0x01);//超速
            
            /*数据更新*/
            if(stOBC_RunInfo.ucWalk == 1)
              {
                  MC_ControlCode.GearSt = MC_GearSt_WALK;
              }
            else if(stOBC_RunInfo.ucPWM == 0)                 //1-255
              {
                  MC_ControlCode.GearSt = MC_GearSt_OFF;
              }
            else if(stOBC_RunInfo.ucPWM <= 76)                 //1-255
              {
                  MC_ControlCode.GearSt = MC_GearSt_Torque_ECO;
              }
            else if(stOBC_RunInfo.ucPWM <= 127)                 //1-255
              {
                  MC_ControlCode.GearSt = MC_GearSt_Torque_NORM;
              }
            else if(stOBC_RunInfo.ucPWM <= 178)                 //1-255
              {
                  MC_ControlCode.GearSt = MC_GearSt_Torque_SPORT;
              }
            else if(stOBC_RunInfo.ucPWM <= 204)                 //1-255
              {
                  MC_ControlCode.GearSt = MC_GearSt_Torque_TURBO;
              }
            else
            {
                  MC_ControlCode.GearSt = MC_GearSt_SMART;
            }

            KM5S_MingruiRxGearStUpdata();

            if(stOBC_RunInfo.ucLightSwitch == 1)                           //大灯
            {
                MC_ControlCode.LightSwitch = MC_LightSwitch_ON;
            }
            else
            {
                MC_ControlCode.LightSwitch = MC_LightSwitch_OFF;
            }         
            
            MC_RunInfo.GearSt = MC_ControlCode.GearSt;           //当前助力档位更新
            MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch; //大灯状态更新
            KM5S_SendData_OBC(ptUartTx, Mode, 0x05, 0x00);
            ulOBC_ComTimeOutCount = cp_ulSystickCnt;
        }
        else if((Mode == 0x53) && (Length == 0x07))         //参数设置
        {
            KM5S_OBCSetPara(Data);
            KM5S_SendData_OBC(ptUartTx, Mode, 0x05, stOBC_SetInfo.ucShakingCode);
        }
    }
    else if(Addr == UARTADDR_BMS)
    {
        /*if((Mode == 0x10) && (Length == 0x02))              //总容量
        {
            BMS_RunInfo.FCC = (UWORD)(Data[4] + (Data[5]<<8));
        }
        else if((Mode == 0x0f) && (Length == 0x02))              //剩余容量
        {
            BMS_RunInfo.RC = (UWORD)(Data[4] + (Data[5]<<8));
            ulBMS_ComTimeOutCount = cp_ulSystickCnt;
        }
        else if((Mode == 0x09) && (Length == 0x02))              //当前电压
        {
            BMS_RunInfo.Voltage = (UWORD)(Data[4] + (Data[5]<<8));
        }
        else if((Mode == 0x0A) && (Length == 0x02))              //当前电流
        {
            BMS_RunInfo.Current = (UWORD)(Data[4] + (Data[5]<<8));
        }
        else if((Mode == 0x17) && (Length == 0x02))              //充放电的 cycle次数
        {
            BMS_RunInfo.RecyclNm = (UWORD)(Data[4] + (Data[5]<<8));
        }
        else if((Mode == 0x08) && (Length == 0x02))              //温度
        {
            BMS_RunInfo.Cell_NTC = (UBYTE)((Data[4] + (Data[5]<<8) - 2731)/10 + 40);
        }
        else if((Mode == 0x0d) && (Length == 0x01))              //相对容量百分比
        {
            BMS_RunInfo.SOC = Data[4];
            ulBMS_ComTimeOutCount = cp_ulSystickCnt;
        }*/
#if (UART_ID == 3)    
        if((Mode == 0x0d) && (Length == 0x01))              //相对容量百分比
        {
            BMS_RunInfo.SOC = Data[4];
            ulBMS_ComTimeOutCount = cp_ulSystickCnt;

            UART_PutChar(&UART_TxBuff_Struct_OBC, BMS_RunInfo.SOC);
            UART_PutChar(&UART_TxBuff_Struct_OBC, BMS_RunInfo.SOC);
        }
#endif
    }
}

void DataProcess(USART_Buf_TypeDef* ptUartTx, UWORD ID, UBYTE Mode, UWORD Cmd, UBYTE *Data)
{
    uint8_t DataLength;
    DataLength = (uint8_t)(Cmd & 0x00FF);
    switch (ID)
    {
    //处理BMS发送的指令
    case ID_BMS_BC:
    case ID_BMS_TO_MC: {
        switch (Cmd)
        {
        case 0x1010: // BMS运行信息
        {
            //更新电池运行信息
            memcpy(&BMS_RunInfo.Voltage, Data, DataLength);
           // MC_RunInfo.SOC = BMS_RunInfo.SOC;
            ulBMS_ComTimeOutCount = cp_ulSystickCnt;
            break;
        }
        case 0x1308: //关机指令
        {
            //电池关闭电源前控制器存储数据
            //...
            //发送关机就绪信号
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1305, (uint8_t *)"READY");
            break;
        }
        default:
            break;
        }
        break;
    }
   //处理OBC发送的指令
    case ID_PBU_BC:
    case ID_PBU_TO_MC: {
        switch (Cmd)
        {
        case 0x1008:  // OBC关机指令
        {
            //仪表关闭电源前控制器存储数据
            power_stPowStateOut.powerstate = POWER_OFF;
            power_stPowStateOut.blPowerStartupFlg = FALSE;
            //发送关机就绪信号
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1305, (uint8_t *)"READY");
            break;
        }
           // OBC发送给MC的指令
        case 0x3002://控制电机指令
        {
            memcpy(&MC_ControlCode.GearSt, Data, DataLength);
            MC_RunInfo.GearSt = MC_ControlCode.GearSt;           //当前助力档位更新
            MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch; //大灯状态更新
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t *)&MC_RunInfo.BikeSpeed);
            ulOBC_ComTimeOutCount = cp_ulSystickCnt;
            break;
        }
          case 0x3105: {
            if (power_stPowStateOut.powerstate == POWER_ON_END)
            {
                SendData(ptUartTx,ID_MC_BC, MODE_REPORT, 0x1305, (uint8_t *)"READY");
            }
            break;
        }
        case 0x3300: // OBC设置用户参数
        {
            OBC_SetCustomPara.uwWheelPerimeter = ass_ParaCong.uwWheelPerimeter;
            OBC_SetCustomPara.StartUpMod = ass_ParaCong.uwStartMode;
            OBC_SetCustomPara.BikeSpeedLimit = ass_ParaSet.uwAssistLimitBikeSpdStart;
            OBC_SetCustomPara.DeltDiameter = ass_ParaCong.swDeltPerimeter;
            OBC_SetCustomPara.AssistMod = ass_ParaSet.uwAsssistSelectNum;
            OBC_SetCustomPara.AutoPowerOffTime = ass_ParaCong.uwAutoPowerOffTime;
            OBC_SetCustomPara.scDeltaBikeSpeedLimit = (SBYTE)ass_ParaCong.swDeltaBikeSpeedLimit;
            OBC_SetCustomPara.ubControlFunCruise=(UBYTE)cp_stControlPara.uwControlFunEN;//巡航使能位
            SendData(ptUartTx, ID_MC_TO_PBU, MODE_REPORT, 0x5408, (uint8_t *)&OBC_SetCustomPara.uwWheelPerimeter);
            break;
        }
        case 0x3408: // OBC设置用户参数
        {
            OBC_SetCustomPara.DeltDiameter = Data[0];
            OBC_SetCustomPara.StartUpMod = Data[1];
            OBC_SetCustomPara.AssistMod = Data[2];
            OBC_SetCustomPara.AutoPowerOffTime = Data[3];
            if(OBC_SetCustomPara.DeltDiameter > 10)
            {
                OBC_SetCustomPara.DeltDiameter = 10;
            }
            else if(OBC_SetCustomPara.DeltDiameter < -10)
            {
                OBC_SetCustomPara.DeltDiameter = -10;
            }
            else
            {
                //do nothing
            }            
            OBC_SetCustomPara.scDeltaBikeSpeedLimit = (SBYTE)Data[4];
                       if(OBC_SetCustomPara.scDeltaBikeSpeedLimit > 0)
                       {
                           OBC_SetCustomPara.scDeltaBikeSpeedLimit = 0;
                       }
                       else if(OBC_SetCustomPara.scDeltaBikeSpeedLimit < (-ass_ParaSet.uwAssistLimitBikeSpdStart))
                       {
                           OBC_SetCustomPara.scDeltaBikeSpeedLimit = (-ass_ParaSet.uwAssistLimitBikeSpdStart);
                       }
                       else
                       {
                           //do nothing
                       }
                       OBC_ControlFUN.ubControlFunCruise= Data[5]; //控制器功能

            ass_ParaCong.swDeltPerimeter = OBC_SetCustomPara.DeltDiameter;
            ass_ParaCong.uwStartMode = OBC_SetCustomPara.StartUpMod;
            ass_ParaSet.uwAsssistSelectNum = OBC_SetCustomPara.AssistMod;
            ass_ParaCong.uwAutoPowerOffTime &= ~0x00FF;
            ass_ParaCong.uwAutoPowerOffTime |= OBC_SetCustomPara.AutoPowerOffTime;  
            ass_ParaCong.swDeltaBikeSpeedLimit = (SWORD)OBC_SetCustomPara.scDeltaBikeSpeedLimit;
            cp_stControlPara.uwControlFunEN &=0xff00;
            cp_stControlPara.uwControlFunEN |=OBC_ControlFUN.ubControlFunCruise; //

            MC_UpcInfo.stBikeInfo.uwSaveFlg = TRUE;
            MC_UpcInfo.stBikeInfo.swWheelSizeAdjust = OBC_SetCustomPara.DeltDiameter;
            MC_UpcInfo.stBikeInfo.uwStartMode = OBC_SetCustomPara.StartUpMod;
            MC_UpcInfo.stBikeInfo.uwAutoPowerOffTime =  ass_ParaCong.uwAutoPowerOffTime; 
            MC_UpcInfo.stBikeInfo2.uwSaveFlg = TRUE;
            MC_UpcInfo.stBikeInfo2.swDeltaBikeSpeedLimit = (SWORD)OBC_SetCustomPara.scDeltaBikeSpeedLimit;
            MC_UpcInfo.stMContorlInfo.uwControlFunEN &=0xff00;
            MC_UpcInfo.stMContorlInfo.uwControlFunEN |=OBC_ControlFUN.ubControlFunCruise;//巡航
            cp_stFlg.ParaUpdateFlg = TRUE;

            cp_stFlg.ParaBikeInfoUpdateFlg = TRUE;            
			cp_stFlg.ParaBikeInfo2UpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;

            MC_UpcInfo.stMContorlInfo.uwSaveFlg=TRUE;
            cp_stFlg.ParaMCInfoUpdateFlg = TRUE;
            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
          if(( power_stPowStateOut.powerstate != POWER_OFF)&&( power_stPowStateOut.powerstate != POWER_OFF_END))
          {
            cp_stFlg.ParaSaveEEFlg = TRUE;
          }
            SendData(ptUartTx, ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t *)"ACK");
            break;
        }
        case 0x3500: //查询骑行历史
        {
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t *)&MC_RideLog.ODO_Km);
            break;
        }
        case 0x3605: // OBC清除TRIP信息
        {
            if (strncmp("CLEAR", (char *)Data, DataLength) == 0)
            {
                MC_RideLog.TRIP_Km = 0;
                MC_RideLog.TRIP_Time = 0;
                SendData(ptUartTx, ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t *)"ACK");
                MC_RunInfo.Ride_Km = 0;
                MC_RunInfo.Ride_Time = 0;
                cp_stHistoryPara.ulTripSum=0;
                cp_stHistoryPara.ulTripSumTime=0;
                cp_stBikeRunInfoPara.ulRiTirpTime=0;
            }
            break;
        }
        case 0x3900: //返回电机版本信息
        {
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1240, (UBYTE *)MC_VerInfo.Mode);
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1720, (UBYTE *)Firmware_Special);
            break;
        }
        case 0x3A02: //OBC按键状态
        {
            OBC_ButtonStatus.Reserver = Data[0];
            OBC_ButtonStatus.ButtonStatu.KeyStatus = Data[1];
            OBC_ButtonStatus.ulButtonSetTimeCnt = cp_ulSystickCnt;
            OBC_ButtonStatus.blOBCbuttonPress = TRUE;
            break;
        }
         case 0x4300: //返回骑行参数
        {
            SendData(ptUartTx,ID_MC_TO_CDL, MODE_REPORT, 0xBC20, (UBYTE *)&MC_UpcInfo.stRideParaInfo.ucAssistRatioGain1);
            break;
        }
        case 0x4420: //仪表修改骑行参数
        {
            memcpy((uint8_t*)&MC_UpcInfo.stRideParaInfo.ucAssistRatioGain1, Data, DataLength);

            MC_UpcInfo.stRideParaInfo.uwSaveFlg = 1;
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaRideInfoUpdateFlg = TRUE;         
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            cp_stFlg.ParaSaveEEFlg = TRUE;
            

            SendData(ptUartTx,ID_MC_TO_CDL, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
            break;
        }
        default:
            break;
        }
        break;
    }
    //处理上位机发送的指令
    case ID_CDL_BC:
    case ID_CDL_TO_MC: {
        switch (Cmd)
        {
        case 0xF000: // 上位机握手指令 返回应答指令
        {
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xF000, (uint8_t *)0);
            break;
        }

        case 0x1200:  //查询电机版本信息
        {
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1240, (UBYTE *)MC_VerInfo.Mode);
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1720, (UBYTE *)Firmware_Special);
            break;
        }
        case 0x1300: //查询自定义字符串1
        {
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA610, (uint8_t *)MC_RsASSCII.CustomASCII1);

            break;
        }
        case 0x1410: //写入自定义字符串1
        {
            memcpy(MC_RsASSCII.CustomASCII1, Data, DataLength);
            //执行存储操作
            memcpy( Syspara2.flash_stPara.ubRsASSCII.CustomASCII1, MC_RsASSCII.CustomASCII1, sizeof(MC_RsASSCII.CustomASCII1));
            //...
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x1500: //查询自定义字符串2
        {
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA710, (uint8_t *)MC_RsASSCII.CustomASCII2);
            break;
        }
        case 0x1610:  //写入自定义字符串2
        {
            memcpy(MC_RsASSCII.CustomASCII2, Data, DataLength);
            //执行存储操作
            memcpy(Syspara2.flash_stPara.ubRsASSCII.CustomASCII2, MC_RsASSCII.CustomASCII2, sizeof(MC_RsASSCII.CustomASCII2));
            //...
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
         case 0x1700: //查询自定义字符串3
        {
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA810, (uint8_t *)MC_RsASSCII.CustomASCII3);
            break;
        }
        case 0x1810: //写入自定义字符串3
        {
            memcpy(MC_RsASSCII.CustomASCII3, Data, DataLength);
            //执行存储操作
            memcpy(Syspara2.flash_stPara.ubRsASSCII.CustomASCII3, MC_RsASSCII.CustomASCII3, sizeof(MC_RsASSCII.CustomASCII3));
            //...
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }

        case 0x1901: //写入电机工作模式
        {
            MC_WorkMode = *Data; // 0-关闭定时发送，1-开启定时发送
            if(*Data == 2)
            {
                MC_BC_COM = 1;
            }
            break;
        }

        case 0x1E00: //查询历史信息
        {
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB74C, (uint8_t *)&MC_UpcInfo.stHistoryInfo.uwOpenTimes);
            break;
        }

        case 0x1F00: //查询电机生产信息
        {
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xA520, (uint8_t *)MC_MacInfo.Manufacturer);
            break;
        }

        case 0x2210: //写入电机型号
        {
            memcpy(MC_VerInfo.Mode, Data, DataLength);
            //执行存储操作
           // memcpy(Syspara2.flash_stPara.ubMotorVersion, MC_VerInfo.Mode, sizeof(Syspara2.flash_stPara.ubMotorVersion));
            memcpy(Productionpara.ubMotorVersion, MC_VerInfo.Mode, sizeof(Productionpara.ubMotorVersion));

            //...
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x2310: //写入电机SN
        {
            memcpy(MC_VerInfo.SN_Num, Data, DataLength);
            //执行存储操作
            //...
            //memcpy(Syspara2.flash_stPara.ubSN, MC_VerInfo.SN_Num, sizeof(Syspara2.flash_stPara.ubSN));
            memcpy(Productionpara.ubSN, MC_VerInfo.SN_Num, sizeof(Productionpara.ubSN));

            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x2420: //写入电机生产信息
        {
            memcpy(MC_MacInfo.Manufacturer, Data, DataLength);
            //执行存储操作
            //...
           // memcpy(Syspara2.flash_stPara.ubProdInfo.Manufacturer, MC_MacInfo.Manufacturer, sizeof(Syspara2.flash_stPara.ubProdInfo));
            memcpy(Productionpara.ubProdInfo.Manufacturer, MC_MacInfo.Manufacturer, sizeof(Productionpara.ubProdInfo));
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }

        case 0x2505: //复位指令
        {
            if (strncmp("OFF..", (char *)Data, DataLength) == 0)
            {
                power_stPowStateOut.powerstate = POWER_OFF;
                power_stPowStateOut.blPowerStartupFlg = FALSE;
                SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t *)"ACK");                
            }
            else if (strncmp("RESET", (char *)Data, DataLength) == 0)
            {
                //执行复位，跳转进入Bootloader
                SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
//                __set_FAULTMASK(1);//关闭所有中断
                DL_WWDT_disablePower(WWDT0_INST);
                NVIC_SystemReset();
            }
            break;
        }
        case 0x2605: //系统清除
        {
            if (strncmp("CLEAR", (char *)Data, DataLength) == 0)
            {
                DISABLE_IRQ;
                
                //flash_voParaInit();
                flash_voErrorClear();//历史信息
                que_voInit(&que_stFlashErrorLog);
                flash_voSysParaInit();
                CodeHistoryParaDelete();
                mn_voEEHistoryParaUpdate();
                flash_voSysParaInit();
                flash_voSysParaWrite();//
                flash_HistoryWrite(); //
                ENABLE_IRQ;
               /* DISABLE_IRQ;

                i2c_voDefaultWriteBuffer();
                i2c_voInfoWrite2EE(&i2c_stTXCoef, &i2c_stTXOut);

                CodeHistoryParaDelete();
                mn_voEEHistoryParaUpdate();
                i2c_voHistoryWriteBuffer();
                i2c_voHistoryWrite2EE(&i2c_stTXCoef, &i2c_stTXOut);

                ENABLE_IRQ;*/

              //  if (I2C_EEFltFlg != TRUE)
                {
                    SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
                }
                
                //GPIO_ResetBits(POWER_LOCK_PORT,POWER_LOCK_PIN);
            }
            break;
        }
        case 0x2708: //参数还原
        {
            if (strncmp("RECOVERY", (char *)Data, DataLength) == 0)
            {
                DISABLE_IRQ;
                
                //flash_voParaInit();
              //  flash_voWrite();
                flash_voSysParaInit();
                flash_voSysParaInit();
                flash_voSysParaWrite();//tbd
                
                ENABLE_IRQ;
                /*DISABLE_IRQ;
                i2c_voDefaultWriteBuffer();
                i2c_voInfoWrite2EE(&i2c_stTXCoef, &i2c_stTXOut);
                cp_stFlg.ParaSaveEEFlg = FALSE;
                ENABLE_IRQ;*/
                cp_stFlg.ParaSaveEEFlg = FALSE;
               // if (I2C_EEFltFlg != TRUE)
                {
                    SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
                }
               //GPIO_ResetBits(POWER_LOCK_PORT,POWER_LOCK_PIN);
            }
            break;
        }
        case 0x2802: //控制指令
        {
            memcpy(&MC_ControlCode.GearSt, Data, DataLength);
            MC_RunInfo.GearSt = MC_ControlCode.GearSt; //当前助力档位更新
            MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t *)&MC_RunInfo.BikeSpeed);
            break;
        }

        case 0x2C01: //控制指令
        {
            MC_MotorSPD_rpm_Percent = *Data;
            break;
        }

        case 0x2D08: //读取存储器指定地址数据 故障日志
        {
            do
            {
                uint32_t DataLength, AddressBegin, AddressEnd;
                AddressBegin = (uint32_t)((Data[0] << 24) + (Data[1] << 16) + (Data[2] << 8) + (Data[3]));
                AddressEnd = (uint32_t)((Data[4] << 24) + (Data[5] << 16) + (Data[6] << 8) + (Data[7]));

                if(((AddressBegin <= AddressEnd) &&(AddressBegin>0) &&(AddressEnd<=(uint32_t)(0x0001FFFF)))
                    ||((AddressBegin <= AddressEnd) &&(AddressBegin>=(uint32_t)(0x20200000)) &&(AddressEnd<(uint32_t)(0x20208000))) )
                {
                    DataLength = AddressEnd - AddressBegin+ 1;
                
                    memcpy((uint8_t*)(Data + 8), (uint8_t*)(AddressBegin), DataLength);
                
                    SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, (0xAB08 + DataLength), (uint8_t*)Data);
                }
            } while (0);
            break;
        }

        case 0x2E00:  //查询骑行历史信息
        {
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t *)&MC_RideLog.ODO_Km);
            break;
        }

        case 0x3909: // 历史信息清除
        {
            if (strncmp("LOG CLEAR", (char *)Data, DataLength) == 0)
            {
                DISABLE_IRQ;
                
                flash_voErrorClear();//清故障日志
                que_voInit(&que_stFlashErrorLog);
                CodeHistoryParaDelete();
                mn_voEEHistoryParaUpdate();
                flash_HistoryWrite(); //

               ENABLE_IRQ;
                /*i2c_voHistoryWriteBuffer();
                i2c_voHistoryWrite2EE(&i2c_stTXCoef, &i2c_stTXOut);
                ENABLE_IRQ;*/
               // if (I2C_EEFltFlg != TRUE)
                {
                    SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
                }
               //GPIO_ResetBits(POWER_LOCK_PORT,POWER_LOCK_PIN);
            }
            break;
        }
        ////////////////////////////////////////
        case 0x3A00: //读取马达信息
        { 
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB226, (uint8_t *)&MC_UpcInfo.stMotorInfo.uwPolePairs);
            break;
        }
           case 0x3B10: 
        {
            memcpy(&MC_RideLog.ODO_Km, Data, DataLength);
            
            cp_stHistoryPara.ulODOTrip = MC_RideLog.ODO_Km;
            cp_stHistoryPara.ulODOTime = MC_RideLog.ODO_Time;
            cp_stHistoryPara.ulTripSum = MC_RideLog.TRIP_Km;
            cp_stHistoryPara.ulTripSumTime = MC_RideLog.TRIP_Time;
            
            MC_UpcInfo.stHistoryInfo.uwODOTripH = (UWORD)(cp_stHistoryPara.ulODOTrip >> 16);
            MC_UpcInfo.stHistoryInfo.uwODOTripL = (UWORD)cp_stHistoryPara.ulODOTrip;
            MC_UpcInfo.stHistoryInfo.uwODOTimeH = (UWORD)(cp_stHistoryPara.ulODOTime >> 16);
            MC_UpcInfo.stHistoryInfo.uwODOTimeL = (UWORD)cp_stHistoryPara.ulODOTime;
            MC_UpcInfo.stHistoryInfo.uwTripSumH = (UWORD)(cp_stHistoryPara.ulTripSum >> 16);
            MC_UpcInfo.stHistoryInfo.uwTripSumL = (UWORD)cp_stHistoryPara.ulTripSum;
            MC_UpcInfo.stHistoryInfo.uwTripSumTimeH = (UWORD)(cp_stHistoryPara.ulTripSumTime >> 16);
            MC_UpcInfo.stHistoryInfo.uwTripSumTimeL = (UWORD)cp_stHistoryPara.ulTripSumTime;
           
            cp_stBikeRunInfoPara.ulRiTime = 0;
            
            SendData(ptUartTx,ID_MC_TO_CDL, MODE_REPORT, 0xA903, (UBYTE *)"ACK");
            break;
        }
        case 0x3B28: //写入马达信息
        {
            memcpy(&MC_UpcInfo.stMotorInfo, Data, DataLength);
            if (MC_UpcInfo.stMotorInfo.uwSaveFlg == 1)
            {
                cp_stFlg.ParaSaveEEFlg = TRUE;
            }
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            cp_stFlg.ParaMInfoUpdateFlg = TRUE;
            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x3C00: //读取整车信息
        {
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB31A, (uint8_t *)&MC_UpcInfo.stBikeInfo.uwWheelPerimeter);
            break;
        }
        case 0x3D1C: //写入整车信息
        {
            memcpy(&MC_UpcInfo.stBikeInfo, Data, DataLength);
            if (MC_UpcInfo.stBikeInfo.uwSaveFlg == 1)
            {
                cp_stFlg.ParaSaveEEFlg = TRUE;
            }
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaBikeInfoUpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
         case 0x3D20: //写入电机标签信息
        {
            memcpy(MC_VerInfo.ProductLabel, Data, DataLength);
            //执行存储操作
            memcpy(Productionpara.ucProductLabel, MC_VerInfo.ProductLabel, sizeof(Productionpara.ucProductLabel));
            SendData(ptUartTx,ID_MC_BC,MODE_REPORT, 0xA903, (UBYTE *)"ACK");
            break;
        }
        case 0x3E00: //查询控制器参数
        {
            MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetOrigin = 0;//spi_stResolverOut.swSpiThetaOffsetOrignPu;
            MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetNow = 0;//spi_stResolverOut.swSpiThetaOffsetPu;
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB420, (uint8_t *)&MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetOrigin);
            break;
        }
        case 0x3F22: //写入控制器参数
        {
            memcpy(&MC_UpcInfo.stMContorlInfo, Data, DataLength);
            if (MC_UpcInfo.stMContorlInfo.uwSaveFlg == 1)
            {
                cp_stFlg.ParaSaveEEFlg = TRUE;
            }
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaMCInfoUpdateFlg = TRUE;
            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x4000: //查询传感器参数
        {
            MC_UpcInfo.stSensorInfo.uwTorSensorOffsetOrigin = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
            MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow1 = torsensor_stTorSensorCof.uwTorqueOffsetNow1;
            MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow2 = torsensor_stTorSensorCof.uwTorqueOffsetNow2;
            MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow3 = torsensor_stTorSensorCof.uwTorqueOffsetNow3;
            MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow4 = torsensor_stTorSensorCof.uwTorqueOffsetNow4;
            MC_UpcInfo.stSensorInfo.uwBikeTorMaxNm = torsensor_stTorSensorCof.uwMaxSensorTorquePu;
            MC_UpcInfo.stSensorInfo.uwBikeTor1StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep1RealNm;
            MC_UpcInfo.stSensorInfo.uwBikeTor1StepADC = torsensor_stTorSensorCof.uwBikeTorStep1ADC;
            MC_UpcInfo.stSensorInfo.uwBikeTor2StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep2RealNm;
            MC_UpcInfo.stSensorInfo.uwBikeTor2StepADC = torsensor_stTorSensorCof.uwBikeTorStep2ADC;
            MC_UpcInfo.stSensorInfo.uwBikeTor3StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep3RealNm;
            MC_UpcInfo.stSensorInfo.uwBikeTor3StepADC = torsensor_stTorSensorCof.uwBikeTorStep3ADC;
            MC_UpcInfo.stSensorInfo.uwBikeTor4StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep4RealNm;
            MC_UpcInfo.stSensorInfo.uwBikeTor4StepADC = torsensor_stTorSensorCof.uwBikeTorStep4ADC;
            MC_UpcInfo.stSensorInfo.uwTorque_SensorPulseNm = cadence_stFreGetCof.uwTorque_NumbersPulses;
            MC_UpcInfo.stSensorInfo.uwBikeSpdSensorPulseNm = bikespeed_stFreGetCof.uwNumbersPulses;   
            MC_UpcInfo.stSensorInfo.uwCad_SensorPulseNm=cadence_stFreGetCof.uwCad_NumbersPulses;
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB528, (uint8_t *)&MC_UpcInfo.stSensorInfo.uwTorSensorOffsetOrigin);
            break;
        }
        case 0x4104: //写入力矩传感器参数
        {
            UWORD SAVETemp[2];
            memcpy(&SAVETemp, Data, DataLength);
            if (SAVETemp[0] == 1)
            {
                MC_UpcInfo.stSensorInfo.uwBikeTor1StepRealNm = SAVETemp[1];
                MC_UpcInfo.stSensorInfo.uwBikeTor1StepADC =TORQUEVOLREG();// DL_ADC12_getMemResult(ADC12_1_INST, DL_ADC12_MEM_IDX_1);
                SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            }
            else if (SAVETemp[0] == 2)
            {
                MC_UpcInfo.stSensorInfo.uwBikeTor2StepRealNm = SAVETemp[1];
                MC_UpcInfo.stSensorInfo.uwBikeTor2StepADC =TORQUEVOLREG();// DL_ADC12_getMemResult(ADC12_1_INST, DL_ADC12_MEM_IDX_1);
                SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            }
            else if (SAVETemp[0] == 3)
            {
                MC_UpcInfo.stSensorInfo.uwBikeTor3StepRealNm = SAVETemp[1];
                MC_UpcInfo.stSensorInfo.uwBikeTor3StepADC = TORQUEVOLREG();//DL_ADC12_getMemResult(ADC12_1_INST, DL_ADC12_MEM_IDX_1);
                SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            }
            else if (SAVETemp[0] == 4)
            {
                MC_UpcInfo.stSensorInfo.uwBikeTor4StepRealNm = SAVETemp[1];
                MC_UpcInfo.stSensorInfo.uwBikeTor4StepADC = TORQUEVOLREG();//DL_ADC12_getMemResult(ADC12_1_INST, DL_ADC12_MEM_IDX_1);
                SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            }
            else
            {}

            cp_stFlg.ParaSaveEEFlg = TRUE;
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaSensorInfoUpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            break;
        }
        case 0x420E: //写入其它传感器参数
        {
            memcpy(&MC_UpcInfo.stSensorInfo.uwSaveFlg, Data, 2);
            memcpy(&MC_UpcInfo.stSensorInfo.uwTorque_SensorPulseNm, Data + 2, DataLength - 2);
            if (MC_UpcInfo.stSensorInfo.uwSaveFlg == 1)
            {
                cp_stFlg.ParaSaveEEFlg = TRUE;
            }
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaSensorInfoUpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x4304: //查询助力参数
        {
            memcpy(&MC_UpcInfo.stCurveOrderInfo, Data, DataLength);
            if(MC_UpcInfo.stCurveOrderInfo.uwTorqueCurveNum > 15)
            {
                MC_UpcInfo.stCurveOrderInfo.uwTorqueCurveNum = 15;
            }
            else if(MC_UpcInfo.stCurveOrderInfo.uwTorqueCurveNum < 1)
            {
                MC_UpcInfo.stCurveOrderInfo.uwTorqueCurveNum = 1;
            }
            
            if(MC_UpcInfo.stCurveOrderInfo.uwCadenceCurveNum > 5)
            {
                MC_UpcInfo.stCurveOrderInfo.uwCadenceCurveNum = 5;
            }
            else if(MC_UpcInfo.stCurveOrderInfo.uwCadenceCurveNum < 1)
            {
                MC_UpcInfo.stCurveOrderInfo.uwCadenceCurveNum = 1;
            }
            Can_AssistCoef_Read(&MC_UpcInfo.stCurveOrderInfo);
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB64C, (uint8_t *)&MC_UpcInfo.stAssistInfo.swStartupGain);
            break;
        }
        case 0x4450: //写入助力参数
        {
            memcpy(&MC_UpcInfo.stAssistInfo, Data, DataLength);
            if(MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwTorqueCurveNum > 15)
            {
                MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwTorqueCurveNum = 15;
            }
            else if(MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwTorqueCurveNum < 1)
            {
                MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwTorqueCurveNum = 1;
            }
            
            if(MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwCadenceCurveNum > 5)
            {
                MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwCadenceCurveNum = 5;
            }
            else if(MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwCadenceCurveNum < 1)
            {
                MC_UpcInfo.stAssistInfo.stCurveOrderInfo.uwCadenceCurveNum = 1;
            }
            
            Can_AssistCoef_Write(&MC_UpcInfo.stAssistInfo.stCurveOrderInfo);
            if (MC_UpcInfo.stAssistInfo.uwSaveFlg == 1)
            {

                cp_stFlg.ParaSaveEEFlg = TRUE;
            }
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaAInfoUpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x4500: //查询调试参数
        {
            MC_UpcInfo.stTestParaInfo.RunModelSelect = cp_stFlg.RunModelSelect;
            MC_UpcInfo.stTestParaInfo.ThetaGetModelSelect = cp_stFlg.ThetaGetModelSelect;
            MC_UpcInfo.stTestParaInfo.CurrentSampleModelSelect = cp_stFlg.CurrentSampleModelSelect;
            MC_UpcInfo.stTestParaInfo.RotateDirectionSelect = cp_stFlg.RotateDirectionSelect;
            MC_UpcInfo.stTestParaInfo.uwInitPosCurAmp = cp_stControlPara.swAlignCurAp ;  
            MC_UpcInfo.stTestParaInfo.uwVFControlVolAmp = cp_stControlPara.swDragVolAp ;
            MC_UpcInfo.stTestParaInfo.uwIFControlCurAmp = cp_stControlPara.swDragCurAp ;
            MC_UpcInfo.stTestParaInfo.uwVFIFTargetFreHz = cp_stControlPara.swDragSpdHz;
            MC_UpcInfo.stTestParaInfo.uwSpeedLoopAccRate = cp_stControlPara.swSpeedAccRate ;
            MC_UpcInfo.stTestParaInfo.uwSpeedLoopDecRate = cp_stControlPara.swSpeedDccRate;
            MC_UpcInfo.stTestParaInfo.uwSpeedLoopBandWidthHz = cp_stControlPara.swAsrPIBandwidth;
            MC_UpcInfo.stTestParaInfo.uwSpeedLoopCoefM = cp_stControlPara.swAsrPIM;
            MC_UpcInfo.stTestParaInfo.uwCuerrentLoopBandWidthHz = cp_stControlPara.swAcrPIBandwidth;
            MC_UpcInfo.stTestParaInfo.uwCurrentLoopCoefM = cp_stControlPara.swAcrRaCoef;
            MC_UpcInfo.stTestParaInfo.uwFluxObsCoefM = cp_stControlPara.swObsFluxPIDampratio;
            MC_UpcInfo.stTestParaInfo.uwFluxObsBandWidthHz = cp_stControlPara.swObsFluxPICrossfreHz;
            MC_UpcInfo.stTestParaInfo.uwThetaObsPLLCoefM = cp_stControlPara.swObsSpdPLLM;
            MC_UpcInfo.stTestParaInfo.uwThetaObsPLLBandWidthHz = cp_stControlPara.swObsSpdPLLBandWidthHz;
            MC_UpcInfo.stTestParaInfo.uwPWMMaxDuty = cp_stControlPara.swPWMMaxDuty;
            MC_UpcInfo.stTestParaInfo.uwPWM7to5Duty = cp_stControlPara.swPWM7to5Duty;
            MC_UpcInfo.stTestParaInfo.uwPwrLimit = cp_stControlPara.swPwrLimitValWt;
            MC_UpcInfo.stTestParaInfo.uwPwrLimitError = cp_stControlPara.swPwrLimitErrWt;
            MC_UpcInfo.stTestParaInfo.uwPwrLimitKp = cp_stControlPara.swPwrLimitKpPu;
            MC_UpcInfo.stTestParaInfo.uwPwrLimitKi = cp_stControlPara.swPwrLimitKiPu;    
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB83A, (uint8_t *)&MC_UpcInfo.stTestParaInfo.RunModelSelect);            
            break;
        }
        case 0x463C: //写入调试参数
        {
            memcpy(&MC_UpcInfo.stTestParaInfo.uwTestParaSaveFlg, Data, DataLength);          
//            if (MC_UpcInfo.stTestParaInfo.uwSaveFlg == 1)
//            {
            cp_stFlg.ParaSaveEEFlg = TRUE;
            if(MC_UpcInfo.stTestParaInfo.RunModelSelect <= 3)
            {
                MC_UpcInfo.stTestParaInfo.uwSaveFlg = FALSE;
            }
            else
            {
                MC_UpcInfo.stTestParaInfo.uwSaveFlg = TRUE;
            }
//        }

            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.TestParaInfoUpdateFlg = TRUE;
            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        
        case 0x472E://写入力矩传感器参数
        {
          
            memcpy(&MC_UpcInfo.stSensorInfo.uwSaveFlg, Data, 30);
            if (MC_UpcInfo.stSensorInfo.uwSaveFlg == 1)
            {
                cp_stFlg.ParaSaveEEFlg = TRUE;
            }

            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaSensorInfoUpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");  
            break;
        }

        
        case 0x4800: //读取储存标志
        {
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xB904, (uint8_t *)&MC_UpcInfo.stTestParaInfo.uwEEFirstDefaultSetFlg);
            break;
        }

        case 0x4906: //写入储存标志
        {
            memcpy(&MC_UpcInfo.stTestParaInfo.uwSaveFlg, Data, DataLength);
            if(MC_UpcInfo.stTestParaInfo.uwSaveFlg == 1)
            {
                cp_stFlg.ParaSaveEEFlg = TRUE;
            }
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaMCInfoUpdateFlg = TRUE;
            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
           case 0x4A00: 
        {
            SendData(ptUartTx,ID_MC_BC, MODE_REPORT, 0xBC20, (UBYTE *)&MC_UpcInfo.stRideParaInfo.ucAssistRatioGain1);
            break;
        }
        case 0x4A12: //内阻校准指令
        {
            memcpy(&MC_UpcInfo.stResistanceCalibInfo.uwSaveFlg, Data, DataLength);
             memcpy(&Syspara2.EepromMosPara.EEP_K50,&MC_UpcInfo.stResistanceCalibInfo.Coeff1,10 );
            MosResInside.blCalibFlag=TRUE;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        
        case 0x4B00: //读取内阻校准参数
        {
            MC_UpcInfo.stWriteResistanceCalibInfo.MOSResA = Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES1;
            MC_UpcInfo.stWriteResistanceCalibInfo.MOSResB = Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES1;
            MC_UpcInfo.stWriteResistanceCalibInfo.MOSResC = Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES1;
            MC_UpcInfo.stWriteResistanceCalibInfo.Coeff1 = Syspara2.EepromMosPara.EEP_K50;
            MC_UpcInfo.stWriteResistanceCalibInfo.Coeff2 = Syspara2.EepromMosPara.EEP_K75;
            MC_UpcInfo.stWriteResistanceCalibInfo.Coeff3 = Syspara2.EepromMosPara.EEP_K100;
            MC_UpcInfo.stWriteResistanceCalibInfo.Coeff4 = Syspara2.EepromMosPara.EEP_K125;
            MC_UpcInfo.stWriteResistanceCalibInfo.Coeff5 = Syspara2.EepromMosPara.EEP_K150;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve1 = 0;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve2 = 0;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve3 = 0;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve4 = 0;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve5 = 0;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve6 = 0;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve7 = 0;
            MC_UpcInfo.stWriteResistanceCalibInfo.reserve8 = 0;
            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xBC20, (uint8_t *)&MC_UpcInfo.stWriteResistanceCalibInfo.MOSResA);
            break;
        }
 case 0x4B22:  //上位机设置骑行参数
        {
            memcpy(&MC_UpcInfo.stRideParaInfo.uwSaveFlg, Data, DataLength);
            if (MC_UpcInfo.stRideParaInfo.uwSaveFlg == 1)
            {
                cp_stFlg.ParaSaveEEFlg = TRUE;
            }
            cp_stFlg.ParaUpdateFlg = TRUE;
            cp_stFlg.ParaRideInfoUpdateFlg = TRUE;
            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
            SendData(ptUartTx,ID_MC_TO_CDL, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
            break;
        }
          case 0x4C00: 
        {
            SendData(ptUartTx,ID_MC_BC, MODE_REPORT, 0xBD20, (UBYTE *)&MC_UpcInfo.stBikeInfo2.uwNoneOBCEnable);
            break;
        }
        case 0x4C22: //写入内阻校准参数
        {
         //   memcpy(&MC_UpcInfo.stWriteResistanceCalibInfo.uwSaveFlg, Data, DataLength);
//            if(MC_UpcInfo.stWriteResistanceCalibInfo.uwSaveFlg == 1)
//            {
//                cp_stFlg.ParaSaveEEFlg = TRUE;
//            }
//            cp_stFlg.ParaUpdateFlg = TRUE;
//            cp_stFlg.ParaMCInfoUpdateFlg = TRUE;
//            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;

            SendData(ptUartTx, ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t *)"ACK");
            break;
        }
        case 0x4D22:
           {
               memcpy(&MC_UpcInfo.stBikeInfo2.uwSaveFlg, Data, DataLength);
               if(MC_UpcInfo.stBikeInfo2.swDeltaBikeSpeedLimit > 0)
               {
                   MC_UpcInfo.stBikeInfo2.swDeltaBikeSpeedLimit = 0;
               }
               else if(MC_UpcInfo.stBikeInfo2.swDeltaBikeSpeedLimit < (-ass_ParaSet.uwAssistLimitBikeSpdStart))
               {
                   MC_UpcInfo.stBikeInfo2.swDeltaBikeSpeedLimit = (-ass_ParaSet.uwAssistLimitBikeSpdStart);
               }
               else
               {
                   //do nothing
               }

               if (MC_UpcInfo.stBikeInfo2.uwSaveFlg == 1)
               {
                   cp_stFlg.ParaSaveEEFlg = TRUE;
               }
               cp_stFlg.ParaUpdateFlg = TRUE;
               cp_stFlg.ParaBikeInfo2UpdateFlg = TRUE;
               cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
               SendData(ptUartTx, ID_MC_BC,MODE_REPORT, 0xA903, (UBYTE *)"ACK");
               break;
           }
            case 0x4E00: 
        {
            SendData(ptUartTx, ID_MC_BC,MODE_REPORT, 0xBB20, (UBYTE *)MC_VerInfo.ProductLabel);
            break;
        }
        case 0x5200: //读取故障日志地址范围
        {
            ManageError_Address.ulErrAStart_Address= StartServerManageError_Address;
            ManageError_Address.ulErrEnd_Address=EndServerManageError_Address;
            SendData(ptUartTx, ID_MC_TO_CDL, MODE_REPORT, 0xC008, (uint8_t *)&ManageError_Address.ulErrAStart_Address);
            break;
        }
        default:
            break;
        }
        break;
    }
    //切换解析函数
    case 0x07FF: {
        switch (Cmd)
        {
        case 0x7702:
        {
            ucUartAnalyseID = Data[0];
//        #if (UART_ID == 3)
//            usart_reset(UART_RxBuff_Struct_OBC.usart_periph);
//            hw_voInitUART1(9600);
//        #endif 
        }
        default:
            break;
        }
        break;
    }
    default:
        break;
    }
}

UBYTE UART_ReadChar(USART_Buf_TypeDef * ptRx, UBYTE ucNum)	 
{	
    UBYTE ucData;
    UWORD  i;
    i = ucNum;
    if ((*ptRx).ucBufCnt >= ucNum)
    {
        i += (*ptRx).ucBufRdInde;
        if (i >= (*ptRx).ucBufSize)
        {	
            i -=((*ptRx).ucBufSize);
        }
    }
    else
    {
        i=0;
    }
    ucData = *((*ptRx).pcBufAddr + i);
    return ucData;
}

void UART_DelChar(USART_Buf_TypeDef * ptRx, UBYTE ucNum)	 
{	
    UWORD i;
    if ((*ptRx).ucBufCnt >= ucNum)	
    {	
//        usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, FALSE);
        DL_UART_Main_disableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_RX );
        (*ptRx).ucBufCnt -= ucNum;	
//        usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, TRUE);
        DL_UART_Main_enableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_RX );
        i = ucNum;
        i += (*ptRx).ucBufRdInde;
        if (i >= (*ptRx).ucBufSize)
        {
          i -= (*ptRx).ucBufSize;
        }
        (*ptRx).ucBufRdInde = i;
    }
    else
    {  
//        usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, FALSE);
        DL_UART_Main_disableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_RX );
        i = (*ptRx).ucBufCnt;
        (*ptRx).ucBufCnt = 0;
//        usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, TRUE);
        DL_UART_Main_enableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_RX );
        i += (*ptRx).ucBufRdInde;
        if (i >= (*ptRx).ucBufSize)
        {
            i -= (*ptRx).ucBufSize;
        }
        (*ptRx).ucBufRdInde = i;
     }
}

void UART_PutChar(USART_Buf_TypeDef * ptTx, UBYTE ucData)
{	
    while ((*ptTx).ucBufCnt == (*ptTx).ucBufSize);
//        usart_interrupt_enable(ptTx->usart_periph, USART_TDBE_INT, FALSE);
    DL_UART_Main_disableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
    if((*ptTx).ucBufCnt == 0)
    {
//        if(usart_flag_get(ptTx->usart_periph, USART_TDBE_FLAG) == SET) //check if transmit data register full or not
    if(DL_UART_isTXFIFOEmpty(UART_HMI_INST) == TRUE)
   {
//            usart_data_transmit(ptTx->usart_periph, ucData);
//            usart_interrupt_enable(ptTx->usart_periph, USART_TDBE_INT, TRUE);

            DL_UART_Main_enableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
            DL_UART_Main_transmitData(UART_HMI_INST, ucData);
            return;
        }
    }	
    *((*ptTx).pcBufAddr + (*ptTx).ucBufWrInde) = ucData;
    if(++(*ptTx).ucBufWrInde == (*ptTx).ucBufSize)
    {
        (*ptTx).ucBufWrInde = 0;
    }
    ++(*ptTx).ucBufCnt;
//    usart_interrupt_enable(ptTx->usart_periph, USART_TDBE_INT, TRUE);
    DL_UART_Main_enableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
}

void SendData(USART_Buf_TypeDef* ptUartTx, UWORD ID, UBYTE Mode, UWORD Command, UBYTE *Data)
{
    if(ucCommType != 2)
    {
        ULONG CRC_Result = 0x00000000U;
        UBYTE  DataLength;
        UBYTE CanSendData[255], CanSendData_CRC_Buf[255];

        DataLength = (UBYTE)(Command & 0xFF);
        CanSendData[0] = FRAME_BEGIN1;
        CanSendData[1] = FRAME_BEGIN2;
        CanSendData[2] = Mode;
        CanSendData[3] = DataLength + 2;
        CanSendData[4] = (UBYTE)((Command >> 8) & 0xFF);
        CanSendData[5] = DataLength;
        if((DataLength)> (255 - 6))
        {
            DataLength = 255 - 6;
        }
        memcpy(CanSendData + 6, Data, DataLength);
        CanSendData_CRC_Buf[0] = FRAME_BEGIN1;
        CanSendData_CRC_Buf[1] = FRAME_BEGIN2;
        CanSendData_CRC_Buf[2] = (UBYTE)(ID >> 8);
        CanSendData_CRC_Buf[3] = (UBYTE)(ID & 0xFF);
        if((DataLength + 4 )> (255 - 4))
        {
            DataLength = 251 - 4 - 4;
        }
        memcpy(CanSendData_CRC_Buf + 4, CanSendData + 2, DataLength + 4);
        CRC_Result = CRC32_Calculate(CanSendData_CRC_Buf, DataLength + 8); //帧头2bytes + ID 2bytes + 模式 1byte + 命令段长度 1byte + 命令字 2bytes
        CanSendData[6 + DataLength] = (UBYTE)((CRC_Result >> 24) & 0xFF);
        CanSendData[7 + DataLength] = (UBYTE)((CRC_Result >> 16) & 0xFF);
        CanSendData[8 + DataLength] = (UBYTE)((CRC_Result >> 8) & 0xFF);
        CanSendData[9 + DataLength] = (UBYTE)(CRC_Result & 0xFF);
        CanSendData[10 + DataLength] = FRAME_END;
        CAN_SendData(ID, ID_MODE_STANDARD, CanSendData, DataLength + 11);
    }

    if(ucCommType != 1)
    {
        UBYTE i = 0;
        UBYTE len = 0;
        UWORD checksum = 0;
        UBYTE databuf[256] = {0};

        len = (UBYTE)((Command & 0xff) + 4);
        if(len > 247)
        {
            len = 247;
        }

        databuf[0] = UARTFRAME_BEGIN;
        databuf[1] = UARTADDR_CDL;
        databuf[2] = Mode;
        databuf[3] = len;
        databuf[4] = (UBYTE)((ID >> 8) & 0xFF);
        databuf[5] = (UBYTE)(ID & 0xFF);
        databuf[6] = (UBYTE)((Command >> 8) & 0xFF);
        databuf[7] = (UBYTE)(Command & 0xFF);

        for(i=0; i<(len-4); i++)
        {
            databuf[8+i] = Data[i];
        }

        for(i=1; i<(len+4); i++)
        {
            checksum = (UWORD)(databuf[i] + checksum);
        }

        databuf[4+len] = (UBYTE)checksum;
        databuf[5+len] = (UBYTE)(checksum>>8);
        databuf[6+len] = UARTFRAME_END1;
        databuf[7+len] = UARTFRAME_END2;

        for(i=0; i<(len+8); i++)
        {
            UART_PutChar(ptUartTx, databuf[i]);
        }
    }
}

void KM5S_OBCSetPara(UBYTE* Data)
{
    UWORD tmpdata;
    
    /*数据获取*/
    if((Data[4] & 0x40) == 0x40)                           //助力方向
    {
        stOBC_SetInfo.AssistDir = Assist_Backward;
    }
    else
    {
        stOBC_SetInfo.AssistDir = Assist_Forward;
    }
    stOBC_SetInfo.ucAssistedMagnetSteel = (Data[4] & 0x3F);//助力过几个磁钢
    stOBC_SetInfo.ucAssistRatio = Data[5];
    stOBC_SetInfo.ucThrottleGt = ((Data[6] & 0x80)>>7);
    stOBC_SetInfo.ucThrottleLimited = ((Data[6] & 0x40)>>6);
    stOBC_SetInfo.ucSlowStartMode = ((Data[6] & 0x30)>>4);
    stOBC_SetInfo.ucSpeedSensorPulses = (Data[6] & 0x0F);
    if((Data[7] & 0x80) == 0x80)
    {
        stOBC_SetInfo.swUnderVoltageBias = (SWORD)(-1 * (Data[7] & 0x7F));//0.1V
    }
    else
    {
        stOBC_SetInfo.swUnderVoltageBias = (SWORD)(1 * (Data[7] & 0x7F));
    }

    if((Data[8] & 0xC0) == 0xC0)
    {
        stOBC_SetInfo.uwUnderVoltageBase = 420;//0.1V
    }
    else if((Data[8] & 0xC0) == 0x40)
    {
        stOBC_SetInfo.uwUnderVoltageBase = 210;
    }
    else
    {
        stOBC_SetInfo.uwUnderVoltageBase = 315;
    }
    stOBC_SetInfo.ucCurrentLimiation = (Data[8] & 0x3F);//0.5A
    stOBC_SetInfo.ucShakingCode = Data[9];
    stOBC_SetInfo.ucSpeedLimiation = ((Data[10] & 0xF8)>>3) + 10;//km/h
    stOBC_SetInfo.ucWheelDiameterCode = (Data[10] & 0x07);

#if(MINGRUI_ENABLE == 1)
    stOBC_SetInfo.ucSpeedLimiation = ((Data[10] & 0xF8)>>3) + 20;//km/h
#endif

#if(0)
    /*低压保护阈值更新*/
    if(MC_UpcInfo.stMContorlInfo.uwAlamUVolV != (UWORD)(stOBC_SetInfo.uwUnderVoltageBase + stOBC_SetInfo.swUnderVoltageBias))
    {
        MC_UpcInfo.stMContorlInfo.uwAlamUVolV = (UWORD)(stOBC_SetInfo.uwUnderVoltageBase + stOBC_SetInfo.swUnderVoltageBias);
        MC_UpcInfo.stMContorlInfo.uwSaveFlg = 1;
        cp_stFlg.ParaSaveEEFlg = TRUE;
        cp_stFlg.ParaUpdateFlg = TRUE;
        cp_stFlg.ParaMCInfoUpdateFlg = TRUE;
        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
    }
#endif
    /*功率限幅阈值更新*/
//    #if (IPM_VOLTAGE_SEL == IPM_VOLTAGE_48V)
//        UWORD uwVolt = 480;
//    #elif (IPM_VOLTAGE_SEL == IPM_VOLTAGE_36V)
//        UWORD uwVolt = 360;
//    #else
//        UWORD uwVolt = 360;
//    #endif
#if(0)
        UWORD uwVolt =cp_stMotorPara.swRUdcV;
    if(MC_UpcInfo.stTestParaInfo.uwPwrLimit != ((stOBC_SetInfo.ucCurrentLimiation*uwVolt>>1) + 500))
    {
        MC_UpcInfo.stTestParaInfo.uwPwrLimit = (UWORD)((stOBC_SetInfo.ucCurrentLimiation*uwVolt>>1) + 500);
        MC_UpcInfo.stTestParaInfo.uwSaveFlg = 1;
        cp_stFlg.ParaSaveEEFlg = TRUE;
        cp_stFlg.ParaUpdateFlg = TRUE;
        cp_stFlg.TestParaInfoUpdateFlg = TRUE;
        ]
        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
    }
#endif

#if(0)
    /*限速阈值更新*/
    if(MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStart != stOBC_SetInfo.ucSpeedLimiation)
    {
        MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStart = stOBC_SetInfo.ucSpeedLimiation;
        MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStop = stOBC_SetInfo.ucSpeedLimiation + 2;
        MC_UpcInfo.stBikeInfo.uwThrottleMaxSpdKmH = stOBC_SetInfo.ucSpeedLimiation;
        MC_UpcInfo.stBikeInfo.uwSaveFlg = 1;
        MC_UpcInfo.stAssistInfo.uwSaveFlg = 1;
        cp_stFlg.ParaSaveEEFlg = TRUE;
        cp_stFlg.ParaUpdateFlg = TRUE;
        cp_stFlg.ParaAInfoUpdateFlg = TRUE;
        cp_stFlg.ParaBikeInfoUpdateFlg = TRUE;
        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
    }
#endif

#if(0)
    /*轮径更新*/
    if(stOBC_SetInfo.ucWheelDiameterCode <= 5)
    {
        tmpdata = (stOBC_SetInfo.ucWheelDiameterCode*2 + 16) * 8;    //3.14*2.54=7.9756=8
    }
    else if(stOBC_SetInfo.ucWheelDiameterCode == 6)
    {
        tmpdata = 219;    //3.14*700mm=2198mm
    }
    else
    {
        tmpdata = 223;    //3.14*2.54*28
    }
    if(MC_UpcInfo.stBikeInfo.uwWheelPerimeter != tmpdata)
    {
        MC_UpcInfo.stBikeInfo.uwWheelPerimeter = tmpdata;
        MC_UpcInfo.stBikeInfo.uwSaveFlg = 1;
        cp_stFlg.ParaSaveEEFlg = TRUE;
        cp_stFlg.ParaUpdateFlg = TRUE;
        cp_stFlg.ParaBikeInfoUpdateFlg = TRUE;
        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
    }
#endif
}

void KM5S_SendData_OBC(USART_Buf_TypeDef* ptUartTx, UBYTE Mode, UBYTE Length, UBYTE checknum)
{
    UBYTE i = 0;
    UWORD checksum = 0;
    UBYTE databuf[13] = {0};
    UBYTE tmp = 0;
    
    if(MC_RunInfo.BusVoltage > 63000)
    {
        tmp = 0x3F;             //max=63V
    }
    else
    {
       tmp = (UBYTE)((MC_RunInfo.BusVoltage/1000)&0x3F);
    }  
    stMC2OBC_RRunInfo.Stage = (UBYTE)(stOBC_RunInfo.ucLowPower << 7)          //欠压,MC_ErrorCode.ERROR_Bit.Protect_UnderVoltage
                              | (bikeCruise.CruiseMode << 6)                                     //巡航，由控制器判定
                              | tmp;
    stMC2OBC_RRunInfo.Current = (UBYTE)(abs(MC_RunInfo.BusCurrent/1000)*3);//电流
    if(bikespeed_stFreGetOut.uwLPFFrequencyPu == 0)
    {
        stMC2OBC_RRunInfo.Speed = 0;
    }
    else
    {
        stMC2OBC_RRunInfo.Speed = (UWORD)((SQWORD)(1000 << 20) / bikespeed_stFreGetOut.uwLPFFrequencyPu / FBASE); //车轮转动一圈时间，ms
    }
    
    //故障码
    if(1 == MC_ErrorCode.ERROR_Bit.Protect_OverCurrent)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x21;//电流异常
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Fault_Throttle)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x22;//转把异常
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Fault_PhaseLine)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x23;//电机缺相
    }
    else if(1 == MC_ErrorCode.ERROR_Bit.Fault_HallSensor)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x24;//电机霍尔异常
    }
    else if(1 == alm_unBikeCode.bit.Brake)
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x25;//刹车异常
    }
    else
    {
        stMC2OBC_RRunInfo.ErrorCode = 0x00;
    }
    
    KM5S_MingruiTxErrorCodeUpdata();

    databuf[0] = UARTFRAME_BEGIN;
    databuf[1] = UARTADDR_OBC;
    databuf[2] = Mode;
    databuf[3] = Length;
    
    databuf[4] = stMC2OBC_RRunInfo.Stage;
    databuf[5] = stMC2OBC_RRunInfo.Current;
    databuf[6] = (UBYTE)((stMC2OBC_RRunInfo.Speed &0xFF00)>>8);
    databuf[7] = (UBYTE)(stMC2OBC_RRunInfo.Speed &0xFF);
    if(Mode == 0x53)
    {
        if(checknum > 63)
        {
          checknum = 63;
        }
        databuf[7] = ucOBC_password[checknum];//握手查表
    }
    databuf[8] = stMC2OBC_RRunInfo.ErrorCode;
    
    for(i=1; i<(Length+4); i++)
    {
        checksum = (UWORD)(databuf[i] + checksum);
    }
    
    databuf[4+Length] = (UBYTE)checksum;
    databuf[5+Length] = (UBYTE)(checksum>>8);
    databuf[6+Length] = UARTFRAME_END1;
    databuf[7+Length] = UARTFRAME_END2;
    
    for(i=0; i<(Length+8); i++)
    {
        UART_PutChar(ptUartTx, databuf[i]);
    }
}
/*******************************************************************************
* Function:void USARTx_Rx_IRQ(USART_Buf_TypeDef *USARTx_RxBuf_Struct)
* Discrible:
* Input:
* Output: 
* Return: 
* Others: 
*    date    version	  author        record
* -----------------------------------------------
* 20151107     V1.0     VINCENT       Create
*********************************************************************************/
//void USARTx_Rx_IRQ(USART_Buf_TypeDef *USARTx_RxBuf_Struct)
//{
//    UBYTE ucData;
//
////    if(USARTx_RxBuf_Struct->usart_periph->ctrl1_bit.rdbfien != RESET) //接收中斷
//   if((DL_UART_Main_getPendingInterrupt(UART_HMI_INST))==DL_UART_MAIN_IIDX_RX)
//    {
////        if(RESET != usart_flag_get(USARTx_RxBuf_Struct->usart_periph, USART_RDBF_FLAG))
//        {
////            ucData = (UBYTE)usart_data_receive(USARTx_RxBuf_Struct->usart_periph);
//            ucData =  DL_UART_Main_receiveDataBlocking(UART_HMI_INST);
//
//            {
//                *((* USARTx_RxBuf_Struct).pcBufAddr + (* USARTx_RxBuf_Struct).ucBufWrInde) = ucData;
//                if(++(* USARTx_RxBuf_Struct).ucBufWrInde >= (* USARTx_RxBuf_Struct).ucBufSize)
//                {
//                    (* USARTx_RxBuf_Struct).ucBufWrInde = 0;
//                }
//                if(++(* USARTx_RxBuf_Struct).ucBufCnt > (* USARTx_RxBuf_Struct).ucBufSize)
//                {
//                    (* USARTx_RxBuf_Struct).ucBufCnt = (* USARTx_RxBuf_Struct).ucBufSize;
//                    (* USARTx_RxBuf_Struct).ucBufOvf = 1;
//                }
//            }
//        }
//    }
//}
//
//void USARTx_Tx_IRQ(USART_Buf_TypeDef *USARTx_TxBuf_Struct)
//{
////    if(USARTx_TxBuf_Struct->usart_periph->ctrl1_bit.tdbeien != RESET)
// if( (DL_UART_Main_getPendingInterrupt(UART_HMI_INST))==DL_UART_MAIN_IIDX_EOT_DONE)
//     //      if( (DL_UART_Main_getPendingInterrupt(UART_HMI_INST))==  DL_UART_MAIN_IIDX_EOT_DONE)
//    {
////        if(RESET != usart_flag_get(USARTx_TxBuf_Struct->usart_periph, USART_TDBE_FLAG))
//      // if(DL_UART_isTXFIFOEmpty(UART_HMI_INST) == TRUE)
//       {
//
//            if((* USARTx_TxBuf_Struct).ucBufCnt)
//            {
//                --(* USARTx_TxBuf_Struct).ucBufCnt;
//                /* write one byte to the transmit data register */
////                usart_data_transmit(USARTx_TxBuf_Struct->usart_periph, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
//                DL_UART_Main_transmitData(UART_HMI_INST, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
//                if(++(* USARTx_TxBuf_Struct).ucBufRdInde >= (* USARTx_TxBuf_Struct).ucBufSize)
//                {
//                    (* USARTx_TxBuf_Struct).ucBufRdInde = 0;
//                }
//            }
//            else
//            {
//                /* Disable the UART Transmit Data Register Empty Interrupt */
////                usart_interrupt_enable(USARTx_TxBuf_Struct->usart_periph, USART_TDBE_INT, FALSE);
//                DL_UART_Main_disableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
//            }
//        }
//    }
//}

unsigned uartcnt=0;
void USARTx_RxTX_IRQ(USART_Buf_TypeDef *USARTx_RxBuf_Struct,USART_Buf_TypeDef *USARTx_TxBuf_Struct,USART_FrameBuf_TypeDef *USART_RxFrameBuf_Struct)
{

    UBYTE ucData;
    switch (DL_UART_Main_getPendingInterrupt(UART_HMI_INST))
       {
           case DL_UART_MAIN_IIDX_RX:
                       ucData = (UBYTE) DL_UART_Main_receiveDataBlocking(UART_HMI_INST);

                          USARTx_RxBuf_Struct->ul_UartComTimeOutCount = 0;
                          USART_RxFrameBuf_Struct->uwDataCount[USART_RxFrameBuf_Struct->ucBufWrIndex]++;
                          //if(((USARTx_RxBuf_Struct->ptUartHandel->Instance->SR) & 0x0000) == 0)
                          {
                              *((* USARTx_RxBuf_Struct).pcBufAddr + (* USARTx_RxBuf_Struct).ucBufWrInde) = ucData;
                              if(++(* USARTx_RxBuf_Struct).ucBufWrInde >= (* USARTx_RxBuf_Struct).ucBufSize)
                              {
                                  (* USARTx_RxBuf_Struct).ucBufWrInde = 0;
                              }
                              if(++(* USARTx_RxBuf_Struct).ucBufCnt > (* USARTx_RxBuf_Struct).ucBufSize)
                              {
                                  (* USARTx_RxBuf_Struct).ucBufCnt = (* USARTx_RxBuf_Struct).ucBufSize;
                                  (* USARTx_RxBuf_Struct).ucBufOvf = 1;
                              }
                          }

               break;
           case DL_UART_MAIN_IIDX_EOT_DONE:

               uartcnt++;
                if((* USARTx_TxBuf_Struct).ucBufCnt)
                {
                    --(* USARTx_TxBuf_Struct).ucBufCnt;
                    /* write one byte to the transmit data register */
    //                usart_data_transmit(USARTx_TxBuf_Struct->usart_periph, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
                    DL_UART_Main_transmitData(UART_HMI_INST, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
                    if(++(* USARTx_TxBuf_Struct).ucBufRdInde >= (* USARTx_TxBuf_Struct).ucBufSize)
                    {
                        (* USARTx_TxBuf_Struct).ucBufRdInde = 0;
                    }
                }
                else
                {
                    /* Disable the UART Transmit Data Register Empty Interrupt */
    //                usart_interrupt_enable(USARTx_TxBuf_Struct->usart_periph, USART_TDBE_INT, FALSE);
                      DL_UART_Main_disableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
                }

                //-----------


               break;
           default:
               break;
       }
}

//void USARTx_RxTX_IRQ(USART_Buf_TypeDef *USARTx_RxBuf_Struct,USART_Buf_TypeDef *USARTx_TxBuf_Struct)
//{
//    static unsigned uartcnt=0;
//    UBYTE ucData;
//    switch (DL_UART_Main_getPendingInterrupt(UART_HMI_INST))
//       {
//           case DL_UART_MAIN_IIDX_RX:
//               ucData =  DL_UART_Main_receiveDataBlocking(UART_HMI_INST);
//
//                             *((* USARTx_RxBuf_Struct).pcBufAddr + (* USARTx_RxBuf_Struct).ucBufWrInde) = ucData;
//                             if(++(* USARTx_RxBuf_Struct).ucBufWrInde >= (* USARTx_RxBuf_Struct).ucBufSize)
//                             {
//                                 (* USARTx_RxBuf_Struct).ucBufWrInde = 0;
//                             }
//                             if(++(* USARTx_RxBuf_Struct).ucBufCnt > (* USARTx_RxBuf_Struct).ucBufSize)
//                             {
//                                 (* USARTx_RxBuf_Struct).ucBufCnt = (* USARTx_RxBuf_Struct).ucBufSize;
//                                 (* USARTx_RxBuf_Struct).ucBufOvf = 1;
//                             }
//
//               break;
//           case DL_UART_MAIN_IIDX_EOT_DONE:
//
//               uartcnt++;
//                if((* USARTx_TxBuf_Struct).ucBufCnt)
//                {
//                    --(* USARTx_TxBuf_Struct).ucBufCnt;
//                    /* write one byte to the transmit data register */
//    //                usart_data_transmit(USARTx_TxBuf_Struct->usart_periph, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
//                    DL_UART_Main_transmitData(UART_HMI_INST, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
//                    if(++(* USARTx_TxBuf_Struct).ucBufRdInde >= (* USARTx_TxBuf_Struct).ucBufSize)
//                    {
//                        (* USARTx_TxBuf_Struct).ucBufRdInde = 0;
//                    }
//                }
//                else
//                {
//                    /* Disable the UART Transmit Data Register Empty Interrupt */
//    //                usart_interrupt_enable(USARTx_TxBuf_Struct->usart_periph, USART_TDBE_INT, FALSE);
//                     DL_UART_Main_disableInterrupt(UART_HMI_INST, DL_UART_MAIN_INTERRUPT_EOT_DONE );
//                }
//               break;
//           default:
//               break;
//       }
//}
/************************ (C) END OF FILE *********************************/