【TBOX】基於CANoe實現的自動化測試方案

　　為滿足項目過程中不同階段絕大部分測試需求，更方便快捷構造測試場景，支持異常場景測試。更早介入，不依賴周邊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 = 10;
  const int varCycTime20 = 20;
  const int varCycTime50 = 50;
  const int varCycTime100 = 100;
  const int varCycTime200 = 200;
  const int varCycTime500 = 500;
  const int varCycTime1000 = 1000;
  
  // varCarType車型定義， 0=純油, 1=純電, 2=混動, others=error
  // 字母代碼 AFV=純油， EV=純電， HEV=混動（不區分直插式和充電樁式）
  // 全局LOG
  long mTrace = 0; 
  //severity
  dword INFO = 1;
  dword WARN = 2;
  dword ERROR = 3;
  // 鑒權秘鑰
  byte varESKCode[10][8] = {
    //。。。略
  }; 
  
  // varCarCode 標記當前被測車型， 用於選擇調用正確的鑒權碼
  int varESKNumber;
  // 記錄當前電源模式,0=OFF; 1=ACC; 2=ON; 3=reserved; 4=start; 5,6,7=reserved
  int varPowerMode=0;
  int lastPowerMode=0;
  // 發動機狀態
  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 = 0;
}

/***********************************************************
* description  : 全局日志記錄函數
* parameter    : None
* creation date: 2018/10/26
* author       : xxx   
* revision date: 
* revision log : 
* modifier     : 
***********************************************************/
void InitLogging()
{
  mTrace = writeCreate("Logging");
  writeConfigure(mTrace,1024*1000,1,"..\\Proj\\Log\\write.txt");
  writeclear(1);
}

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 = 0;
  varVelSpeed = getValue(ESC_VehicleSpeed);
  
  //轉換成儀表顯示, KPH
  if(varPowerMode!=2)
  {
    writeDbgLevel(1, "PowerMode=OFF,車速調節無效");
    ESC_Status.ESC_VehicleSpeed = 0;
    putValue(ESC_VehicleSpeed, 0);
  }
  else
  {
    if(varVelSpeed!=0) //置位發動機轉速
    {
      writeDbgLevel(1, "點火狀態，車速不為零，設置發動機轉速");
      putValue(EMS_EngineSpeedRPM,3000);
    }
    else
    {
      putValue(EMS_EngineSpeedRPM,0);
    }
    if(varVelSpeed>25) //車速>25時，自動落鎖
    {
      writeDbgLevel(1,"車速>25碼，自動落鎖");
      putValue(LockDoors, 1);
    }
    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, 0);
  ESC_Status.xxx=0;
}

//激活
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 = 0;//5; //時差
  const m_offset = 0;//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[9];
  char t_canoe[26];
  char t_now[26];
}

