Surendar S / OBD2113

f211

Dependencies:   mbed-dev1

Fork of OBD21121 by Surendar S

main.cpp@17:8c76a8b1f46f, 2017-08-10 (annotated)

Committer:
takeuz
Date:
Thu Aug 10 11:38:15 2017 +0000
Revision:
17:8c76a8b1f46f
Parent:
16:02f94a84e211 
updated OBD code

Who changed what in which revision?

UserRevisionLine numberNew contents of line
takeuz 0:ccd2474129f2 1 #include "mbed.h"
takeuz 2:d58ef72b4ab0 2 #include "functions.h"
takeuz 2:d58ef72b4ab0 3
takeuz 2:d58ef72b4ab0 4 #define PID_REQUEST 0x7DF
takeuz 14:03fd47f2b21d 5 //#define PID_REQUEST 0x18DB33F1
takeuz 2:d58ef72b4ab0 6 #define PID_REPLY 0x7E8
takeuz 14:03fd47f2b21d 7 //#define PID_REPLY 0x18DAF110
takeuz 2:d58ef72b4ab0 8
takeuz 8:cc3cb620c3bd 9 #define CANSPEED_500 500000
takeuz 8:cc3cb620c3bd 10 #define CANSPEED_250 250000
takeuz 8:cc3cb620c3bd 11 #define CANSPEED_125 125000
takeuz 2:d58ef72b4ab0 12 #define sendDebugMessage 1
takeuz 2:d58ef72b4ab0 13 #define pushDebugData 1
takeuz 2:d58ef72b4ab0 14
takeuz 8:cc3cb620c3bd 15 const int canSpeeds[3]= {CANSPEED_125,CANSPEED_500,CANSPEED_250};
takeuz 10:fe1b976a3f9c 16 //Serial serialPorts[2] = {Serial(P0_11,P0_13),Serial(P0_15,P0_14)};
takeuz 10:fe1b976a3f9c 17 Serial *serialPorts[2] = {NULL,NULL};
takeuz 8:cc3cb620c3bd 18 Serial *kLineUART=NULL;
takeuz 10:fe1b976a3f9c 19 DigitalOut *klineWakeup=NULL;
takeuz 10:fe1b976a3f9c 20 DigitalOut *canDisableKey=NULL;
takeuz 10:fe1b976a3f9c 21 CAN *canBus=NULL;
takeuz 2:d58ef72b4ab0 22
takeuz 8:cc3cb620c3bd 23 Ticker timeCounter;
takeuz 8:cc3cb620c3bd 24 Timer OBDTimer;
takeuz 8:cc3cb620c3bd 25 CANMessage can_MsgRx;
takeuz 15:47abd7926beb 26 CANMessage can_MsgTx;
takeuz 15:47abd7926beb 27 char kLineCmd[7]= {'\0','\0','\0','\0','\0','\0'};
takeuz 7:42cb4b01909c 28
takeuz 8:cc3cb620c3bd 29 void clearOBDCommand();
takeuz 8:cc3cb620c3bd 30 void flushBuffer();
takeuz 10:fe1b976a3f9c 31 void processUserCommand(char *_incomingDataInInterFace);
takeuz 7:42cb4b01909c 32 void sendCommandToVehicle(char *_cmd);
takeuz 8:cc3cb620c3bd 33 void setKLineMsg(char *_cmd);
takeuz 8:cc3cb620c3bd 34 void flushBuffer();
takeuz 8:cc3cb620c3bd 35 void kLinekeepalive();
takeuz 8:cc3cb620c3bd 36 char tolower(unsigned char ch);
takeuz 7:42cb4b01909c 37 int findStringLength(char *_cmd);
takeuz 10:fe1b976a3f9c 38 int checkCarStatus();
takeuz 10:fe1b976a3f9c 39 void initPins();
takeuz 2:d58ef72b4ab0 40
takeuz 10:fe1b976a3f9c 41 int _powerSaveFlag=0;
takeuz 10:fe1b976a3f9c 42 int isKeepAliveCommand=0;
takeuz 8:cc3cb620c3bd 43 int isPoweredupNow=1;
takeuz 17:8c76a8b1f46f 44 int interFace=1;
takeuz 7:42cb4b01909c 45 int debug=1;
takeuz 2:d58ef72b4ab0 46 int currentOBDProtocol=0;
takeuz 2:d58ef72b4ab0 47 const int protCan=1;
takeuz 7:42cb4b01909c 48 const int protkLine9141=2;
takeuz 7:42cb4b01909c 49 const int protkLine14230=3;
takeuz 2:d58ef72b4ab0 50 int canFrequency;
takeuz 7:42cb4b01909c 51 int cmd;
takeuz 2:d58ef72b4ab0 52 char can_msg[8];
takeuz 2:d58ef72b4ab0 53 char *incomingDataInInterFace;
takeuz 2:d58ef72b4ab0 54 const int incomingDataInInterFaceSize=256;
takeuz 2:d58ef72b4ab0 55 int incomingDataInInterFaceCounter=0;
takeuz 8:cc3cb620c3bd 56 char * incomingDataInOBD;
takeuz 2:d58ef72b4ab0 57 const int incomingDataInOBDSize=256;
takeuz 2:d58ef72b4ab0 58 int incomingDataInOBDCounter=0;
takeuz 2:d58ef72b4ab0 59 const int waitTimeForOBDComm=2000;
takeuz 16:02f94a84e211 60 const int sleepTime=10000;
takeuz 11:853d12fe7ec0 61 const int powerSaveTime=30;
takeuz 2:d58ef72b4ab0 62 int OBDCmdReceived=0;
takeuz 2:d58ef72b4ab0 63 int interfaceCmdReceived=0;
takeuz 2:d58ef72b4ab0 64 int lastOBDCmdRcvdTime=0;
takeuz 2:d58ef72b4ab0 65 int lastInterfaceCmdRcvdTime=0;
takeuz 8:cc3cb620c3bd 66 int KlineReadCount=0;
takeuz 8:cc3cb620c3bd 67 int isVehicleCommandProcessing=0;
takeuz 8:cc3cb620c3bd 68 int kLineCommandCount=0;
takeuz 8:cc3cb620c3bd 69 char kByte=0;
takeuz 4:3e1e2b161403 70
takeuz 10:fe1b976a3f9c 71 void flip()
takeuz 10:fe1b976a3f9c 72 {
takeuz 10:fe1b976a3f9c 73 // led = !led;
takeuz 10:fe1b976a3f9c 74 }
takeuz 15:47abd7926beb 75
takeuz 2:d58ef72b4ab0 76 void readInterface()
takeuz 2:d58ef72b4ab0 77 {
takeuz 2:d58ef72b4ab0 78 char c;
takeuz 10:fe1b976a3f9c 79 while(serialPorts[interFace]->readable()) {
takeuz 2:d58ef72b4ab0 80 lastInterfaceCmdRcvdTime=0;
takeuz 10:fe1b976a3f9c 81 c = serialPorts[interFace]->getc();
takeuz 7:42cb4b01909c 82
takeuz 10:fe1b976a3f9c 83 serialPorts[debug]->putc(c);
takeuz 8:cc3cb620c3bd 84
takeuz 6:741524d110fe 85 if(incomingDataInInterFaceCounter<incomingDataInInterFaceSize && c!='\r' && c!='\n') {
takeuz 2:d58ef72b4ab0 86 incomingDataInInterFace[incomingDataInInterFaceCounter] = c;
takeuz 2:d58ef72b4ab0 87 }
takeuz 2:d58ef72b4ab0 88 incomingDataInInterFaceCounter++;
takeuz 4:3e1e2b161403 89
takeuz 7:42cb4b01909c 90 if(c=='\r') {
takeuz 2:d58ef72b4ab0 91 interfaceCmdReceived=1;
takeuz 10:fe1b976a3f9c 92 serialPorts[debug]->puts("nl\r\n");
takeuz 2:d58ef72b4ab0 93 }
takeuz 2:d58ef72b4ab0 94
takeuz 2:d58ef72b4ab0 95 }
takeuz 2:d58ef72b4ab0 96 }
takeuz 2:d58ef72b4ab0 97
takeuz 4:3e1e2b161403 98 void canReader()
takeuz 4:3e1e2b161403 99 {
takeuz 10:fe1b976a3f9c 100 // serialPorts[debug]->puts("a");
takeuz 17:8c76a8b1f46f 101 // serialPorts[debug]->printf("can Reader\r\n");
takeuz 10:fe1b976a3f9c 102 if (canBus->read(can_MsgRx)) {
takeuz 17:8c76a8b1f46f 103 // serialPorts[debug]->printf("one : %s\r\n",can_MsgRx);
takeuz 2:d58ef72b4ab0 104 lastOBDCmdRcvdTime=0;
takeuz 17:8c76a8b1f46f 105 if (can_MsgRx.id == PID_REPLY) {
takeuz 10:fe1b976a3f9c 106 for (int i = 0; i < (int)can_MsgRx.len && currentOBDProtocol!=0; i++) {
takeuz 10:fe1b976a3f9c 107 char c;
takeuz 10:fe1b976a3f9c 108 // sprintf(c, "%02X",can_MsgRx.data[i]);
takeuz 10:fe1b976a3f9c 109 // serialPorts[interFace].puts(c);
takeuz 10:fe1b976a3f9c 110 if(incomingDataInOBDCounter< incomingDataInOBDSize) {
takeuz 10:fe1b976a3f9c 111 incomingDataInOBD[incomingDataInOBDCounter]=can_MsgRx.data[i];
takeuz 10:fe1b976a3f9c 112 incomingDataInOBDCounter++;
takeuz 10:fe1b976a3f9c 113 }
takeuz 10:fe1b976a3f9c 114 }
takeuz 7:42cb4b01909c 115 OBDCmdReceived=1;
takeuz 2:d58ef72b4ab0 116 }
takeuz 2:d58ef72b4ab0 117 }
takeuz 2:d58ef72b4ab0 118 }
takeuz 2:d58ef72b4ab0 119
takeuz 8:cc3cb620c3bd 120 void readKLine()
takeuz 8:cc3cb620c3bd 121 {
takeuz 8:cc3cb620c3bd 122 char c;
takeuz 8:cc3cb620c3bd 123 while(kLineUART->readable()) {
takeuz 8:cc3cb620c3bd 124 c=kLineUART->getc();
takeuz 14:03fd47f2b21d 125 serialPorts[debug]->printf("%02X",c);
takeuz 10:fe1b976a3f9c 126 lastOBDCmdRcvdTime=0;
takeuz 10:fe1b976a3f9c 127 if(incomingDataInOBDCounter< incomingDataInOBDSize) {
takeuz 10:fe1b976a3f9c 128 incomingDataInOBD[incomingDataInOBDCounter]=c;
takeuz 10:fe1b976a3f9c 129 incomingDataInOBDCounter++;
takeuz 10:fe1b976a3f9c 130 }
takeuz 8:cc3cb620c3bd 131 }
takeuz 8:cc3cb620c3bd 132 }
takeuz 8:cc3cb620c3bd 133
takeuz 8:cc3cb620c3bd 134
takeuz 4:3e1e2b161403 135 void timeCounterFunction()
takeuz 4:3e1e2b161403 136 {
takeuz 2:d58ef72b4ab0 137 lastInterfaceCmdRcvdTime++;
takeuz 2:d58ef72b4ab0 138 lastOBDCmdRcvdTime++;
takeuz 10:fe1b976a3f9c 139 /*KlineReadCount++;
takeuz 8:cc3cb620c3bd 140 if(currentOBDProtocol==protkLine14230 && KlineReadCount>=3) {
takeuz 7:42cb4b01909c 141 KlineReadCount=0;
takeuz 8:cc3cb620c3bd 142 if(incomingDataInInterFaceCounter) {
takeuz 7:42cb4b01909c 143 return;
takeuz 7:42cb4b01909c 144 }
takeuz 8:cc3cb620c3bd 145 kLinekeepalive();
takeuz 10:fe1b976a3f9c 146 }*/
takeuz 8:cc3cb620c3bd 147
takeuz 2:d58ef72b4ab0 148 }
takeuz 0:ccd2474129f2 149
takeuz 4:3e1e2b161403 150 int main()
takeuz 4:3e1e2b161403 151 {
takeuz 10:fe1b976a3f9c 152 //Serial serialPorts[2] = {Serial(P0_11,P0_13),Serial(P0_15,P0_14)};
takeuz 10:fe1b976a3f9c 153
takeuz 10:fe1b976a3f9c 154 initPins();
takeuz 10:fe1b976a3f9c 155 serialPorts[debug]->puts("f2120\r\n");
takeuz 2:d58ef72b4ab0 156 incomingDataInInterFace=(char *)malloc(incomingDataInInterFaceSize*sizeof(char));
takeuz 2:d58ef72b4ab0 157 incomingDataInOBD=(char *)malloc(incomingDataInOBDSize*sizeof(char));
takeuz 10:fe1b976a3f9c 158
takeuz 8:cc3cb620c3bd 159 *klineWakeup=0;
takeuz 2:d58ef72b4ab0 160 clearMemoryLocation(incomingDataInInterFace,incomingDataInInterFaceSize);
takeuz 4:3e1e2b161403 161 clearMemoryLocation(incomingDataInOBD,incomingDataInOBDSize);
takeuz 11:853d12fe7ec0 162 wait_ms(800);
takeuz 2:d58ef72b4ab0 163 timeCounter.attach(&timeCounterFunction, 1.0);
takeuz 10:fe1b976a3f9c 164 serialPorts[interFace]->attach(&readInterface);
takeuz 10:fe1b976a3f9c 165 serialPorts[interFace]->puts("+TU211 v1.0\r");
takeuz 10:fe1b976a3f9c 166 serialPorts[interFace]->puts("OK\r\n");
takeuz 15:47abd7926beb 167 wait_ms(300); //????? suren : have to remove wait
takeuz 0:ccd2474129f2 168 while(1) {
takeuz 7:42cb4b01909c 169 if(interfaceCmdReceived && checkForLocalInterfaceCommand()) {
takeuz 10:fe1b976a3f9c 170 serialPorts[debug]->puts("Going to clear UART data\r\n");
takeuz 7:42cb4b01909c 171 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 172 serialPorts[debug]->puts("UART data cleared\r\n");
takeuz 7:42cb4b01909c 173 }
takeuz 11:853d12fe7ec0 174 if(currentOBDProtocol==0/* && isPoweredupNow*/) {
takeuz 11:853d12fe7ec0 175 // isPoweredupNow=0;
takeuz 4:3e1e2b161403 176 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 177 serialPorts[debug]->puts("Going to figure protocol\r\n");
takeuz 15:47abd7926beb 178 serialPorts[debug]->puts("Searching...\r\n");
takeuz 4:3e1e2b161403 179 #endif
takeuz 2:d58ef72b4ab0 180 checkCommunicationProtocol();
takeuz 4:3e1e2b161403 181 if(!currentOBDProtocol) {
takeuz 4:3e1e2b161403 182 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 183 serialPorts[debug]->puts("!Unknownprotocol\r\n");
takeuz 4:3e1e2b161403 184 #endif
takeuz 7:42cb4b01909c 185 } else if(currentOBDProtocol==protCan) {
takeuz 10:fe1b976a3f9c 186 *canDisableKey=0;
takeuz 7:42cb4b01909c 187 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 188 serialPorts[debug]->puts("can Protocol\r\n");
takeuz 7:42cb4b01909c 189 #endif
takeuz 8:cc3cb620c3bd 190 } else if(currentOBDProtocol==protkLine14230) {
takeuz 10:fe1b976a3f9c 191 *canDisableKey=1;
takeuz 7:42cb4b01909c 192 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 193 serialPorts[debug]->puts("Kline Protocol\r\n");
takeuz 7:42cb4b01909c 194 #endif
takeuz 2:d58ef72b4ab0 195 }
takeuz 2:d58ef72b4ab0 196 }
takeuz 7:42cb4b01909c 197 if(interfaceCmdReceived && checkForLocalInterfaceCommand()) {
takeuz 10:fe1b976a3f9c 198 serialPorts[debug]->puts("Going to clear UART data\r\n");
takeuz 7:42cb4b01909c 199 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 200 serialPorts[debug]->puts("UART data cleared\r\n");
takeuz 2:d58ef72b4ab0 201 }
takeuz 7:42cb4b01909c 202 if(interfaceCmdReceived && currentOBDProtocol) {
takeuz 10:fe1b976a3f9c 203 serialPorts[debug]->puts("Going to process user command\r\n");
takeuz 7:42cb4b01909c 204 clearOBDCommand();
takeuz 8:cc3cb620c3bd 205 if(currentOBDProtocol==protCan) {
takeuz 14:03fd47f2b21d 206 while(isVehicleCommandProcessing) {}
takeuz 10:fe1b976a3f9c 207 processUserCommand(incomingDataInInterFace);
takeuz 8:cc3cb620c3bd 208 } else if(currentOBDProtocol==protkLine14230) {
takeuz 14:03fd47f2b21d 209 while(isVehicleCommandProcessing) {}
takeuz 7:42cb4b01909c 210 flushBuffer();
takeuz 8:cc3cb620c3bd 211 /*kLineUART->attach(NULL);
takeuz 8:cc3cb620c3bd 212 kLineUART->attach(&readKLine);*/
takeuz 7:42cb4b01909c 213 sendCommandToVehicle(incomingDataInInterFace);
takeuz 7:42cb4b01909c 214 wait_ms(500);
takeuz 10:fe1b976a3f9c 215 serialPorts[debug]->printf("\r\n");
takeuz 8:cc3cb620c3bd 216 } else {
takeuz 8:cc3cb620c3bd 217 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 218 serialPorts[interFace]->puts("?\r\n");
takeuz 8:cc3cb620c3bd 219 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 220 serialPorts[debug]->puts("?\r\n");
takeuz 8:cc3cb620c3bd 221 #endif
takeuz 2:d58ef72b4ab0 222 }
takeuz 8:cc3cb620c3bd 223 } else if(interfaceCmdReceived) {
takeuz 7:42cb4b01909c 224 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 225 serialPorts[interFace]->puts("?\r\n");
takeuz 7:42cb4b01909c 226 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 227 serialPorts[debug]->puts("?\r\n");
takeuz 7:42cb4b01909c 228 #endif
takeuz 2:d58ef72b4ab0 229 }
takeuz 10:fe1b976a3f9c 230 // sleepProcess();
takeuz 11:853d12fe7ec0 231 if(lastOBDCmdRcvdTime> powerSaveTime /*&& lastInterfaceCmdRcvdTime> powerSaveTime */) {
takeuz 14:03fd47f2b21d 232 // powerSaveMode();
takeuz 10:fe1b976a3f9c 233 } else {
takeuz 10:fe1b976a3f9c 234 sleepProcess();
takeuz 10:fe1b976a3f9c 235 }
takeuz 8:cc3cb620c3bd 236 /*if(lastOBDCmdRcvdTime> powerSaveTime && lastInterfaceCmdRcvdTime> powerSaveTime ) {
takeuz 2:d58ef72b4ab0 237 powerSaveMode();
takeuz 7:42cb4b01909c 238 } else {
takeuz 7:42cb4b01909c 239 sleepProcess();
takeuz 7:42cb4b01909c 240 }*/
takeuz 0:ccd2474129f2 241 }
takeuz 0:ccd2474129f2 242 }
takeuz 4:3e1e2b161403 243 void checkCommunicationProtocol()
takeuz 4:3e1e2b161403 244 {
takeuz 8:cc3cb620c3bd 245 /* #if sendDebugMessage
takeuz 8:cc3cb620c3bd 246 serialPorts[debug].puts("check Communication protocal ENT\r\n");
takeuz 8:cc3cb620c3bd 247 #endif*/
takeuz 2:d58ef72b4ab0 248 int i=0;
takeuz 4:3e1e2b161403 249 do {
takeuz 15:47abd7926beb 250
takeuz 4:3e1e2b161403 251 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 252 serialPorts[debug]->puts("CanBusCheck\r\n");
takeuz 4:3e1e2b161403 253 #endif
takeuz 10:fe1b976a3f9c 254 canBus->reset();
takeuz 10:fe1b976a3f9c 255 canBus->frequency(canSpeeds[i]);
takeuz 10:fe1b976a3f9c 256 canBus->attach(NULL);
takeuz 10:fe1b976a3f9c 257 canBus->attach(&canReader);
takeuz 2:d58ef72b4ab0 258 OBDTimer.reset();
takeuz 2:d58ef72b4ab0 259 OBDTimer.start();
takeuz 2:d58ef72b4ab0 260 OBDCmdReceived=0;
takeuz 15:47abd7926beb 261
takeuz 15:47abd7926beb 262 // can_MsgTx.format = CANStandard;//CANStandard;// or CANExtended; // standard or extended ID (can be skipped for standard)
takeuz 15:47abd7926beb 263 // can_MsgTx.id = PID_REQUEST;
takeuz 15:47abd7926beb 264 // can_MsgTx.len = 8;//length in bytes (1 to 8);
takeuz 15:47abd7926beb 265 // can_MsgTx.data[0]=0x42;
takeuz 7:42cb4b01909c 266 setCanMessage("010D");
takeuz 15:47abd7926beb 267
takeuz 10:fe1b976a3f9c 268 if (canBus->write(CANMessage(PID_REQUEST, can_msg, 8))) {
takeuz 15:47abd7926beb 269 // if (canBus->write(can_MsgTx)) {
takeuz 4:3e1e2b161403 270 while(OBDTimer.read_ms() < waitTimeForOBDComm) {
takeuz 4:3e1e2b161403 271 if(OBDCmdReceived) {
takeuz 2:d58ef72b4ab0 272 currentOBDProtocol=protCan;
takeuz 4:3e1e2b161403 273 canFrequency=i;
takeuz 8:cc3cb620c3bd 274 break;
takeuz 2:d58ef72b4ab0 275 }
takeuz 2:d58ef72b4ab0 276 }
takeuz 2:d58ef72b4ab0 277 }
takeuz 2:d58ef72b4ab0 278 wait_ms(200);
takeuz 4:3e1e2b161403 279 i++;
takeuz 8:cc3cb620c3bd 280 } while(i<3 && canFrequency==0);
takeuz 2:d58ef72b4ab0 281 OBDTimer.stop();
takeuz 10:fe1b976a3f9c 282 canBus->attach(NULL);
takeuz 8:cc3cb620c3bd 283 if(!currentOBDProtocol) {
takeuz 7:42cb4b01909c 284 //Kline interface check
takeuz 7:42cb4b01909c 285 initializeKLine();
takeuz 7:42cb4b01909c 286 }
takeuz 4:3e1e2b161403 287 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 288 serialPorts[debug]->puts("check Communication protocal EXT\r\n");
takeuz 4:3e1e2b161403 289 #endif
takeuz 2:d58ef72b4ab0 290 }
takeuz 2:d58ef72b4ab0 291 void clearMemoryLocation( char *base, int _size)
takeuz 2:d58ef72b4ab0 292 {
takeuz 2:d58ef72b4ab0 293 for(int forCount=0; forCount<_size; forCount++) {
takeuz 2:d58ef72b4ab0 294 base[forCount]='\0';
takeuz 2:d58ef72b4ab0 295 }
takeuz 2:d58ef72b4ab0 296 }
takeuz 7:42cb4b01909c 297 void setCanMessage(char* _cmd)
takeuz 4:3e1e2b161403 298 {
takeuz 10:fe1b976a3f9c 299 serialPorts[debug]->puts("user Command :");
takeuz 10:fe1b976a3f9c 300 serialPorts[debug]->puts(_cmd);
takeuz 10:fe1b976a3f9c 301 serialPorts[debug]->puts("\r\n");
takeuz 8:cc3cb620c3bd 302 int len=findStringLength(_cmd)/2;
takeuz 7:42cb4b01909c 303 char _mode[2]="";
takeuz 7:42cb4b01909c 304 for(int i=0; i<2; i++) {
takeuz 7:42cb4b01909c 305 _mode[i]=_cmd[i];
takeuz 7:42cb4b01909c 306 }
takeuz 7:42cb4b01909c 307 int mode=strtol(_mode,NULL, 16);
takeuz 7:42cb4b01909c 308 cmd=strtol((_cmd+2),NULL, 16);
takeuz 17:8c76a8b1f46f 309 can_msg[0] = len;
takeuz 7:42cb4b01909c 310 can_msg[1] = mode;
takeuz 7:42cb4b01909c 311 can_msg[2] = cmd;
takeuz 4:3e1e2b161403 312 can_msg[3] = 0;
takeuz 4:3e1e2b161403 313 can_msg[4] = 0;
takeuz 4:3e1e2b161403 314 can_msg[5] = 0;
takeuz 4:3e1e2b161403 315 can_msg[6] = 0;
takeuz 17:8c76a8b1f46f 316 can_msg[7] = 0;
takeuz 15:47abd7926beb 317
takeuz 17:8c76a8b1f46f 318 /*can_MsgTx.len = len;
takeuz 15:47abd7926beb 319 can_MsgTx.data[0] = mode;
takeuz 15:47abd7926beb 320 can_MsgTx.data[1] = cmd;
takeuz 17:8c76a8b1f46f 321 can_MsgTx.data[3] = 0;
takeuz 15:47abd7926beb 322 can_MsgTx.data[4] = 0;
takeuz 15:47abd7926beb 323 can_MsgTx.data[5] = 0;
takeuz 15:47abd7926beb 324 can_MsgTx.data[6] = 0;
takeuz 15:47abd7926beb 325 can_MsgTx.data[7] = 0;*/
takeuz 2:d58ef72b4ab0 326 }
takeuz 10:fe1b976a3f9c 327 void processUserCommand(char *_incomingDataInInterFace)
takeuz 4:3e1e2b161403 328 {
takeuz 11:853d12fe7ec0 329 isVehicleCommandProcessing=1;
takeuz 7:42cb4b01909c 330 OBDTimer.reset();
takeuz 10:fe1b976a3f9c 331 setCanMessage(_incomingDataInInterFace);
takeuz 7:42cb4b01909c 332 OBDTimer.start();
takeuz 7:42cb4b01909c 333 OBDCmdReceived=0;
takeuz 10:fe1b976a3f9c 334 clearOBDCommand();
takeuz 10:fe1b976a3f9c 335 canBus->attach(NULL);
takeuz 10:fe1b976a3f9c 336 canBus->attach(&canReader);
takeuz 10:fe1b976a3f9c 337 if (canBus->write(CANMessage(PID_REQUEST, can_msg, 8))) {
takeuz 7:42cb4b01909c 338 while(OBDTimer.read_ms() < waitTimeForOBDComm) {
takeuz 7:42cb4b01909c 339 if(OBDCmdReceived) {
takeuz 7:42cb4b01909c 340 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 341 if(_powerSaveFlag) {
takeuz 10:fe1b976a3f9c 342 serialPorts[interFace]->printf("+TUAWAKE\r\n");
takeuz 10:fe1b976a3f9c 343 _powerSaveFlag=0;
takeuz 10:fe1b976a3f9c 344 break;
takeuz 10:fe1b976a3f9c 345 }
takeuz 10:fe1b976a3f9c 346 int len=incomingDataInOBD[0];
takeuz 10:fe1b976a3f9c 347 for(int i=1; i<=len; i++) {
takeuz 10:fe1b976a3f9c 348 if(incomingDataInOBD[i]!=0x00) {
takeuz 10:fe1b976a3f9c 349 serialPorts[interFace]->printf("%02X",incomingDataInOBD[i]);
takeuz 10:fe1b976a3f9c 350 } else {
takeuz 10:fe1b976a3f9c 351 serialPorts[interFace]->printf("%02X",00);
takeuz 10:fe1b976a3f9c 352 }
takeuz 10:fe1b976a3f9c 353 }
takeuz 7:42cb4b01909c 354 break;
takeuz 7:42cb4b01909c 355 }
takeuz 7:42cb4b01909c 356 }
takeuz 7:42cb4b01909c 357 }
takeuz 7:42cb4b01909c 358 OBDTimer.stop();
takeuz 7:42cb4b01909c 359 if(!OBDCmdReceived) {
takeuz 7:42cb4b01909c 360 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 361 if(!_powerSaveFlag) {
takeuz 10:fe1b976a3f9c 362 serialPorts[interFace]->puts("?");
takeuz 10:fe1b976a3f9c 363 }
takeuz 7:42cb4b01909c 364 }
takeuz 10:fe1b976a3f9c 365 clearOBDCommand();
takeuz 10:fe1b976a3f9c 366 if(!_powerSaveFlag) {
takeuz 10:fe1b976a3f9c 367 serialPorts[interFace]->puts("\r\n");
takeuz 10:fe1b976a3f9c 368 }
takeuz 11:853d12fe7ec0 369 isVehicleCommandProcessing=0;
takeuz 2:d58ef72b4ab0 370 }
takeuz 4:3e1e2b161403 371 void sleepProcess()
takeuz 4:3e1e2b161403 372 {
takeuz 4:3e1e2b161403 373
takeuz 2:d58ef72b4ab0 374 #if pushDebugData
takeuz 10:fe1b976a3f9c 375 serialPorts[debug]->puts("SPe\r\n");
takeuz 2:d58ef72b4ab0 376 #endif
takeuz 2:d58ef72b4ab0 377 OBDTimer.reset();
takeuz 2:d58ef72b4ab0 378 OBDTimer.start();
takeuz 4:3e1e2b161403 379 while(OBDTimer.read_ms()<sleepTime && !interfaceCmdReceived) {
takeuz 2:d58ef72b4ab0 380 wait_ms(50);
takeuz 10:fe1b976a3f9c 381 KlineReadCount=KlineReadCount+50;
takeuz 10:fe1b976a3f9c 382 if(currentOBDProtocol==protkLine14230 && KlineReadCount>=3000) {
takeuz 10:fe1b976a3f9c 383 KlineReadCount=0;
takeuz 11:853d12fe7ec0 384 if(isVehicleCommandProcessing) {
takeuz 10:fe1b976a3f9c 385 continue;
takeuz 10:fe1b976a3f9c 386 }
takeuz 10:fe1b976a3f9c 387 kLinekeepalive();
takeuz 10:fe1b976a3f9c 388 }
takeuz 2:d58ef72b4ab0 389 }
takeuz 2:d58ef72b4ab0 390 OBDTimer.stop();
takeuz 2:d58ef72b4ab0 391 }
takeuz 2:d58ef72b4ab0 392
takeuz 4:3e1e2b161403 393 void powerSaveMode()
takeuz 4:3e1e2b161403 394 {
takeuz 2:d58ef72b4ab0 395 #if pushDebugData
takeuz 10:fe1b976a3f9c 396 serialPorts[debug]->puts("Ignition test\r\n");
takeuz 2:d58ef72b4ab0 397 #endif
takeuz 10:fe1b976a3f9c 398 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 399 clearOBDCommand();
takeuz 10:fe1b976a3f9c 400 strcpy(incomingDataInInterFace,"010D");
takeuz 10:fe1b976a3f9c 401 _powerSaveFlag=1;
takeuz 10:fe1b976a3f9c 402 if(currentOBDProtocol==protCan) {
takeuz 14:03fd47f2b21d 403 while(isVehicleCommandProcessing) {}
takeuz 10:fe1b976a3f9c 404 processUserCommand(incomingDataInInterFace);
takeuz 10:fe1b976a3f9c 405 } else if(currentOBDProtocol==protkLine14230) {
takeuz 10:fe1b976a3f9c 406 while(isVehicleCommandProcessing);
takeuz 10:fe1b976a3f9c 407 flushBuffer();
takeuz 10:fe1b976a3f9c 408 sendCommandToVehicle(incomingDataInInterFace);
takeuz 10:fe1b976a3f9c 409 wait_ms(500);
takeuz 10:fe1b976a3f9c 410 serialPorts[debug]->printf("\r\n");
takeuz 10:fe1b976a3f9c 411 }
takeuz 2:d58ef72b4ab0 412 #if pushDebugData
takeuz 10:fe1b976a3f9c 413 serialPorts[debug]->puts("Ignition test done\r\n");
takeuz 2:d58ef72b4ab0 414 #endif
takeuz 10:fe1b976a3f9c 415 if(!_powerSaveFlag) {
takeuz 10:fe1b976a3f9c 416 #if pushDebugData
takeuz 10:fe1b976a3f9c 417 serialPorts[debug]->puts("Vehicle is in Power mode\r\n");
takeuz 10:fe1b976a3f9c 418 #endif
takeuz 10:fe1b976a3f9c 419 return;
takeuz 8:cc3cb620c3bd 420 }
takeuz 10:fe1b976a3f9c 421 #if pushDebugData
takeuz 10:fe1b976a3f9c 422 serialPorts[debug]->puts("Power save On\r\n");
takeuz 10:fe1b976a3f9c 423 #endif
takeuz 10:fe1b976a3f9c 424 if(currentOBDProtocol==protkLine14230) {
takeuz 10:fe1b976a3f9c 425 kLineUART->attach(NULL);
takeuz 5:53d84cbf9890 426 }
takeuz 10:fe1b976a3f9c 427 serialPorts[debug]->attach(NULL);
takeuz 10:fe1b976a3f9c 428 serialPorts[interFace]->attach(NULL);
takeuz 10:fe1b976a3f9c 429 timeCounter.detach();
takeuz 10:fe1b976a3f9c 430 *canDisableKey=1;
takeuz 10:fe1b976a3f9c 431
takeuz 10:fe1b976a3f9c 432 // LPC_SYSCON->SYSAHBCLKCTRL1 |= (1<<7);
takeuz 16:02f94a84e211 433 LPC_SWM->PINASSIGN0 = 0xffffffffUL;
takeuz 9:a3bdc9a71466 434 LPC_SWM->PINASSIGN1 = 0xffffffffUL;
takeuz 9:a3bdc9a71466 435 LPC_SWM->PINASSIGN2 = 0xffffffffUL;
takeuz 9:a3bdc9a71466 436 LPC_SWM->PINASSIGN3 = 0xffffffffUL;
takeuz 9:a3bdc9a71466 437 LPC_SWM->PINASSIGN4 = 0xffffffffUL;
takeuz 9:a3bdc9a71466 438 LPC_SWM->PINASSIGN5 = 0xffffffffUL;
takeuz 9:a3bdc9a71466 439 LPC_SWM->PINASSIGN8 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 440 // LPC_SYSCON->SYSAHBCLKCTRL1 |= (0<<7);
takeuz 10:fe1b976a3f9c 441 clearInterfaceCommand();
takeuz 11:853d12fe7ec0 442 // serialPorts[interFace]->attach(&readInterface); // it will not work
takeuz 10:fe1b976a3f9c 443 InterruptIn in2(P0_22);
takeuz 10:fe1b976a3f9c 444 InterruptIn in3(P0_27);
takeuz 10:fe1b976a3f9c 445 in2.rise(&flip);
takeuz 10:fe1b976a3f9c 446 in3.rise(&flip);
takeuz 10:fe1b976a3f9c 447 while(1) {
takeuz 10:fe1b976a3f9c 448 // serialPorts[debug]->printf("Waiting for interupt..\r\n");
takeuz 10:fe1b976a3f9c 449 __WFI();
takeuz 10:fe1b976a3f9c 450 int waitTime=3000;
takeuz 10:fe1b976a3f9c 451 while(waitTime>0) {
takeuz 10:fe1b976a3f9c 452 if(interfaceCmdReceived) {
takeuz 10:fe1b976a3f9c 453 break;
takeuz 10:fe1b976a3f9c 454 }
takeuz 10:fe1b976a3f9c 455 wait_ms(50);
takeuz 10:fe1b976a3f9c 456 waitTime=(waitTime-50);
takeuz 10:fe1b976a3f9c 457 }
takeuz 10:fe1b976a3f9c 458 if(interfaceCmdReceived) {
takeuz 10:fe1b976a3f9c 459 // serialPorts[debug]->printf("%s\r\n",incomingDataInInterFace);
takeuz 10:fe1b976a3f9c 460 if(checkForLocalInterfaceCommand()) {
takeuz 10:fe1b976a3f9c 461 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 462 } else {
takeuz 11:853d12fe7ec0 463 serialPorts[interFace]->printf("?\r\n"); // here ahave to send "TTUF" // sleep command
takeuz 10:fe1b976a3f9c 464 }
takeuz 10:fe1b976a3f9c 465 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 466 } else {
takeuz 10:fe1b976a3f9c 467 break;
takeuz 10:fe1b976a3f9c 468 }
takeuz 10:fe1b976a3f9c 469 }
takeuz 10:fe1b976a3f9c 470 NVIC_SystemReset();
takeuz 10:fe1b976a3f9c 471 #if pushDebugData
takeuz 10:fe1b976a3f9c 472 serialPorts[debug]->puts("PowerSaveOff\r\n");
takeuz 10:fe1b976a3f9c 473 #endif
takeuz 10:fe1b976a3f9c 474 }
takeuz 10:fe1b976a3f9c 475 int checkForLocalInterfaceCommand()
takeuz 10:fe1b976a3f9c 476 {
takeuz 10:fe1b976a3f9c 477 serialPorts[debug]->puts("CommandDETECTED\r\n");
takeuz 10:fe1b976a3f9c 478 int i=0;
takeuz 10:fe1b976a3f9c 479 while(incomingDataInInterFace[i]!='\0') {
takeuz 10:fe1b976a3f9c 480 incomingDataInInterFace[i]=tolower(incomingDataInInterFace[i]);
takeuz 10:fe1b976a3f9c 481 i++;
takeuz 10:fe1b976a3f9c 482 }
takeuz 10:fe1b976a3f9c 483 char temp[2]= {incomingDataInInterFace[0],incomingDataInInterFace[1]};
takeuz 10:fe1b976a3f9c 484 if(strcmp(temp,"at")!=0) {
takeuz 10:fe1b976a3f9c 485 serialPorts[debug]->puts("Not Local Command\r\n");
takeuz 10:fe1b976a3f9c 486 return 0;
takeuz 10:fe1b976a3f9c 487 }
takeuz 10:fe1b976a3f9c 488 if(strcmp(incomingDataInInterFace,"atz")==0) {
takeuz 6:741524d110fe 489 NVIC_SystemReset();
takeuz 6:741524d110fe 490 }
takeuz 8:cc3cb620c3bd 491 if(strcmp(incomingDataInInterFace,"atrv")==0) {
takeuz 10:fe1b976a3f9c 492 serialPorts[interFace]->puts("12.1V\r\n");
takeuz 7:42cb4b01909c 493 clearMemoryLocation(incomingDataInInterFace,incomingDataInInterFaceSize);
takeuz 7:42cb4b01909c 494 return 1;
takeuz 6:741524d110fe 495 }
takeuz 10:fe1b976a3f9c 496 serialPorts[interFace]->puts("?\r\n");
takeuz 7:42cb4b01909c 497 return 2;
takeuz 2:d58ef72b4ab0 498 }
takeuz 4:3e1e2b161403 499 void sendResponseToInterface()
takeuz 4:3e1e2b161403 500 {
takeuz 10:fe1b976a3f9c 501 serialPorts[interFace]->puts(incomingDataInOBD);
takeuz 10:fe1b976a3f9c 502 serialPorts[interFace]->puts("\r\n");
takeuz 7:42cb4b01909c 503 }
takeuz 7:42cb4b01909c 504
takeuz 7:42cb4b01909c 505 void clearInterfaceCommand()
takeuz 7:42cb4b01909c 506 {
takeuz 7:42cb4b01909c 507 incomingDataInInterFaceCounter=0;
takeuz 7:42cb4b01909c 508 interfaceCmdReceived=0;
takeuz 7:42cb4b01909c 509 clearMemoryLocation(incomingDataInInterFace,incomingDataInInterFaceSize);
takeuz 7:42cb4b01909c 510 }
takeuz 7:42cb4b01909c 511
takeuz 7:42cb4b01909c 512 void clearOBDCommand()
takeuz 7:42cb4b01909c 513 {
takeuz 7:42cb4b01909c 514 clearMemoryLocation(incomingDataInOBD,incomingDataInOBDSize);
takeuz 8:cc3cb620c3bd 515 incomingDataInOBDCounter=0;
takeuz 8:cc3cb620c3bd 516 OBDCmdReceived=0;
takeuz 8:cc3cb620c3bd 517 }
takeuz 8:cc3cb620c3bd 518 int findStringLength(char *_cmd)
takeuz 8:cc3cb620c3bd 519 {
takeuz 8:cc3cb620c3bd 520 int i=0;
takeuz 8:cc3cb620c3bd 521 for(i=0; _cmd[i]!='\0'; ++i);
takeuz 8:cc3cb620c3bd 522 return i;
takeuz 8:cc3cb620c3bd 523 }
takeuz 8:cc3cb620c3bd 524 int initializeKLine()
takeuz 8:cc3cb620c3bd 525 {
takeuz 8:cc3cb620c3bd 526 #if sendDebugMessage
takeuz 10:fe1b976a3f9c 527 serialPorts[debug]->puts("K-Line Check\r\n");
takeuz 8:cc3cb620c3bd 528 #endif
takeuz 16:02f94a84e211 529 LPC_SWM->PINASSIGN2 = 0xffffffffUL;
takeuz 8:cc3cb620c3bd 530 *klineWakeup=1;
takeuz 15:47abd7926beb 531 wait_ms(25);
takeuz 8:cc3cb620c3bd 532 *klineWakeup=0;
takeuz 8:cc3cb620c3bd 533 wait_ms(25);
takeuz 8:cc3cb620c3bd 534 *klineWakeup=1;
takeuz 8:cc3cb620c3bd 535 wait_ms(25);
takeuz 16:02f94a84e211 536 //delete klineWakeup;
takeuz 16:02f94a84e211 537 LPC_SWM->PINASSIGN2 = 0x1B1CFFFFUL;
takeuz 16:02f94a84e211 538 #if sendDebugMessage
takeuz 16:02f94a84e211 539 serialPorts[debug]->puts("Bitbang done\r\n");
takeuz 16:02f94a84e211 540 serialPorts[debug]->printf("%X",LPC_SWM->PINASSIGN2 );
takeuz 16:02f94a84e211 541 #endif
takeuz 16:02f94a84e211 542 // klineWakeup = new DigitalOut(P0_28);
takeuz 16:02f94a84e211 543
takeuz 10:fe1b976a3f9c 544 clearOBDCommand();
takeuz 8:cc3cb620c3bd 545 kLineUART->baud(10400);
takeuz 8:cc3cb620c3bd 546 kLineUART->attach(&readKLine);
takeuz 8:cc3cb620c3bd 547 uint8_t crc=0;
takeuz 8:cc3cb620c3bd 548 crc=crc+0xC1;
takeuz 8:cc3cb620c3bd 549 crc=crc+0x33;
takeuz 8:cc3cb620c3bd 550 crc=crc+0xF1;
takeuz 8:cc3cb620c3bd 551 crc=crc+0x81;
takeuz 8:cc3cb620c3bd 552 kLineUART->putc(0xC1);
takeuz 8:cc3cb620c3bd 553 kLineUART->putc(0x33);
takeuz 8:cc3cb620c3bd 554 kLineUART->putc(0xF1);
takeuz 8:cc3cb620c3bd 555 kLineUART->putc(0x81);
takeuz 8:cc3cb620c3bd 556 kLineUART->putc(crc);
takeuz 10:fe1b976a3f9c 557 wait(2);
takeuz 10:fe1b976a3f9c 558 if(incomingDataInOBD[5]!='\0') {
takeuz 10:fe1b976a3f9c 559 currentOBDProtocol=protkLine14230;
takeuz 10:fe1b976a3f9c 560 }
takeuz 16:02f94a84e211 561
takeuz 16:02f94a84e211 562 #if sendDebugMessage
takeuz 16:02f94a84e211 563 serialPorts[debug]->puts("K-Line Check2\r\n");
takeuz 16:02f94a84e211 564 #endif
takeuz 16:02f94a84e211 565 kLineUART->attach(NULL);
takeuz 16:02f94a84e211 566 /*if(currentOBDProtocol!=protkLine14230){
takeuz 16:02f94a84e211 567 delete kLineUART;
takeuz 16:02f94a84e211 568 kLineUART=NULL;
takeuz 16:02f94a84e211 569 LPC_SWM->PINASSIGN2 = 0xffffffffUL;
takeuz 16:02f94a84e211 570 klineWakeup = new DigitalOut(P0_28);
takeuz 16:02f94a84e211 571 }*/
takeuz 8:cc3cb620c3bd 572 return 0;
takeuz 7:42cb4b01909c 573 }
takeuz 7:42cb4b01909c 574
takeuz 8:cc3cb620c3bd 575 void setKLineMsg(char *_cmd)
takeuz 8:cc3cb620c3bd 576 {
takeuz 15:47abd7926beb 577 for(int i=3; i<7; i++) {
takeuz 7:42cb4b01909c 578 kLineCmd[i]='\0';
takeuz 7:42cb4b01909c 579 }
takeuz 7:42cb4b01909c 580 int len=findStringLength(_cmd)/2;
takeuz 7:42cb4b01909c 581 char _mode[2]="";
takeuz 7:42cb4b01909c 582 uint8_t crc=0;
takeuz 8:cc3cb620c3bd 583 if(len==1) {
takeuz 7:42cb4b01909c 584 crc=crc+0xC1;
takeuz 7:42cb4b01909c 585 kLineCmd[0]=0xC1;
takeuz 7:42cb4b01909c 586 crc=crc+0x33;
takeuz 7:42cb4b01909c 587 kLineCmd[1]=(0x33);
takeuz 7:42cb4b01909c 588 crc=crc+0xF1;
takeuz 7:42cb4b01909c 589 kLineCmd[2]=(0xF1);
takeuz 7:42cb4b01909c 590 crc=crc+strtol((_cmd),NULL, 16);
takeuz 7:42cb4b01909c 591 kLineCmd[3]=(strtol((_cmd),NULL, 16));
takeuz 7:42cb4b01909c 592 kLineCmd[4]=(crc);
takeuz 8:cc3cb620c3bd 593 } else if(len==2) {
takeuz 7:42cb4b01909c 594 crc=crc+0xC2;
takeuz 7:42cb4b01909c 595 kLineCmd[0]=(0xC2);
takeuz 7:42cb4b01909c 596 crc=crc+0x33;
takeuz 7:42cb4b01909c 597 kLineCmd[1]=(0x33);
takeuz 7:42cb4b01909c 598 crc=crc+0xF1;
takeuz 7:42cb4b01909c 599 kLineCmd[2]=(0xF1);
takeuz 7:42cb4b01909c 600 for(int i=0; i<2; i++) {
takeuz 7:42cb4b01909c 601 _mode[i]=_cmd[i];
takeuz 7:42cb4b01909c 602 }
takeuz 7:42cb4b01909c 603 crc=crc+strtol(_mode,NULL, 16);
takeuz 7:42cb4b01909c 604 kLineCmd[3]=(strtol(_mode,NULL, 16));
takeuz 14:03fd47f2b21d 605 if(_cmd[2]==0&&_cmd[3]==0) {
takeuz 14:03fd47f2b21d 606 crc=crc+0;
takeuz 14:03fd47f2b21d 607 kLineCmd[4]=0;
takeuz 14:03fd47f2b21d 608 } else {
takeuz 14:03fd47f2b21d 609 crc=crc+(strtol((_cmd+2),NULL, 16));
takeuz 14:03fd47f2b21d 610 kLineCmd[4]=(strtol((_cmd+2),NULL, 16));
takeuz 14:03fd47f2b21d 611 }
takeuz 7:42cb4b01909c 612 kLineCmd[5]=(crc);
takeuz 15:47abd7926beb 613 }else if(len==3) {
takeuz 15:47abd7926beb 614 char _cmd1[2]="";
takeuz 15:47abd7926beb 615 crc=crc+0xC3;
takeuz 15:47abd7926beb 616 kLineCmd[0]=(0xC3);
takeuz 15:47abd7926beb 617 crc=crc+0x33;
takeuz 15:47abd7926beb 618 kLineCmd[1]=(0x33);
takeuz 15:47abd7926beb 619 crc=crc+0xF1;
takeuz 15:47abd7926beb 620 kLineCmd[2]=(0xF1);
takeuz 15:47abd7926beb 621 for(int i=0; i<2; i++) {
takeuz 15:47abd7926beb 622 _mode[i]=_cmd[i];
takeuz 15:47abd7926beb 623 }
takeuz 15:47abd7926beb 624 crc=crc+strtol(_mode,NULL, 16);
takeuz 15:47abd7926beb 625 kLineCmd[3]=(strtol(_mode,NULL, 16));
takeuz 15:47abd7926beb 626 for(int i=2,j=0; i<4,j<2; i++,j++) {
takeuz 15:47abd7926beb 627 _cmd1[j]=_cmd[i];
takeuz 15:47abd7926beb 628 }
takeuz 15:47abd7926beb 629 crc=crc+strtol(_cmd1,NULL, 16);
takeuz 15:47abd7926beb 630 kLineCmd[4]=(strtol(_cmd1,NULL, 16));
takeuz 15:47abd7926beb 631 crc=crc+(strtol((_cmd+2),NULL, 16));
takeuz 15:47abd7926beb 632 kLineCmd[5]=(strtol((_cmd+2),NULL, 16));
takeuz 15:47abd7926beb 633 /*if(_cmd[2]==0&&_cmd[3]==0) {
takeuz 15:47abd7926beb 634 crc=crc+0;
takeuz 15:47abd7926beb 635 kLineCmd[4]=0;
takeuz 15:47abd7926beb 636 } else {
takeuz 15:47abd7926beb 637 crc=crc+(strtol((_cmd+2),NULL, 16));
takeuz 15:47abd7926beb 638 kLineCmd[4]=(strtol((_cmd+2),NULL, 16));
takeuz 15:47abd7926beb 639 }*/
takeuz 15:47abd7926beb 640 kLineCmd[6]=(crc);
takeuz 7:42cb4b01909c 641 }
takeuz 7:42cb4b01909c 642 }
takeuz 8:cc3cb620c3bd 643
takeuz 8:cc3cb620c3bd 644 void sendCommandToVehicle(char *_cmd)
takeuz 8:cc3cb620c3bd 645 {
takeuz 7:42cb4b01909c 646 isVehicleCommandProcessing=1;
takeuz 14:03fd47f2b21d 647 int cmdLen=((findStringLength(_cmd)/2)+4);
takeuz 7:42cb4b01909c 648 setKLineMsg(_cmd);
takeuz 10:fe1b976a3f9c 649 clearOBDCommand();
takeuz 10:fe1b976a3f9c 650 flushBuffer();
takeuz 10:fe1b976a3f9c 651 kLineUART->attach(&readKLine);
takeuz 14:03fd47f2b21d 652 for(kLineCommandCount=0; kLineCommandCount<cmdLen; kLineCommandCount++) {
takeuz 14:03fd47f2b21d 653 /*if(kLineCmd[kLineCommandCount]=='\0' && cmdLen) {
takeuz 7:42cb4b01909c 654 break;
takeuz 14:03fd47f2b21d 655 }*/
takeuz 7:42cb4b01909c 656 kLineUART->putc(kLineCmd[kLineCommandCount]);
takeuz 7:42cb4b01909c 657 }
takeuz 11:853d12fe7ec0 658 wait_ms(1000);
takeuz 14:03fd47f2b21d 659 serialPorts[debug]->printf("\r\n");
takeuz 10:fe1b976a3f9c 660 serialPorts[debug]->printf("Got Data\r\n");
takeuz 7:42cb4b01909c 661 //have to check given and received commands are same.
takeuz 10:fe1b976a3f9c 662 //if it is same we have to read the response else just flush buffer and send the command again
takeuz 14:03fd47f2b21d 663 /* for(int i=0; i<strlen(incomingDataInOBD); i++) {
takeuz 14:03fd47f2b21d 664 if(incomingDataInOBD[i]==0) {
takeuz 14:03fd47f2b21d 665 serialPorts[debug]->printf("00");
takeuz 14:03fd47f2b21d 666 } else {
takeuz 14:03fd47f2b21d 667 serialPorts[debug]->printf("%02X",incomingDataInOBD[i]);
takeuz 14:03fd47f2b21d 668 }
takeuz 14:03fd47f2b21d 669 }*/
takeuz 10:fe1b976a3f9c 670 kLineUART->attach(NULL);
takeuz 14:03fd47f2b21d 671 /* strcpy(incomingDataInOBD,(incomingDataInOBD+kLineCommandCount)); //cut request from hole response
takeuz 14:03fd47f2b21d 672 for(int i=0; i<strlen(incomingDataInOBD); i++) {
takeuz 14:03fd47f2b21d 673 serialPorts[debug]->printf("%02X",incomingDataInOBD[i]);
takeuz 10:fe1b976a3f9c 674 }
takeuz 14:03fd47f2b21d 675 serialPorts[debug]->printf("\r\n");
takeuz 14:03fd47f2b21d 676 serialPorts[debug]->printf("%02X\r\n",incomingDataInOBD[0]);
takeuz 14:03fd47f2b21d 677 int len=(incomingDataInOBD[0]%16);//convert first char to integer and find kength of the response
takeuz 14:03fd47f2b21d 678 serialPorts[debug]->printf("Response Length : %d\r\n",len);
takeuz 14:03fd47f2b21d 679 serialPorts[debug]->printf("Response Length : %d\r\n",strlen(incomingDataInOBD));
takeuz 14:03fd47f2b21d 680 // strcpy(incomingDataInOBD,(incomingDataInOBD+3)); //again cut first three byte
takeuz 14:03fd47f2b21d 681 serialPorts[debug]->printf("Response Length : %d\r\n",strlen(incomingDataInOBD));
takeuz 14:03fd47f2b21d 682 int obdDataLength=strlen(incomingDataInOBD);
takeuz 14:03fd47f2b21d 683 int count=0;
takeuz 14:03fd47f2b21d 684 while(count<len) {
takeuz 14:03fd47f2b21d 685 if(_powerSaveFlag) {
takeuz 14:03fd47f2b21d 686 serialPorts[interFace]->printf("+TUAWAKE");
takeuz 14:03fd47f2b21d 687 _powerSaveFlag=0;
takeuz 14:03fd47f2b21d 688 break;
takeuz 14:03fd47f2b21d 689 }
takeuz 14:03fd47f2b21d 690 if(incomingDataInOBD[count]!=0){
takeuz 14:03fd47f2b21d 691 serialPorts[interFace]->printf("%02X",incomingDataInOBD[count]);
takeuz 14:03fd47f2b21d 692 // serialPorts[debug]->printf("%02X",incomingDataInOBD[count]);
takeuz 14:03fd47f2b21d 693 }else{
takeuz 14:03fd47f2b21d 694 serialPorts[interFace]->printf("%02X",0x00);
takeuz 14:03fd47f2b21d 695 // serialPorts[debug]->printf("%02X",0x00);
takeuz 14:03fd47f2b21d 696 }
takeuz 14:03fd47f2b21d 697
takeuz 14:03fd47f2b21d 698 if(obdDataLength>0) { // have to recheck this condition
takeuz 14:03fd47f2b21d 699 serialPorts[interFace]->printf("%02X",incomingDataInOBD[count]);
takeuz 14:03fd47f2b21d 700 serialPorts[debug]->printf("%02X",incomingDataInOBD[count]);
takeuz 14:03fd47f2b21d 701 } else {
takeuz 14:03fd47f2b21d 702 serialPorts[interFace]->printf("%02X",0x00);
takeuz 14:03fd47f2b21d 703 serialPorts[debug]->printf("%02X",0x00);
takeuz 14:03fd47f2b21d 704 }
takeuz 14:03fd47f2b21d 705 count++;
takeuz 14:03fd47f2b21d 706 obdDataLength--;
takeuz 10:fe1b976a3f9c 707 }
takeuz 14:03fd47f2b21d 708
takeuz 14:03fd47f2b21d 709
takeuz 14:03fd47f2b21d 710 //????? suren: Have to recheck the following lines
takeuz 14:03fd47f2b21d 711 if(len==0) {
takeuz 14:03fd47f2b21d 712 if(!_powerSaveFlag) {
takeuz 14:03fd47f2b21d 713 serialPorts[interFace]->printf("?");
takeuz 14:03fd47f2b21d 714 serialPorts[debug]->printf("?");
takeuz 14:03fd47f2b21d 715 }
takeuz 14:03fd47f2b21d 716 }
takeuz 10:fe1b976a3f9c 717 if(!_powerSaveFlag) {
takeuz 14:03fd47f2b21d 718 serialPorts[interFace]->printf("\r\n");
takeuz 14:03fd47f2b21d 719 serialPorts[debug]->printf("\r\n");
takeuz 14:03fd47f2b21d 720 serialPorts[debug]->printf("Done\r\n");
takeuz 14:03fd47f2b21d 721 }
takeuz 14:03fd47f2b21d 722 */
takeuz 11:853d12fe7ec0 723 wait_ms(300);
takeuz 8:cc3cb620c3bd 724 clearInterfaceCommand();
takeuz 10:fe1b976a3f9c 725 clearOBDCommand();
takeuz 7:42cb4b01909c 726 isVehicleCommandProcessing=0;
takeuz 7:42cb4b01909c 727 }
takeuz 7:42cb4b01909c 728
takeuz 8:cc3cb620c3bd 729 void flushBuffer()
takeuz 8:cc3cb620c3bd 730 {
takeuz 8:cc3cb620c3bd 731 while(kLineUART->readable()) {
takeuz 7:42cb4b01909c 732 kLineUART->getc();
takeuz 7:42cb4b01909c 733 }
takeuz 7:42cb4b01909c 734 }
takeuz 8:cc3cb620c3bd 735 void kLinekeepalive()
takeuz 8:cc3cb620c3bd 736 {
takeuz 10:fe1b976a3f9c 737 serialPorts[debug]->printf("KeepAlive ENT\r\n");
takeuz 8:cc3cb620c3bd 738 kLineUART->putc(0xc1);
takeuz 8:cc3cb620c3bd 739 kLineUART->putc(0x33);
takeuz 8:cc3cb620c3bd 740 kLineUART->putc(0xf1);
takeuz 8:cc3cb620c3bd 741 kLineUART->putc(0x3e);
takeuz 8:cc3cb620c3bd 742 kLineUART->putc(0x23);
takeuz 10:fe1b976a3f9c 743 serialPorts[debug]->printf("EXT\r\n");
takeuz 8:cc3cb620c3bd 744 }
takeuz 10:fe1b976a3f9c 745 char tolower(unsigned char ch)
takeuz 10:fe1b976a3f9c 746 {
takeuz 8:cc3cb620c3bd 747 if (ch >= 'A' && ch <= 'Z')
takeuz 8:cc3cb620c3bd 748 ch = 'a' + (ch - 'A');
takeuz 8:cc3cb620c3bd 749 return ch;
takeuz 10:fe1b976a3f9c 750 }
takeuz 10:fe1b976a3f9c 751
takeuz 10:fe1b976a3f9c 752 int checkCarStatus()
takeuz 10:fe1b976a3f9c 753 {
takeuz 10:fe1b976a3f9c 754 // LPC_SYSCON->SYSAHBCLKCTRL1 |= (1<<7);
takeuz 10:fe1b976a3f9c 755 LPC_SWM->PINASSIGN0 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 756 LPC_SWM->PINASSIGN1 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 757 LPC_SWM->PINASSIGN2 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 758 LPC_SWM->PINASSIGN3 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 759 LPC_SWM->PINASSIGN4 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 760 LPC_SWM->PINASSIGN5 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 761 LPC_SWM->PINASSIGN8 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 762 // LPC_SYSCON->SYSAHBCLKCTRL1 |= (0<<7);
takeuz 15:47abd7926beb 763 DigitalIn kLine(P0_27);
takeuz 15:47abd7926beb 764 DigitalIn canLine(P0_22);
takeuz 10:fe1b976a3f9c 765 if(kLine.read()) {
takeuz 10:fe1b976a3f9c 766 return 1;
takeuz 10:fe1b976a3f9c 767 }
takeuz 10:fe1b976a3f9c 768 if(canLine.read()) {
takeuz 10:fe1b976a3f9c 769 return 2;
takeuz 10:fe1b976a3f9c 770 }
takeuz 10:fe1b976a3f9c 771 return 0;
takeuz 10:fe1b976a3f9c 772 }
takeuz 10:fe1b976a3f9c 773
takeuz 10:fe1b976a3f9c 774 void initPins()
takeuz 10:fe1b976a3f9c 775 {
takeuz 10:fe1b976a3f9c 776 // LPC_SYSCON->SYSAHBCLKCTRL1 |= (1<<7);
takeuz 10:fe1b976a3f9c 777 LPC_SWM->PINASSIGN0 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 778 LPC_SWM->PINASSIGN1 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 779 LPC_SWM->PINASSIGN2 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 780 LPC_SWM->PINASSIGN3 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 781 LPC_SWM->PINASSIGN4 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 782 LPC_SWM->PINASSIGN5 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 783 LPC_SWM->PINASSIGN8 = 0xffffffffUL;
takeuz 10:fe1b976a3f9c 784 // LPC_SYSCON->SYSAHBCLKCTRL1 |= (0<<7);
takeuz 17:8c76a8b1f46f 785 serialPorts[0] = new Serial(P0_11,P0_13);
takeuz 17:8c76a8b1f46f 786 serialPorts[1] = new Serial(P0_15,P0_14);
takeuz 17:8c76a8b1f46f 787 /* serialPorts[0] = new Serial(P0_16,P0_12);
takeuz 17:8c76a8b1f46f 788 serialPorts[1] = new Serial(USBTX,USBRX);*/
takeuz 10:fe1b976a3f9c 789 klineWakeup = new DigitalOut(P0_28);
takeuz 10:fe1b976a3f9c 790 canBus = new CAN(P0_22, P0_23);
takeuz 10:fe1b976a3f9c 791 canDisableKey=new DigitalOut(P0_0,0);
takeuz 16:02f94a84e211 792 kLineUART=new Serial(P0_28,P0_27);
takeuz 16:02f94a84e211 793 serialPorts[interFace]->baud(9600);
takeuz 16:02f94a84e211 794 serialPorts[debug]->baud(9600);
takeuz 10:fe1b976a3f9c 795 }