Working bms temp sense, prepping for CAN

Author: Mayamelon

bms/.mbed

@@ -1,3 +1,4 @@
 ROOT=.
 TARGET=NUCLEO_L432KC
 TARGET_CODE=0770
+TARGET_SERIAL=0671FF555185754867150637

bms/src/BmsConfig.h

@@ -79,10 +79,23 @@ extern DigitalOut* chargerControl;
 //
 // Units: millivolts
 #ifndef BMS_BALANCE_THRESHOLD
-#define BMS_BALANCE_THRESHOLD 3700
+#define BMS_BALANCE_THRESHOLD 3900
 #endif
 
+// highest power allowed
+#ifndef CAR_MAX_POWER
+#define CAR_MAX_POWER 80000
+#endif
+
+// percent of highest power allowed (for tolerance)
+#ifndef CAR_POWER_PERCENT
+#define CAR_POWER_PERCENT 0.95
+#endif
 
+// percent of precharge needed to consider precharging done (and close the +AIR)
+#ifndef PRECHARGE_PERCENT
+#define PRECHARGE_PERCENT 0.95
+#endif
 
 
 // BMS Cell lookup

bms/src/BmsThread.cpp

@@ -3,6 +3,7 @@
 #include "LTC681xBus.h"
 #include "LTC681xCommand.h"
 #include "ThisThread.h"
+#include <algorithm>
 #include <cstdint>
 #include <cstdio>
 
