CAN Rearchitecture (#337)

* CAN: got this tx signal mapping almost compiling

* CAN: More signal map work

* CAN: Got msg map working

* CAN: add mbed error warnings

* CAN: add dual CAN bus support, add simple test app

* CAN: use std::unordered_map::contains()

* CAN: add can filtering function

* CAN: start updating arm app

* CAN: migrate apps to new CAN library

* CAN: add switch CAN bus to apps, add PID tuning handler to science and gimbal

* CAN: fix multiple filters, revert to try_get(), add can_load_test script

* CAN: add diagnostic messages

* CAN: add test-stress-can app

* CAN: edit CAN diagnostics messages

* CAN: fix clang format

* CAN: make can load test script log streamed vs one-shots

* CAN: swap CAN 1 CAN 2 pins

* CAN: Add RX one-shot messages to msg map

* CAN: fix test-lookup-table

* CAN: kinda fix hw filter issue (TODO: fix mbed bug)

* CAN: fix bus switching

* CAN: minor fixes

* CAN: add safety check, fix signal value enum naming

* Add num CAN rx/tx faults signals to msg maps

* CAN: rebase master

* remove leftover lib folder

* CAN: fix test-can build errors

* Fix test-stress-can buld errors

* Update submodule commit

Author: cindyli-13

CMakeLists.txt

@@ -111,6 +111,7 @@ add_app_subdirectory(${TEST_APPS_DIR}/test-pid)
 add_app_subdirectory(${TEST_APPS_DIR}/test-pwm)
 add_app_subdirectory(${TEST_APPS_DIR}/test-pwmin)
 add_app_subdirectory(${TEST_APPS_DIR}/test-quadrature64cpr)
+add_app_subdirectory(${TEST_APPS_DIR}/test-stress-can)
 add_app_subdirectory(${TEST_APPS_DIR}/test-units)
 add_app_subdirectory(${TEST_APPS_DIR}/test-watchdog)
 

libs/can/CMakeLists.txt

@@ -21,8 +21,20 @@ add_library(CANBus STATIC)
 target_sources(CANBus PRIVATE src/CANBus.cpp)
 target_include_directories(CANBus PUBLIC include)
 target_link_libraries(CANBus
+        PRIVATE
+        uwrt-mars-rover-hw-bridge
+        mbed-os
+        )
+
+add_library(CANInterface STATIC)
+target_sources(CANInterface PRIVATE src/CANInterface.cpp)
+target_include_directories(CANInterface PUBLIC include)
+target_link_libraries(CANInterface
         PUBLIC
         mbed-os
+        mbed-events
         PRIVATE
         uwrt-mars-rover-hw-bridge
+        CANBus
+        CANMsg
         )

libs/can/include/CANBus.h

@@ -14,7 +14,7 @@ class CANBus : public CAN {
   /* Filter out incoming CAN msgs
    */
   int setFilter(HWBRIDGE::CANFILTER filter, CANFormat format = CANAny,
-                uint16_t mask = HWBRIDGE::ROVERCONFIG::ROVER_CANID_FILTER_MASK, int handle = 0);
+                uint16_t mask = HWBRIDGE::ROVER_CANID_FILTER_MASK, int handle = 0);
 
   can_t *getHandle();
 

libs/can/include/CANInterface.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include "CANBus.h"
+#include "CANMsg.h"
+#include "hw_bridge.h"
+#include "mbed.h"
+
+class CANInterface {
+ public:
+  typedef struct {
+    // CAN bus pins
+    PinName can1_RX;
+    PinName can1_TX;
+    PinName can2_RX;
+    PinName can2_TX;
+
+    // Message maps and handlers
+    HWBRIDGE::CANMsgMap *rxMsgMap;
+    HWBRIDGE::CANMsgMap *txMsgMap;
+    const CANMsg::CANMsgHandlerMap *rxOneShotMsgHandler;
+
+    // Bus frequency
+    uint32_t frequency_hz = HWBRIDGE::ROVER_CANBUS_FREQUENCY_HZ;
+  } Config;
+
+  // Initialize CAN interface
+  CANInterface(const Config &config);
+
+  // Queue up a one shot message to be sent
+  bool sendOneShotMessage(CANMsg &msg, Kernel::Clock::duration_u32 timeout);
+
+  // Update a TX CAN signal
+  bool setTXSignalValue(HWBRIDGE::CANID msgID, HWBRIDGE::CANSIGNAL signalName, HWBRIDGE::CANSignalValue_t signalValue);
+
+  // Read a RX CAN signal
+  bool getRXSignalValue(HWBRIDGE::CANID msgID, HWBRIDGE::CANSIGNAL signalName, HWBRIDGE::CANSignalValue_t &signalValue);
+
+  // Switch CAN bus
+  bool switchCANBus(HWBRIDGE::CANBUSID canBusID);
+
+  // Set CAN bus hw filter
+  bool setFilter(HWBRIDGE::CANFILTER filter, CANFormat format = CANStandard,
+                 uint16_t mask = HWBRIDGE::ROVER_CANID_FILTER_MASK, int handle = 0);
+
+  // For diagnostic purposes
+  uint32_t getNumStreamedMsgsReceived(void);
+  uint32_t getNumOneShotMsgsReceived(void);
+  uint32_t getNumStreamedMsgsSent(void);
+  uint32_t getNumOneShotMsgsSent(void);
+
+  uint16_t getNumCANRXFaults(void);
+  uint16_t getNumCANTXFaults(void);
+
+ private:
+  static constexpr osPriority RX_POSTMAN_THREAD_PRIORITY   = osPriorityRealtime;
+  static constexpr osPriority RX_CLIENT_THREAD_PRIORITY    = osPriorityAboveNormal;
+  static constexpr osPriority TX_PROCESSOR_THREAD_PRIORITY = osPriorityBelowNormal;
+  static constexpr std::chrono::milliseconds TX_INTERDELAY = 1ms;
+  static constexpr std::chrono::milliseconds TX_PERIOD     = 10ms;
+
+  void rxISR(void);
+  void rxPostman(void);
+  void rxClient(void);
+  void txProcessor(void);
+
+  CANBus m_CANBus1;
+  CANBus m_CANBus2;
+  CANBus *m_activeCANBus;
+
+  Thread m_rxPostmanThread;
+  Thread m_rxClientThread;
+  Thread m_txProcessorThread;
+
+  Mutex m_rxMutex;
+  Mutex m_txMutex;
+
+  Mail<CANMsg, 100> m_rxMailbox;
+  Mail<CANMsg, 32> m_txMailboxOneShot;
+  EventQueue m_rxEventQueue;
+
+  HWBRIDGE::CANMsgMap *m_rxMsgMap;
+  HWBRIDGE::CANMsgMap *m_txMsgMap;
+
+  const CANMsg::CANMsgHandlerMap *m_rxOneShotMsgHandler;
+
+  // For diagnostic purposes
+  uint32_t m_numStreamedMsgsReceived;
+  uint32_t m_numOneShotMsgsReceived;
+  uint32_t m_numStreamedMsgsSent;
+  uint32_t m_numOneShotMsgsSent;
+
+  uint16_t m_numCANRXFaults;
+  uint16_t m_numCANTXFaults;
+};

libs/can/include/CANMsg.h

@@ -8,11 +8,15 @@ class CANMsg : public CANMessage {
  private:
   using CAN_Message::id;
 
+  static mbed_error_status_t defaultCANMsgHandler(void) {
+    MBED_WARNING(MBED_MAKE_ERROR(MBED_MODULE_APPLICATION, MBED_ERROR_CODE_INVALID_ARGUMENT),
+                 "Invalid key to CANMsgHandlerMap");
+    return MBED_ERROR_CODE_INVALID_ARGUMENT;
+  }
+
  public:
-  using CANMsgHandler = mbed_error_status_t (*)(CANMsg &);
-  using CANMsgHandlerMap =
-      Utility::LookupTable<HWBRIDGE::CANID, CANMsg::CANMsgHandler,
-                           +[](CANMsg &) -> mbed_error_status_t { return MBED_ERROR_CODE_INVALID_ARGUMENT; }>;
+  using CANMsgHandler    = mbed_error_status_t (*)(void);
+  using CANMsgHandlerMap = Utility::LookupTable<HWBRIDGE::CANID, CANMsg::CANMsgHandler, &defaultCANMsgHandler>;
 
   template <class T>
   union CANPayload {
@@ -66,6 +70,14 @@ class CANMsg : public CANMessage {
     this->len              = sizeof(T);
   }
 
+  /** Set the payload data with custom length
+   */
+  template <class T>
+  void setPayload(const T value, size_t length) {
+    setPayload(value);
+    len = length;
+  }
+
   /** Get the payload data
    */
   template <class T>

libs/can/src/CANBus.cpp

@@ -10,4 +10,4 @@ int CANBus::setFilter(HWBRIDGE::CANFILTER canFilter, CANFormat format, uint16_t
 
 can_t *CANBus::getHandle() {
   return &_can;
-}
+}