***********************************************************
* 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[5]-100;
  IPK_DateTime.IPK_Month = tm[4]+1;
  
  IPK_DateTime.IPK_Second = tm[0];
  //以上API獲取的時間比北京時間快6h 5min
  if(tm[2]>=h_offset) //24小時制
  {
    IPK_DateTime.IPK_Hour = tm[2]-h_offset; //減去快的6H
    IPK_DateTime.IPK_Day = tm[3];
  }
  else
  {
    IPK_DateTime.IPK_Hour = tm[2] -h_offset+24; //當時間跳到第二天凌晨,逆向+18
    IPK_DateTime.IPK_Day = tm[3] -1; // day-1
  }
  if(tm[1]>=m_offset) //處理分鍾
  {
    IPK_DateTime.IPK_Minute = tm[1] -m_offset;
  }
  else
  {
    IPK_DateTime.IPK_Minute = tm[1] -m_offset + 60;
    //此時小時跨度要再減一小時
    IPK_DateTime.IPK_Hour = tm[2]-(h_offset+1); //減去快的6H and 跨時段1
  }
  
  //格式化當前時間戳
  snprintf(t_now, elcount(t_now),"%d/%d/%d %02d:%02d:%02d", tm[5]+1900, tm[4]+1, tm[3], IPK_DateTime.IPK_Hour,IPK_DateTime.IPK_Minute,tm[0]);
}
//log輸出  提示作用
on timer DateRemanderTimer
{
  writeDbgLevel(1, "CANoe Time: %s", t_canoe);
  writeDbgLevel(1, "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 = 0;
  
  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[32] = "BCM狀態圖";
  char EMSCtrl[8] = "發動機";
  
  //本消息由EMS發出，包含引擎轉速、加速踏板狀態信號
  message 0x334 EMS_EngineRPM;

  msTimer EMS_timer;
}

on envVar PEPS_PowerMode
{
  //獲取電源模式 + 車速
  varPowerMode = getValue(PEPS_PowerMode);
  if(varPowerMode==3)
  {
    putValue(EMS_EngStatus, 0);//stop
    putValue(EMS_EngineSpeedRPM,0);
    InactiveEMS();
    lastPowerMode = varPowerMode;
  }
  else
  {
    if(lastPowerMode==3 && varPowerMode==0)
    {
      ;
    }
    else
    {
      switch(varPowerMode)
      {
        case 0:
          putValue(EMS_EngStatus, 0);//stop
          putValue(EMS_EngineSpeedRPM,0);
          break;
        case 1:
          putValue(EMS_EngStatus, 0);//stop
          putValue(EMS_EngineSpeedRPM,0);
          break;
        case 2:
          putValue(EMS_EngStatus, 3);
          break;
        case 4:
          putValue(EMS_EngStatus, 1);//Cranking
          putValue(EMS_EngineSpeedRPM,0);
          break;
        default:
          break;
      }
      ActiveEMS();          
    }
  }
}

//更新車身仿真器的狀態
on envVar EMS_EngStatus
{
  int temp;
  temp = getValue(EMS_EngStatus);
  EMS_EngineRPM.EMS_EngStatus = temp;
  if(temp==3)
  {
    IsEngineWorking = 1; //發動機工作中
    setPictureBoxImage(BCMStatusPanel, EMSCtrl, "..\\Panels\\picture\\啟動中.bmp");
  }
  else if (temp==0)//油車
  {
    IsEngineWorking = 0;
    setPictureBoxImage(BCMStatusPanel, EMSCtrl, "..\\Panels\\picture\\未啟動.bmp");
  }
  else if(temp==2) //PHEV
  {
    if(@GEEA1::varCarType == 2)
    {
      IsEngineWorking = 0;
      setPictureBoxImage(BCMStatusPanel, EMSCtrl, "..\\Panels\\picture\\未啟動.bmp");
    }
  }
}

//略去 EMS激活，去激活，初始值，報文發送的函數

BCM仿真器實現，四門六蓋，鎖狀態

variables
{
  char BCMCtrlPanel[32] = "ControlPanel";
  char BCMStatusPanel[32] = "BCM狀態圖";
  char BCMHoodCtrl[32]= "引擎蓋";
  char BCMTrunkCtrl[32]= "后備箱";
  char BCMLFDoorCtrl[32]= "左前門";
  char BCMLRDoorCtrl[32]= "左后門";
  char BCMRFDoorCtrl[32]= "右前門";
  char BCMRRDoorCtrl[32]= "右后門";
  char BCMSunroofCtrl[32]= "天窗";
  char BCMLockCtrl[32]= "鎖";
  
  //本消息由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==3) //CAN-Sleep
  {
    InactiveBCM();
    lastPowerMode = varPowerMode;
  }
  else
  {
    if((varPowerMode==0)&&(lastPowerMode==3))
    {
      ;
    }
    else if((2==varPowerMode) || (1==varPowerMode) || (4==varPowerMode))
    {
      ActiveBCM(); //不是從3跳到0的模式，全激活
    }
    lastPowerMode = varPowerMode;
  }
}
//天窗
on envVar BCM_SunroofAjarStatus
{
  int temp;
  
  temp = getValue(BCM_SunroofAjarStatus);
  writeDbgLevel(1,"天窗信號=%d",temp);
  BCM_SunroofState.L_Sunroof_Position=temp;
  if(temp==0) //未知
  {
    setPictureBoxImage(BCMStatusPanel,BCMSunroofCtrl,"..\\Panels\\picture\\天窗未知.bmp");  
  }
  else if(temp==1) //關閉
  { 
    setPictureBoxImage(BCMStatusPanel,BCMSunroofCtrl,"..\\Panels\\picture\\天窗關閉.bmp");  
  }
  else if(temp==2) //開啟
  {
    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(1,"駕駛位車窗=%d",x);
  BCM_LDoorWindowState.L_Drv_Wdw_PositionSts = x;
  if((x==1)&&(y==0))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前窗開.bmp");  
  }
  else if((x==1)&&(y==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前門和窗未關閉.bmp");  
  }
  else if((x==2)&&(y==0))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前門關閉.bmp");  
  }
  else if((x==2)&&(y==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前門未關閉.bmp");  
  }
  else if((x==0)&&(y==0))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前窗透氣.bmp");  
  }
   else if((x==0)&&(y==1))
  {
   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(1,"左后車窗=%d",x);
  BCM_LDoorWindowState.L_RLD_Wdw_PositionSts = x;
  if((y==0) && (x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后窗開.bmp");  
  }
  else if((y==1) && (x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后門和窗未關閉.bmp");  
  }
   else if((y==0)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后門關閉.bmp");  
  }
   else if((y==1)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后門未關閉.bmp");  
  }
  else if((y==0)&&(x==0))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后窗透氣.bmp");  
  }
  else if((y==1)&&(x==0))
  {
   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==1) && (z==1) && (varPowerMode==0))
  { //防盜入侵報警，熄火OFF+鎖車+開左前門觸發,10s后恢復armed
     putValue(BCM_ATWS_St,4);  //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==1)&&(x==0))
  {
    setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前窗開.bmp");  
  }
  if((y==1)&&(x==1))
  {
    setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前門和窗未關閉.bmp");  
  }
  if((y==2)&&(x==0))
  {
    setPictureBoxImage(BCMStatusPanel, BCMLFDoorCtrl, "..\\Panels\\picture\\左前門關閉.bmp");  
  }
  if((y==2)&&(x==1))
  {
    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==0)&&(y==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后窗開.bmp");  
  }
  else if((x==1)&&(y==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后門和窗未關閉.bmp");  
  }
   else if((x==0)&&(y==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后門關閉.bmp");  
  }
   else if((x==1)&&(y==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMLRDoorCtrl, "..\\Panels\\picture\\左后門未關閉.bmp");  
  }

}
//駕駛側鎖
on envVar BCM_DoorLockStatusDrv
{
  int temp;
  temp=getValue(BCM_DoorLockStatusDrv);
  writeDbgLevel(1,"門鎖信號=%d",temp);
  BCM_LDoorWindowState.BCM_DoorLockStatusDrv=temp;
  if(temp==0)
  {
    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(1,"副駕車窗=%d",x);
  BCM_RDoorWindowState.L_Pas_Wdw_PositionSts=x;
  if((y==0)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前窗開.bmp");  
  }
  else if((y==1)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前門和窗未關閉.bmp");  
  }
  else if((y==0)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前門關閉.bmp");  
  }
  else if((y==1)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前門未關閉.bmp");  
  }
   else if((y==0)&&(x==0))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前窗透氣.bmp");  
  }
   else if((y==1)&&(x==0))
  {
   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(1,"右后車窗=%d",x);
  BCM_RDoorWindowState.L_RRD_Wdw_PositionSts=x;
  if((y==0)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后窗開.bmp");  
  }
  if((y==1)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后門和窗未關閉.bmp");  
  }
  if((y==0)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后門關閉.bmp");  
  }
  if((y==1)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后門未關閉.bmp");  
  }
  if((y==0)&&(x==0))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后窗透氣.bmp");  
  }
  if((y==1)&&(x==0))
  {
   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==0)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前窗開.bmp");  
  }
  else if((y==1)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前門和窗未關閉.bmp");  
  }
  else if((y==0)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRFDoorCtrl, "..\\Panels\\picture\\右前門關閉.bmp");  
  }
  else if((y==1)&&(x==2))
  {
   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==0)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后窗開.bmp");  
  }
 if((y==1)&&(x==1))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后門和窗未關閉.bmp");  
  }
  if((y==0)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后門關閉.bmp");  
  }
  if((y==1)&&(x==2))
  {
   setPictureBoxImage(BCMStatusPanel, BCMRRDoorCtrl, "..\\Panels\\picture\\右后門未關閉.bmp");  
  }
}

//一鍵關門
on envVar CloseDoors
{
  int temp;
  temp = getValue(CloseDoors);
  if(temp==0) //關閉 
  { 
    putValue(BCM_FrontLeftDoorAjarStatus,0);
    putValue(BCM_FrontRightDoorAjarStatus,0);
    putValue(BCM_RearLeftDoorAjarStatus,0);
    putValue(BCM_RearRightDoorAjarStatus,0);
    
  }
  else //開啟
  {
    putValue(BCM_FrontLeftDoorAjarStatus,1);
    putValue(BCM_FrontRightDoorAjarStatus,1);
    putValue(BCM_RearLeftDoorAjarStatus,1);
    putValue(BCM_RearRightDoorAjarStatus,1);
  }
}
//一鍵關窗
on envVar CloseWnds
{
  int temp;
  temp = getValue(CloseWnds);
  //writeDbgLevel(1,"一鍵關窗=%d",temp);
  if(temp==0) //關閉
  {
    putValue(BCM_Drv_Wdw_PositionSts,2);
    putValue(BCM_Pas_Wdw_PositionSts,2);
    putValue(BCM_RLD_Wdw_PositionSts,2);
    putValue(BCM_RRD_Wdw_PositionSts,2);
    
    //天窗
    putValue(BCM_SunroofAjarStatus, 1);
    //開度值=0
    putValue(BCM_Val_Wdw_Opened,0);
  }
  else //全開
  {
    putValue(BCM_Drv_Wdw_PositionSts,1);
    putValue(BCM_Pas_Wdw_PositionSts,1);
    putValue(BCM_RLD_Wdw_PositionSts,1);
    putValue(BCM_RRD_Wdw_PositionSts,1);
    
    //可屏蔽天窗
    putValue(BCM_SunroofAjarStatus, 2);
    //開度值=100
    putValue(BCM_Val_Wdw_Opened,100);
  }
}
//一鍵鎖止
on envVar LockDoors
{
  int temp;
  temp = getValue(LockDoors);
  if(1==temp)//鎖
  {
    putValue(BCM_DoorLockStatusDrv,1);
    putValue(BCM_DoorLockStatusRL,1);
    putValue(BCM_DoorLockStatusPassenger,1);
    putValue(BCM_DoorLockStatusRR,1);
    setPictureBoxImage(BCMStatusPanel,BCMLockCtrl,"..\\Panels\\picture\\鎖閉.bmp");  
  }
  else //未鎖
  {
    putValue(BCM_DoorLockStatusDrv,0);
    putValue(BCM_DoorLockStatusRL,0);
    putValue(BCM_DoorLockStatusPassenger,0);
    putValue(BCM_DoorLockStatusRR,0);
    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==0) //關閉
  {
    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==0)
  {
    setPictureBoxImage(BCMStatusPanel, BCMHoodCtrl, "..\\Panels\\picture\\引擎蓋關閉.bmp");  
  }
  else if(temp==1)
  {
    setPictureBoxImage(BCMStatusPanel, BCMHoodCtrl, "..\\Panels\\picture\\引擎蓋未關閉.bmp");  
  }
  else
  {
    writeDbgLevel(1, "預留值，無定義");
  } 
}

on envVar  BCM_Val_Wdw_Opened
{
  int temp; 
  temp = getValue(BCM_Val_Wdw_Opened);
  writeDbgLevel(1, "窗戶開度值=%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[128];
  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=0;
  //是否已認真過
  int IsAuthed = 0;
  
  
  //遠程控制請求
  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 = 0;
  int rmtEngWorkTime = 0;  //遠程發動機啟動時長， 單位s
  //延時
  byte rmtEngWorkDelayTimeLvl = 0;
  //遠程運行時間
  int rmtWorkTime = 0; //包含啟動空調，加熱，綠凈的時長
  int tempWorkTime; //臨時變量 存放rmtworkTime
  //遠程禁允發動機
  byte rmtForbidEngReq;
  byte rmtPermitEngReq;
  
  //記憶PEPS應答報文的發送次數
  int pepsRespCnt=0;
  //記憶PEPS認證報文的發送次數
  int pepsAuthCnt=0;
  //
  int pepsRecvCnt=0;
}

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==3)
  {
    InactivePEPS();
    lastPowerMode = varPowerMode;
  }
  else
  {
    if((varPowerMode==0)&&(lastPowerMode==3))
    {
      ;
    }
    else if((2==varPowerMode) || (1==varPowerMode) || (4==varPowerMode))
    {
      ActivePEPS(); //不是從3跳到0的模式，全激活
    }
    lastPowerMode = varPowerMode;
  }
}