@@ -90,6 +91,8 @@ void BMSThread::threadWorker() {
   std::array<uint16_t, BMS_BANK_COUNT * BMS_BANK_CELL_COUNT> allVoltages;
   std::array<int8_t, BMS_BANK_COUNT * BMS_BANK_TEMP_COUNT> allTemps;
   while (true) {
+
+      bool isBalancing = false;
 
     while(!mainToBMSMailbox->empty()) {
         MainToBMSEvent *mainToBMSEvent;
@@ -210,7 +213,7 @@ void BMSThread::threadWorker() {
 
         int8_t temp = convertTemp(tempVoltage / 10);
         // printf("%d: T: %d\n", j, temp);
-        allTemps[j] = temp;
+        allTemps[(BMS_BANK_CELL_COUNT * i) + j] = temp;
       }
 
       for (int j = 0; j < 12; j++) {
@@ -235,7 +238,7 @@ void BMSThread::threadWorker() {
         maxVoltage = allVoltages[i];
       }
     }
-
+    
     int8_t minTemp = allTemps[0];
     int8_t maxTemp = 0;
     for (int i = 0; i < BMS_BANK_COUNT * BMS_BANK_TEMP_COUNT; i++) {
@@ -245,7 +248,11 @@ void BMSThread::threadWorker() {
         maxTemp = allTemps[i];
       }
     }
-    printf("min temp: %d, max temp: %d\nmin volt: %d, max volt %d\n", minTemp, maxTemp, minVoltage, maxVoltage);
+    // printf("0 Temps: %d, %d, %d, %d, %d, %d, %d\n", allTemps[0], allTemps[1], allTemps[2], allTemps[3], allTemps[4], allTemps[5], allTemps[6]);
+    // printf("1 Temps: %d, %d, %d, %d, %d, %d, %d\n", allTemps[7], allTemps[8], allTemps[9], allTemps[10], allTemps[11], allTemps[12], allTemps[13]);
+    // printf("2 Temps: %d, %d, %d, %d, %d, %d, %d\n", allTemps[14], allTemps[15], allTemps[16], allTemps[17], allTemps[18], allTemps[19], allTemps[20]);
+    // printf("3 Temps: %d, %d, %d, %d, %d, %d, %d\n\n", allTemps[21], allTemps[22], allTemps[23], allTemps[24], allTemps[25], allTemps[26], allTemps[27]);
+    // printf("min temp: %d, max temp: %d\nmin volt: %d, max volt %d\n", minTemp, maxTemp, minVoltage, maxVoltage);
 
     if (minVoltage <= BMS_FAULT_VOLTAGE_THRESHOLD_LOW ||
         maxVoltage >= BMS_FAULT_VOLTAGE_THRESHOLD_HIGH ||
@@ -271,6 +278,7 @@ void BMSThread::threadWorker() {
               cellVoltage >= minVoltage + BMS_DISCHARGE_THRESHOLD) {
             // printf("Balancing cell %d\?n", cellNum);
             dischargeValue |= (0x1 << j);
+            isBalancing = true;
           }
         }
 
@@ -304,6 +312,11 @@ void BMSThread::threadWorker() {
             msg->temperatureValues[i] = allTemps[i];
         }
         msg->bmsState = bmsState;
+        msg->isBalancing = isBalancing;
+        msg->minVolt = (uint8_t)(minVoltage*50/1000.0);
+        msg->maxVolt = (uint8_t)(maxVoltage*50/1000.0);
+        msg->minTemp = minTemp;
+        msg->maxTemp = maxTemp;
         bmsEventMailbox->put((BmsEvent *)msg);
     }
 
@@ -317,7 +330,5 @@ void BMSThread::threadWorker() {
 }
 
 void BMSThread::throwBmsFault() {
-  // bmsState = BMSThreadState::BMSFault;
-  // palClearLine(LINE_BMS_FLT);
-  // palSetLine(LINE_CHARGER_CONTROL);
+  bmsState = BMSThreadState::BMSFault;
 }

bms/src/Can.cpp

@@ -0,0 +1,49 @@
+#include "Can.h"
+#include <cstdint>
+
+CANMessage accBoardBootup () {
+  const char * startupMessage = 0x00;
+  return CANMessage(kNMT_ACC_HEARTBEAT, startupMessage);  
+}
+
+CANMessage accBoardState(uint8_t glvVoltage, uint16_t tsVoltage, bool bmsFault, bool bmsBalancing, bool prechargeDone, bool charging, bool fansOn, bool shutdownClosed, bool unused_A, bool unused_B, uint8_t minCellVoltage, uint8_t maxCellVoltage, int16_t tsCurrent) {
+    uint8_t data[8];
+    data[0] = glvVoltage;
+    data[1] = tsVoltage;
+    data[2] = tsVoltage >> 8;
+    data[3] = bmsFault + (bmsBalancing << 1) + (prechargeDone << 2) + (charging << 3) + (fansOn << 4) + (shutdownClosed << 5) + (unused_A << 6) +(unused_B << 7);
+    data[4] = minCellVoltage;
+    data[5] = maxCellVoltage;
+    data[6] = tsCurrent;
+    data[7] = tsCurrent >> 8;
+    return CANMessage(kTPDO_ACC_BOARD_State, data);
+}
+
+CANMessage accBoardTemp(uint8_t segment, int8_t *temps) {
+    uint8_t data[8];
+    data[0] = segment;
+    for (int i = 0; i < 7; i++) {
+        data[i+1] = (uint8_t)(temps[i]+40);
+    }
+    
+    return CANMessage(kTPDO_ACC_BOARD_Temp, data);
+}
+
+CANMessage accBoardVolt(uint8_t segment, uint16_t *volts) {
+    uint8_t data[8];
+    data[0] = segment;
+    for (int i = 0; i < 7; i++) {
+        data[i+1] = (uint8_t) (50.0*volts[i]/1000.0);
+    }
+    
+    return CANMessage(kTPDO_ACC_BOARD_Volt, data);
+}
+
+CANMessage motorControllerCurrentLim(uint16_t chargeCurLim, uint16_t dischargeCurLim) {
+    uint8_t data[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+    data[0] = chargeCurLim;
+    data[1] = chargeCurLim >> 8;
+    data[2] = dischargeCurLim;
+    data[3] = dischargeCurLim >> 8;
+    return CANMessage(kRPDO_MAX_CURRENTS, data);
+}

bms/src/Can.h

@@ -10,50 +10,24 @@
 
 // SIDs From Accumulator
 constexpr uint32_t kTPDO_ACC_BOARD_State = 0x182;
-constexpr uint32_t kTPDO_ACC_BOARD_Temp_0 = 0x282;
-constexpr uint32_t kTPDO_ACC_BOARD_Temp_1 = 0x382;
-constexpr uint32_t kTPDO_ACC_BOARD_Temp_2 = 0x482;
-constexpr uint32_t kTPDO_ACC_BOARD_Temp_3 = 0x582;
+constexpr uint32_t kTPDO_ACC_BOARD_Temp = 0x282;
+constexpr uint32_t kTPDO_ACC_BOARD_Volt = 0x382;
 constexpr uint32_t kNMT_ACC_HEARTBEAT = 0x702;
+constexpr uint32_t kRPDO_MAX_CURRENTS = 0x286;
 
-CANMessage AccBoardBootup () {
-  const char * startupMessage = 0x00;
-  return CANMessage(kNMT_ACC_HEARTBEAT, startupMessage);  
-}
-
-CANMessage AccBoardState(uint8_t glvVoltage, uint16_t tsVoltage, bool bmsFault, bool bmsBalancing, bool prechargeDone, bool charging, bool fansOn, bool shutdownClosed, bool unused_A, bool unused_B, uint8_t minCellVoltage, uint8_t maxCellVoltage, int16_t tsCurrent) {
-    uint8_t data[8];
-    data[0] = glvVoltage;
-    data[1] = tsVoltage;
-    data[2] = tsVoltage >> 8;
-    data[3] = bmsFault + (bmsBalancing << 1) + (prechargeDone << 2) + (charging << 3) + (fansOn << 4) + (shutdownClosed << 5) + (unused_A << 6) +(unused_B << 7);
-    data[4] = minCellVoltage;
-    data[5] = maxCellVoltage;
-    data[6] = tsCurrent;
-    data[7] = tsCurrent >> 8;
-    return CANMessage(kTPDO_ACC_BOARD_State, data);
-}
-
-CANMessage AccBoardTemp(int segment, uint8_t *temps) {
-    uint8_t data[8];
-    for (int i = 0; i < 7; i++) {
-        data[i] = temps[i];
-    }
-    int canID;
-    switch (segment) {
-        case 0:
-            return kTPDO_ACC_BOARD_Temp_0;
-        case 1:
-            return kTPDO_ACC_BOARD_Temp_1;
-        case 2:
-            return kTPDO_ACC_BOARD_Temp_2;
-        case 3:
-            return kTPDO_ACC_BOARD_Temp_3;
-        default:
-            return NULL;
-            break;
-    }
-    return CANMessage(canID, data);
-}
+/* Bootup message */
+CANMessage accBoardBootup ();
+
+/* TPDO that sends various states and information about the accumulator */
+CANMessage accBoardState(uint8_t glvVoltage, uint16_t tsVoltage, bool bmsFault, bool bmsBalancing, bool prechargeDone, bool charging, bool fansOn, bool shutdownClosed, bool unused_A, bool unused_B, uint8_t minCellVoltage, uint8_t maxCellVoltage, int16_t tsCurrent);
+
+/* TPDO that sends all temperatures for one segment */
+CANMessage accBoardTemp(uint8_t segment, int8_t *temps);
+
+/* TPDO that sends all voltages for one segment */
+CANMessage accBoardVolt(uint8_t segment, uint16_t *voltages);
+
+/* RPDO for limiting the current to the Motor Controller (AC-X1) */
+CANMessage motorControllerCurrentLim(uint16_t chargeCurLim, uint16_t dischargeCurLim);
 
 #endif // _FS_BMS_SRC_CAN_H_

bms/src/Event.h

@@ -15,6 +15,11 @@ class BmsEvent {
 public:
   uint16_t voltageValues[BMS_BANK_COUNT * BMS_BANK_CELL_COUNT];
   int8_t temperatureValues[BMS_BANK_COUNT * BMS_BANK_TEMP_COUNT];
+  uint8_t minVolt;
+  uint8_t maxVolt;
+  int8_t minTemp;
+  int8_t maxTemp;
+  bool isBalancing;
   BMSThreadState bmsState;
 };
 

bms/src/Main.cpp

@@ -10,6 +10,8 @@
 #include "LTC681xParallelBus.h"
 #include "BmsThread.h"
 
+#include "Can.h"
+
 
 CAN* canBus;
 
@@ -40,13 +42,20 @@ AnalogIn glv_voltage_pin(ACC_GLV_VOLTAGE);
 bool prechargeDone = false;
 bool hasBmsFault = false;
 bool isCharging = false;
+bool hasFansOn = false;
+bool isBalancing = false;
 
-uint32_t dcBusVoltage;
-uint32_t tsVoltage;
+uint16_t dcBusVoltage;
+uint16_t tsVoltage;
+uint8_t glvVoltage;
+uint16_t tsCurrent;
 
 uint16_t allVoltages[BMS_BANK_COUNT*BMS_BANK_CELL_COUNT];
 int8_t allTemps[BMS_BANK_COUNT*BMS_BANK_TEMP_COUNT];
 
+int8_t minCellVolt; // factor of 0.02 so 255 is 5.1 volts
+int8_t maxCellVolt; // factor of 0.02 so 255 is 5.1 volts
+
 int main() {
 
   printf("main\n");
@@ -74,7 +83,7 @@ int main() {
   Timer t;
   t.start();
   while (1) {
-    int glv_voltage = glv_voltage_pin * 18530; // in mV
+    glvVoltage = glv_voltage_pin * 18530; // in mV
     //printf("GLV voltage: %d mV\n", glv_voltage);
 
     while (!bmsMailbox->empty()) {
@@ -93,6 +102,10 @@ int main() {
             case BMSThreadState::BMSIdle:
                 hasBmsFault = false;
 
+                minCellVolt = bmsEvent->minVolt;
+                maxCellVolt = bmsEvent->maxVolt;
+                isBalancing = bmsEvent->isBalancing;
+
                 tsVoltage = 0;
 
                 for (int i = 0; i < BMS_BANK_COUNT*BMS_BANK_CELL_COUNT; i++) {
@@ -140,21 +153,28 @@ int main() {
     }
 
 
-    if (dcBusVoltage >= tsVoltage * 0.95) {
+    if (dcBusVoltage >= tsVoltage * PRECHARGE_PERCENT) {
         prechargeDone = true;
     }
 
     precharge_control_pin = prechargeDone;
     bms_fault_pin = hasBmsFault;
 
-    if (prechargeDone || charge_state_pin) {
-        fan_control_pin = true;
-    }
+    hasFansOn = (prechargeDone || charge_state_pin);
+    
 
     isCharging = charge_state_pin;
     // printf("charge state: %x\n", isCharging);
 
     charge_enable_pin = isCharging && !hasBmsFault && shutdown_measure_pin;
+    fan_control_pin = hasFansOn;
+
+
+    // times 1.5 to change from 3.3v to 5v
+    // divided by 0.625 for how the current sensor works :/
+    // divided by 300 because that's the nominal current reading of the sensor (ie baseline)
+    // multiplied by 10 and cast to a uint16 for 1 decimal place
+    tsCurrent = (uint16_t)(((current_sense_pin-current_vref_pin)/125.0)*10);
 
 
     ThisThread::sleep_for(50 - (t.read_ms()%50));
@@ -181,6 +201,56 @@ void canRX() {
     }
 }
 
-void canTX() {
-    
+void canBootupTX() {
+    canBus->write(accBoardBootup());
+}
+
+void canBoardStateTX() {
+    canBus->write(accBoardState(
+        glvVoltage,
+        tsVoltage,
+        hasBmsFault,
+        isBalancing,
+        prechargeDone,
+        isCharging,
+        hasFansOn,
+        shutdown_measure_pin,
+        false,
+        false,
+        minCellVolt,
+        maxCellVolt,
+        tsCurrent
+    ));
+}
+
+void canBoardTempTX(uint8_t segment) {
+    int8_t temps[7] = {
+            allTemps[(segment * BMS_BANK_CELL_COUNT)],
+            allTemps[(segment * BMS_BANK_CELL_COUNT) + 1],
+            allTemps[(segment * BMS_BANK_CELL_COUNT) + 2],
+            allTemps[(segment * BMS_BANK_CELL_COUNT) + 3],
+            allTemps[(segment * BMS_BANK_CELL_COUNT) + 4],
+            allTemps[(segment * BMS_BANK_CELL_COUNT) + 5],
+            allTemps[(segment * BMS_BANK_CELL_COUNT) + 6]
+    };
+    canBus->write(accBoardTemp(segment, temps));
+}
+
+void canBoardVoltTX(uint8_t segment) {
+    uint16_t volts[7] = {
+            allVoltages[(segment * BMS_BANK_CELL_COUNT)],
+            allVoltages[(segment * BMS_BANK_CELL_COUNT) + 1],
+            allVoltages[(segment * BMS_BANK_CELL_COUNT) + 2],
+            allVoltages[(segment * BMS_BANK_CELL_COUNT) + 3],
+            allVoltages[(segment * BMS_BANK_CELL_COUNT) + 4],
+            allVoltages[(segment * BMS_BANK_CELL_COUNT) + 5],
+            allVoltages[(segment * BMS_BANK_CELL_COUNT) + 6]
+    };
+    canBus->write(accBoardVolt(segment, volts));
+}
+
+void canCurrentLimTX() {
+    uint16_t chargeCurrentLimit = 0x0000;
+    uint16_t dischargeCurrentLimit = (uint16_t)(CAR_MAX_POWER/tsVoltage)*CAR_POWER_PERCENT;
+    canBus->write(motorControllerCurrentLim(chargeCurrentLimit, dischargeCurrentLimit));
 }