Support for defining starting special char for commands. Added aux bat readings for BMW i3

CarBmwI3.cpp

@@ -33,9 +33,11 @@ void CarBmwI3::activateCommandQueue() {
 		// BMS
 		"ATSH6F1",
 
+    "22402B", // STATUS_MESSWERTE_IBS - 12V Bat
+    //"22F101", // STATUS_A_T_ELUE ???
     "22DDC0", // TEMPERATUREN
     "22DD69", // HV_STORM
-    "22DD6C", // KUEHLKREISLAUF_TEMP
+    //"22DD6C", // KUEHLKREISLAUF_TEMP
     "22DDB4", // HV_SPANNUNG
     "22DDBC"  // SOC
 		
@@ -66,12 +68,14 @@ void CarBmwI3::activateCommandQueue() {
 */
 void CarBmwI3::parseRowMerged() 
 {
-  Serial.println("--Parsing row merged: ");  
+  
-  Serial.print("--responseRowMerged: ");  Serial.println(liveData->responseRowMerged);
+//  Serial.println("--Parsing row merged: ");  
-  Serial.print("--currentAtshRequest: ");   Serial.println(liveData->currentAtshRequest);
+//  Serial.print("--responseRowMerged: ");  Serial.println(liveData->responseRowMerged);
-  Serial.print("--commandRequest: ");       Serial.println(liveData->commandRequest);
+//  Serial.print("--currentAtshRequest: ");   Serial.println(liveData->currentAtshRequest);
-  Serial.print("--mergedLength: ");         Serial.println(liveData->responseRowMerged.length());
+//  Serial.print("--commandRequest: ");       Serial.println(liveData->commandRequest);
+//  Serial.print("--mergedLength: ");         Serial.println(liveData->responseRowMerged.length());
   Serial.print("--mergedVectorLength: ");   Serial.println(liveData->vResponseRowMerged.size());
+  
   if (liveData->responseRowMerged.length() <= 6) {
     Serial.println("--too short data, skiping processing");
   }
@@ -94,19 +98,39 @@ void CarBmwI3::parseRowMerged()
   std::vector<uint8_t> payloadReversed(pHeader->pData, pHeader->pData + payloadLength);
   std::reverse(payloadReversed.begin(), payloadReversed.end());
   
-  Serial.print("--extracted PID: "); Serial.println(pHeader->getPid());
+  //Serial.print("--extracted PID: "); Serial.println(pHeader->getPid());
-  Serial.print("--payload length: "); Serial.println(payloadLength);
+  //Serial.print("--payload length: "); Serial.println(payloadLength);
   
   
   // BMS
   if (liveData->currentAtshRequest.equals("ATSH6F1")) {
 
     switch (pHeader->getPid()) {
+    case 0x402B:
+    {
+      struct s402B_t {
+        int16_t unknown[13];
+        uint16_t auxRawCurrent;
+        uint16_t auxRawVoltage;
+        int16_t auxTemp;
+      };
+
+      if (payloadLength == sizeof(s402B_t)) {
+        s402B_t* ptr = (s402B_t*)payloadReversed.data();
+
+        liveData->params.auxPerc = ptr->auxTemp / 10.0;
+        liveData->params.auxVoltage = ptr->auxRawVoltage / 4000.0 + 6;
+        liveData->params.auxCurrentAmp = - (ptr->auxRawCurrent / 12.5 - 200);
+      }
+        
+    }
+    break;
+    
     case 0xDD69:
     {
       struct DD69_t {
         uint8_t unknown[4];
-        uint32_t batAmp;
+        int32_t batAmp;
       };
 
       if (payloadLength == sizeof(DD69_t)) { 
@@ -123,6 +147,22 @@ void CarBmwI3::parseRowMerged()
 
     case 0xDD6C:
     {
+      struct DD6C_t {
+        int16_t tempCoolant;
+      };
+
+      if (payloadLength == sizeof(DD6C_t)) {
+        DD6C_t* ptr = (DD6C_t*)payloadReversed.data();
+
+        liveData->params.coolingWaterTempC = ptr->tempCoolant / 10.0;
+        liveData->params.coolantTemp1C = ptr->tempCoolant / 10.0;
+        liveData->params.coolantTemp2C = ptr->tempCoolant / 10.0;
+        /*  
+        float coolingWaterTempC;
+        float coolantTemp1C;
+        float coolantTemp2C;
+        */
+      }
       
     }
     break;
@@ -148,9 +188,9 @@ void CarBmwI3::parseRowMerged()
     {
       struct DDC0_t {
         uint8_t unknown[2];
-        uint16_t tempAvg;
+        int16_t tempAvg;
-        uint16_t tempMax;
+        int16_t tempMax;
-        uint16_t tempMin;
+        int16_t tempMin;
       };
       
       if (payloadLength == sizeof(DDC0_t)) {
@@ -178,8 +218,10 @@ void CarBmwI3::parseRowMerged()
       
       if (payloadLength == sizeof(DDBC_t)) {
         DDBC_t* ptr = (DDBC_t*)payloadReversed.data();
-        
+
+        liveData->params.socPercPrevious = liveData->params.socPerc;
         liveData->params.socPerc = ptr->soc / 10.0;
+        liveData->params.sohPerc = 92.0; // TODO: gother somewhere this value
       }
     }
     break;

CommObd2Can.cpp

@@ -149,8 +149,14 @@ void CommObd2Can::sendPID(const uint16_t pid, const String& cmd) {
     };
     
     Packet_t* pPacket = (Packet_t*)txBuf;
+
+    if (cmd == "22402B" || cmd == "22F101") {
+      pPacket->startChar = txStartChar = 0x12;
+    } else {
+      pPacket->startChar = txStartChar = 0x07;
+    }
+    
     
-    pPacket->startChar = 0x07;
     pPacket->length = cmd.length() / 2;
     
     for (uint8_t i = 0; i < sizeof(pPacket->data); i++) {
@@ -201,7 +207,7 @@ void CommObd2Can::sendFlowControlFrame() {
   // insert 0x07 into beginning for BMW i3
   if (liveData->settings.carType == CAR_BMW_I3_2014) {
     memmove(txBuf + 1, txBuf, 7);
-    txBuf[0] = 0x07;
+    txBuf[0] = txStartChar;
   }
     
   const uint8_t sndStat = CAN->sendMsgBuf(lastPid, 0, 8, txBuf); // 11 bit
@@ -332,7 +338,7 @@ bool CommObd2Can::processFrameBytes() {
       
       rxRemaining = 0;
       
-      Serial.print("----Processing SingleFrame payload: "); printHexBuffer(pSingleFrame->pData, pSingleFrame->size, true);
+      //Serial.print("----Processing SingleFrame payload: "); printHexBuffer(pSingleFrame->pData, pSingleFrame->size, true);
       
       // single frame - process directly
       buffer2string(liveData->responseRowMerged, mergedData.data(), mergedData.size());
@@ -365,7 +371,7 @@ bool CommObd2Can::processFrameBytes() {
       dataRows[0].assign(pFirstFrame->pData, pFirstFrame->pData + framePayloadSize);
       rxRemaining -= framePayloadSize;
       
-      Serial.print("----Processing FirstFrame payload: "); printHexBuffer(pFirstFrame->pData, framePayloadSize, true);
+      //Serial.print("----Processing FirstFrame payload: "); printHexBuffer(pFirstFrame->pData, framePayloadSize, true);
     }
     break;
     
@@ -379,14 +385,14 @@ bool CommObd2Can::processFrameBytes() {
       };
       
       const uint8_t structSize = sizeof(ConsecutiveFrame_t);
-      Serial.print("[debug] sizeof(ConsecutiveFrame_t) is expected to be 1 and it's "); Serial.println(structSize);
+      //Serial.print("[debug] sizeof(ConsecutiveFrame_t) is expected to be 1 and it's "); Serial.println(structSize);
       
       ConsecutiveFrame_t* pConseqFrame = (ConsecutiveFrame_t*)pDataStart;
       const uint8_t framePayloadSize = frameLenght - sizeof(ConsecutiveFrame_t);  // remove one byte of header
       dataRows[pConseqFrame->index].assign(pConseqFrame->pData, pConseqFrame->pData + framePayloadSize);
       rxRemaining -= framePayloadSize;
       
-      Serial.print("----Processing ConsecFrame payload: "); printHexBuffer(pConseqFrame->pData, framePayloadSize, true);
+      //Serial.print("----Processing ConsecFrame payload: "); printHexBuffer(pConseqFrame->pData, framePayloadSize, true);
     }
     break;
     
@@ -400,10 +406,10 @@ bool CommObd2Can::processFrameBytes() {
   if (rxRemaining <= 0) {
     // multiple frames and no data remaining - merge everything to single packet
     for (int i = 0; i < dataRows.size(); i++) {
-      Serial.print("------merging packet index ");
+      //Serial.print("------merging packet index ");
-      Serial.print(i);
+      //Serial.print(i);
-      Serial.print(" with length ");
+      //Serial.print(" with length ");
-      Serial.println(dataRows[i].size());
+      //Serial.println(dataRows[i].size());
       
       mergedData.insert(mergedData.end(), dataRows[i].begin(), dataRows[i].end());
     }

CommObd2Can.h

@@ -22,6 +22,7 @@ class CommObd2Can : public CommInterface {
     char msgString[128];                        // Array to store serial string
     uint16_t lastPid;
     unsigned long lastDataSent = 0;
+    uint8_t txStartChar = 0; // set when sending PID, used when sending FlowControl
     
     std::vector<uint8_t> mergedData;
     std::unordered_map<uint16_t, std::vector<uint8_t>> dataRows;