//標記PEPS應答的錯誤碼
on envVar PEPS_FailReason2TBOX
{
  int temp;
  temp = getValue(PEPS_FailReason2TBOX);
  writeDbgLevel(1,"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(1) & 0x03);
  //遠程控制 +　查詢類
  rmtCtrlReq = this.TBOX_DoorsLock;
  rmtReqPM = this.TBOX_PM25;

  //遠程發動機延時等級
  rmtEngWorkDelayTimeLvl = this.TBOX_EngineDelayTime;
  rmtStartReq = this.TBOX_EngineStartReq;
  rmtStopReq = this.TBOX_EngineStopReq;
  rmtACReq = this.byte(3);
  rmtAirCleanerReq = this.TBOX_AirCleanerReq;
  rmtForbidEngReq = this.TBOX_EngineForbidReq;
  rmtPermitEngReq = this.TBOX_EnginePermitReq;
  //PEPSRespReceived(); //只要一接到接收指令 立即回復處理中
  //遠程控制
  RespRmtCtrlCmd(rmtCtrlReq);
  if(0 != rmtEngWorkDelayTimeLvl) //如果不等於0， 有控制請求
  {
    PEPSRespReceived();
    switch(rmtEngWorkDelayTimeLvl)
    {
      case 0x1://1min
        rmtWorkTime = 60;
        break;
      case 0x2://3min
        rmtWorkTime = 180;
        break;
      case 0x3://5min
        rmtWorkTime = 300;
        break;
      case 0x4://10min
        rmtWorkTime = 600;
        break;
      default:
        break;
    }
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，發動機運行時間延長%d", timeNow()/tFactor, rmtWorkTime);
    writeLineEx(mTrace, INFO, log);
    PEPSRespSuccess();
  }
  //遠程查詢
  if(1 == rmtReqPM)
  {
    PEPSRespReceived();
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，PM2.5查詢", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    putValue(AC_PM25Sts, 2);//complate
    PEPSRespSuccess();
  }
  if(3 == rmtReqQ)
  {
    PEPSRespReceived();
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，查詢天窗車窗", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    PEPSRespSuccess();
  }
  //遠程啟動
  if(1 == rmtStartReq)
  {
    PEPSRespReceived(); 
    rmtReqTpye = 1;
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，啟動發動機", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    rmtEngWorkTimeLvl = this.TBOX_EngineStartTime;
    switch(rmtEngWorkTimeLvl)
    {
      case 0x1://1min
        rmtEngWorkTime = 60;
        break;
      case 0x2://3min
        rmtEngWorkTime = 180;
        break;
      case 0x3://5min
        rmtEngWorkTime = 300;
        break;
      case 0x4://10min
        rmtEngWorkTime = 600;
        break;
      default:
        break;
    }
    snprintf(log, elcount(log),"%f <- TBOX, 啟動發動機時長%d", timeNow()/tFactor, rmtEngWorkTime);
    writeLineEx(mTrace, INFO, log);
    PEPSReqAuth();
  }
  
  //遠程停止
  if(rmtStopReq==1)
  {
    rmtReqTpye = 2;
    PEPSRespReceived();
    
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，停止發動機", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    
    PEPSRespSuccess();
    RespRmtStop();
  }
   //遠程禁止發動機
  if(1 == rmtForbidEngReq)
  {
    rmtReqTpye = 4;
    PEPSRespReceived();
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，禁止啟動", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    
    PEPSReqAuth();
  }
  //遠程使能發動機
  if(1 == rmtPermitEngReq) 
  {
    rmtReqTpye = 3;
    PEPSRespReceived();
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令，允許啟動", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    
    PEPSReqAuth();
  }
  //PM 凈化  
  if(2==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(1==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 >> 6) & 0x3);
    acTemp = (rmtACReq & 0x1F);
    snprintf(log, elcount(log),"%f <- TBOX, 接收到指令, 操作空調req=%d, temp=%d", timeNow()/tFactor,acReq,acTemp);
    writeLineEx(mTrace, INFO, log);
  
    PEPSRespSuccess();
    if(2==acReq)
    {
      RespRmtOpenAC();  //open
    }
    else if(1==acReq)
    {
      RespRmtCloseAC();  //close
    }
  }
  if(this.byte(4)!=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 == 1){
    RespRmtStart();
    //設置發動機的運行模式與運行時長，啟動定時器
    snprintf(log, elcount(log),"%f <- TBOX, engine work time=%d", timeNow()/tFactor, rmtEngWorkTime);
    writeLineEx(mTrace, INFO, log);
    setTimer(RespRmtEngineWorkingTimer, rmtEngWorkTime);
  }
  else if(rmtReqTpye == 2) //實測關閉發動機不需要鑒權
  {
    RespRmtStop();
  }
  else if(3 == rmtReqTpye) //使能
  {
    RespRmtPermit();
  }
  else if(4 == rmtReqTpye) //禁止
  {
    RespRmtForbidden();
  }
}

