飞思卡尔MC9S12XEP芯片的CAN总线代码

#define CAN_GLOBALS

#include "can.h"

void EEC1_Process(uint8_t OutPtr, uint8_t InPtr);

void EEC2_Process(uint8_t OutPtr, uint8_t InPtr);

void EEC3_Process(uint8_t OutPtr, uint8_t InPtr);

void ET1_Process(uint8_t OutPtr, uint8_t InPtr);

void CCVS_Process(uint8_t OutPtr, uint8_t InPtr);

void LFE_Process(uint8_t OutPtr, uint8_t InPtr);

void AMB_Process(uint8_t OutPtr, uint8_t InPtr);

void IC1_Process(uint8_t OutPtr, uint8_t InPtr);

void VEP1_Process(uint8_t OutPtr, uint8_t InPtr);

void EFL_P1_Process(uint8_t OutPtr, uint8_t InPtr);

void LFC_Process(uint8_t OutPtr, uint8_t InPtr);

void Digit2Ascii1(uint32_t Digit, uint8_t InPtr); //一位小数

void Digit2Ascii0(uint32_t Digit, uint8_t InPtr); //数字转化为ASCII码 0位小数void Digit2AsciiPos0(uint32_t Digit, uint8_t InPtr); //数字转化为ASCII码 0位小数负数

uint8_t *Result;

HMI_Text_Dis_tPtr HMI_Text_DisPtr;

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

//Function:

//Param:

//Return:

//note

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

void CANFilterInit(uint8_t CAN)

