2128 lines
55 KiB
C
2128 lines
55 KiB
C
/********************************************************************************
|
||
Copyright (C), Sinowealth Electronic. Ltd.
|
||
Author: Sino
|
||
Version: V0.0
|
||
Date: 2020/04/26
|
||
History:
|
||
V2.0 2020/04/26 Preliminary
|
||
********************************************************************************/
|
||
#include "Main.h"
|
||
|
||
|
||
BOOL bISPFlg; //ISP升级标志，进入ISP程序
|
||
BOOL bUart0ReadFlg;
|
||
BOOL bUart0WriteFlg;
|
||
BOOL bUart0SndAckFlg; //UART已经发送ACK给主机
|
||
|
||
BOOL bUart1ReadFlg;
|
||
BOOL bUart1WriteFlg;
|
||
BOOL bUart1SndAckFlg; //UART已经发送ACK给主机
|
||
|
||
BOOL bUart2ReadFlg;
|
||
BOOL bUart2WriteFlg;
|
||
BOOL bUart2SndAckFlg; //UART已经发送ACK给主机
|
||
|
||
U8 xdata ucSubClassID;
|
||
U8 xdata ucUart0Buf[150] _at_ 0x400; //UART接收数据的BUF
|
||
U8 xdata ucUart0BufPT; //UART数据指针
|
||
U8 xdata ucUart0SndLength; //UART数据长度
|
||
U8 xdata ucUart0TimeoutCnt; //UART通讯定时器计数
|
||
|
||
U8 xdata ucUart1Buf[150] _at_ 0x4a0; //UART接收数据的BUF
|
||
U8 xdata ucUart1BufPT; //UART数据指针
|
||
U8 xdata ucUart1SndLength; //UART数据长度
|
||
U8 xdata ucUart1TimeoutCnt; //UART通讯定时器计数
|
||
|
||
U8 xdata ucUart2Buf[150] _at_ 0x540; //UART接收数据的BUF
|
||
U8 xdata ucUart2BufPT; //UART数据指针
|
||
U8 xdata ucUart2SndLength; //UART数据长度
|
||
U8 xdata ucUart2TimeoutCnt; //UART通讯定时器计数
|
||
|
||
U16 xdata uiReceCheckSum; //帧头判断正确
|
||
U8 xdata ucUartErrCode;
|
||
|
||
|
||
/*******************************************************************************
|
||
Function: Page1WrRdFuncTable()
|
||
Description:
|
||
Input: NULL
|
||
Output: NULL
|
||
Others: NULL
|
||
*******************************************************************************/
|
||
U16 code Page1WrRdFuncTable[18]=
|
||
{
|
||
SYS_PARA_MAP_ADDR, //SubClassID 0x00
|
||
SYSINFO_MAP_ADDR, //0x01
|
||
CHG_PARA_MAP_ADDR, //0x02
|
||
DSG_PARA_MAP_ADDR, //0x03
|
||
0x00, //0x04
|
||
DSG_PWM_PARA_MAP_ADDR, //0x05
|
||
CHG_TEMP_PARA_MAP_ADDR, //0x06
|
||
DSG_TEMP_PARA_MAP_ADDR, //0x07
|
||
BAL_PARA_MAP_ADDR, //0x08
|
||
SOC_PARA_MAP_ADDR, //0x09
|
||
AFE_PARA_MAP_ADDR, //0x0A
|
||
CALI_PARA_MAP_ADDR, //0x0B
|
||
DataflashCheck_Map_ADDR, //0x0C
|
||
0x00, //0x0D
|
||
0x00, //0x0E
|
||
0x00, //0x0F
|
||
0x00, //0x10
|
||
0x00, //0x11
|
||
};
|
||
|
||
/*******************************************************************************
|
||
Function: Page2WrRdFuncTable()
|
||
Description:
|
||
Input: NULL
|
||
Output: NULL
|
||
Others: NULL
|
||
*******************************************************************************/
|
||
U16 code Page2WrRdFuncTable[18]=
|
||
{
|
||
SYS_PARA_MAP_ADDR+32, //SubClassID 0x00
|
||
SYSINFO_MAP_ADDR+32, //0x01
|
||
CHG_PARA_MAP_ADDR+32, //0x02
|
||
DSG_PARA_MAP_ADDR+32, //0x03
|
||
0x00, //0x04
|
||
DSG_PWM_PARA_MAP_ADDR+32, //0x05
|
||
CHG_TEMP_PARA_MAP_ADDR+32, //0x06
|
||
DSG_TEMP_PARA_MAP_ADDR+32, //0x07
|
||
BAL_PARA_MAP_ADDR+32, //0x08
|
||
SOC_PARA_MAP_ADDR+32, //0x09
|
||
AFE_PARA_MAP_ADDR+32, //0x0A
|
||
CALI_PARA_MAP_ADDR+32, //0x0B
|
||
DataflashCheck_Map_ADDR+32, //0x0C
|
||
0x00, //0x0D
|
||
0x00, //0x0E
|
||
0x00, //0x0F
|
||
0x00, //0x10
|
||
0x00, //0x11
|
||
};
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0Handshake
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0通讯握手协议
|
||
*************************************************************************************************/
|
||
void Uart0Handshake(void)
|
||
{
|
||
if(ucUart0Buf[2] == 0x00) //Testing equipment is properly
|
||
{
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1Handshake
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1通讯握手协议
|
||
*************************************************************************************************/
|
||
void Uart1Handshake(void)
|
||
{
|
||
if(ucUart1Buf[2] == 0x00) //Testing equipment is properly
|
||
{
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2Handshake
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART2通讯握手协议
|
||
*************************************************************************************************/
|
||
void Uart2Handshake(void)
|
||
{
|
||
if(ucUart2Buf[2] == 0x00) //Testing equipment is properly
|
||
{
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0WriteInfo
|
||
* 参 数: ptr：数据需要写入的起始地址
|
||
* 返回值: 无
|
||
* 描 述: UART0写数据
|
||
*************************************************************************************************/
|
||
void Uart0WriteInfo(U8 xdata *ptr)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
for(i=0; i<ucUart0Buf[UART_LENGTH]; i++)
|
||
{
|
||
McuWDTClear();
|
||
*ptr = ucUart0Buf[3+i];
|
||
ptr++;
|
||
}
|
||
bMcuFlashWrWaitFlg = 1; //Updated parameters, and written to the flash
|
||
bMcuFlashWrWaitCnt = 0;
|
||
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1WriteInfo
|
||
* 参 数: ptr：数据需要写入的起始地址
|
||
* 返回值: 无
|
||
* 描 述: UART1写数据
|
||
*************************************************************************************************/
|
||
void Uart1WriteInfo(U8 xdata *ptr)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
for(i=0; i<ucUart1Buf[UART_LENGTH]; i++)
|
||
{
|
||
McuWDTClear();
|
||
*ptr = ucUart1Buf[3+i];
|
||
ptr++;
|
||
}
|
||
bMcuFlashWrWaitFlg = 1; //Updated parameters, and written to the flash
|
||
bMcuFlashWrWaitCnt = 0;
|
||
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2WriteInfo
|
||
* 参 数: ptr：数据需要写入的起始地址
|
||
* 返回值: 无
|
||
* 描 述: UART2写数据
|
||
*************************************************************************************************/
|
||
void Uart2WriteInfo(U8 xdata *ptr)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
for(i=0; i<ucUart2Buf[UART_LENGTH]; i++)
|
||
{
|
||
McuWDTClear();
|
||
*ptr = ucUart2Buf[3+i];
|
||
ptr++;
|
||
}
|
||
bMcuFlashWrWaitFlg = 1; //Updated parameters, and written to the flash
|
||
bMcuFlashWrWaitCnt = 0;
|
||
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0ReadInfo
|
||
* 参 数: ptr：数据需要读出的起始地址
|
||
* 返回值: 无
|
||
* 描 述: UART0读数据
|
||
*************************************************************************************************/
|
||
void Uart0ReadInfo(U8 xdata *ptr)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart0Buf[UART_LENGTH] > 140)
|
||
{
|
||
ucUart0Buf[UART_LENGTH] = 0;
|
||
}
|
||
for(i=0; i<ucUart0Buf[UART_LENGTH]; i++)
|
||
{
|
||
McuWDTClear();
|
||
ucUart0Buf[3+i] = *ptr;
|
||
ptr++;
|
||
}
|
||
ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] = CRC8cal(&ucUart0Buf,ucUart0Buf[UART_LENGTH]+3);
|
||
|
||
Uart0SendData(); //Start Send Data; Set UART REG
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1ReadInfo
|
||
* 参 数: ptr：数据需要读出的起始地址
|
||
* 返回值: 无
|
||
* 描 述: UART1读数据
|
||
*************************************************************************************************/
|
||
void Uart1ReadInfo(U8 xdata *ptr)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart1Buf[UART_LENGTH] > 140)
|
||
{
|
||
ucUart1Buf[UART_LENGTH] = 0;
|
||
}
|
||
for(i=0; i<ucUart1Buf[UART_LENGTH]; i++)
|
||
{
|
||
McuWDTClear();
|
||
ucUart1Buf[3+i] = *ptr;
|
||
ptr++;
|
||
}
|
||
ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] = CRC8cal(&ucUart1Buf,ucUart1Buf[UART_LENGTH]+3);
|
||
|
||
Uart1SendData(); //Start Send Data; Set UART REG
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2ReadInfo
|
||
* 参 数: ptr：数据需要读出的起始地址
|
||
* 返回值: 无
|
||
* 描 述: UART2读数据
|
||
*************************************************************************************************/
|
||
void Uart2ReadInfo(U8 xdata *ptr)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart2Buf[UART_LENGTH] > 140)
|
||
{
|
||
ucUart2Buf[UART_LENGTH] = 0;
|
||
}
|
||
for(i=0; i<ucUart2Buf[UART_LENGTH]; i++)
|
||
{
|
||
McuWDTClear();
|
||
ucUart2Buf[3+i] = *ptr;
|
||
ptr++;
|
||
}
|
||
ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] = CRC8cal(&ucUart2Buf,ucUart2Buf[UART_LENGTH]+3);
|
||
|
||
Uart2SendData(); //Start Send Data; Set UART REG
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0WriteManufacture
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: 上位机通过UART0写入自定义命令
|
||
0x41：系统复位
|
||
0x05：系统进入PD
|
||
*************************************************************************************************/
|
||
void Uart0WriteManufacture(void)
|
||
{
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
if(ucUart0Buf[4] == 0x41) //0x0041: Reset system
|
||
{
|
||
ucResetFlag = 0x12;
|
||
}
|
||
else if(ucUart0Buf[4] == 0x05) //0x0005: Enter sleep mode
|
||
{
|
||
bPCEnterPDFlg = 1;
|
||
}
|
||
bUart0SndAckFlg = 0;
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1WriteManufacture
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: 上位机通过UART1写入自定义命令
|
||
0x41：系统复位
|
||
0x05：系统进入PD
|
||
*************************************************************************************************/
|
||
void Uart1WriteManufacture(void)
|
||
{
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
if(ucUart1Buf[4] == 0x41) //0x0041: Reset system
|
||
{
|
||
ucResetFlag = 0x12;
|
||
}
|
||
else if(ucUart1Buf[4] == 0x05) //0x0005: Enter sleep mode
|
||
{
|
||
bPCEnterPDFlg = 1;
|
||
}
|
||
bUart1SndAckFlg = 0;
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2WriteManufacture
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: 上位机通过UART2写入自定义命令
|
||
0x41：系统复位
|
||
0x05：系统进入PD
|
||
*************************************************************************************************/
|
||
void Uart2WriteManufacture(void)
|
||
{
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
if(ucUart2Buf[4] == 0x41) //0x0041: Reset system
|
||
{
|
||
ucResetFlag = 0x12;
|
||
}
|
||
else if(ucUart2Buf[4] == 0x05) //0x0005: Enter sleep mode
|
||
{
|
||
bPCEnterPDFlg = 1;
|
||
}
|
||
bUart2SndAckFlg = 0;
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0ReadSubClassID
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0解析子命令号
|
||
*************************************************************************************************/
|
||
void Uart0ReadSubClassID(void)
|
||
{
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
ucSubClassID=ucUart0Buf[3];
|
||
|
||
bUart0SndAckFlg = 0;
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1ReadSubClassID
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1解析子命令号
|
||
*************************************************************************************************/
|
||
void Uart1ReadSubClassID(void)
|
||
{
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
ucSubClassID=ucUart1Buf[3];
|
||
|
||
bUart1SndAckFlg = 0;
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2ReadSubClassID
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART2解析子命令号
|
||
*************************************************************************************************/
|
||
void Uart2ReadSubClassID(void)
|
||
{
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
ucSubClassID=ucUart2Buf[3];
|
||
|
||
bUart2SndAckFlg = 0;
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0RdCmdProcess
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART读命令处理函数
|
||
*************************************************************************************************/
|
||
void Uart0RdCmdProcess(void)
|
||
{
|
||
U8 xdata *rdaddr;
|
||
|
||
switch(ucUart0Buf[UART_CMD_NO])
|
||
{
|
||
case CELL1:
|
||
case CELL2:
|
||
case CELL3:
|
||
case CELL4:
|
||
case CELL5:
|
||
case CELL6:
|
||
case CELL7:
|
||
case CELL8:
|
||
case CELL9:
|
||
case CELL10:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiVCell[ucUart0Buf[UART_CMD_NO]-1]);
|
||
break;
|
||
|
||
case TOTAL_VOLTAGE:
|
||
Uart0ReadInfo((U8 xdata *)&Info.ulVoltage);
|
||
break;
|
||
|
||
case CADC_CURRENT:
|
||
Uart0ReadInfo((U8 xdata *)&Info.slCurr);
|
||
break;
|
||
|
||
case EXT_TEMP1:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiTS[0]);
|
||
break;
|
||
|
||
case EXT_TEMP2:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiTS[1]);
|
||
break;
|
||
|
||
case DIE_TEMP1:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiICTempe[0]);
|
||
break;
|
||
|
||
case DIE_TEMP2:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiICTempe[1]);
|
||
break;
|
||
|
||
case FULL_CHG_CAP:
|
||
Uart0ReadInfo((U8 xdata *)&Info.ulFCC);
|
||
break;
|
||
|
||
case REMAIN_CAP:
|
||
Uart0ReadInfo((U8 xdata *)&Info.ulRC);
|
||
break;
|
||
|
||
case R_SOC:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiRSOC);
|
||
break;
|
||
|
||
case CYCLE_COUNT:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiCycleCount);
|
||
break;
|
||
|
||
case PACK_STATUS:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiPackStatus);
|
||
break;
|
||
|
||
case BATTERY_STATUS:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiBatStatus);
|
||
break;
|
||
|
||
case PACK_CONFIG:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiPackConfig);
|
||
break;
|
||
|
||
case MANUFACTURE_COMMAND:
|
||
Uart0ReadInfo((U8 xdata *)&Info.uiManuCommand);
|
||
break;
|
||
|
||
default: //read extern EEPRom data
|
||
if(ucUart0Buf[UART_LENGTH] >= 128)
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bUart0E2PRdData = 1;
|
||
}
|
||
else if(ucUart0Buf[UART_CMD_NO] == SUB_PAGE1 && ucSubClassID == RTC_SUBID)
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bUart0RTCRdTime = 1;
|
||
}
|
||
else if(ucUart0Buf[UART_CMD_NO] == SUB_PAGE1)
|
||
{
|
||
rdaddr = (U8 xdata *)Page1WrRdFuncTable[ucSubClassID];
|
||
Uart0ReadInfo(rdaddr);
|
||
}
|
||
else if(ucUart0Buf[UART_CMD_NO] == SUB_PAGE2)
|
||
{
|
||
rdaddr = (U8 xdata *)Page2WrRdFuncTable[ucSubClassID];
|
||
Uart0ReadInfo(rdaddr);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0RdCmdProcess
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART读命令处理函数
|
||
*************************************************************************************************/
|
||
void Uart1RdCmdProcess(void)
|
||
{
|
||
U8 xdata *rdaddr;
|
||
|
||
switch(ucUart1Buf[UART_CMD_NO])
|
||
{
|
||
case CELL1:
|
||
case CELL2:
|
||
case CELL3:
|
||
case CELL4:
|
||
case CELL5:
|
||
case CELL6:
|
||
case CELL7:
|
||
case CELL8:
|
||
case CELL9:
|
||
case CELL10:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiVCell[ucUart1Buf[UART_CMD_NO]-1]);
|
||
break;
|
||
|
||
case TOTAL_VOLTAGE:
|
||
Uart1ReadInfo((U8 xdata *)&Info.ulVoltage);
|
||
break;
|
||
|
||
case CADC_CURRENT:
|
||
Uart1ReadInfo((U8 xdata *)&Info.slCurr);
|
||
break;
|
||
|
||
case EXT_TEMP1:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiTS[0]);
|
||
break;
|
||
|
||
case EXT_TEMP2:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiTS[1]);
|
||
break;
|
||
|
||
case DIE_TEMP1:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiICTempe[0]);
|
||
break;
|
||
|
||
case DIE_TEMP2:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiICTempe[1]);
|
||
break;
|
||
|
||
case FULL_CHG_CAP:
|
||
Uart1ReadInfo((U8 xdata *)&Info.ulFCC);
|
||
break;
|
||
|
||
case REMAIN_CAP:
|
||
Uart1ReadInfo((U8 xdata *)&Info.ulRC);
|
||
break;
|
||
|
||
case R_SOC:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiRSOC);
|
||
break;
|
||
|
||
case CYCLE_COUNT:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiCycleCount);
|
||
break;
|
||
|
||
case PACK_STATUS:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiPackStatus);
|
||
break;
|
||
|
||
case BATTERY_STATUS:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiBatStatus);
|
||
break;
|
||
|
||
case PACK_CONFIG:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiPackConfig);
|
||
break;
|
||
|
||
case MANUFACTURE_COMMAND:
|
||
Uart1ReadInfo((U8 xdata *)&Info.uiManuCommand);
|
||
break;
|
||
|
||
default: //read extern EEPRom data
|
||
if(ucUart1Buf[UART_LENGTH] >= 128)
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bUart1E2PRdData = 1;
|
||
}
|
||
else if(ucUart1Buf[UART_CMD_NO] == SUB_PAGE1 && ucSubClassID == RTC_SUBID)
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bUart1RTCRdTime = 1;
|
||
}
|
||
else if(ucUart1Buf[UART_CMD_NO] == SUB_PAGE1)
|
||
{
|
||
rdaddr = (U8 xdata *)Page1WrRdFuncTable[ucSubClassID];
|
||
Uart1ReadInfo(rdaddr);
|
||
}
|
||
else if(ucUart1Buf[UART_CMD_NO] == SUB_PAGE2)
|
||
{
|
||
rdaddr = (U8 xdata *)Page2WrRdFuncTable[ucSubClassID];
|
||
Uart1ReadInfo(rdaddr);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0RdCmdProcess
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART读命令处理函数
|
||
*************************************************************************************************/
|
||
void Uart2RdCmdProcess(void)
|
||
{
|
||
U8 xdata *rdaddr;
|
||
|
||
switch(ucUart2Buf[UART_CMD_NO])
|
||
{
|
||
case CELL1:
|
||
case CELL2:
|
||
case CELL3:
|
||
case CELL4:
|
||
case CELL5:
|
||
case CELL6:
|
||
case CELL7:
|
||
case CELL8:
|
||
case CELL9:
|
||
case CELL10:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiVCell[ucUart2Buf[UART_CMD_NO]-1]);
|
||
break;
|
||
|
||
case TOTAL_VOLTAGE:
|
||
Uart2ReadInfo((U8 xdata *)&Info.ulVoltage);
|
||
break;
|
||
|
||
case CADC_CURRENT:
|
||
Uart2ReadInfo((U8 xdata *)&Info.slCurr);
|
||
break;
|
||
|
||
case EXT_TEMP1:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiTS[0]);
|
||
break;
|
||
|
||
case EXT_TEMP2:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiTS[1]);
|
||
break;
|
||
|
||
case DIE_TEMP1:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiICTempe[0]);
|
||
break;
|
||
|
||
case DIE_TEMP2:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiICTempe[1]);
|
||
break;
|
||
|
||
case FULL_CHG_CAP:
|
||
Uart2ReadInfo((U8 xdata *)&Info.ulFCC);
|
||
break;
|
||
|
||
case REMAIN_CAP:
|
||
Uart2ReadInfo((U8 xdata *)&Info.ulRC);
|
||
break;
|
||
|
||
case R_SOC:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiRSOC);
|
||
break;
|
||
|
||
case CYCLE_COUNT:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiCycleCount);
|
||
break;
|
||
|
||
case PACK_STATUS:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiPackStatus);
|
||
break;
|
||
|
||
case BATTERY_STATUS:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiBatStatus);
|
||
break;
|
||
|
||
case PACK_CONFIG:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiPackConfig);
|
||
break;
|
||
|
||
case MANUFACTURE_COMMAND:
|
||
Uart2ReadInfo((U8 xdata *)&Info.uiManuCommand);
|
||
break;
|
||
|
||
default: //read extern EEPRom data
|
||
if(ucUart2Buf[UART_LENGTH] >= 128)
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bUart2E2PRdData = 1;
|
||
}
|
||
else if(ucUart2Buf[UART_CMD_NO] == SUB_PAGE1 && ucSubClassID == RTC_SUBID)
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bUart2RTCRdTime = 1;
|
||
}
|
||
else if(ucUart2Buf[UART_CMD_NO] == SUB_PAGE1)
|
||
{
|
||
rdaddr = (U8 xdata *)Page1WrRdFuncTable[ucSubClassID];
|
||
Uart2ReadInfo(rdaddr);
|
||
}
|
||
else if(ucUart2Buf[UART_CMD_NO] == SUB_PAGE2)
|
||
{
|
||
rdaddr = (U8 xdata *)Page2WrRdFuncTable[ucSubClassID];
|
||
Uart2ReadInfo(rdaddr);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0CaliCurrent
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0通讯发送校准总电压的数据
|
||
*************************************************************************************************/
|
||
void Uart0CaliVoltage(void)
|
||
{
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
ulExtVPack = ((U16)ucUart0Buf[3]<<8)|ucUart0Buf[4];
|
||
|
||
if(!ulExtVPack)
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
else
|
||
{
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x01;
|
||
Uart0SendAck();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1CaliCurrent
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1通讯发送校准总电压的数据
|
||
*************************************************************************************************/
|
||
void Uart1CaliVoltage(void)
|
||
{
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
ulExtVPack = ((U16)ucUart1Buf[3]<<8)|ucUart1Buf[4];
|
||
|
||
if(!ulExtVPack)
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
else
|
||
{
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x01;
|
||
Uart1SendAck();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2CaliCurrent
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART2通讯发送校准总电压的数据
|
||
*************************************************************************************************/
|
||
void Uart2CaliVoltage(void)
|
||
{
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
ulExtVPack = ((U16)ucUart2Buf[3]<<8)|ucUart2Buf[4];
|
||
|
||
if(!ulExtVPack)
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
else
|
||
{
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x01;
|
||
Uart2SendAck();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0CaliCurrent、Uart0CaliCurOffset
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0通讯发送校准电流采集增益&Offset的数据
|
||
*************************************************************************************************/
|
||
void Uart0CaliCurrent(void)
|
||
{
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
slExtCur = ((U32)ucUart0Buf[3]<<24)
|
||
| ((U32)ucUart0Buf[4]<<16)
|
||
| ((U32)ucUart0Buf[5]<<8)
|
||
| ((U32)ucUart0Buf[6]);
|
||
|
||
if((!AFE.siCurr) || (!slExtCur))
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
else
|
||
{
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x10;
|
||
Uart0SendAck();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
|
||
|
||
void Uart0CaliCurOffset(void)
|
||
{
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration offset Current
|
||
ucExtcaliSwitch1 |= 0x20;
|
||
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1CaliCurrent、Uart1CaliCurOffset
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1通讯发送校准电流采集增益&Offset的数据
|
||
*************************************************************************************************/
|
||
void Uart1CaliCurrent(void)
|
||
{
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
slExtCur = ((U32)ucUart1Buf[3]<<24)
|
||
| ((U32)ucUart1Buf[4]<<16)
|
||
| ((U32)ucUart1Buf[5]<<8)
|
||
| ((U32)ucUart1Buf[6]);
|
||
|
||
if((!AFE.siCurr) || (!slExtCur))
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
else
|
||
{
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x10;
|
||
Uart1SendAck();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
|
||
|
||
void Uart1CaliCurOffset(void)
|
||
{
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration offset Current
|
||
ucExtcaliSwitch1 |= 0x20;
|
||
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2CaliCurrent、Uart2CaliCurOffset
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART2通讯发送校准电流采集增益&Offset的数据
|
||
*************************************************************************************************/
|
||
void Uart2CaliCurrent(void)
|
||
{
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
slExtCur = ((U32)ucUart2Buf[3]<<24)
|
||
| ((U32)ucUart2Buf[4]<<16)
|
||
| ((U32)ucUart2Buf[5]<<8)
|
||
| ((U32)ucUart2Buf[6]);
|
||
|
||
if((!AFE.siCurr) || (!slExtCur))
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
else
|
||
{
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x10;
|
||
Uart2SendAck();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
|
||
|
||
void Uart2CaliCurOffset(void)
|
||
{
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration offset Current
|
||
ucExtcaliSwitch1 |= 0x20;
|
||
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0CaliTS1、Uart0CaliTS2
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0通讯发送校准TS1/TS2数据
|
||
*************************************************************************************************/
|
||
void Uart0CaliTS1(void)
|
||
{
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration TS1
|
||
uiExtTemp1 = ((U16)ucUart0Buf[3]<<8)|ucUart0Buf[4];
|
||
ucExtcaliSwitch1 |= 0x04;
|
||
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
|
||
|
||
void Uart0CaliTS2(void)
|
||
{
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration TS2
|
||
uiExtTemp2 = ((U16)ucUart0Buf[3]<<8)|ucUart0Buf[4];
|
||
ucExtcaliSwitch1 |= 0x08;
|
||
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1CaliTS1、Uart1CaliTS2
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1通讯发送校准TS1/TS2数据
|
||
*************************************************************************************************/
|
||
void Uart1CaliTS1(void)
|
||
{
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration TS1
|
||
uiExtTemp1 = ((U16)ucUart1Buf[3]<<8)|ucUart1Buf[4];
|
||
ucExtcaliSwitch1 |= 0x04;
|
||
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
|
||
|
||
void Uart1CaliTS2(void)
|
||
{
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration TS2
|
||
uiExtTemp2 = ((U16)ucUart1Buf[3]<<8)|ucUart1Buf[4];
|
||
ucExtcaliSwitch1 |= 0x08;
|
||
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2CaliTS1、Uart2CaliTS2
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART2通讯发送校准TS1/TS2数据
|
||
*************************************************************************************************/
|
||
void Uart2CaliTS1(void)
|
||
{
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration TS1
|
||
uiExtTemp1 = ((U16)ucUart2Buf[3]<<8)|ucUart2Buf[4];
|
||
ucExtcaliSwitch1 |= 0x04;
|
||
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
|
||
|
||
void Uart2CaliTS2(void)
|
||
{
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
bCaliFlg = 1; //Calibration TS2
|
||
uiExtTemp2 = ((U16)ucUart2Buf[3]<<8)|ucUart2Buf[4];
|
||
ucExtcaliSwitch1 |= 0x08;
|
||
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0CaliRTC
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0通讯发送校准RTC数据
|
||
*************************************************************************************************/
|
||
void Uart0CaliRTC(void)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart0Buf[3+ucUart0Buf[UART_LENGTH]] == CRC8cal(&ucUart0Buf, ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
for(i=0; i<7; i++)
|
||
{
|
||
ucExtRTC[i] = ucUart0Buf[3+i];
|
||
}
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x80;
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1CaliRTC
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1通讯发送校准RTC数据
|
||
*************************************************************************************************/
|
||
void Uart1CaliRTC(void)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart1Buf[3+ucUart1Buf[UART_LENGTH]] == CRC8cal(&ucUart1Buf, ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
for(i=0; i<7; i++)
|
||
{
|
||
ucExtRTC[i] = ucUart1Buf[3+i];
|
||
}
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x80;
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2CaliRTC
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART2通讯发送校准RTC数据
|
||
*************************************************************************************************/
|
||
void Uart2CaliRTC(void)
|
||
{
|
||
U8 i;
|
||
|
||
if(ucUart2Buf[3+ucUart2Buf[UART_LENGTH]] == CRC8cal(&ucUart2Buf, ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
for(i=0; i<7; i++)
|
||
{
|
||
ucExtRTC[i] = ucUart2Buf[3+i];
|
||
}
|
||
bCaliFlg = 1;
|
||
ucExtcaliSwitch1 |= 0x80;
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0WrCmdProcess
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0写命令处理函数
|
||
*************************************************************************************************/
|
||
void Uart0WrCmdProcess(void)
|
||
{
|
||
U8 xdata *rdaddr;
|
||
switch(ucUart0Buf[UART_CMD_NO])
|
||
{
|
||
case MANUFACTURE_COMMAND:
|
||
Uart0WriteManufacture();
|
||
break;
|
||
case DATA_FLASH_COMMAND:
|
||
Uart0ReadSubClassID(); //accept command is dataflashcommand 0x77
|
||
break;
|
||
case CALI_CUR_COMMAND:
|
||
Uart0CaliCurrent();
|
||
break;
|
||
case CALI_VOL_COMMAND:
|
||
Uart0CaliVoltage();
|
||
break;
|
||
case CALI_ZERO_CUR_COMMAND:
|
||
Uart0CaliCurOffset();
|
||
break;
|
||
case CALI_TS1_COMMAND:
|
||
Uart0CaliTS1();
|
||
break;
|
||
case CALI_TS2_COMMAND:
|
||
Uart0CaliTS2();
|
||
break;
|
||
|
||
case CALI_RTC_COMMAND:
|
||
Uart0CaliRTC();
|
||
break;
|
||
case SUB_PAGE1:
|
||
rdaddr = (U8 xdata *)Page1WrRdFuncTable[ucSubClassID];
|
||
Uart0WriteInfo(rdaddr);
|
||
break;
|
||
case SUB_PAGE2:
|
||
rdaddr = (U8 xdata *)Page2WrRdFuncTable[ucSubClassID];
|
||
Uart0WriteInfo(rdaddr);
|
||
break;
|
||
|
||
case CMD_E2PROM_ERASE:
|
||
if(ucUart0Buf[UART_DATA] == 0x55) //Testing equipment is properly
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bE2PErase = 1;
|
||
Uart0SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart0SendNack();
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1WrCmdProcess
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1写命令处理函数
|
||
*************************************************************************************************/
|
||
void Uart1WrCmdProcess(void)
|
||
{
|
||
U8 xdata *rdaddr;
|
||
switch(ucUart1Buf[UART_CMD_NO])
|
||
{
|
||
case MANUFACTURE_COMMAND:
|
||
Uart1WriteManufacture();
|
||
break;
|
||
case DATA_FLASH_COMMAND:
|
||
Uart1ReadSubClassID(); //accept command is dataflashcommand 0x77
|
||
break;
|
||
case CALI_CUR_COMMAND:
|
||
Uart1CaliCurrent();
|
||
break;
|
||
case CALI_VOL_COMMAND:
|
||
Uart1CaliVoltage();
|
||
break;
|
||
case CALI_ZERO_CUR_COMMAND:
|
||
Uart1CaliCurOffset();
|
||
break;
|
||
case CALI_TS1_COMMAND:
|
||
Uart1CaliTS1();
|
||
break;
|
||
case CALI_TS2_COMMAND:
|
||
Uart1CaliTS2();
|
||
break;
|
||
|
||
case CALI_RTC_COMMAND:
|
||
Uart1CaliRTC();
|
||
break;
|
||
case SUB_PAGE1:
|
||
rdaddr = (U8 xdata *)Page1WrRdFuncTable[ucSubClassID];
|
||
Uart1WriteInfo(rdaddr);
|
||
break;
|
||
case SUB_PAGE2:
|
||
rdaddr = (U8 xdata *)Page2WrRdFuncTable[ucSubClassID];
|
||
Uart1WriteInfo(rdaddr);
|
||
break;
|
||
|
||
case CMD_E2PROM_ERASE:
|
||
if(ucUart1Buf[UART_DATA] == 0x55) //Testing equipment is properly
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bE2PErase = 1;
|
||
Uart1SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart1SendNack();
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2WrCmdProcess
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART2写命令处理函数
|
||
*************************************************************************************************/
|
||
void Uart2WrCmdProcess(void)
|
||
{
|
||
U8 xdata *rdaddr;
|
||
switch(ucUart2Buf[UART_CMD_NO])
|
||
{
|
||
case MANUFACTURE_COMMAND:
|
||
Uart2WriteManufacture();
|
||
break;
|
||
case DATA_FLASH_COMMAND:
|
||
Uart2ReadSubClassID(); //accept command is dataflashcommand 0x77
|
||
break;
|
||
case CALI_CUR_COMMAND:
|
||
Uart2CaliCurrent();
|
||
break;
|
||
case CALI_VOL_COMMAND:
|
||
Uart2CaliVoltage();
|
||
break;
|
||
case CALI_ZERO_CUR_COMMAND:
|
||
Uart2CaliCurOffset();
|
||
break;
|
||
case CALI_TS1_COMMAND:
|
||
Uart2CaliTS1();
|
||
break;
|
||
case CALI_TS2_COMMAND:
|
||
Uart2CaliTS2();
|
||
break;
|
||
|
||
case CALI_RTC_COMMAND:
|
||
Uart2CaliRTC();
|
||
break;
|
||
case SUB_PAGE1:
|
||
rdaddr = (U8 xdata *)Page1WrRdFuncTable[ucSubClassID];
|
||
Uart2WriteInfo(rdaddr);
|
||
break;
|
||
case SUB_PAGE2:
|
||
rdaddr = (U8 xdata *)Page2WrRdFuncTable[ucSubClassID];
|
||
Uart2WriteInfo(rdaddr);
|
||
break;
|
||
|
||
case CMD_E2PROM_ERASE:
|
||
if(ucUart2Buf[UART_DATA] == 0x55) //Testing equipment is properly
|
||
{
|
||
bE2PProcessFlg = 1;
|
||
bE2PErase = 1;
|
||
Uart2SendAck();
|
||
}
|
||
else
|
||
{
|
||
Uart2SendNack();
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart0IapCheckHandshake
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: IAP和ISP握手协议
|
||
*************************************************************************************************/
|
||
void Uart0IapCheckHandshake(void)
|
||
{
|
||
U8 i, databak;
|
||
U16 checksum = 0;
|
||
|
||
if(ucUart0BufPT == 2)
|
||
{
|
||
if(ucUart0Buf[HEARD2] != 0xA5)
|
||
{
|
||
ucUart0BufPT = 0;
|
||
}
|
||
else
|
||
{
|
||
uiReceCheckSum = 0; //帧头判断正确
|
||
ucUartErrCode = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(ucUart0BufPT < (ucUart0Buf[LENGTH]+9))
|
||
{
|
||
if(ucUart0BufPT <= (ucUart0Buf[LENGTH]+7))
|
||
{
|
||
uiReceCheckSum += ucUart0Buf[ucUart0BufPT-1];
|
||
}
|
||
if(ucUart0BufPT == (TARGET+1)) //检查ID
|
||
{
|
||
if(ucUart0Buf[TARGET] != IAP_BMSID)
|
||
{
|
||
ucUart0BufPT = 0;
|
||
}
|
||
}
|
||
else if(ucUart0BufPT == (COMMAND+1)) //检查COMMAND
|
||
{
|
||
if((ucUart0Buf[COMMAND] != IAP_CMD_HANDSHAKE))
|
||
{
|
||
ucUartErrCode |= IAPERROR_CMD;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ucUart0BufPT = 0;
|
||
if(uiReceCheckSum != ((ucUart0Buf[ucUart0Buf[LENGTH]+8]<<8) + ucUart0Buf[ucUart0Buf[LENGTH]+7]))
|
||
{
|
||
ucUartErrCode |= IAPERROR_CHECKSUM;
|
||
}
|
||
|
||
if(ucUartErrCode != 0) //如果有错误代码则不执行命令处理
|
||
{
|
||
ucUart0Buf[INDEXES] = ucUartErrCode;
|
||
}
|
||
else
|
||
{
|
||
bISPFlg = 1; //跳转到BOOT区
|
||
ucUart0Buf[INDEXES] = 0;
|
||
}
|
||
|
||
ucUart0Buf[LENGTH] = 0;
|
||
ucUart0Buf[COMMAND] = 0x0B;
|
||
|
||
databak = ucUart0Buf[SOURCE]; //交换源ID和目标ID
|
||
ucUart0Buf[SOURCE] = ucUart0Buf[TARGET];
|
||
ucUart0Buf[TARGET] = databak;
|
||
|
||
for(i=2; i<(ucUart0Buf[LENGTH]+7); i++)
|
||
{
|
||
checksum += ucUart0Buf[i];
|
||
}
|
||
|
||
ucUart0Buf[7+ucUart0Buf[LENGTH]] = checksum%256;
|
||
ucUart0Buf[8+ucUart0Buf[LENGTH]] = checksum/256;
|
||
|
||
Uart0SendAck();
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart1IapCheckHandshake
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: IAP和ISP握手协议
|
||
*************************************************************************************************/
|
||
void Uart1IapCheckHandshake(void)
|
||
{
|
||
U8 i, databak;
|
||
U16 checksum = 0;
|
||
|
||
if(ucUart1BufPT == 2)
|
||
{
|
||
if(ucUart1Buf[HEARD2] != 0xA5)
|
||
{
|
||
ucUart1BufPT = 0;
|
||
}
|
||
else
|
||
{
|
||
uiReceCheckSum = 0; //帧头判断正确
|
||
ucUartErrCode = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(ucUart1BufPT < (ucUart1Buf[LENGTH]+9))
|
||
{
|
||
if(ucUart1BufPT <= (ucUart1Buf[LENGTH]+7))
|
||
{
|
||
uiReceCheckSum += ucUart1Buf[ucUart1BufPT-1];
|
||
}
|
||
if(ucUart1BufPT == (TARGET+1)) //检查ID
|
||
{
|
||
if(ucUart1Buf[TARGET] != IAP_BMSID)
|
||
{
|
||
ucUart1BufPT = 0;
|
||
}
|
||
}
|
||
else if(ucUart1BufPT == (COMMAND+1)) //检查COMMAND
|
||
{
|
||
if((ucUart1Buf[COMMAND] != IAP_CMD_HANDSHAKE))
|
||
{
|
||
ucUartErrCode |= IAPERROR_CMD;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ucUart1BufPT = 0;
|
||
if(uiReceCheckSum != ((ucUart1Buf[ucUart1Buf[LENGTH]+8]<<8) + ucUart1Buf[ucUart1Buf[LENGTH]+7]))
|
||
{
|
||
ucUartErrCode |= IAPERROR_CHECKSUM;
|
||
}
|
||
|
||
if(ucUartErrCode != 0) //如果有错误代码则不执行命令处理
|
||
{
|
||
ucUart1Buf[INDEXES] = ucUartErrCode;
|
||
}
|
||
else
|
||
{
|
||
bISPFlg = 1; //跳转到BOOT区
|
||
ucUart1Buf[INDEXES] = 0;
|
||
}
|
||
|
||
ucUart1Buf[LENGTH] = 0;
|
||
ucUart1Buf[COMMAND] = 0x0B;
|
||
|
||
databak = ucUart1Buf[SOURCE]; //交换源ID和目标ID
|
||
ucUart1Buf[SOURCE] = ucUart1Buf[TARGET];
|
||
ucUart1Buf[TARGET] = databak;
|
||
|
||
for(i=2; i<(ucUart1Buf[LENGTH]+7); i++)
|
||
{
|
||
checksum += ucUart1Buf[i];
|
||
}
|
||
|
||
ucUart1Buf[7+ucUart1Buf[LENGTH]] = checksum%256;
|
||
ucUart1Buf[8+ucUart1Buf[LENGTH]] = checksum/256;
|
||
|
||
Uart1SendAck();
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: Uart2IapCheckHandshake
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: IAP和ISP握手协议
|
||
*************************************************************************************************/
|
||
void Uart2IapCheckHandshake(void)
|
||
{
|
||
U8 i, databak;
|
||
U16 checksum = 0;
|
||
|
||
if(ucUart2BufPT == 2)
|
||
{
|
||
if(ucUart2Buf[HEARD2] != 0xA5)
|
||
{
|
||
ucUart2BufPT = 0;
|
||
}
|
||
else
|
||
{
|
||
uiReceCheckSum = 0; //帧头判断正确
|
||
ucUartErrCode = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(ucUart2BufPT < (ucUart2Buf[LENGTH]+9))
|
||
{
|
||
if(ucUart2BufPT <= (ucUart2Buf[LENGTH]+7))
|
||
{
|
||
uiReceCheckSum += ucUart2Buf[ucUart2BufPT-1];
|
||
}
|
||
if(ucUart2BufPT == (TARGET+1)) //检查ID
|
||
{
|
||
if(ucUart2Buf[TARGET] != IAP_BMSID)
|
||
{
|
||
ucUart2BufPT = 0;
|
||
}
|
||
}
|
||
else if(ucUart2BufPT == (COMMAND+1)) //检查COMMAND
|
||
{
|
||
if((ucUart2Buf[COMMAND] != IAP_CMD_HANDSHAKE))
|
||
{
|
||
ucUartErrCode |= IAPERROR_CMD;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ucUart2BufPT = 0;
|
||
if(uiReceCheckSum != ((ucUart2Buf[ucUart2Buf[LENGTH]+8]<<8) + ucUart2Buf[ucUart2Buf[LENGTH]+7]))
|
||
{
|
||
ucUartErrCode |= IAPERROR_CHECKSUM;
|
||
}
|
||
|
||
if(ucUartErrCode != 0) //如果有错误代码则不执行命令处理
|
||
{
|
||
ucUart2Buf[INDEXES] = ucUartErrCode;
|
||
}
|
||
else
|
||
{
|
||
bISPFlg = 1; //跳转到BOOT区
|
||
ucUart2Buf[INDEXES] = 0;
|
||
}
|
||
|
||
ucUart2Buf[LENGTH] = 0;
|
||
ucUart2Buf[COMMAND] = 0x0B;
|
||
|
||
databak = ucUart2Buf[SOURCE]; //交换源ID和目标ID
|
||
ucUart2Buf[SOURCE] = ucUart2Buf[TARGET];
|
||
ucUart2Buf[TARGET] = databak;
|
||
|
||
for(i=2; i<(ucUart2Buf[LENGTH]+7); i++)
|
||
{
|
||
checksum += ucUart2Buf[i];
|
||
}
|
||
|
||
ucUart2Buf[7+ucUart2Buf[LENGTH]] = checksum%256;
|
||
ucUart2Buf[8+ucUart2Buf[LENGTH]] = checksum/256;
|
||
|
||
Uart2SendAck();
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART0_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart0AppRx
|
||
* 参 数: RxData：Uart0接收的数据，从SBUF0获取
|
||
* 返回值: 无
|
||
* 描 述: UART接收中断服务程序接口，中断处理函数会调用该函数
|
||
ucUart0Buf[0]--Slave Addr
|
||
ucUart0Buf[1]--CMD No.
|
||
ucUart0Buf[2]--Offset
|
||
ucUart0Buf[3]--Data Length
|
||
ucUart0Buf[4...]--Data
|
||
*************************************************************************************************/
|
||
void InterruptUart0AppRx(U8 RxData)
|
||
{
|
||
ucUart0Buf[ucUart0BufPT] = RxData;
|
||
ucUart0BufPT++;
|
||
if(ucUart0BufPT >= 140)
|
||
{
|
||
ucUart0BufPT = 0;
|
||
}
|
||
if(ucUart0BufPT == 1)
|
||
{
|
||
if((ucUart0Buf[UART_SLAVE_ADDR]&0xFE) == SADDR) //接收的第一个字节是否和UART地址匹配
|
||
{
|
||
if((ucUart0Buf[UART_SLAVE_ADDR]&0x01)==0) //bit7是R/W标志；0--R, 1--W
|
||
{
|
||
bUart0ReadFlg = 1;
|
||
bUart0WriteFlg = 0;
|
||
}
|
||
else
|
||
{
|
||
bUart0WriteFlg = 1;
|
||
bUart0ReadFlg = 0;
|
||
}
|
||
}
|
||
else if(ucUart0Buf[HEARD1] != 0x5A) //判断是否为IAP/ISP的起始帧
|
||
{
|
||
ucUart0BufPT = 0; //如果帧头错误，则复位指针
|
||
}
|
||
}
|
||
|
||
if(bUart0ReadFlg)
|
||
{
|
||
if(ucUart0BufPT==3)
|
||
{
|
||
Uart0RdCmdProcess(); //Read the command process
|
||
}
|
||
}
|
||
else if(bUart0WriteFlg)
|
||
{
|
||
if(ucUart0BufPT > (ucUart0Buf[UART_LENGTH]+3)) //If a write operation, and complete all the data has been received
|
||
{
|
||
Uart0WrCmdProcess(); //Write the command peocess
|
||
bUart0WriteFlg = 0; //PC write MCU communiaction over
|
||
ucUart0BufPT = 0;
|
||
}
|
||
}
|
||
else //非读非写操作时，即为ISP或者IAP的begin命令
|
||
{
|
||
Uart0IapCheckHandshake();
|
||
}
|
||
bUart0SndAckFlg = 0;
|
||
|
||
ucSleepTimerCnt = 0; //UART正常通讯会清零低功耗计数，UART复位计数
|
||
ucPDTimerCnt = 0;
|
||
ucUart0TimeoutCnt = 0;
|
||
}
|
||
|
||
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart0AppTx
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0发送中断服务程序接口，中断处理函数会调用该函数
|
||
*************************************************************************************************/
|
||
void InterruptUart0AppTx(void)
|
||
{
|
||
if((ucUart0Buf[HEARD1] == 0x5A) && (ucUart0Buf[HEARD2] == 0xA5) || bISPFlg)
|
||
{
|
||
if(ucUart0BufPT >= (ucUart0Buf[LENGTH]+8))
|
||
{
|
||
Uart0RxEn(); //Allow UART receive data
|
||
ucUart0BufPT = 0;
|
||
bUart0ReadFlg = 0; //PC read MCU communication over
|
||
ucUart0Buf[0] = 0;
|
||
ucUart0Buf[1] = 0;
|
||
ucUart0Buf[2] = 0;
|
||
ucUart0Buf[3] = 0;
|
||
bUart0SndAckFlg = 1;
|
||
}
|
||
else
|
||
{
|
||
ucUart0BufPT++;
|
||
Uart0TxEn(ucUart0Buf[ucUart0BufPT]); //20220620
|
||
}
|
||
}
|
||
else if((ucUart0BufPT==0) || (ucUart0BufPT>=ucUart0Buf[UART_LENGTH]+3))
|
||
{
|
||
Uart0RxEn(); //UART允许接收数据
|
||
ucUart0BufPT = 0;
|
||
bUart0ReadFlg = 0;
|
||
ucUart0Buf[0] = 0;
|
||
ucUart0Buf[1] = 0;
|
||
ucUart0Buf[2] = 0;
|
||
ucUart0Buf[3] = 0;
|
||
bUart0SndAckFlg = 1; //UART已发送过数据，主要用于需要等待发送ACK才能进一步操作的功能
|
||
}
|
||
else
|
||
{
|
||
ucUart0BufPT++;
|
||
Uart0TxEn(ucUart0Buf[ucUart0BufPT]);
|
||
}
|
||
|
||
ucSleepTimerCnt = 0; //UART正常通讯会清零低功耗计数，UART复位计数
|
||
ucPDTimerCnt = 0;
|
||
ucUart0TimeoutCnt = 0;
|
||
}
|
||
|
||
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart0AppTx
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART0发送中断服务程序接口，中断处理函数会调用该函数
|
||
*************************************************************************************************/
|
||
void Uart0Check(void)
|
||
{
|
||
if(++ucUart0TimeoutCnt >= 4) //如果4*50mS没有UART通讯，则复位指针向量，并切换到接收模式
|
||
{
|
||
ucUart0TimeoutCnt = 0;
|
||
ucUart0BufPT = 0;
|
||
Uart0RxEn(); //UART允许接收数据
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART1_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart1AppRx
|
||
* 参 数: RxData：Uart1接收的数据，从SBUF1获取
|
||
* 返回值: 无
|
||
* 描 述: UART1接收中断服务程序接口，中断处理函数会调用该函数
|
||
ucUart1Buf[0]--Slave Addr
|
||
ucUart1Buf[1]--CMD No.
|
||
ucUart1Buf[2]--Offset
|
||
ucUart1Buf[3]--Data Length
|
||
ucUart1Buf[4...]--Data
|
||
*************************************************************************************************/
|
||
void InterruptUart1AppRx(U8 RxData)
|
||
{
|
||
ucUart1Buf[ucUart1BufPT] = RxData;
|
||
ucUart1BufPT++;
|
||
if(ucUart1BufPT >= 140)
|
||
{
|
||
ucUart1BufPT = 0;
|
||
}
|
||
if(ucUart1BufPT == 1)
|
||
{
|
||
McuBank1Sel();
|
||
if((ucUart1Buf[UART_SLAVE_ADDR]&0xFE) == SADDR1) //接收的第一个字节是否和UART地址匹配
|
||
{
|
||
McuBank0Sel();
|
||
if((ucUart1Buf[UART_SLAVE_ADDR]&0x01)==0) //bit7是R/W标志；0--R, 1--W
|
||
{
|
||
bUart1ReadFlg = 1;
|
||
bUart1WriteFlg = 0;
|
||
}
|
||
else
|
||
{
|
||
bUart1WriteFlg = 1;
|
||
bUart1ReadFlg = 0;
|
||
}
|
||
}
|
||
else if(ucUart1Buf[HEARD1] != 0x5A) //判断是否为IAP/ISP的起始帧
|
||
{
|
||
ucUart1BufPT = 0; //如果帧头错误，则复位指针
|
||
}
|
||
}
|
||
|
||
if(bUart1ReadFlg)
|
||
{
|
||
if(ucUart1BufPT==3)
|
||
{
|
||
Uart1RdCmdProcess(); //Read the command process
|
||
}
|
||
}
|
||
else if (bUart1WriteFlg)
|
||
{
|
||
if(ucUart1BufPT > (ucUart1Buf[UART_LENGTH]+3)) //If a write operation, and complete all the data has been received
|
||
{
|
||
Uart1WrCmdProcess(); //Write the command peocess
|
||
bUart1WriteFlg = 0; //PC write MCU communiaction over
|
||
ucUart1BufPT = 0;
|
||
}
|
||
}
|
||
else //非读非写操作时，即为ISP或者IAP的begin命令
|
||
{
|
||
Uart1IapCheckHandshake();
|
||
}
|
||
bUart1SndAckFlg = 0;
|
||
|
||
ucSleepTimerCnt = 0; //UART正常通讯会清零低功耗计数，UART复位计数
|
||
ucPDTimerCnt = 0;
|
||
ucUart1TimeoutCnt = 0;
|
||
}
|
||
|
||
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart1AppTx
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1发送中断服务程序接口，中断处理函数会调用该函数
|
||
*************************************************************************************************/
|
||
void InterruptUart1AppTx(void)
|
||
{
|
||
if((ucUart1Buf[HEARD1] == 0x5A) && (ucUart1Buf[HEARD2] == 0xA5) || bISPFlg)
|
||
{
|
||
if(ucUart1BufPT >= (ucUart1Buf[LENGTH]+8))
|
||
{
|
||
Uart1RxEn(); //Allow UART receive data
|
||
ucUart1BufPT = 0;
|
||
bUart1ReadFlg = 0; //PC read MCU communication over
|
||
ucUart1Buf[0] = 0;
|
||
ucUart1Buf[1] = 0;
|
||
ucUart1Buf[2] = 0;
|
||
ucUart1Buf[3] = 0;
|
||
bUart1SndAckFlg = 1;
|
||
}
|
||
else
|
||
{
|
||
ucUart1BufPT++;
|
||
Uart1TxEn(ucUart1Buf[ucUart1BufPT]); //20220620
|
||
}
|
||
}
|
||
else if((ucUart1BufPT==0) || (ucUart1BufPT>=ucUart1Buf[UART_LENGTH]+3))
|
||
{
|
||
Uart1RxEn(); //UART允许接收数据
|
||
ucUart1BufPT = 0;
|
||
bUart1ReadFlg = 0;
|
||
ucUart1Buf[0] = 0;
|
||
ucUart1Buf[1] = 0;
|
||
ucUart1Buf[2] = 0;
|
||
ucUart1Buf[3] = 0;
|
||
bUart1SndAckFlg = 1; //UART已发送过数据，主要用于需要等待发送ACK才能进一步操作的功能
|
||
}
|
||
else
|
||
{
|
||
ucUart1BufPT++;
|
||
Uart1TxEn(ucUart1Buf[ucUart1BufPT]);
|
||
}
|
||
|
||
ucSleepTimerCnt = 0; //UART正常通讯会清零低功耗计数，UART复位计数
|
||
ucPDTimerCnt = 0;
|
||
ucUart1TimeoutCnt = 0;
|
||
}
|
||
|
||
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart1AppTx
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART1发送中断服务程序接口，中断处理函数会调用该函数
|
||
*************************************************************************************************/
|
||
void Uart1Check(void)
|
||
{
|
||
if(++ucUart1TimeoutCnt >= 4) //如果4*50mS没有UART通讯，则复位指针向量，并切换到接收模式
|
||
{
|
||
ucUart1TimeoutCnt = 0;
|
||
ucUart1BufPT = 0;
|
||
Uart1RxEn(); //UART允许接收数据
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (UART2_DEFINE != 0)
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart2AppRx
|
||
* 参 数: RxData：Uart2接收的数据，从SBUF2获取
|
||
* 返回值: 无
|
||
* 描 述: UART2接收中断服务程序接口，中断处理函数会调用该函数
|
||
ucUart2Buf[0]--Slave Addr
|
||
ucUart2Buf[1]--CMD No.
|
||
ucUart2Buf[2]--Offset
|
||
ucUart2Buf[3]--Data Length
|
||
ucUart2Buf[4...]--Data
|
||
*************************************************************************************************/
|
||
void InterruptUart2AppRx(U8 RxData)
|
||
{
|
||
ucUart2Buf[ucUart2BufPT] = RxData;
|
||
ucUart2BufPT++;
|
||
if(ucUart2BufPT >= 140)
|
||
{
|
||
ucUart2BufPT = 0;
|
||
}
|
||
if(ucUart2BufPT == 1)
|
||
{
|
||
McuBank1Sel();
|
||
if((ucUart2Buf[UART_SLAVE_ADDR]&0xFE) == SADDR2) //接收的第一个字节是否和UART地址匹配
|
||
{
|
||
McuBank0Sel();
|
||
if((ucUart2Buf[UART_SLAVE_ADDR]&0x01)==0) //bit7是R/W标志；0--R, 1--W
|
||
{
|
||
bUart2ReadFlg = 1;
|
||
bUart2WriteFlg = 0;
|
||
}
|
||
else
|
||
{
|
||
bUart2WriteFlg = 1;
|
||
bUart2ReadFlg = 0;
|
||
}
|
||
}
|
||
else if(ucUart2Buf[HEARD1] != 0x5A) //判断是否为IAP/ISP的起始帧
|
||
{
|
||
ucUart2BufPT = 0; //如果帧头错误，则复位指针
|
||
}
|
||
}
|
||
|
||
if(bUart2ReadFlg)
|
||
{
|
||
if(ucUart2BufPT==3)
|
||
{
|
||
Uart2RdCmdProcess(); //Read the command process
|
||
}
|
||
}
|
||
else if(bUart2WriteFlg)
|
||
{
|
||
if(ucUart2BufPT > (ucUart2Buf[UART_LENGTH]+3)) //If a write operation, and complete all the data has been received
|
||
{
|
||
Uart2WrCmdProcess(); //Write the command peocess
|
||
bUart2WriteFlg = 0; //PC write MCU communiaction over
|
||
ucUart2BufPT = 0;
|
||
}
|
||
}
|
||
else //非读非写操作时，即为ISP或者IAP的begin命令
|
||
{
|
||
Uart2IapCheckHandshake();
|
||
}
|
||
bUart2SndAckFlg = 0;
|
||
|
||
ucSleepTimerCnt = 0; //UART正常通讯会清零低功耗计数，UART复位计数
|
||
ucPDTimerCnt = 0;
|
||
ucUart2TimeoutCnt = 0;
|
||
}
|
||
|
||
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUartAppTx
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART发送中断服务程序接口，中断处理函数会调用该函数
|
||
*************************************************************************************************/
|
||
void InterruptUart2AppTx(void)
|
||
{
|
||
if((ucUart2Buf[HEARD1] == 0x5A) && (ucUart2Buf[HEARD2] == 0xA5) || bISPFlg)
|
||
{
|
||
if(ucUart2BufPT >= (ucUart2Buf[LENGTH]+8))
|
||
{
|
||
Uart2RxEn(); //Allow UART receive data
|
||
ucUart2BufPT = 0;
|
||
bUart2ReadFlg = 0; //PC read MCU communication over
|
||
ucUart2Buf[0] = 0;
|
||
ucUart2Buf[1] = 0;
|
||
ucUart2Buf[2] = 0;
|
||
ucUart2Buf[3] = 0;
|
||
bUart2SndAckFlg = 1;
|
||
}
|
||
else
|
||
{
|
||
ucUart2BufPT++;
|
||
Uart2TxEn(ucUart2Buf[ucUart2BufPT]); //20220620
|
||
}
|
||
}
|
||
else if((ucUart2BufPT==0) || (ucUart2BufPT>=ucUart2Buf[UART_LENGTH]+3))
|
||
{
|
||
Uart2RxEn(); //UART允许接收数据
|
||
ucUart2BufPT = 0;
|
||
bUart2ReadFlg = 0;
|
||
ucUart2Buf[0] = 0;
|
||
ucUart2Buf[1] = 0;
|
||
ucUart2Buf[2] = 0;
|
||
ucUart2Buf[3] = 0;
|
||
bUart2SndAckFlg = 1; //UART已发送过数据，主要用于需要等待发送ACK才能进一步操作的功能
|
||
}
|
||
else
|
||
{
|
||
ucUart2BufPT++;
|
||
Uart2TxEn(ucUart2Buf[ucUart2BufPT]);
|
||
}
|
||
|
||
ucSleepTimerCnt = 0; //UART正常通讯会清零低功耗计数，UART复位计数
|
||
ucPDTimerCnt = 0;
|
||
ucUart2TimeoutCnt = 0;
|
||
}
|
||
|
||
|
||
/*************************************************************************************************
|
||
* 函数名: InterruptUart0AppTx
|
||
* 参 数: 无
|
||
* 返回值: 无
|
||
* 描 述: UART发送中断服务程序接口，中断处理函数会调用该函数
|
||
*************************************************************************************************/
|
||
void Uart2Check(void)
|
||
{
|
||
if(++ucUart2TimeoutCnt >= 4) //如果4*50mS没有UART通讯，则复位指针向量，并切换到接收模式
|
||
{
|
||
ucUart2TimeoutCnt = 0;
|
||
ucUart2BufPT = 0;
|
||
Uart2RxEn(); //UART允许接收数据
|
||
}
|
||
}
|
||
#endif
|