//遠程啟動發動機運行時長定時器
on timer RespRmtEngineWorkingTimer
{
  //發動機置位遠程啟動模式
  putValue(PEPS_RemoteControlSt,0);
  //電源置為ON
  putValue(PEPS_PowerMode, 0);
  //發動機置位running
  putValue(EMS_EngStatus,0);
}

//空調開啟一段時間后 更新溫度傳感器信號
on timer UpdateStatusTimer
{
  ; //未實現
}

//空調運行時長定時器
on timer RmtACOnTimer
{
  putValue(AC_OnState, 0);
}

//空氣凈化運行時長定時器
on timer RmtAirCleanTimer
{
  putValue(AC_AirCleanState, 0);
  putValue(AC_OnState,0); 
}

//主駕加熱運行時長定時器
on timer RmtDrvHeatTimer
{
  putValue(HVSM_DrvHeatSts, 0);
}

//副駕加熱運行時長定時器
on timer RmtPasHeatTimer
{
  putValue(HVSM_PassHeatSts,0);
}

//響應遠程加熱主駕座椅
void RespRmtOpenDrvHeat(int level)
{
  putValue(HVSM_DrvHeatSts,level);
  if((1==IsEngineWorking) && (rmtWorkTime!=0))
  {
    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=0; 
  }
  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((1==IsEngineWorking) && (rmtWorkTime!=0))
  {
    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=0; //用完后歸零
  }
  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, 0);
}