{

if(CAN

{

switch(CAN)

{

case CAN0:

CAN0IDAR0 = 0xFF;

CAN0IDAR1 = 0xFF;

CAN0IDAR2 = 0xFF;

CAN0IDAR3 = 0xFF;

CAN0IDMR0 = 0xFF;

CAN0IDMR1 = 0xFF;

CAN0IDMR2 = 0xFF;

CAN0IDMR3 = 0xFF;

CAN0IDAR4 = 0xFF;

CAN0IDAR5 = 0xFF;

CAN0IDAR6 = 0xFF;

CAN0IDAR7 = 0xFF;

CAN0IDMR4 = 0xFF;

CAN0IDMR5 = 0xFF;

CAN0IDMR6 = 0xFF;

CAN0IDMR7 = 0xFF;

break;

case CAN1:

CAN1IDAR0 = 0xFF;

CAN1IDAR1 = 0xFF;

CAN1IDAR2 = 0xFF;

CAN1IDAR3 = 0xFF;

CAN1IDMR0 = 0xFF;

CAN1IDMR1 = 0xFF;

CAN1IDMR2 = 0xFF;

CAN1IDMR3 = 0xFF;

CAN1IDAR4 = 0xFF;

CAN1IDAR5 = 0xFF;

CAN1IDAR6 = 0xFF;

CAN1IDAR7 = 0xFF;

CAN1IDMR4 = 0xFF;

CAN1IDMR5 = 0xFF;

CAN1IDMR6 = 0xFF;

CAN1IDMR7 = 0xFF;

break;

}

}

}

/*--------------------------------------------------------------------------------------------------------

Function:

Param:

Return:

note

----------------------------------------------------------------------------------------------------------*/

void CANRxQueInit(void)

{

CAN_RxQue.Front = 0;

CAN_RxQue.Rear = 0;

memset(&CAN_RxQue, 0, sizeof(CAN_RxQue));

}

/*--------------------------------------------------------------------------------------------------------

Function: CAN0 CAN1初始化

Param:

Return:

note

----------------------------------------------------------------------------------------------------------*/

CAN_EXT void CANInit(uint8_t CAN)

{

if(CAN

{

switch(CAN)

{

case CAN0:

CAN0CTL1_CANE = 1; //使能CAN模块

CAN0CTL1_LISTEN = 0; //除能监听模式

CAN0BTR0 = CAN0BTR0_Val; //设置波特率

CAN0BTR1 = CAN0BTR1_Val;

CANFilterInit(CAN0); //设置验收、屏蔽滤波器

CAN0CTL0_INITRQ = 0; //请求退出初始化

while(CAN0CTL1_INITAK == 1){ //请求处理ing

_asm(nop);

}

while(CAN0CTL0_SYNCH == 0){

_asm(nop);

}

CAN0RFLG = 0xC3; //清除接收相关标志位

CANRxQueInit(); //CAN中断接收队列

CAN0RIER_RXFIE = 1; //接收中断允许

break;

case CAN1:

CAN1CTL1_CANE = 1; //使能CAN模块

CAN1CTL1_LISTEN = 0; //除能监听模式

CAN1BTR0 = CAN1BTR0_Val; //设置波特率

CAN1BTR1 = CAN1BTR1_Val;

CANFilterInit(CAN1); //设置验收、屏蔽滤波器

CAN1CTL0_INITRQ = 0; //请求退出初始化

while(CAN1CTL1_INITAK == 1){ //请求处理ing

_asm(nop);

}

while(CAN1CTL0_SYNCH == 0){

_asm(nop);

}

CAN1RFLG = 0xC3; //清除接收相关标志位

CANRxQueInit(); //CAN中断接收队列

CAN1RIER_RXFIE = 1; //接收中断允许

break;

}

}

}

/*----------------------------------------------------------------------------------------------------------

Function:存储并显示把CAN_RxQue 队列里的数据存放到 FLASH 中，某些数据再存到HMI_Text_Dis_Que 队列里进行显示

其中 CAN_RxQue 的ID转换为 PGNTmp 再转换为 HMI_Text_Dis_Que 显示的位置

CAN_RxQue 的数据即 HMI_Text_Dis_Que 的数据

起始帧命令帧终止帧都已包含

Param:

Return:

note

----------------------------------------------------------------------------------------------------------*/

CAN_EXT void CANRxQueToProcess(void)

{

ID_tPtr IDPtr;

uint32_t PGNTmp;

while(CAN_RxQue.Front!= CAN_RxQue.Rear) //源队列未空，可出列

{

IDPtr = &(CAN_RxQue.PDUs[CAN_RxQue.Front].Bits.ID); //指向出列项ID域

PGNTmp = 0;

PGNTmp |= (uint8_t)(IDPtr->Bits.DP | IDPtr->Bits.R<<1);

//析取DP和R

PGNTmp <<= 8;

PGNTmp |= (uint8_t)(IDPtr->Bits.PF0 | IDPtr->Bits.PF1<<2 | IDPtr->Bits.PF2<<5); //析取PF

PGNTmp <<= 8;

PGNTmp |= (uint8_t)(IDPtr->Bits.PS0 | IDPtr->Bits.PS1<<7);

//析取PS

if(PGNTmp == (uint16_t)PGN_FAULT_MEMORY)

{

FAULT_flag = 1;

}

else

{

FAULT_flag = 0;

}

switch(PGNTmp){

case (uint16_t)PGN_EEC1:

EEC1_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_EEC2:

EEC2_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_EEC3:

EEC3_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_AMB:

AMB_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_CCVS:

CCVS_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_ET1:

ET1_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_LFE:

LFE_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_EFL_P1:

EFL_P1_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_IC1:

IC1_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_VEP1:

VEP1_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_LFC: // 时间太大目前只能计算两个字节的

LFC_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear);

break;

case (uint16_t)PGN_FAULT_MEMORY:

FAULT_MEMORY_Process(CAN_RxQue.Front, HMI_Text_Dis_Que.Rear, 0, 0); //为了方便触摸屏看故障类型上下条时使用

break;

default:

break;

}

CAN_RxQue.Front = (uint8_t)(CAN_RxQue.Front+1)%CAN_RXQUE_LEN;

//出列一项

}

CANRxQueInit();

}

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

//Function:

//Param:

//Return:

//note

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

void EEC1_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t engspeed;

uint32_t actualengtorque;

eec1 = (EEC1_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

engspeed = (((uint32_t)swab16(eec1->EngSpeed))*12) + (((uint32_t)swab16(eec1->EngSpeed))>>1);

actualengtorque = ((uint32_t)(eec1->ActualEngTorque)) * 100;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) {

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis +

HMI_Text_Dis_Que.Rear;

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START;

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII;

HMI_Text_DisPtr->Start_Point.x = 145;

HMI_Text_DisPtr->Start_Point.y = 150;

Digit2Ascii0(engspeed, InPtr);

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN;

}

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) {

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear;

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START;

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII;

HMI_Text_DisPtr->Start_Point.x = 590;

HMI_Text_DisPtr->Start_Point.y = 150;

if(actualengtorque<12500)

{

actualengtorque = 12500 - actualengtorque;

Digit2AsciiPos0(actualengtorque, HMI_Text_Dis_Que.Rear);

}

else

{

actualengtorque = actualengtorque - 12500;

Digit2Ascii0(actualengtorque, HMI_Text_Dis_Que.Rear);

}

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void EEC2_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t accpedalpos1;

eec2 = (EEC2_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

accpedalpos1 = ((uint32_t)(eec2->AccPedalPos1)) * 40;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) //目的队列未满，可入列

{

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear; //指向入列项

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START; //写入命令头

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII; //写入命令种类 HMI_Text_DisPtr->Start_Point.x = 145; //文本显示位置x坐标

HMI_Text_DisPtr->Start_Point.y = 315; //文本显示位置y坐标

Digit2Ascii0(accpedalpos1, InPtr); //%

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void EEC3_Process(uint8_t OutPtr, uint8_t InPtr)

{

eec3 = (EEC3_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void ET1_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t engcoolanttemp;

et1 = (ET1_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

engcoolanttemp = ((uint32_t)(et1->EngCoolantTemp)) *100;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) //目的队列未满，可入列

{

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear; //指向入列项

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START; //写入命令头

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII; //写入命令种类 HMI_Text_Dis_Que.HMI_Text_Dis[InPtr].Start_Point.x = 145; //文本显示位置x坐标

HMI_Text_Dis_Que.HMI_Text_Dis[InPtr].Start_Point.y = 390;

if(engcoolanttemp<4000)

{

engcoolanttemp = 4000 - engcoolanttemp;

Digit2AsciiPos0(engcoolanttemp, InPtr);

}

else

{

engcoolanttemp = engcoolanttemp - 4000;

Digit2Ascii0(engcoolanttemp, InPtr);

}

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void CCVS_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t vehiclespeed;

ccvs = (CCVS_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

vehiclespeed = (((uint32_t)swab16(ccvs->VehicleSpeed)) * 100) >> 8;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) //目的队列未满，可入列

{

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear; //指向入列项

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START; //写入命令头

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII; //写入命令种类 HMI_Text_DisPtr->Start_Point.x = 370; //文本显示位置x坐标

HMI_Text_DisPtr->Start_Point.y = 150; //文本显示位置y坐标

Digit2Ascii1(vehiclespeed, InPtr); //%

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void LFE_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t engfuelrate;

lfe = (LFE_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

engfuelrate = ((uint32_t)swab16(lfe->EngFuelRate)) * 5;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) {

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear;

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START;

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII;

HMI_Text_DisPtr->Start_Point.x = 370;

HMI_Text_DisPtr->Start_Point.y = 365;

Digit2Ascii0(engfuelrate, InPtr);

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

static void AMB_Process(uint8_t OutPtr, uint8_t InPtr)

{

amb = (AMB_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void IC1_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t engintakemanifold1temp; // 进气温度

uint32_t engairinletpressure; //绝对增压压力

ic1 = (IC1_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

engintakemanifold1temp = ((uint32_t)(ic1->EngIntakeManifold1Temp)) * 100;

engairinletpressure = ((uint32_t)(ic1->EngAirInletPressure)) * 200;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) //目的队列未满，可入列

{

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear; //指向入列项

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START; //写入命令头

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII; //写入命令种类 HMI_Text_DisPtr->Start_Point.x = 370; //文本显示位置x坐标

HMI_Text_DisPtr->Start_Point.y = 255;

if(engintakemanifold1temp<4000)

{

engintakemanifold1temp = 4000 - engintakemanifold1temp;

Digit2AsciiPos0(engintakemanifold1temp, InPtr);

}

else

{

engintakemanifold1temp = engintakemanifold1temp - 4000;

Digit2Ascii0(engintakemanifold1temp, InPtr);

}

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) {

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear;

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START;

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII;

HMI_Text_DisPtr->Start_Point.x = 590;//590

HMI_Text_DisPtr->Start_Point.y = 255;

Digit2Ascii0(engairinletpressure, HMI_Text_Dis_Que.Rear);

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void VEP1_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t batterybotentialswitched;

vep1 = (VEP1_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

batterybotentialswitched = ((uint32_t)swab16(vep1->BatteryPotentialSwitched))*5;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) {

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear;

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START;

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII;

HMI_Text_DisPtr->Start_Point.x = 590;

HMI_Text_DisPtr->Start_Point.y = 365;

Digit2Ascii1(batterybotentialswitched, InPtr);

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear =

(uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN;

}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void EFL_P1_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t engoilpressure;

efl_p1 = (EFL_P1_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

engoilpressure = ((uint32_t)(efl_p1->EngOilPressure)) * 400;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) //目的队列未满，可入列

{

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear; //指向入列项

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START; //写入命令头

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII; //写入命令种类 HMI_Text_DisPtr->Start_Point.x = 145; //文本显示位置x坐标

HMI_Text_DisPtr->Start_Point.y = 230; //文本显示位置y坐标

Digit2Ascii0(engoilpressure, InPtr);

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

void LFC_Process(uint8_t OutPtr, uint8_t InPtr)

{

uint32_t engtotalfuelused;

lfc = (LFC_t *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

engtotalfuelused = ((uint32_t)swab32(lfc->EngTotalFuelUsed))>>1 ;

if(HMI_Text_Dis_Que.Front != (HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN) //目的队列未满，可入列

{

HMI_Text_DisPtr = HMI_Text_Dis_Que.HMI_Text_Dis + HMI_Text_Dis_Que.Rear; //指向入列项

HMI_Text_DisPtr->Cmd_Start = HMI_CMD_START; //写入命令头

HMI_Text_DisPtr->Cmd_Type = HMI_CMD_TEXTDIS_ASCII; //写入命令种类 HMI_Text_DisPtr->Start_Point.x = 125; //文本显示位置x坐标

HMI_Text_DisPtr->Start_Point.y = 220; //文本显示位置y坐标

Digit2Ascii1(engtotalfuelused, InPtr);

HMI_Text_DisPtr->Cmd_End = HMI_CMD_END;

HMI_Text_Dis_Que.Rear = (uint8_t)(HMI_Text_Dis_Que.Rear+1)%HMI_TEXTDIS_QUELEN; //进列一项}

Record_Write();

}

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

//Function:

//Param:

//Return:

//note

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

CAN_EXT void FAULT_MEMORY_Process(uint8_t OutPtr, uint8_t InPtr, uint8_t Touch_flag, uint16_t num)

{

uint16_t Fault_Type;

uint8_t error1[]="安全晶体管电磁阀阵列1(高边)故障";

uint8_t error2[]="安全晶体管电磁阀阵列1(低边)故障";

uint8_t error3[]="安全晶体管电磁阀阵列3(高边)故障";

uint8_t error4[]="存储器控制错误";

uint8_t error5[]="看门狗控制错误";

uint8_t error6[]="处理器控制错误";

uint8_t error7[]="TRAP控制错误";

uint8_t error8[]="5V电压控制错误";

uint8_t error9[]="12V传感器电压控制错误";

uint8_t error10[]="12.5V电压控制错误";

uint8_t error11[]="24V电压错误";

uint8_t error12[]="nvSRAM控制错误";

uint8_t error13[]="nvSRAM数据控制错误";

uint8_t error14[]="CAN接口初始化错误";

uint8_t error15[]="SEAJ1939协议错误";

uint8_t error16[]="传感器电缆堵塞";

uint8_t error17[]="温度传感器。。。";

uint8_t error18[]="温度传感器控制单元内部错误";

uint8_t error19[]="频率传感器的输入速度和冗余速度的信息，在同一时间出现故障"; uint8_t error20[]="频率传感器的输入速度故障";

uint8_t error21[]="频率传感器的输出速度故障";

uint8_t error22[]="频率传感器的输出速度和冗余速度的信息，在同一时间出现故障"; uint8_t error23[]="接近开关换向片A旋转方向故障";

uint8_t error24[]="接近开关换向片B旋转方向故障";

uint8_t error25[]="电磁阀转换器1故障";

uint8_t error26[]="当前电磁阀转换器1超出范围";

uint8_t error27[]="电磁阀联轴器1故障";

uint8_t error28[]="当前电磁阀联轴器1超出范围";

uint8_t error29[]="电磁阀换向片A旋转方向故障";

uint8_t error30[]="当前电磁阀换向片A旋转方向超出范围";

uint8_t error31[]="电磁阀换向片B旋转方向故障";

uint8_t error32[]="当前电磁阀换向片B方向超出范围";

uint8_t error33[]="使能信号UTR1故障";

uint8_t error34[]="换向气缸叶端位置";

uint8_t error35[]="倒车单位不正确组合/双啮合";

uint8_t error36[]="VTDC只获得一个填充命令";

uint8_t error37[]="VTDC获得两个旋转方向命令";

uint8_t error38[]="在热交换前变速箱油温警告";

uint8_t error39[]="在热交换前变速箱油过热";

uint8_t error40[]="倒车超时停止";

uint8_t error41[]="倒车缸没到中间位置";

uint8_t error42[]="滑动联轴器1过高";

uint8_t error43[]="对于范围和旋转模式，输入速度过高";

if(!Touch_flag)

{

fault_memory = (FAULT_MEMORY *)CAN_RxQue.PDUs[OutPtr].Bits.DataField;

Fault_Type = swab16(fault_memory->Num);

}

else if(Touch_flag)

{

Fault_Type = num;

}

if(!HMI_Error_Dis.Cmd_Start) //目的队列未满，可入列

{

HMI_Error_Dis.Cmd_Start = HMI_CMD_START;

HMI_Error_Dis.Cmd_Type = HMI_CMD_TEXTDIS_ASCII;

HMI_Error_Dis.Start_Point.x = 101;

HMI_Error_Dis.Start_Point.y = 490;

switch(Fault_Type){

case 1:

Result = memcpy(HMI_Error_Dis.Str_Dis, error1, 31);

break;

case 2:

Result = memcpy(HMI_Error_Dis.Str_Dis, error2, 31);

break;

case 4:

Result = memcpy(HMI_Error_Dis.Str_Dis, error3, 31);

break;

case 6:

Result = memcpy(HMI_Error_Dis.Str_Dis, error4, 14);

break;

case 7:

Result = memcpy(HMI_Error_Dis.Str_Dis, error5, 14);

break;

case 8:

Result = memcpy(HMI_Error_Dis.Str_Dis, error6, 14);

break;

case 11:

Result = memcpy(HMI_Error_Dis.Str_Dis, error7, 12);

break;

case 12:

Result = memcpy(HMI_Error_Dis.Str_Dis, error8, 14);

break;

case 13:

Result = memcpy(HMI_Error_Dis.Str_Dis, error9, 21);

break;

case 15:

Result = memcpy(HMI_Error_Dis.Str_Dis, error10, 17);

break;

case 16:

Result = memcpy(HMI_Error_Dis.Str_Dis, error11, 11);

break;

case 17:

Result = memcpy(HMI_Error_Dis.Str_Dis, error12, 14);

break;

case 18:

Result = memcpy(HMI_Error_Dis.Str_Dis, error13, 18);

break;

case 41:

Result = memcpy(HMI_Error_Dis.Str_Dis, error14, 17);

break;

case 46:

Result = memcpy(HMI_Error_Dis.Str_Dis, error15, 16);

break;

case 100:

Result = memcpy(HMI_Error_Dis.Str_Dis, error16, 14);

break;

case 110:

Result = memcpy(HMI_Error_Dis.Str_Dis, error17, 16);

break;

case 118:

Result = memcpy(HMI_Error_Dis.Str_Dis, error18, 26);

break;

case 132:

Result = memcpy(HMI_Error_Dis.Str_Dis, error19, 56);

break;

case 133:

Result = memcpy(HMI_Error_Dis.Str_Dis, error20, 24);

break;

case 136:

Result = memcpy(HMI_Error_Dis.Str_Dis, error21, 24);

break;

case 139:

Result = memcpy(HMI_Error_Dis.Str_Dis, error22, 56);

break;

case 140:

Result = memcpy(HMI_Error_Dis.Str_Dis, error23, 27);

break;

case 141:

Result = memcpy(HMI_Error_Dis.Str_Dis, error24, 27);

break;

case 201:

Result = memcpy(HMI_Error_Dis.Str_Dis, error25, 17);

break;

case 202:

Result = memcpy(HMI_Error_Dis.Str_Dis, error26, 25);

break;

case 213:

Result = memcpy(HMI_Error_Dis.Str_Dis, error27, 17);

break;

case 214:

Result = memcpy(HMI_Error_Dis.Str_Dis, error28, 25);

break;

case 223:

Result = memcpy(HMI_Error_Dis.Str_Dis, error29, 25);

case 224:

Result = memcpy(HMI_Error_Dis.Str_Dis, error30, 33);

break;

case 225:

Result = memcpy(HMI_Error_Dis.Str_Dis, error31, 25);

break;

case 226:

Result = memcpy(HMI_Error_Dis.Str_Dis, error32, 29);

break;

case 300:

Result = memcpy(HMI_Error_Dis.Str_Dis, error33, 16);

break;

case 319:

Result = memcpy(HMI_Error_Dis.Str_Dis, error34, 16);

break;

case 325:

Result = memcpy(HMI_Error_Dis.Str_Dis, error35, 25);

break;

case 326:

Result = memcpy(HMI_Error_Dis.Str_Dis, error36, 22);

break;

case 327:

Result = memcpy(HMI_Error_Dis.Str_Dis, error37, 24);

break;

case 328:

Result = memcpy(HMI_Error_Dis.Str_Dis, error38, 24);

break;

case 331:

Result = memcpy(HMI_Error_Dis.Str_Dis, error39, 22);

break;

case 335:

Result = memcpy(HMI_Error_Dis.Str_Dis, error40, 12);

break;

case 339:

Result = memcpy(HMI_Error_Dis.Str_Dis, error41, 18);

break;

case 342:

Result = memcpy(HMI_Error_Dis.Str_Dis, error42, 15);

break;

case 351:

Result = memcpy(HMI_Error_Dis.Str_Dis, error43, 32);

break;

default:

}

HMI_Error_Dis.Cmd_End = HMI_CMD_END;

}

else{

return;

}

if(!Touch_flag)

{

Record_Write();

}

}

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

//Function: 数字转化为Ascii码如101->'1''.''0''1',1002->'1''0''.''2'

//Param:

//Return:

//note

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

void Digit2Ascii1(uint32_t Digit, uint8_t InPtr)

{

uint8_t i, j, k;

uint32_t Temp;

Temp = Digit;

k = 6;

if((Digit > 1000000) || (Digit == 1000000))

{

i = 7;

}

else if((Digit > 100000) || (Digit == 100000))

{

i = 6;

}

else if((Digit > 10000) || (Digit == 10000))

{

i = 5;

}

else if((Digit > 1000) || (Digit == 1000))

{

i = 4;

}

else

{

i = 3;

}

j = i-1;

i = i-1;

Temp /= 10;

do{

if(i-j != 1){

HMI_Text_Dis_Que.HMI_Text_Dis[InPtr].Str_Dis[k] = Temp%10 | 0x30;

Temp /= 10;

}

else{

HMI_Text_Dis_Que.HMI_Text_Dis[InPtr].Str_Dis[k] = '.';

}

k--;

j--;

}while(j);

HMI_Text_Dis_Que.HMI_Text_Dis[InPtr].Str_Dis[k] = Temp%10 | 0x30;

}

void Digit2Ascii0(uint32_t Digit, uint8_t InPtr)

{

uint8_t i, j, k;

uint32_t Temp;

Temp = Digit;

k = 6;

if((Digit > 1000000) || (Digit == 1000000))

{

i = 7;

}

else if((Digit > 100000) || (Digit == 100000))

{

i = 6;

}

else if((Digit > 10000) || (Digit == 10000))

{

i = 5;

}

else if((Digit > 1000) || (Digit == 1000))

{

i = 4;

}

else

{

i = 3;