Merge pull request #6 from RIT-EVT/feature/actuallyzach/canpowertrain

ActuallyTaylor · web-flow · commit ca28e2ba6d85 · 2023-02-20T19:45:55.000-05:00
CAN You Hear My Status
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -6,6 +6,11 @@ if(EVT_CORE_LOG_ENABLE)
 endif()
 cmake_minimum_required(VERSION 3.15)
 
+# Increases the number of RPDOs that CAN Open can handle.
+# Also able to change the number of TPDOs if RPDO in the definition
+# is changed to TPDO (CO_TPDO_N=50)
+add_compile_definitions(CO_RPDO_N=50)
+
 set(EVT_CORE_DIR      ${CMAKE_SOURCE_DIR}/libs/EVT-core)
 set(TARGET_DEV        "STM32F302x8")
 
diff --git a/include/HUDL/HUDL.hpp b/include/HUDL/HUDL.hpp
@@ -70,9 +70,21 @@ class HUDL {
 
     uint32_t thermTemps[4] = {};
 
-    static constexpr uint16_t OBJECT_DICTIONARY_SIZE = 30;
+    /** The status word provided by the MC node over CAN. Found in the first 16 bits of the 1st PDO coming from the MC. */
+    uint16_t statusWord = 0;
+    /** The position actual value provided by the MC node over CAN. Found in the middle 32 bits of the 1st PDO coming from the MC. */
+    uint32_t positionActual = 0;
+    /** The torque actual value provided by the MC node over CAN. Found in the last 16 bits of the 1st PDO coming from the MC. */
+    uint16_t torqueActual = 0;
+
+    uint16_t velocityActual = 0;
+
+    uint32_t rpdo4First32BitsDummyData = 0;
+
+    static constexpr uint16_t OBJECT_DICTIONARY_SIZE = 47;
     static constexpr uintptr_t TMS_NODE_ID = 0x08;
     static constexpr uintptr_t BMS_NODE_ID = 0x05;
+    static constexpr uintptr_t MC_NODE_ID = 0x01;
 
     CO_OBJ_T objectDictionary[OBJECT_DICTIONARY_SIZE + 1] = {
         // Sync ID, defaults to 0x80
@@ -192,6 +204,49 @@ class HUDL {
             .Data = (uintptr_t) 0xFE,
         },
 
+        /**
+         * RPDO3 settings
+         * 0: RPDO number in index and total number of sub indexes.
+         * 1: The COB-ID to receive PDOs from.
+         * 2: transmission trigger
+         */
+        {
+            .Key = CO_KEY(0x1403, 0, CO_UNSIGNED8 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) 3,
+        },
+        {
+            .Key = CO_KEY(0x1403, 1, CO_UNSIGNED32 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) CO_COBID_TPDO_DEFAULT(0) + MC_NODE_ID,
+        },
+        {
+            .Key = CO_KEY(0x1403, 2, CO_UNSIGNED8 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) 0xFE,
+        },
+        /**
+         * RPDO4 settings
+         * 0: RPDO number in index and total number of sub indexes.
+         * 1: The COB-ID to receive PDOs from.
+         * 2: transmission trigger
+         */
+        {
+            .Key = CO_KEY(0x1404, 0, CO_UNSIGNED8 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) 3,
+        },
+        {
+            .Key = CO_KEY(0x1404, 1, CO_UNSIGNED32 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) CO_COBID_TPDO_DEFAULT(3) + MC_NODE_ID,
+        },
+        {
+            .Key = CO_KEY(0x1404, 2, CO_UNSIGNED8 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) 0xFE,
+        },
+
         /**
          * RPDO0 mapping, determines the PDO messages to receive when RPDO0 is triggered
          * 0: The number of PDO message associated with the RPDO
@@ -252,9 +307,58 @@ class HUDL {
             .Data = CO_LINK(0x2101, 0, 32),
         },
 
+        /**
+         * RPDO3 mapping, determines the PDO messages to receive when RPDO3 is triggered
+         * 0: The number of PDO message associated with the RPDO
+         * 1: Link to the first PDO message - statusWord
+         * 2: Link to the second PD0 message - positionActual
+         * 3: Link to the third PD0 message - torqueActual
+         */
+        {
+            .Key = CO_KEY(0x1603, 0, CO_UNSIGNED8 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) 3,
+        },
+        {
+            .Key = CO_KEY(0x1603, 1, CO_UNSIGNED32 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = CO_LINK(0x2103, 0, 16),
+        },
+        {
+            .Key = CO_KEY(0x1603, 2, CO_UNSIGNED32 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = CO_LINK(0x2103, 1, 32),
+        },
+        {
+            .Key = CO_KEY(0x1603, 3, CO_UNSIGNED32 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = CO_LINK(0x2103, 2, 16),
+        },
+
+        /**
+         * RPDO4 mapping, determines the PDO messages to receive when RPDO4 is triggered
+         * 0: The number of PDO message associated with the RPDO
+         * 1: Link to the first PDO message - empty value
+         * 2: Link to the second PDO message - velocityActual
+         */
+        {
+            .Key = CO_KEY(0x1604, 0, CO_UNSIGNED8 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = (uintptr_t) 2,
+        },
+        {
+            .Key = CO_KEY(0x1604, 1, CO_UNSIGNED32 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = CO_LINK(0x2104, 0, 32),
+        },
+        {
+            .Key = CO_KEY(0x1604, 2, CO_UNSIGNED32 | CO_OBJ_D__R_),
+            .Type = nullptr,
+            .Data = CO_LINK(0x2104, 1, 32),
+        },
         /**
          * User defined data. Put elements that can be accessed via SDO
-         * and depdning on the configuration PDO
+         * and depending on the configuration PDO
          */
         {
             .Key = CO_KEY(0x2100, 0, CO_UNSIGNED32 | CO_OBJ___PRW),
@@ -281,19 +385,43 @@ class HUDL {
             .Type = nullptr,
             .Data = (uintptr_t) &totalVoltage,
         },
-
+        {
+            .Key = CO_KEY(0x2103, 0, CO_UNSIGNED16 | CO_OBJ___PRW),
+            .Type = nullptr,
+            .Data = (uintptr_t) &statusWord,
+        },
+        {
+            .Key = CO_KEY(0x2103, 1, CO_UNSIGNED32 | CO_OBJ___PRW),
+            .Type = nullptr,
+            .Data = (uintptr_t) &positionActual,
+        },
+        {
+            .Key = CO_KEY(0x2103, 2, CO_UNSIGNED16 | CO_OBJ___PRW),
+            .Type = nullptr,
+            .Data = (uintptr_t) &torqueActual,
+        },
+        {
+            .Key = CO_KEY(0x2104, 0, CO_UNSIGNED32 | CO_OBJ___PRW),
+            .Type = nullptr,
+            .Data = (uintptr_t) &rpdo4First32BitsDummyData,
+        },
+        {
+            .Key = CO_KEY(0x2104, 1, CO_UNSIGNED32 | CO_OBJ___PRW),
+            .Type = nullptr,
+            .Data = (uintptr_t) &velocityActual,
+        },
         CO_OBJ_DIR_ENDMARK,
     };
 
     static constexpr char* SECTION_TITLES[9]{
         "B Voltage",
-        "Speed",
+        "Velocity",
         "RPM",
         "Temp 1",
         "Temp 2",
         "Temp 3",
-        "Status 1",
-        "Pre Stat",
+        "MC Stat",
+        "Position",
         "Torque"};
 };
 
diff --git a/src/HUDL/HUDL.cpp b/src/HUDL/HUDL.cpp
@@ -36,30 +36,46 @@ uint16_t HUDL::getObjectDictionarySize() const {
 }
 
 void HUDL::updateLCD() {
-    char tempOne[32];
-    std::sprintf(tempOne, "%lu C", *(this->thermTemps + 0));
+    char temps[32][4];
+    for (int i = 0; i < sizeof(thermTemps) / sizeof(uint32_t); i++) {
+        std::sprintf(temps[i], "%d C", thermTemps[i]);
+    }
 
-    char tempTwo[32];
-    std::sprintf(tempTwo, "%lu C", *(this->thermTemps + 1));
+    char voltage[32];
+    std::sprintf(voltage, "%d v", totalVoltage);
 
-    char tempThree[32];
-    std::sprintf(tempThree, "%lu C", *(this->thermTemps + 2));
+    char status[32];
+    std::sprintf(status, "0x%X", statusWord);
 
-    char tempFour[32];
-    std::sprintf(tempFour, "%lu C", *(this->thermTemps + 3));
+    char position[32];
+    std::sprintf(position, "0x%X", positionActual);
 
-    char voltage[32];
-    std::sprintf(voltage, "%lu v", totalVoltage);
+    char torque[32];
+    std::sprintf(torque, "0x%X", torqueActual);
+
+    char velocity[32];
+    std::sprintf(velocity, "0x%X", velocityActual);
 
     lcd.setTextForSection(0, voltage);
-    //    setTextForSection(2g "25 MPH");
-    //    setTextForSection(2, "3000");
-    lcd.setTextForSection(3, tempOne);
-    lcd.setTextForSection(4, tempTwo);
-    lcd.setTextForSection(5, tempThree);
-    //    setTextForSection(6, "ON");
-    //    setTextForSection(7, "Ready");
-    //    setTextForSection(8, "100 NM");
+    lcd.setTextForSection(1, velocity);
+    lcd.setTextForSection(2, "3000");
+    lcd.setTextForSection(3, temps[0]);
+    lcd.setTextForSection(4, temps[1]);
+    lcd.setTextForSection(5, temps[2]);
+    lcd.setTextForSection(6, status);
+    lcd.setTextForSection(7, position);
+    lcd.setTextForSection(8, torque);
+
+    for (int i = 0; i < sizeof(thermTemps) / sizeof(uint32_t); i++) {
+        log::LOGGER.log(log::Logger::LogLevel::DEBUG, "Temp %d: %d\n\r", i, thermTemps[i]);
+    }
+    log::LOGGER.log(log::Logger::LogLevel::DEBUG, "Total Voltage: %d\n\r", totalVoltage);
+
+    log::LOGGER.log(log::Logger::LogLevel::DEBUG, "Status Word: 0x%X\n\r", statusWord);
+    log::LOGGER.log(log::Logger::LogLevel::DEBUG, "Position Actual: 0x%X\n\r", positionActual);
+    log::LOGGER.log(log::Logger::LogLevel::DEBUG, "Torque Actual: 0x%X\n\r", torqueActual);
+    log::LOGGER.log(log::Logger::LogLevel::DEBUG, "Velocity Value: 0x%X\n\r", velocityActual);
+    log::LOGGER.log(log::Logger::LogLevel::DEBUG, "Dummy Data: 0x%X\n\r", rpdo4First32BitsDummyData);
 }
 
 }// namespace HUDL
diff --git a/targets/HUDL/main.cpp b/targets/HUDL/main.cpp
@@ -131,8 +131,14 @@ int main() {
         log::LOGGER.log(log::Logger::LogLevel::ERROR, "Failed to connect to CAN network\r\n");
 
         return 1;
+    } else {
+        log::LOGGER.log(log::Logger::LogLevel::INFO, "Connected to CAN network\r\n");
     }
 
+    // Crashes the HUDL
+    //    IO::UART& uart = IO::getUART<IO::Pin::UART_TX, IO::Pin::UART_RX>(9600);
+    //    log::LOGGER.setUART(&uart);
+
     ///////////////////////////////////////////////////////////////////////////
     // Setup CAN configuration, this handles making drivers, applying settings.
     // And generally creating the CANopen stack node which is the interface