//響應關閉座椅加熱
void RespRmtClosePasHeat()
{
  cancelTimer(RmtPasHeatTimer);
  putValue(HVSM_PassHeatSts, 0);
}

//響應開啟空調
void RespRmtOpenAC()
{
  putValue(AC_OnState, 1);
  if((1==IsEngineWorking) && (rmtWorkTime!=0))
  {
    //先啟動發動機 后啟動空調
    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=0; //用完后歸零
  }
  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, 0);
}

//響應關閉空氣凈化
void RespRmtCloseAirClean()
{
  cancelTimer(RmtAirCleanTimer);
  putValue(AC_AirCleanState, 0);
  putValue(AC_OnState, 0);
  
}

//響應開啟PM凈化
void RespRmtOpenAirClean()
{
  putValue(AC_OnState, 1);
  putValue(AC_AirCleanState, 1);
  if((1==IsEngineWorking)  && (rmtWorkTime!=0))
  {
    //先啟動發動機 后啟動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 = 0;
  }
  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=1;
}

//遠程允許啟動發動機
void RespRmtPermit()
{
  GW_Info.PEPS_EngineforbidSt=0;
}


//遠程停止發動機
void RespRmtStop()
{
  cancelTimer(RespRmtEngineWorkingTimer); 

  putValue(PEPS_RemoteControlSt,0); 
  putValue(EMS_EngStatus, 0);
  putValue(PEPS_PowerMode, 0);
  //停止發動機后  所有控制器開的狀態都歸零
  putValue(AC_AirCleanState, 0);
  putValue(AC_OnState,0); 
  putValue(HVSM_DrvHeatSts, 0);
  putValue(HVSM_PassHeatSts, 0);
}

