为满足项目过程中不同阶段绝大部分测试需求，更方便快捷构造测试场景，支持异常场景测试。更早介入，不依赖周边ECU的稳定情况，专注于被测ECU。更经济，不加油，不充电，时间节省，物料节省等维度考虑。我们需要一个建设测试台架至少可覆盖实车上80%的测试场景需求。
目标任务分解
1、车内网络模型建立
模拟车内网络通信模型，各节点信号仿真
2、业务关联的ECU仿真
封装ECU之间的业务交互逻辑，车身控制器，仪表台模拟等
a)每个ECU的逻辑都是随CANoe启动，激活CAN通信；
b)根据PEPS电源信号状态决定该ECU的活跃状态;
c)ECU 根据具体业务处理总线上的请求；
d)设计仿真器的ECU则根据信号变化情况，更新仿真器的状态
CAPL编程实现
1、环境变量
为实现控制面板输入输出与信号同步，实现仿真器的状态更新，先定义与信号成映射关系的环境变量。环境变量的定义主要根据各ECU的相关信号与业务的关联度决定。基本上与T业务挂钩的信号都应该设置相应的环境变量，监控信号变化，实时更新仿真器的状态。
2、各ECU通用代码块
存储一些全局变量，日志记录等，各ECU可包含此文件调用
variables
{
// 报文发送周期， 单位ms
const int varCycTime10 = ;
const int varCycTime20 = ;
const int varCycTime50 = ;
const int varCycTime100 = ;
const int varCycTime200 = ;
const int varCycTime500 = ;
const int varCycTime1000 = ; // varCarType车型定义， 0=纯油, 1=纯电, 2=混动, others=error
// 字母代码 AFV=纯油， EV=纯电， HEV=混动（不区分直插式和充电桩式）
// 全局LOG
long mTrace = ;
//severity
dword INFO = ;
dword WARN = ;
dword ERROR = ;
// 鉴权秘钥
byte varESKCode[][] = {
//。。。略
}; // varCarCode 标记当前被测车型， 用于选择调用正确的鉴权码
int varESKNumber;
// 记录当前电源模式,0=OFF; 1=ACC; 2=ON; 3=reserved; 4=start; 5,6,7=reserved
int varPowerMode=;
int lastPowerMode=;
// 发动机状态
int varEngineStatus; //总线报文管理，0=停发， 1=启动
int varNM;// 远程控制请求中，启动发动机的时间
int varRmStartTime;
// 远程控制请求中，启动发动机的时间长度 分级
int varRmStartTimeLvl; ////0=No Req; 1=3min; 2=5min; 3=8min; 4=10min; 5,6,7=reserved
// // 防盗报警定时器
// timer BCM_ATWS_timer;
//车速
int varVelSpeed; //标记发动机是否已启动
int IsEngineWorking = ;
} /***********************************************************
* description : 全局日志记录函数
* parameter : None
* creation date: 2018/10/26
* author : xxx
* revision date:
* revision log :
* modifier :
***********************************************************/
void InitLogging()
{
mTrace = writeCreate("Logging");
writeConfigure(mTrace,*,,"..\\Proj\\Log\\write.txt");
writeclear();
}
3、ESC封装车速信号，处理行车过程中自动落锁的逻辑
此处详尽展现代码实现段落开始处所描述的四点逻辑，后续ECU只展现具体的业务处理，不在代码展示中继续保留a）& b)，或 d）
includes
{
#include "ECUsVar.can"
} variables
{
//本消息由ESC发出，包含ESC状态,车速、以及刹车板状态信号， 此处ID由我捏造为0x111
message 0x111 ESC_Status;
msTimer ESC_timer;
} on timer ESC_timer
{
output(ESC_Status);
setTimer(ESC_timer, varCycTime20);
} //车速
on envVar ESC_VehicleSpeed
{
float factor = 0.05625;
int offset = ;
varVelSpeed = getValue(ESC_VehicleSpeed); //转换成仪表显示, KPH
if(varPowerMode!=)
{
writeDbgLevel(, "PowerMode=OFF,车速调节无效");
ESC_Status.ESC_VehicleSpeed = ;
putValue(ESC_VehicleSpeed, );
}
else
{
if(varVelSpeed!=) //置位发动机转速
{
writeDbgLevel(, "点火状态，车速不为零，设置发动机转速");
putValue(EMS_EngineSpeedRPM,);
}
else
{
putValue(EMS_EngineSpeedRPM,);
}
if(varVelSpeed>) //车速>25时，自动落锁
{
writeDbgLevel(,"车速>25码，自动落锁");
putValue(LockDoors, );
}
ESC_Status.ESC_VehicleSpeed = (varVelSpeed-offset)/ factor;
}
} on envVar PEPS_PowerMode
{
// 此处根据PEPS电源状态封装ESC在网络上的活跃情况(是否对外发送信号和处理总线上的请求)
} on start
{
InitESCValue();
ActiveESC();
} //初始化
void InitESCValue()
{
varPowerMode = getValue(PEPS_PowerMode);
//以下两行代码初始化ESC信号,此处略去其它很多信号，自填......
putValue(ESC_VehicleSpeed, );
ESC_Status.xxx=;
} //激活
void ActiveESC()
{
setTimer(ESC_timer, varCycTime20);
}
//去激活
void InactiveESC()
{
cancelTimer(ESC_timer);
}
4、IPK实现同步系统时间
若你的车联网系统的标准时钟来自其它ECU，则以该ECU的时间为参考。这涉及判断T业务的实时性与有效性逻辑。（注意：我所用的CANoe 8.5.98的调用getLocalTimeString获取系统时间异常，我通过代码矫正了一下，11.0版本则不用矫正）
variables
{
const h_offset = ;//5; //时差
const m_offset = ;//5; //分差
// IPK提供日期时间信息, 年月日，时分秒；500ms
message 0x222 IPK_DateTime; //以下报文ID全由我捏造，可根据实际DBC中定义修改成相应ID // IPK提供纯电续航里程、平均电耗、瞬时电耗、油耗, 1000ms
message 0x223 IPK_Data; // 本消息由IPK发出，包含仪表的信息,100ms
// 安全气囊控制器状态检查反馈，剩余油量，平均车速，手刹状态，保养提示报警，背光调节，机油压力低报警状态
message 0x224 IPK_STS; // 本消息由IPK发出，包含总里程的信息，可续航里程，保养里程；1000ms
message 0x225 IPK_Odometer; msTimer IPK_Date_timer;
msTimer IPK_ODO_timer;
msTimer IPK_Sts_timer;
//当前时间提示器， 用来核对TBOX系统时间是否正确
timer DateRemanderTimer; // 存放时间的数组，当IPK负载不存在时，仿真实现。传递时间到TBOX
long tm[];
char t_canoe[];
char t_now[];
}
***********************************************************
* description : 由IPK发出的系统时间，传递给TBOX同步此时间
* parameter : None
* creation date: 2018/10/15
* author : xxx
* revision date:
* revision log :
* modifier :
***********************************************************/
on timer IPK_Date_timer
{
output(IPK_DateTime);
setTimer(IPK_Date_timer, varCycTime500);
} /***********************************************************
* description : 由IPK发出的仪表盘信息
* parameter : None
* creation date: 2018/10/15
* author : xxx
* revision date:
* revision log :
* modifier :
***********************************************************/
on timer IPK_Sts_timer
{
GetSysTime();
output(IPK_STS);
setTimer(IPK_Sts_timer, varCycTime100);
} /***********************************************************
* description : 由IPK发出的里程相关信息，可能会根据油车，混动，纯电，展示的信息不一致，根据DBC定义来实现
* parameter : None
* creation date: 2018/10/15
* author : xxx
* revision date:
* revision log :
* modifier :
***********************************************************/
on timer IPK_ODO_timer
{
output(IPK_Odometer);
setTimer(IPK_AFV_ODO_timer, varCycTime1000);
}/***********************************************************
* description : 获取当前PC时间，作为IPK时间发布到CAN线上
* parameter : None
* creation date: 2018/10/15
* author : xxx
* revision date:
* revision log :
* modifier :
***********************************************************/
void GetSysTime()
{
getLocalTimeString(t_canoe); getLocalTime(tm);
// year since 1900; month from 0-11
IPK_DateTime.IPK_Year = tm[]-;
IPK_DateTime.IPK_Month = tm[]+; IPK_DateTime.IPK_Second = tm[];
//以上API获取的时间比北京时间快6h 5min
if(tm[]>=h_offset) //24小时制
{
IPK_DateTime.IPK_Hour = tm[]-h_offset; //减去快的6H
IPK_DateTime.IPK_Day = tm[];
}
else
{
IPK_DateTime.IPK_Hour = tm[] -h_offset+; //当时间跳到第二天凌晨,逆向+18
IPK_DateTime.IPK_Day = tm[] -; // day-1
}
if(tm[]>=m_offset) //处理分钟
{
IPK_DateTime.IPK_Minute = tm[] -m_offset;
}
else
{
IPK_DateTime.IPK_Minute = tm[] -m_offset + ;
//此时小时跨度要再减一小时
IPK_DateTime.IPK_Hour = tm[]-(h_offset+); //减去快的6H and 跨时段1
} //格式化当前时间戳
snprintf(t_now, elcount(t_now),"%d/%d/%d %02d:%02d:%02d", tm[]+, tm[]+, tm[], IPK_DateTime.IPK_Hour,IPK_DateTime.IPK_Minute,tm[]);
}
//log输出 提示作用
on timer DateRemanderTimer
{
writeDbgLevel(, "CANoe Time: %s", t_canoe);
writeDbgLevel(, "Now Time:%s", t_now);
setTimer(DateRemanderTimer, varCycTime10);
} //激活IPK(当电源ON时，触发)
//去激活IPK(当电源OFF时，停发IPK报文)// 设置每次启动CANoe时，仪表盘的初值//电源模式变更时,处理IPK在总线上的活跃状态 //以下代码举两个例子描述，具体信号的变化，呈现在控制面板上的为物理值。其余信号可自己根据样板添加
//平均油耗 L/100Km
on envVar IPK_AverageFuelConsumption
{
int temp;
//偏移量与精度值
float factor = 0.01;
int offset = ; temp = getValue(IPK_AverageFuelConsumption); IPK_Data.IPK_AverageFuelConsumption = (temp-offset)/factor;
} //平均电耗 KWH/100km
on envVar IPK_AveragePowerConsumption
{
int temp;
//偏移量与精度值
float factor = 0.1;
int offset = -99.9;
temp = getValue(IPK_AveragePowerConsumption); IPK_Data.IPK_AveragePowerConsumption = (temp-offset)/factor;
}
5、车身模拟器，BCM+EMS
EMS仿真实现，发动机状态更新
variables
{
char BCMStatusPanel[] = "BCM状态图";
char EMSCtrl[] = "发动机"; //本消息由EMS发出，包含引擎转速、加速踏板状态信号
message 0x334 EMS_EngineRPM; msTimer EMS_timer;
} on envVar PEPS_PowerMode
{
//获取电源模式 + 车速
varPowerMode = getValue(PEPS_PowerMode);
if(varPowerMode==)
{
putValue(EMS_EngStatus, );//stop
putValue(EMS_EngineSpeedRPM,);
InactiveEMS();
lastPowerMode = varPowerMode;
}
else
{
if(lastPowerMode== && varPowerMode==)
{
;
}
else
{
switch(varPowerMode)
{
case :
putValue(EMS_EngStatus, );//stop
putValue(EMS_EngineSpeedRPM,);
break;
case :
putValue(EMS_EngStatus, );//stop
putValue(EMS_EngineSpeedRPM,);
break;
case :
putValue(EMS_EngStatus, );
break;
case :
putValue(EMS_EngStatus, );//Cranking
putValue(EMS_EngineSpeedRPM,);
break;
default:
break;
}
ActiveEMS();
}
}
} //更新车身仿真器的状态
on envVar EMS_EngStatus
{
int temp;
temp = getValue(EMS_EngStatus);
EMS_EngineRPM.EMS_EngStatus = temp;
if(temp==)
{
IsEngineWorking = ; //发动机工作中
setPictureBoxImage(BCMStatusPanel, EMSCtrl, "..\\Panels\\picture\\启动中.bmp");
}
else if (temp==)//油车
{
IsEngineWorking = ;
setPictureBoxImage(BCMStatusPanel, EMSCtrl, "..\\Panels\\picture\\未启动.bmp");
}
else if(temp==) //PHEV
{
if(@GEEA1::varCarType == )
{
IsEngineWorking = ;
setPictureBoxImage(BCMStatusPanel, EMSCtrl, "..\\Panels\\picture\\未启动.bmp");
}
}
} //略去 EMS激活，去激活，初始值，报文发送的函数
BCM仿真器实现，四门六盖，锁状态
variables
{
char BCMCtrlPanel[] = "ControlPanel";
char BCMStatusPanel[] = "BCM状态图";
char BCMHoodCtrl[]= "引擎盖";
char BCMTrunkCtrl[]= "后备箱";
char BCMLFDoorCtrl[]= "左前门";
char BCMLRDoorCtrl[]= "左后门";
char BCMRFDoorCtrl[]= "右前门";
char BCMRRDoorCtrl[]= "右后门";
char BCMSunroofCtrl[]= "天窗";
char BCMLockCtrl[]= "锁"; //本消息由BCM发出,包含BCM控制的各类开关以及加热器继电器开关信号
message 0x1 BCM_StateUpdate;
//左门窗
message 0x2 BCM_LDoorWindowState;
//右门窗
message 0x3 BCM_RDoorWindowState;
//本消息由BCM发出，包含前车窗状态及天窗状态信号
message 0x4 BCM_SunroofState;
// 发送100ms周期的报文
msTimer BCM_WndsDoors_timer; } on start
{
InitBCMValue();
InitBCMPanels();
//BCM不受PEPS电源模式影响，所以启动CANoe即可发出BCM报文
ActiveBCM();
} on timer BCM_WndsDoors_timer
{
output(BCM_SunroofState);
output(BCM_StateUpdate);
output(BCM_LDoorWindowState);
output(BCM_RDoorWindowState);
setTimer(BCM_WndsDoors_timer, varCycTime100);
} //设置每次启动CANoe时，BCM的初值
void InitBCMValue()
{
} void InitBCMPanels()
{
//打开控制面板 capl function, 此处不指明路径 直接遍历工程目录
openPanel(BCMCtrlPanel);
openPanel(BCMStatusPanel);
} //激活BCM往外发送报文
void ActiveBCM()
{
setTimer(BCM_WndsDoors_timer, varCycTime100);
} //停发BCM报文
void InactiveBCM()
{
cancelTimer(BCM_WndsDoors_timer);
} //预留一开关 停发所有报文
on envVar PEPS_PowerMode
{
varPowerMode = getValue(PEPS_PowerMode);
if(varPowerMode==) //CAN-Sleep
{
InactiveBCM();
lastPowerMode = varPowerMode;
}
else
{
if((varPowerMode==)&&(lastPowerMode==))
{
;
}
else if((==varPowerMode) || (==varPowerMode) || (==varPowerMode))
{
ActiveBCM(); //不是从3跳到0的模式，全激活
}
lastPowerMode = varPowerMode;
}
}
//天窗
on envVar BCM_SunroofAjarStatus
{
int temp; temp = getValue(BCM_SunroofAjarStatus);
writeDbgLevel(,"天窗信号=%d",temp);
BCM_SunroofState.L_Sunroof_Position=temp;
if(temp==) //未知
{
setPictureBoxImage(BCMStatusPanel,BCMSunroofCtrl,"..\\Panels\\picture\\天窗未知.bmp");
}
else if(temp==) //关闭
{
setPictureBoxImage(BCMStatusPanel,BCMSunroofCtrl,"..\\Panels\\picture\\天窗关闭.bmp");
}
else if(temp==) //开启
{
setPictureBoxImage(BCMStatusPanel,BCMSunroofCtrl,"..\\Panels\\picture\\天窗未关闭.bmp");
}
}
//驾驶位车窗
on envVar BCM_Drv_Wdw_PositionSts
{
int x,y; x = getvalue(BCM_Drv_Wdw_PositionSts);
y = getvalue(BCM_FrontLeftDoorAjarStatus);
writeDbgLevel(,"驾驶位车窗=%d",x);
BCM_LDoorWindowState.L_Drv_Wdw_PositionSts = x;
if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前窗开.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前门和窗未关闭.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前门关闭.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前门未关闭.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前窗透气.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前门未关闭窗透气.bmp");
}
}
//左后窗
on envVar BCM_RLD_Wdw_PositionSts
{
int x, y;
x = getValue(BCM_RLD_Wdw_PositionSts);
y = getValue(BCM_RearLeftDoorAjarStatus);
writeDbgLevel(,"左后车窗=%d",x);
BCM_LDoorWindowState.L_RLD_Wdw_PositionSts = x;
if((y==) && (x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后窗开.bmp");
}
else if((y==) && (x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后门和窗未关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后门关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后门未关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后窗透气.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后门未关闭窗透气.bmp");
}
}
//左前门
on envVar BCM_FrontLeftDoorAjarStatus
{
int x, y, z;
x = getvalue(BCM_FrontLeftDoorAjarStatus);
y = getvalue(BCM_Drv_Wdw_PositionSts);
z = getValue(BCM_DoorLockStatusDrv);
BCM_LDoorWindowState.BCM_FrontLeftDoorAjarStatus = x;
if((x==) && (z==) && (varPowerMode==))
{ //防盗入侵报警，熄火OFF+锁车+开左前门触发,10s后恢复armed
putValue(BCM_ATWS_St,); //0x0: Armed0x1: Prearmed0x2: Disarmed0x3: Remind0x4: Alarm0x5: Partially Armed0x6: Not used0x7: Not used
BCM_StateUpdate.BCM_ATWS_St=getvalue(BCM_ATWS_St);
//setTimer(BCM_ATWS_timer, varCycTime10);
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前窗开.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前门和窗未关闭.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前门关闭.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前门未关闭.bmp");
}
}
//左后门
on envVar BCM_RearLeftDoorAjarStatus
{
int x,y;
x = getvalue(BCM_RearLeftDoorAjarStatus);
y = getvalue(BCM_RLD_Wdw_PositionSts);
BCM_LDoorWindowState.BCM_RearLeftDoorAjarStatus=x;
if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后窗开.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后门和窗未关闭.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后门关闭.bmp");
}
else if((x==)&&(y==))
{
setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后门未关闭.bmp");
} }
//驾驶侧锁
on envVar BCM_DoorLockStatusDrv
{
int temp;
temp=getValue(BCM_DoorLockStatusDrv);
writeDbgLevel(,"门锁信号=%d",temp);
BCM_LDoorWindowState.BCM_DoorLockStatusDrv=temp;
if(temp==)
{
setPictureBoxImage(BCMStatusPanel,BCMLockCtrl,"..\\Panels\\picture\\锁开.bmp");
}
else
{
setPictureBoxImage(BCMStatusPanel,BCMLockCtrl,"..\\Panels\\picture\\锁闭.bmp");
}
}
//左后门锁
on envVar BCM_DoorLockStatusRL
{
BCM_LDoorWindowState.BCM_DoorLockStatusRL=getValue(BCM_DoorLockStatusRL);
}
//右前窗
on envVar BCM_Pas_Wdw_PositionSts
{
int x,y;
x = getvalue(BCM_Pas_Wdw_PositionSts);
y = getvalue(BCM_FrontRightDoorAjarStatus);
writeDbgLevel(,"副驾车窗=%d",x);
BCM_RDoorWindowState.L_Pas_Wdw_PositionSts=x;
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前窗开.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前门和窗未关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前门关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前门未关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前窗透气.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前门未关闭窗透气.bmp");
}
}
//右后窗
on envVar BCM_RRD_Wdw_PositionSts
{
int x,y;
x = getvalue(BCM_RRD_Wdw_PositionSts);
y = getvalue(BCM_RearRightDoorAjarStatus); writeDbgLevel(,"右后车窗=%d",x);
BCM_RDoorWindowState.L_RRD_Wdw_PositionSts=x;
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后窗开.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后门和窗未关闭.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后门关闭.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后门未关闭.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后窗透气.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后门未关闭窗透气.bmp");
}
}
//副驾门锁
on envVar BCM_DoorLockStatusPassenger
{
BCM_RDoorWindowState.BCM_DoorLockStatusPass=getValue(BCM_DoorLockStatusPassenger);
}
//右后门锁
on envVar BCM_DoorLockStatusRR
{
BCM_RDoorWindowState.BCM_DoorLockStatusRR=getValue(BCM_DoorLockStatusRR);
}
//右前门
on envVar BCM_FrontRightDoorAjarStatus
{
int x,y;
x = getvalue(BCM_Pas_Wdw_PositionSts);;
y = getvalue(BCM_FrontRightDoorAjarStatus);
BCM_RDoorWindowState.BCM_FrontRightDoorAjarStatus=y;
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前窗开.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前门和窗未关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前门关闭.bmp");
}
else if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前门未关闭.bmp");
}
}
//右后门
on envVar BCM_RearRightDoorAjarStatus
{
int x, y;
y = getvalue(BCM_RearRightDoorAjarStatus);
x = getvalue(BCM_RRD_Wdw_PositionSts);
BCM_RDoorWindowState.BCM_RearRightDoorAjarStatus=y;
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后窗开.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后门和窗未关闭.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后门关闭.bmp");
}
if((y==)&&(x==))
{
setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后门未关闭.bmp");
}
} //一键关门
on envVar CloseDoors
{
int temp;
temp = getValue(CloseDoors);
if(temp==) //关闭
{
putValue(BCM_FrontLeftDoorAjarStatus,);
putValue(BCM_FrontRightDoorAjarStatus,);
putValue(BCM_RearLeftDoorAjarStatus,);
putValue(BCM_RearRightDoorAjarStatus,); }
else //开启
{
putValue(BCM_FrontLeftDoorAjarStatus,);
putValue(BCM_FrontRightDoorAjarStatus,);
putValue(BCM_RearLeftDoorAjarStatus,);
putValue(BCM_RearRightDoorAjarStatus,);
}
}
//一键关窗
on envVar CloseWnds
{
int temp;
temp = getValue(CloseWnds);
//writeDbgLevel(1,"一键关窗=%d",temp);
if(temp==) //关闭
{
putValue(BCM_Drv_Wdw_PositionSts,);
putValue(BCM_Pas_Wdw_PositionSts,);
putValue(BCM_RLD_Wdw_PositionSts,);
putValue(BCM_RRD_Wdw_PositionSts,); //天窗
putValue(BCM_SunroofAjarStatus, );
//开度值=0
putValue(BCM_Val_Wdw_Opened,);
}
else //全开
{
putValue(BCM_Drv_Wdw_PositionSts,);
putValue(BCM_Pas_Wdw_PositionSts,);
putValue(BCM_RLD_Wdw_PositionSts,);
putValue(BCM_RRD_Wdw_PositionSts,); //可屏蔽天窗
putValue(BCM_SunroofAjarStatus, );
//开度值=100
putValue(BCM_Val_Wdw_Opened,);
}
}
//一键锁止
on envVar LockDoors
{
int temp;
temp = getValue(LockDoors);
if(==temp)//锁
{
putValue(BCM_DoorLockStatusDrv,);
putValue(BCM_DoorLockStatusRL,);
putValue(BCM_DoorLockStatusPassenger,);
putValue(BCM_DoorLockStatusRR,);
setPictureBoxImage(BCMStatusPanel,BCMLockCtrl,"..\\Panels\\picture\\锁闭.bmp");
}
else //未锁
{
putValue(BCM_DoorLockStatusDrv,);
putValue(BCM_DoorLockStatusRL,);
putValue(BCM_DoorLockStatusPassenger,);
putValue(BCM_DoorLockStatusRR,);
setPictureBoxImage(BCMStatusPanel,BCMLockCtrl,"..\\Panels\\picture\\锁开.bmp");
}
} //防盗报警状态
on envVar BCM_ATWS_St
{
BCM_StateUpdate.BCM_ATWS_St = getValue(BCM_ATWS_St);
} //BCM信号提示后盖箱／后车门开启／关闭
on envVar BCM_TrunkAjarStatus
{
int temp; temp = getValue(BCM_TrunkAjarStatus);
BCM_StateUpdate.BCM_TrunkAjarStatus=temp;
if(temp==) //关闭
{
setPictureBoxImage(BCMStatusPanel,BCMTrunkCtrl,"..\\Panels\\picture\\后备箱关闭.bmp");
}
else{ //开启
setPictureBoxImage(BCMStatusPanel,BCMTrunkCtrl,"..\\Panels\\picture\\后备箱未关闭.bmp");
}
} //BCM信号提示引擎盖开启／关闭
on envVar BCM_HoodAjarStatus
{
int temp; temp = getValue(BCM_HoodAjarStatus);
BCM_StateUpdate.BCM_HoodAjarStatus=temp;
if(temp==)
{
setPictureBoxImage(BCMStatusPanel, BCMHoodCtrl, "..\\Panels\\picture\\引擎盖关闭.bmp");
}
else if(temp==)
{
setPictureBoxImage(BCMStatusPanel, BCMHoodCtrl, "..\\Panels\\picture\\引擎盖未关闭.bmp");
}
else
{
writeDbgLevel(, "预留值，无定义");
}
} on envVar BCM_Val_Wdw_Opened
{
int temp;
temp = getValue(BCM_Val_Wdw_Opened);
writeDbgLevel(, "窗户开度值=%d", temp);
BCM_RDoorWindowState.L_Pas_Val_Wdw_Opened=temp;
BCM_RDoorWindowState.L_RRD_Val_Wdw_Opened=temp;
BCM_LDoorWindowState.L_Drv_Val_Wdw_Opened=temp;
BCM_LDoorWindowState.L_RLD_Val_Wdw_Opened=temp;
}
6、PEPS仿真+T业务主逻辑实现
T业务，处理远程业务时，需根据产品的DBC中定义的报文去解读信号，判断业务逻辑。(示例代码中处理业务逻辑的信号解析规则属于随便举例，实际应用时根据DBC定义进行解读)
variables
{
char log[];
float tFactor = 100000.0; //时间精度值
//本消息由PEPS发出, 鉴权
message 0x5 PEPS_TELChallengeCode;
//本消息由GW发送，包括PEPS的电源模式及报警信号等
message 0x6 GW_Info;
//由TBOX反馈的应答码
message 0x7 TBOX_ResponseCode; msTimer GW_PEPS_Timer;
//远程控制的PEPS响应定时器
msTimer GW_PEPS_TimerRespSuccess;
//接收到报文的定时器
msTimer GW_PEPS_TimerRespReceived;
//PEPS启动认证码的定时器，只发三帧
msTimer GW_PEPS_TimerSendChallengeCode;
//远程启动定时器
timer RespRmtEngineWorkingTimer; //PM 净化定时器
timer RmtAirCleanTimer;
//加热定时器
timer RmtDrvHeatTimer;
timer RmtPasHeatTimer;
//空调允许时间
timer RmtACOnTimer;
//
timer UpdateStatusTimer; //以下内容属于PEPS加密算法的内容
const dword SC32 = 0x00112233;
const qword CC64 = 0x94254547464A5B7DLL; //后最LL
//SK128 无法获取； RN32 每次鉴权随机生成；
dword RN32;
//设别远程启动的类型；在发生鉴权行为的时候会使用到
//1=启动；2=熄火；3=使能；4=禁止;0 预留
int rmtReqTpye=;
//是否已认真过
int IsAuthed = ; //远程控制请求
byte rmtCtrlReq;
// 远程查询PM2.5
byte rmtReqPM;
//远程查询
byte rmtReqQ;
//远程启动
byte rmtStartReq;
byte rmtStopReq;
//远程加热座椅
byte rmtHeatDrvSeat;
byte rmtHeatPasSeat; //远程开关空调
byte rmtACReq; //byte(3) 温度值+空调的启停状态
byte acReq;
byte acTemp; //远程空气净化
byte rmtAirCleanerReq; //发动机运行时长 分级
byte rmtEngWorkTimeLvl = ;
int rmtEngWorkTime = ; //远程发动机启动时长， 单位s
//延时
byte rmtEngWorkDelayTimeLvl = ;
//远程运行时间
int rmtWorkTime = ; //包含启动空调，加热，绿净的时长
int tempWorkTime; //临时变量 存放rmtworkTime
//远程禁允发动机
byte rmtForbidEngReq;
byte rmtPermitEngReq; //记忆PEPS应答报文的发送次数
int pepsRespCnt=;
//记忆PEPS认证报文的发送次数
int pepsAuthCnt=;
//
int pepsRecvCnt=;
} on start
{
InitLogging();
InitPEPSValue();
ActivePEPS(); } //关闭CANoe时 停止记录LOG
on stopMeasurement
{
writeDestroy(mTrace);
} //标记当前电源模式, 3=休眠开关， KL15电源通断可使用VT板卡实现，否则手动操作实现为半自动化方案
on envVar PEPS_PowerMode
{
varPowerMode = getValue(PEPS_PowerMode);
//刷新报文值
GW_Info.PEPS_PowerMode = varPowerMode;
if(varPowerMode==)
{
InactivePEPS();
lastPowerMode = varPowerMode;
}
else
{
if((varPowerMode==)&&(lastPowerMode==))
{
;
}
else if((==varPowerMode) || (==varPowerMode) || (==varPowerMode))
{
ActivePEPS(); //不是从3跳到0的模式，全激活
}
lastPowerMode = varPowerMode;
}
} //标记PEPS应答的错误码
on envVar PEPS_FailReason2TBOX
{
int temp;
temp = getValue(PEPS_FailReason2TBOX);
writeDbgLevel(,"PEPS_FailReason2TBOX=0x%x",temp);
GW_Info.PEPS_FailReason2TBOX = temp;
}
//标记PEPS应答的成功与否
on envVar PEPS_StatusResponse2TBOX
{
GW_Info.PEPS_StatusResponse2TBOX = getValue(PEPS_StatusResponse2TBOX);
}
//标记发动机的启动模式
on envVar PEPS_RemoteControlSt
{
GW_Info.PEPS_RemoteControlSt=getValue(PEPS_RemoteControlSt);
} /***********************************************************
* description : TBOX响应T业务的请求的报文
* parameter : None
* creation date: 2018/10/17
* author : xxx
* revision date:
* revision log :
* modifier :
***********************************************************/
on message TBOX_RmtCtrlInfo //此消息由DBC中定义的远程控制报文可获取, 具体的报文解析，字节信号位等由DBC定义
{
rmtReqQ = (this.byte() & 0x03);
//远程控制 + 查询类
rmtCtrlReq = this.TBOX_DoorsLock;
rmtReqPM = this.TBOX_PM25; //远程发动机延时等级
rmtEngWorkDelayTimeLvl = this.TBOX_EngineDelayTime;
rmtStartReq = this.TBOX_EngineStartReq;
rmtStopReq = this.TBOX_EngineStopReq;
rmtACReq = this.byte();
rmtAirCleanerReq = this.TBOX_AirCleanerReq;
rmtForbidEngReq = this.TBOX_EngineForbidReq;
rmtPermitEngReq = this.TBOX_EnginePermitReq;
//PEPSRespReceived(); //只要一接到接收指令 立即回复处理中
//远程控制
RespRmtCtrlCmd(rmtCtrlReq);
if( != rmtEngWorkDelayTimeLvl) //如果不等于0， 有控制请求
{
PEPSRespReceived();
switch(rmtEngWorkDelayTimeLvl)
{
case 0x1://1min
rmtWorkTime = ;
break;
case 0x2://3min
rmtWorkTime = ;
break;
case 0x3://5min
rmtWorkTime = ;
break;
case 0x4://10min
rmtWorkTime = ;
break;
default:
break;
}
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，发动机运行时间延长%d", timeNow()/tFactor, rmtWorkTime);
writeLineEx(mTrace, INFO, log);
PEPSRespSuccess();
}
//远程查询
if( == rmtReqPM)
{
PEPSRespReceived();
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，PM2.5查询", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
putValue(AC_PM25Sts, );//complate
PEPSRespSuccess();
}
if( == rmtReqQ)
{
PEPSRespReceived();
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，查询天窗车窗", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
PEPSRespSuccess();
}
//远程启动
if( == rmtStartReq)
{
PEPSRespReceived();
rmtReqTpye = ;
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，启动发动机", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
rmtEngWorkTimeLvl = this.TBOX_EngineStartTime;
switch(rmtEngWorkTimeLvl)
{
case 0x1://1min
rmtEngWorkTime = ;
break;
case 0x2://3min
rmtEngWorkTime = ;
break;
case 0x3://5min
rmtEngWorkTime = ;
break;
case 0x4://10min
rmtEngWorkTime = ;
break;
default:
break;
}
snprintf(log, elcount(log),"%f <- TBOX, 启动发动机时长%d", timeNow()/tFactor, rmtEngWorkTime);
writeLineEx(mTrace, INFO, log);
PEPSReqAuth();
} //远程停止
if(rmtStopReq==)
{
rmtReqTpye = ;
PEPSRespReceived(); snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，停止发动机", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log); PEPSRespSuccess();
RespRmtStop();
}
//远程禁止发动机
if( == rmtForbidEngReq)
{
rmtReqTpye = ;
PEPSRespReceived();
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，禁止启动", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log); PEPSReqAuth();
}
//远程使能发动机
if( == rmtPermitEngReq)
{
rmtReqTpye = ;
PEPSRespReceived();
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，允许启动", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log); PEPSReqAuth();
}
//PM 净化
if(==rmtAirCleanerReq) //2=ON , 1=OFF, 0=No Req
{
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，空气净化开启", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log); PEPSRespReceived();
PEPSRespSuccess();
RespRmtOpenAirClean(); //区分
}
else if(==rmtAirCleanerReq)
{
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，空气净化关闭", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log); PEPSRespReceived();
PEPSRespSuccess();
RespRmtCloseAirClean();
} //远程空调
if(0x1F != rmtACReq) //2=ON , 1=OFF, 0=No Req
{
PEPSRespReceived();
acReq = ((rmtACReq >> ) & 0x3);
acTemp = (rmtACReq & 0x1F);
snprintf(log, elcount(log),"%f <- TBOX, 接收到指令, 操作空调req=%d, temp=%d", timeNow()/tFactor,acReq,acTemp);
writeLineEx(mTrace, INFO, log); PEPSRespSuccess();
if(==acReq)
{
RespRmtOpenAC(); //open
}
else if(==acReq)
{
RespRmtCloseAC(); //close
}
}
if(this.byte()!=0xE7)
{
rmtHeatDrvSeat = this.TBOX_DrvHeatReq;
rmtHeatPasSeat = this.TBOX_PassHeatReq; snprintf(log, elcount(log),"%f <- TBOX, 接收到指令, 座椅加热Drv=%d,Pas=%d", timeNow()/tFactor,rmtHeatDrvSeat, rmtHeatPasSeat);
writeLineEx(mTrace, INFO, log); PEPSRespReceived();
PEPSRespSuccess();
//主驾
switch(rmtHeatDrvSeat)
{
case 0x0:
RespRmtCloseDrvHeat();
break;
case 0x1:
RespRmtOpenDrvHeat(rmtHeatDrvSeat);
break;
case 0x2:
RespRmtOpenDrvHeat(rmtHeatDrvSeat);
break;
default:
break;
} //副驾
switch(rmtHeatPasSeat)
{
case 0x0:
RespRmtClosePasHeat();
break;
case 0x1:
RespRmtOpenPasHeat(rmtHeatPasSeat);
break;
case 0x2:
RespRmtOpenPasHeat(rmtHeatPasSeat);
break;
default:
break;
}
}
} //TBOX响应PEPS挑战码，发出的认证码
on message TBOX_ResponseCode
{
snprintf(log, elcount(log),"%f <- TBOX, response peps auth request", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
//PEPS回复控制成功通过
PEPSRespSuccess();
if(rmtReqTpye == ){
RespRmtStart();
//设置发动机的运行模式与运行时长，启动定时器
snprintf(log, elcount(log),"%f <- TBOX, engine work time=%d", timeNow()/tFactor, rmtEngWorkTime);
writeLineEx(mTrace, INFO, log);
setTimer(RespRmtEngineWorkingTimer, rmtEngWorkTime);
}
else if(rmtReqTpye == ) //实测关闭发动机不需要鉴权
{
RespRmtStop();
}
else if( == rmtReqTpye) //使能
{
RespRmtPermit();
}
else if( == rmtReqTpye) //禁止
{
RespRmtForbidden();
}
} //远程启动发动机运行时长定时器
on timer RespRmtEngineWorkingTimer
{
//发动机置位远程启动模式
putValue(PEPS_RemoteControlSt,);
//电源置为ON
putValue(PEPS_PowerMode, );
//发动机置位running
putValue(EMS_EngStatus,);
} //空调开启一段时间后 更新温度传感器信号
on timer UpdateStatusTimer
{
; //未实现
} //空调运行时长定时器
on timer RmtACOnTimer
{
putValue(AC_OnState, );
} //空气净化运行时长定时器
on timer RmtAirCleanTimer
{
putValue(AC_AirCleanState, );
putValue(AC_OnState,);
} //主驾加热运行时长定时器
on timer RmtDrvHeatTimer
{
putValue(HVSM_DrvHeatSts, );
} //副驾加热运行时长定时器
on timer RmtPasHeatTimer
{
putValue(HVSM_PassHeatSts,);
} //响应远程加热主驾座椅
void RespRmtOpenDrvHeat(int level)
{
putValue(HVSM_DrvHeatSts,level);
if((==IsEngineWorking) && (rmtWorkTime!=))
{
snprintf(log, elcount(log),"%f -> HVSM, 先启动发动机，再开启座椅加热，延长发动机运行时长%d", timeNow()/tFactor, rmtWorkTime);
writeLineEx(mTrace, INFO, log);
tempWorkTime = rmtWorkTime;
cancelTimer(RespRmtEngineWorkingTimer); //取消原定时器
setTimer(RespRmtEngineWorkingTimer, tempWorkTime); //重置发动机定时器
setTimer(RmtDrvHeatTimer, tempWorkTime);
rmtWorkTime=;
}
else
{
snprintf(log, elcount(log),"%f -> HVSM, 直接座椅加热，发动机运行时长%d", timeNow()/tFactor, rmtEngWorkTime);
writeLineEx(mTrace, INFO, log);
setTimer(RmtDrvHeatTimer, rmtEngWorkTime);
}
} //响应远程加热副驾座椅
void RespRmtOpenPasHeat(int level)
{
putValue(HVSM_PassHeatSts,level);
if((==IsEngineWorking) && (rmtWorkTime!=))
{
snprintf(log, elcount(log),"%f -> HVSM, 先启动发动机，再加热座椅，延长发动机运行时长%d", timeNow()/tFactor, rmtWorkTime);
writeLineEx(mTrace, INFO, log);
tempWorkTime = rmtWorkTime;
cancelTimer(RespRmtEngineWorkingTimer); //取消原定时器
setTimer(RespRmtEngineWorkingTimer, tempWorkTime); //重置发动机定时器
setTimer(RmtPasHeatTimer, tempWorkTime);
rmtWorkTime=; //用完后归零
}
else
{
snprintf(log, elcount(log),"%f -> HVSM, 直接加热座椅，发动机运行时长%d", timeNow()/tFactor, rmtEngWorkTime);
writeLineEx(mTrace, INFO, log);
setTimer(RmtPasHeatTimer, rmtEngWorkTime);
}
} //响应关闭座椅加热
void RespRmtCloseDrvHeat()
{
cancelTimer(RmtDrvHeatTimer);
putValue(HVSM_DrvHeatSts, );
} //响应关闭座椅加热
void RespRmtClosePasHeat()
{
cancelTimer(RmtPasHeatTimer);
putValue(HVSM_PassHeatSts, );
} //响应开启空调
void RespRmtOpenAC()
{
putValue(AC_OnState, );
if((==IsEngineWorking) && (rmtWorkTime!=))
{
//先启动发动机 后启动空调
snprintf(log, elcount(log),"%f -> AC, 先启动发动机，再开启空调，延长发动机运行时长%d", timeNow()/tFactor, rmtWorkTime);
writeLineEx(mTrace, INFO, log);
tempWorkTime = rmtWorkTime;
cancelTimer(RespRmtEngineWorkingTimer); //取消原定时器
setTimer(RespRmtEngineWorkingTimer, tempWorkTime); //重置发动机定时器
setTimer(RmtACOnTimer, tempWorkTime);
rmtWorkTime=; //用完后归零
}
else
{
//直接启动空调
snprintf(log, elcount(log),"%f -> AC, 直接启动空调，发动机运行时长%d", timeNow()/tFactor, rmtEngWorkTime);
writeLineEx(mTrace, INFO, log);
setTimer(RmtACOnTimer, rmtEngWorkTime);
}
} //响应关闭空调
void RespRmtCloseAC()
{
cancelTimer(RmtACOnTimer);
putValue(AC_OnState, );
} //响应关闭空气净化
void RespRmtCloseAirClean()
{
cancelTimer(RmtAirCleanTimer);
putValue(AC_AirCleanState, );
putValue(AC_OnState, ); } //响应开启PM净化
void RespRmtOpenAirClean()
{
putValue(AC_OnState, );
putValue(AC_AirCleanState, );
if((==IsEngineWorking) && (rmtWorkTime!=))
{
//先启动发动机 后启动PM净化
snprintf(log, elcount(log),"%f -> AC, 先启动发动机 再开空气净化，延长发动机运行时间%d", timeNow()/tFactor, rmtWorkTime);
writeLineEx(mTrace, INFO, log);
tempWorkTime = rmtWorkTime;
cancelTimer(RespRmtEngineWorkingTimer); //取消原定时器
setTimer(RespRmtEngineWorkingTimer, rmtWorkTime); //重置发动机定时器
setTimer(RmtAirCleanTimer, rmtWorkTime); //置位空气净化定时器
rmtWorkTime = ;
}
else
{
//直接启动PM净化
snprintf(log, elcount(log),"%f -> AC, 直接开启空气净化，发动机运行时间%d", timeNow()/tFactor, rmtEngWorkTime);
writeLineEx(mTrace, INFO, log);
setTimer(RmtAirCleanTimer, rmtEngWorkTime); //置位空气净化定时器
} } //响应远程控制指令
void RespRmtCtrlCmd(int cmd)
{
//判断远程控制类逻辑
switch(cmd){
case 0x0://No command
break;
case 0x1://All door lock
snprintf(log, elcount(log),"%f <- TBOX, 接收上锁指令", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
SetDoorsLocked();
PEPSRespSuccess();
break;
case 0x2://Blink lamp 闪灯
break; //APP未实现单独指令
case 0x3://All door unlock
snprintf(log, elcount(log),"%f <- TBOX, 接收解锁指令", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
SetDoorsUnlocked();
PEPSRespSuccess();
break;
case 0x4://Whistle 鸣笛
break; //APP未实现单独指令
case 0x5://Global closing-window up
snprintf(log, elcount(log),"%f <- TBOX, 接收关窗指令", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
SetWndsClosed();
PEPSRespSuccess();
break;
case 0x6://Closing window
break; //APP未实现单独指令
case 0x7: //Closing sunroof
break; //APP未实现单独指令
case 0x8://Global opening-window down
snprintf(log, elcount(log),"%f <- TBOX, 接收开窗指令", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
SetWndsOpened();
PEPSRespSuccess();
break;
case 0x9://Vehicle search
snprintf(log, elcount(log),"%f <- TBOX, 接收寻车指令", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
PEPSRespSuccess();
break;
case 0xA://Trunk unlock
snprintf(log, elcount(log),"%f <- TBOX, 接收开启后备箱指令", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
SetTrunkOpened();
PEPSRespSuccess();
break;
case 0xB://Window ventilate
snprintf(log, elcount(log),"%f <- TBOX, 接收透气指令", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
SetWndsVentilate();
PEPSRespSuccess();
break;
case 0xC://Opening sunroof
break; //APP未实现单独指令
default://others are reserved
break; //预留指令
}
} //远程禁止启动发动机
void RespRmtForbidden()
{
GW_Info.PEPS_EngineforbidSt=;
} //远程允许启动发动机
void RespRmtPermit()
{
GW_Info.PEPS_EngineforbidSt=;
} //远程停止发动机
void RespRmtStop()
{
cancelTimer(RespRmtEngineWorkingTimer); putValue(PEPS_RemoteControlSt,);
putValue(EMS_EngStatus, );
putValue(PEPS_PowerMode, );
//停止发动机后 所有控制器开的状态都归零
putValue(AC_AirCleanState, );
putValue(AC_OnState,);
putValue(HVSM_DrvHeatSts, );
putValue(HVSM_PassHeatSts, );
} //响应远程启动
void RespRmtStart()
{
IsAuthed =;
putValue(EMS_EngStatus, ); //发动机置位远程启动模式
putValue(PEPS_RemoteControlSt,);
//发动机置位running
putValue(EMS_EngStatus, );
//电源置为ON
putValue(PEPS_PowerMode, );
IsEngineWorking = ; //标记发动机已经工作中， Delay时间不会发出
snprintf(log, elcount(log),"%f <- EMS PEPS, Engine running, Power on", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
//TestWaitForTimeout(3000);//延时函数在纯CAPL程序中不能使用
} //初始化电源模式
void InitPEPSValue()
{
putValue(PEPS_PowerMode, );
putValue(PEPS_StatusResponse2TBOX,);
putValue(PEPS_FailReason2TBOX,);
putValue(PEPS_RemoteControlSt,);
GW_Info.PEPS_PowerModeValidity = ;
GW_Info.PEPS_EngineforbidSt=; //发动机允许远程使能状态
} void ActivePEPS()
{
setTImer(GW_PEPS_Timer, varCycTime100);
} void InactivePEPS()
{
cancelTimer(GW_PEPS_Timer);
} //每次鉴权生成随机认证码
void GenerateRN32()
{
RN32 = random(0xFFFFFFFF);
} //窗户透气响应
void SetWndsVentilate()
{
//窗户开
putValue(BCM_Drv_Wdw_PositionSts,);
putValue(BCM_RLD_Wdw_PositionSts,);
putValue(BCM_Pas_Wdw_PositionSts,);
putValue(BCM_RRD_Wdw_PositionSts,);
putValue(BCM_Val_Wdw_Opened, ); //开度值20%
} //响应远程关闭车窗指令
void SetWndsClosed()
{
// putValue(CloseWnds,0);
putValue(BCM_Drv_Wdw_PositionSts,);
putValue(BCM_RLD_Wdw_PositionSts,);
putValue(BCM_Pas_Wdw_PositionSts,);
putValue(BCM_RRD_Wdw_PositionSts,);
putValue(BCM_Val_Wdw_Opened, );
} //响应远程上锁指令
void SetDoorsLocked()
{
putValue(LockDoors,);
} //响应远程解锁指令
void SetDoorsUnlocked()
{
putValue(LockDoors,);
} //响应远程开窗指令
void SetWndsOpened()
{
// putValue(CloseWnds,1);//开启
putValue(BCM_Drv_Wdw_PositionSts,);
putValue(BCM_RLD_Wdw_PositionSts,);
putValue(BCM_Pas_Wdw_PositionSts,);
putValue(BCM_RRD_Wdw_PositionSts,);
putValue(BCM_Val_Wdw_Opened, );
} //响应远程打开后备箱
void SetTrunkOpened()
{
putValue(BCM_TrunkAjarStatus, ); //开启后备箱
} //PEPS回复控制成功报文
void PEPSRespSuccess()
{
setTimer(GW_PEPS_TimerRespSuccess, varCycTime100);
} void PEPSRespReceived()
{
// setTimer(GW_PEPS_TimerRespReceived, varCycTime20);
} //PEPS发起认证请求
void PEPSReqAuth()
{
//算法不实现！
//若实际环境中接入了PEPS设备，则需实车抓取报文使用固定一组报文访问
//安全隐患，PEPS入侵（可能设计：每次随机的挑战码，携带当前时间，设置计数器和校验位验证有效性，限定时间内的重复报文无效）
if(rmtReqTpye ==)
{
GenerateChallengeCode4Start();
}
else if(rmtReqTpye ==)
{
GenerateChallengeCode4Stop();
} setTimer(GW_PEPS_TimerSendChallengeCode, varCycTime20);
IsAuthed = ; //已经发起过鉴权
} void GenerateChallengeCode4Stop()
{
//关闭发动机鉴权
}
//生成PEPS挑战码，启动发动机鉴权
void GenerateChallengeCode4Start()
{
if(pepsAuthCnt==)
{
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte0 = random(0xff);
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte1 = random(0xff);
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte2 = random(0xff);
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte3 = random(0xff);
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte4 = random(0xff);
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte5 = random(0xff);
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte6 = random(0xff);
PEPS_TELChallengeCode.PEPS_TELchallengeCode_Byte7 = random(0xff);
}
} //TBOX预约充电请求（电动车）/
on message TBOX_ReservationChgSet
{
//线束不支持双路CAN 暂且无法实现
} //TBOX被唤醒的原因指示
on message NWM_TBOX_Information
{
int reasons;
reasons = this.TBOX_Wakeup_reasons;
switch(reasons){
case 0x2:
writeLineEx(mTrace, , "NM PDU Received");
break;
case 0x5:
writeLineEx(mTrace, , "KL15 On");
break;
case 0x06:
writeLineEx(mTrace, , "Telematics service");
break;
default:
break;
}
} //PEPS周期报文发送
on timer GW_PEPS_Timer
{
output(GW_Info);
setTimer(GW_PEPS_Timer, varCycTime100);
} //响应远程请求，PEPS反馈Received
on timer GW_PEPS_TimerRespReceived
{
pepsRecvCnt+=;
if(pepsRecvCnt<)
{
snprintf(log, elcount(log),"%f -> PEPS, response 'in progress'", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
putValue(PEPS_FailReason2TBOX, );
putValue(PEPS_StatusResponse2TBOX, );
setTimer(GW_PEPS_TimerRespReceived, varCycTime20); //200ms一帧
}
else
{
cancelTimer(GW_PEPS_TimerRespReceived);
putValue(PEPS_FailReason2TBOX, );
putValue(PEPS_StatusResponse2TBOX, );
pepsRecvCnt = ;
}
} //响应远程请求，PEPS反馈Success
on timer GW_PEPS_TimerRespSuccess
{
pepsRespCnt+=;
if(pepsRespCnt<)
{
snprintf(log, elcount(log),"%f -> PEPS, response 'success'", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log);
putValue(PEPS_FailReason2TBOX, );
putValue(PEPS_StatusResponse2TBOX, );
setTimer(GW_PEPS_TimerRespSuccess, varCycTime100);
}
else
{
cancelTimer(GW_PEPS_TimerRespSuccess);
putValue(PEPS_FailReason2TBOX, );
putValue(PEPS_StatusResponse2TBOX, );
pepsRespCnt = ;
}
} //响应远程启动请求, PEPS发出挑战码
on timer GW_PEPS_TimerSendChallengeCode
{ pepsAuthCnt+=;
if(pepsAuthCnt<)
{
snprintf(log, elcount(log),"%f -> PEPS, send challenge code", timeNow()/tFactor);
writeLineEx(mTrace, INFO, log); output(PEPS_TELChallengeCode);
setTimer(GW_PEPS_TimerSendChallengeCode, varCycTime20);//递归 发三帧,20ms一帧
}
else
{
cancelTimer(GW_PEPS_TimerSendChallengeCode);
pepsAuthCnt = ;
}
}
7、效果展示
整个车辆网功能中涉及到整车中其它ECU相关的业务，也可参照以上实现逻辑去进行仿真。此处不一一举例。
我在台架中接入真实仪表验证我的仿真逻辑（节点支持热增减，没有ECU则使用仿真节点，有真实ECU则屏蔽）。
启动仿真程序后，操作控制器，验证车身仿真器的实现，可以检验出仿真代码实现的正确性
--------------------------以上T业务自动化仿真测试台架全内容完结-----------------------------