基于CANoe的ECU Bootloader刷写软件

目标:

        车辆ECU需要更新软件,通过OBD口实现,通过CAN总线实现,编程语言是CAPL。

        刷写流程基于ISO15765-3;应用层基于UDS(ISO14229)诊断协议;TP层基于ISO15765-2;数据链路层和物理层基于ISO11898

实现:

       1.图形用户界面使用CANoe自带的panel来实现,用户可以选取刷写文件,ECU的地址等信息,这些信息通过环境变量被程序访问,环境变量在CANDB++中编辑生成。

基于CANoe的ECU Bootloader刷写软件_第1张图片

2.软件架构:

刷写工具解析s19 app,如果没有s19 app,那么可以使用HexView将HEX,BIN等app转成s19文件

依据ISO15765-3编写刷写流程代码,将app数据扔给应用层

应用层是基于UDS编写的,应用层在将数据扔给TP层

TP层将数据扔给数据链路层

数据链路层将数据扔给物理层,数据通过CAN总线被ECU接收


基于CANoe的ECU Bootloader刷写软件_第2张图片

代码:

      工作保密原因,只贴出UDS层的代码,秘钥也删了

[cpp]  view plain  copy
  1. includes{  
  2.     
  3. }  
  4.   
  5. variables{  
  6.   char gECU[7]="Tester";  
  7.   
  8.   int     useExtendedId=0;                                      //use standard Id  
  9.   long    useFC=1;                                             //use flow control  
  10.   long    bs=8;                                                //block size of FC  
  11.   long    stmin=20;                                            //set STmin to 10 ms  
  12.   
  13.   dword   tester_address=0x7c1;                               //tester address  
  14.   dword   target_ecu_address=0x7c9;                           //BCM address  
  15.   char    wait_rsp_text_event[18]="response received";        //used to wait for response  
  16.   
  17.   const int BUFFER_SIZE_2048=0x2048;  
  18.   const int BUFFER_SIZE_1024=0x1024;  
  19.   const int LENGTH_4=4;  
  20.   byte      rxBuffer[BUFFER_SIZE_2048];                          //receive buffer  
  21.   long      rxBufferLen=0;                                       //receive buffer length  
  22.   dword     timeout=5000;  
  23.   dword     min_request_distance=50;                            //minum distance between two request  
  24.   dword     dist_request = 10;  
  25.   char      gDebugBuffer[255];  
  26. }  
  27.   
  28. /* 
  29.   read fault memory 
  30. */  
  31. int read_fault_memory(byte _sub_func,byte _status_mask){  
  32.   byte request[3]={0x19,0x02,0x09};  
  33.     
  34.   rxBufferLen=0;  
  35.   request[1]=_sub_func;request[2]=_status_mask;  
  36.   OSEKTL_DataReq(request,elcount(request));  
  37.   return wait_server_response(request,timeout);  
  38. }  
  39.   
  40. /* 
  41.   sessionControl 
  42. */  
  43. int session_control(byte _session_type){  
  44.   byte request[2]={0x10,0x01};  
  45.     
  46.   request[1]=_session_type;  
  47.   OSEKTL_DataReq(request,elcount(request));  
  48.   return wait_server_response(request,timeout);  
  49. }  
  50.   
  51. /* 
  52.   reset 
  53. */  
  54. int reset(byte reset_type){  
  55.   byte request[2]={0x11,0x01};  
  56.     
  57.   request[1]=reset_type;  
  58.   OSEKTL_DataReq(request,elcount(request));  
  59.   return wait_server_response(request,timeout);  
  60. }  
  61.   
  62. /* 
  63.   securityAccess  
  64. */  
  65. int security_access(byte security_level,byte seed_szie,char ecu_name[]){  
  66.   //actual size of Seed & Key Arrays depends on ECU  
  67.   byte      gSeedArray[2];  
  68.   dword     gSeedArraySize   = 4;  
  69.   char      gVariant[9]    = "Variant1";  
  70.   char      gOption[7]     = "option";  
  71.   dword     gMaxKeyArraySize = 4;  
  72.   dword     gActualSize  = 0;  
  73.      
  74.   byte      request_seed[2]={0x27,0x01};  
  75.   byte      send_key[6]={0x27,0x02,0xAA,0xAA,0xAA,0xAA};  
  76.     
  77.   byte      const_secu_flash[4]={};           //security const number for level flash for BCM  
  78.   byte      const_secu_level1[4]={};          //security const number for level 1 for BCM  
  79.   byte      const_secu_flash_rfcm[4]={};           //security const number for level flash for BCM  
  80.     
  81.   byte      seed[4]={0xAA,0xAA,0xAA,0xAA};                       //store the seed received from server  
  82.   byte      _key[4]={0xAA,0xAA,0xAA,0xAA};                       //store the key generated by tester  
  83.   int       i=0;  
  84.     
  85.   request_seed[ 1 ] = security_level;send_key[ 1 ] = security_level + 0x01;  
  86.   OSEKTL_DataReq(request_seed,elcount(request_seed));         
  87.   if(wait_server_response(request_seed,timeout)!=0){  
  88.     write("fail to retrive seed while unlocking ECU");  
  89.     return -1;  
  90.   }  
  91.     
  92.   for(i=0;i
  93.     seed[i]=rxBuffer[i+2];  
  94.   }  
  95.     
  96.   gSeedArraySize = seed_szie;gMaxKeyArraySize = seed_szie;  
  97.   //generate_key(const_secu_flash_rfcm,seed,_key);  
  98.   diagSetTarget(ecu_name);  
  99.   DiagGenerateKeyFromSeed(seed, gSeedArraySize, security_level, gVariant, gOption, _key, gMaxKeyArraySize, gActualSize);  
  100.     
  101.   for(i=0;i
  102.     send_key[i+2]=_key[i];  
  103.   }  
  104.     
  105.   OSEKTL_DataReq(send_key,2+gActualSize);  
  106.   return wait_server_response(send_key,timeout);  
  107. }  
  108.   
  109. _Diag_GetError (char buffer[])  
  110. {  
  111. //called if error in DiagGenerateKeyFromSeed occurs  
  112. snprintf(gDebugBuffer,elcount(gDebugBuffer),"%s", buffer);  
  113. write("CALLBACK %s", gDebugBuffer);  
  114. }  
  115.   
  116.   
  117. /* 
  118.   routineControl 
  119. */  
  120. int routine_control(byte _routine_control_type,byte _routine_id[],byte data_record[],int data_record_length){  
  121.   byte request[BUFFER_SIZE_1024];  
  122.   int index=0;  
  123.     
  124.   request[0]=0x31;  
  125.   request[1]=_routine_control_type;  
  126.   request[2]=_routine_id[0];  
  127.   request[3]=_routine_id[1];  
  128.     
  129.   for(index=0;index
  130.     request[index+4]=data_record[index];  
  131.   }  
  132.     
  133.   OSEKTL_DataReq(request,data_record_length+4);  
  134.     
  135.   return wait_server_response(request,timeout);   
  136. }  
  137.   
  138. /* 
  139.   generate key according to the received seed 
  140. */  
  141. void generate_key(byte const_secu[],byte seed_secu_flash[],byte securityKey[]){  
  142.   byte key1_secu_flash[4]={0x00,0x00,0x00,0x00};  
  143.   byte key2_secu_flash[4]={0x00,0x00,0x00,0x00};  
  144.   int i=0;  
  145.   byte tmp=0x00;  
  146.     
  147.   for(i=0;i<4;++i){  
  148.     key1_secu_flash[i]=seed_secu_flash[i]^const_secu[i];  
  149.   }  
  150.     
  151.   for(i=0;i<2;++i){  
  152.     tmp=seed_secu_flash[i];  
  153.     seed_secu_flash[i]=seed_secu_flash[3-i];  
  154.     seed_secu_flash[3-i]=tmp;  
  155.   }  
  156.     
  157.   for(i=0;i<4;++i){  
  158.     key2_secu_flash[i]=seed_secu_flash[i]^const_secu[i];  
  159.   }  
  160.     
  161.   for(i=0;i<4;++i){  
  162.     securityKey[i]=key1_secu_flash[i]+key2_secu_flash[i];  
  163.   }  
  164. }  
  165.   
  166. /* 
  167.   communicationControl 
  168. */  
  169. int communication_control(byte _control_type,byte _communication_type){  
  170.   byte request[3]={0x28,0x00,0x00};  
  171.     
  172.   request[1]=_control_type;request[2]=_communication_type;  
  173.     
  174.   OSEKTL_DataReq(request,elcount(request));  
  175.   return wait_server_response(request,timeout);  
  176. }  
  177.   
  178.   
  179. /* 
  180.   controlDTCSetting 
  181. */  
  182. int control_dtc_setting(byte _DTC_setting_type){  
  183.   byte request[2]={0x85,0x00};  
  184.     
  185.   request[1]=_DTC_setting_type;  
  186.     
  187.   OSEKTL_DataReq(request,elcount(request));  
  188.   return wait_server_response(request,timeout);  
  189. }  
  190.   
  191. /* 
  192.   tester Present 
  193. */  
  194. int tester_present(byte sub_function){  
  195.   byte request[2]={0x3e,0x00};  
  196.     
  197.   request[1]=sub_function;  
  198.     
  199.   OSEKTL_DataReq(request,elcount(request));  
  200.   return wait_server_response(request,timeout);  
  201. }  
  202.   
  203. /* 
  204.   writeDataByID 
  205. */  
  206. int write_data_by_id(byte did[],byte _data_record[],int _data_record_length){  
  207.   byte request[256];  
  208.   int i=0,_did_length=2;  
  209.     
  210.   request[0]=0x2E;  
  211.     
  212.   for(i=0;i<_did_length;++i){  
  213.     request[1+i]=did[i];  
  214.   }  
  215.     
  216.   for(i=0;i<_data_record_length;++i){  
  217.     request[1+_did_length+i]=_data_record[i];  
  218.   }  
  219.     
  220.   OSEKTL_DataReq(request,1+_did_length+_data_record_length);  
  221.   return wait_server_response(request,timeout);  
  222. }  
  223.   
  224. /* 
  225.   requestDownload 
  226. */  
  227. int request_download(byte _memory_address[],int _memory_address_length,byte _memory_size[],int __memory_size_length){  
  228.   byte request[256];  
  229.   int i=0;  
  230.     
  231.   request[0]=0x34;request[1]=0x00;request[2]=0x44;  
  232.     
  233.   for(i=0;i<_memory_address_length;++i){  
  234.     request[3+i]=_memory_address[i];  
  235.   }  
  236.     
  237.   for(i=0;i<__memory_size_length;++i){  
  238.     request[3+_memory_address_length+i]=_memory_size[i];  
  239.   }  
  240.     
  241.   OSEKTL_DataReq(request,3+_memory_address_length+__memory_size_length);  
  242.   return wait_server_response(request,timeout);  
  243. }  
  244.   
  245. /* 
  246.   tansferData 
  247. */  
  248. int transfer_data(byte _block_sequence,byte _upload_data[],int _upload_data_length){  
  249.   byte request[BUFFER_SIZE_2048];  
  250.   int i=0 , status = 0;  
  251.     
  252.   request[0]=0x36;request[1]=_block_sequence;  
  253.     
  254.   for(i=0;i<_upload_data_length;++i){  
  255.     request[2+i]=_upload_data[i];  
  256.   }  
  257.     
  258.   OSEKTL_DataReq(request,_upload_data_length+2);  
  259.   status = wait_server_response(request,timeout);  
  260.     
  261.   return status;  
  262. }  
  263.   
  264. /* 
  265.   requstTransferExit 
  266. */  
  267. int request_transfer_exit(){  
  268.   byte request[1]={0x37};  
  269.   
  270.   OSEKTL_DataReq(request,elcount(request));  
  271.   return wait_server_response(request,timeout);  
  272. }  
  273.   
  274. int read_data_by_id(byte did[]){  
  275.   byte request[3]={0x22,0x00,0x00};  
  276.     
  277.   request[1]=did[0];  
  278.   request[2]=did[1];  
  279.     
  280.   OSEKTL_DataReq(request,elcount(request));  
  281.   return wait_server_response(request,timeout);  
  282. }  
  283.   
  284. OSEKTL_FirstFrameIndication( long sourceadr, long destadr, long rxCount )  
  285. {  
  286.   /* Print message to write window */  
  287.   //write("CAPL: %s: FF indication called, SA= 0x%02lx, TA= 0x%02lx, RxCount = %ld (AE=%d)", gECU, sourceadr, destadr, rxCount, OSEKTL_GetRecentAE());  
  288. }  
  289.   
  290. //error handle  
  291. OSEKTL_ErrorInd(int error)  
  292. {  
  293.   switch (error)  
  294.   {  
  295.     case 1:     write("----CAPL: Error (%d): Timeout while waiting for CF", error);     break;  
  296.     case 2:     write("----CAPL: Error (%d): Timeout while waiting for FC", error);     break;  
  297.     case 3:     write("----CAPL: Error (%d): Wrong Sequence Number", error);            break;  
  298.     case 4:     write("----CAPL: Error (%d): TP_DLL busy", error);                      break;  
  299.     case 5:     write("----CAPL: Error (%d): Unexpected PDU", error);stop();                   break;  
  300.     case 6:     write("----CAPL: Error (%d): Timeout while waiting for Tx-Ack", error); break;  
  301.     case 7:     write("----CAPL: Error (%d): WFT Overrun", error);                      break;  
  302.     case 8:     write("----CAPL: Error (%d): Buffer overflow", error);                  break;  
  303.     case 9:     write("----CAPL: Error (%d): Wrong parameter", error);                      break;      
  304.     default:    write("----CAPL: Error (%d): unknown error", error);                    break;  
  305.   }  
  306. }  
  307.   
  308. //request confirm  
  309. OSEKTL_DataCon(long status)  
  310. {  
  311.   if (status != 0)   
  312.   {  
  313.       //write("CAPL: %s: data sent using normal addressing", gECU);  
  314.   }  
  315.   else  
  316.   {  
  317.     write("----CAPL: %s: tx error, status is %d", gECU, status);   
  318.   }  
  319. }  
  320.   
  321. OSEKTL_DataInd( long rxCount )  
  322. {  
  323.   dword glhandle=0;  
  324.     
  325.   /* Get received data */  
  326.   OSEKTL_GetRxData( rxBuffer, 4095 );  
  327.   rxBufferLen=rxCount;  
  328.     
  329.   //signal response received  
  330.   TestSupplyTextEvent(wait_rsp_text_event);  
  331. }  
  332.   
  333. //process will suspend for tTime ms to wait for response  
  334. int wait_server_response(byte request[],dword _tTime){  
  335.   long status=0;  
  336.   int result=0;  
  337.   long flag=5;  
  338.     
  339.   flag=2;result=0;status=0;  
  340.     
  341.   //loop while response pending  
  342.   while(flag>=0)          
  343.   {  
  344.     status=testWaitForTextEvent(wait_rsp_text_event,_tTime);  
  345.     if(status<0){  
  346.       write("service %x:fail to wait server response",request[0]);  
  347.       return -1;  
  348.     }else if(status==0){  
  349.       write("service %x:timeout while waiting for server\'s response",request[0]);  
  350.       return -1;  
  351.     }  
  352.       
  353.     result=checkResponse(request);  
  354.       
  355.     if(result==-3){  
  356.       write("response pending");  
  357.       flag=5;  
  358.     }  
  359.       
  360.     if(result==-2){  
  361.       write("Warning:unexpected positive response");  
  362.       flag--;  
  363.     }  
  364.       
  365.     if(result==-1){  
  366.       write("service %x:negative response received",request[0]);  
  367.       break;  
  368.     }  
  369.       
  370.     if(result==0){  
  371.       //write("positive response received\n");  
  372.       break;  
  373.     }  
  374.   }  
  375.   
  376.   if(result<0){    
  377.     msgBeep(5);  
  378.     return -1;  
  379.   }  
  380.     
  381.   return 0;  
  382. }  
  383.   
  384. /* 
  385.   check response 
  386.   return 0 if positive response received 
  387.   otherwise return -1,-2,-3,0 
  388.   */  
  389. int checkResponse(byte request[]){  
  390.   if(rxBufferLen<=0){  
  391.     write("Error:empty response reveived\n");  
  392.     return -1;  
  393.   }  
  394.   else{   
  395.     if(rxBuffer[0]==request[0]+0x40){  
  396.       //write("positive response received\n");  
  397.       return 0;  
  398.     }else if(rxBuffer[0]!=0x7F&&rxBuffer[0]!=(rxBuffer[0]+0x40)){  
  399.       //unexpected positive response  
  400.       return -2;  
  401.     }  
  402.     else if(rxBuffer[0]==0x7F&&rxBuffer[1]==request[0]){   
  403.       if(rxBuffer[2]!=0x78)  
  404.       {  
  405.         //write("Error:negative response received\n");  
  406.         return -1;  
  407.       }else{  
  408.        //response pending  
  409.        return -3;  
  410.       }  
  411.     }  
  412.   }  
  413.   return 0;  
  414. }  


你可能感兴趣的:(CAN总线)