//響應遠程啟動
void RespRmtStart()
{
  IsAuthed =0;
  putValue(EMS_EngStatus, 0);

  //發動機置位遠程啟動模式
  putValue(PEPS_RemoteControlSt,1); 
  //發動機置位running
  putValue(EMS_EngStatus, 3);
  //電源置為ON
  putValue(PEPS_PowerMode, 2);
  IsEngineWorking = 1; //標記發動機已經工作中， 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, 0);
  putValue(PEPS_StatusResponse2TBOX,0);
  putValue(PEPS_FailReason2TBOX,0);
  putValue(PEPS_RemoteControlSt,0);
  GW_Info.PEPS_PowerModeValidity = 2;
  GW_Info.PEPS_EngineforbidSt=0;  //發動機允許遠程使能狀態
}

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,0);
  putValue(BCM_RLD_Wdw_PositionSts,0);
  putValue(BCM_Pas_Wdw_PositionSts,0);
  putValue(BCM_RRD_Wdw_PositionSts,0);
  putValue(BCM_Val_Wdw_Opened, 20); //開度值20%
}

//響應遠程關閉車窗指令
void SetWndsClosed()
{
//  putValue(CloseWnds,0);
  putValue(BCM_Drv_Wdw_PositionSts,2);
  putValue(BCM_RLD_Wdw_PositionSts,2);
  putValue(BCM_Pas_Wdw_PositionSts,2);
  putValue(BCM_RRD_Wdw_PositionSts,2);
  putValue(BCM_Val_Wdw_Opened, 0);
}

//響應遠程上鎖指令
void SetDoorsLocked()
{
  putValue(LockDoors,1);
}

//響應遠程解鎖指令
void SetDoorsUnlocked()
{
  putValue(LockDoors,0);
}

//響應遠程開窗指令
void SetWndsOpened()
{
//  putValue(CloseWnds,1);//開啟
  putValue(BCM_Drv_Wdw_PositionSts,1);
  putValue(BCM_RLD_Wdw_PositionSts,1);
  putValue(BCM_Pas_Wdw_PositionSts,1);
  putValue(BCM_RRD_Wdw_PositionSts,1);
  putValue(BCM_Val_Wdw_Opened, 100);
}

//響應遠程打開后備箱
void SetTrunkOpened()
{
  putValue(BCM_TrunkAjarStatus, 1); //開啟后備箱
}

//PEPS回復控制成功報文
void PEPSRespSuccess()
{
  setTimer(GW_PEPS_TimerRespSuccess, varCycTime100); 
}

void PEPSRespReceived()
{
//  setTimer(GW_PEPS_TimerRespReceived, varCycTime20); 
}

//PEPS發起認證請求
void PEPSReqAuth()
{
  //算法不實現！
  //若實際環境中接入了PEPS設備，則需實車抓取報文使用固定一組報文訪問
  //安全隱患，PEPS入侵（可能設計：每次隨機的挑戰碼，攜帶當前時間，設置計數器和校驗位驗證有效性，限定時間內的重復報文無效）
  if(rmtReqTpye ==1)
  {
    GenerateChallengeCode4Start();
  }
  else if(rmtReqTpye ==2)
  {
    GenerateChallengeCode4Stop();
  }
  
  setTimer(GW_PEPS_TimerSendChallengeCode, varCycTime20);
  IsAuthed = 1; //已經發起過鑒權
}

void GenerateChallengeCode4Stop()
{
  //關閉發動機鑒權
}
//生成PEPS挑戰碼，啟動發動機鑒權
void GenerateChallengeCode4Start()
{
  if(pepsAuthCnt==0)
  {
    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, 1, "NM PDU Received");
      break;
    case 0x5:
      writeLineEx(mTrace, 1, "KL15 On");
      break;
    case 0x06:
      writeLineEx(mTrace, 1, "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+=1;
  if(pepsRecvCnt<2)
  {
    snprintf(log, elcount(log),"%f -> PEPS, response 'in progress'", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    putValue(PEPS_FailReason2TBOX,  0);
    putValue(PEPS_StatusResponse2TBOX, 1);
    setTimer(GW_PEPS_TimerRespReceived, varCycTime20); //200ms一幀
  }
  else
  {
    cancelTimer(GW_PEPS_TimerRespReceived);
    putValue(PEPS_FailReason2TBOX, 0);
    putValue(PEPS_StatusResponse2TBOX, 0);
    pepsRecvCnt = 0;
  }  
}

//響應遠程請求，PEPS反饋Success
on timer GW_PEPS_TimerRespSuccess
{
  pepsRespCnt+=1;
  if(pepsRespCnt<2)
  {
    snprintf(log, elcount(log),"%f -> PEPS, response 'success'", timeNow()/tFactor);
    writeLineEx(mTrace, INFO, log);
    putValue(PEPS_FailReason2TBOX,  0);
    putValue(PEPS_StatusResponse2TBOX, 2);
    setTimer(GW_PEPS_TimerRespSuccess, varCycTime100);
  }
  else
  {
    cancelTimer(GW_PEPS_TimerRespSuccess);
    putValue(PEPS_FailReason2TBOX, 0);
    putValue(PEPS_StatusResponse2TBOX, 0);
    pepsRespCnt = 0;
  }
}

//響應遠程啟動請求, PEPS發出挑戰碼
on timer GW_PEPS_TimerSendChallengeCode
{
  
  pepsAuthCnt+=1;
  if(pepsAuthCnt<2)
  {
    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 = 0;
  }
}

 

7、效果展示

整個車輛網功能中涉及到整車中其它ECU相關的業務，也可參照以上實現邏輯去進行仿真。此處不一一舉例。

我在台架中接入真實儀表驗證我的仿真邏輯（節點支持熱增減，沒有ECU則使用仿真節點，有真實ECU則屏蔽）。

啟動仿真程序后，操作控制器，驗證車身仿真器的實現，可以檢驗出仿真代碼實現的正確性

--------------------------以上T業務自動化仿真測試台架全內容完結-----------------------------