reimplement CANCommClass using Arduino_CAN library

Author: leonardocavagnis

examples/CAN/ReadCan/ReadCan.ino

@@ -11,35 +11,25 @@
 */
 #include <Arduino_MachineControl.h>
 
-#define DATARATE_2MB     2000000
-#define DATARATE_1_5MB   1500000
-#define DATARATE_1MB     1000000
-#define DATARATE_800KB   800000
-
-void setup() {
+void setup()
+{
   Serial.begin(9600);
   while (!Serial) {
     ; // wait for serial port to connect.
   }
 
-  Serial.println("Start CAN initialization");
-  MachineControl_CANComm.begin(DATARATE_800KB);
-
-  Serial.println("Initialization done");
+  if (!MachineControl_CANComm.begin(CanBitRate::BR_500k))
+  {
+    Serial.println("CAN init failed.");
+    for (;;) {}
+  }
 }
 
-void loop() {
-  mbed::CANMessage msg;
-  if (MachineControl_CANComm.read(msg)) {
-
-    // Print the sender ID
-    Serial.print("ID: ");
-    Serial.println(msg.id);
-
-    // Print the first Payload Byte
-    Serial.print("Message received:");
-    Serial.println(msg.data[0], DEC);
+void loop()
+{
+  if (MachineControl_CANComm.available())
+  {
+    CanMsg const msg = MachineControl_CANComm.read();
+    Serial.println(msg);
   }
-
-  delay(100);
 }

examples/CAN/WriteCan/WriteCan.ino

@@ -11,37 +11,46 @@
 */
 #include <Arduino_MachineControl.h>
 
-#define DATARATE_2MB     2000000
-#define DATARATE_1_5MB   1500000
-#define DATARATE_1MB     1000000
-#define DATARATE_800KB   800000
+static uint32_t const CAN_ID = 13ul;
 
-void setup() {
+void setup()
+{
   Serial.begin(9600);
   while (!Serial) {
     ; // wait for serial port to connect.
   }
 
-  Serial.println("Start CAN initialization");
-
-  MachineControl_CANComm.begin(DATARATE_800KB);
-  Serial.println("Initialization done");
+  if (!MachineControl_CANComm.begin(CanBitRate::BR_500k))
+  {
+    Serial.println("CAN init failed.");
+    for (;;) {}
+  }
 }
 
-int counter = 0;
-unsigned char payload = 0x49;
-int payload_size = 1;
+static uint32_t msg_cnt = 0;
+
+void loop()
+{
+  /* Assemble a CAN message */
+  uint8_t const msg_data[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08};
+  memcpy((void *)(msg_data + 8), &msg_cnt, sizeof(msg_cnt));
+  CanMsg msg(CAN_ID, sizeof(msg_data), msg_data);
+
+  /* Transmit the CAN message, capture and display an
+   * error core in case of failure.
+   */
+  if (int const rc = MachineControl_CANComm.write(msg); rc <= 0)
+  {
+    Serial.print  ("CAN write failed with error code ");
+    Serial.println(rc);
+    for (;;) { }
+  }
 
-void loop() {
+  Serial.println("CAN write message!");
 
-  mbed::CANMessage msg = mbed::CANMessage(13ul, &payload, payload_size);
-  if (MachineControl_CANComm.write(msg)) {
-    Serial.println("Message sent");
-  } else {
-    Serial.println("Transmission Error: ");
-    Serial.println(MachineControl_CANComm.tderror());
-    MachineControl_CANComm.reset();
-  }
+  /* Increase the message counter. */
+  msg_cnt++;
 
-  delay(100);
-}
+  /* Only send one message per second. */
+  delay(1000);
+}

src/CANCommClass.cpp

@@ -8,33 +8,45 @@
 #include "CANCommClass.h"
 
 /* Functions -----------------------------------------------------------------*/
-CANCommClass::CANCommClass(PinName can_tx_pin, PinName can_rx_pin) :
-			mbed::CAN(can_tx_pin, can_rx_pin)
+CANCommClass::CANCommClass(PinName can_tx_pin, PinName can_rx_pin, PinName can_stb_pin) :
+			_can(can_rx_pin, can_tx_pin), _tx{can_tx_pin}, _rx{can_rx_pin}, _stb{can_stb_pin}
 { }
 
 CANCommClass::~CANCommClass() 
 { }
 
-bool CANCommClass::begin(int can_bitrate) {
-	pinMode(PinNameToIndex(PA_13), OUTPUT); //Disable CAN pin
-	pinMode(PinNameToIndex(PB_8), OUTPUT);
-	pinMode(PinNameToIndex(PH_13), OUTPUT);
+bool CANCommClass::begin(CanBitRate can_bitrate) {
+	pinMode(PinNameToIndex(_stb), OUTPUT);
 
 	_enable();
 
-	return mbed::CAN::frequency(can_bitrate);
+	return _can.begin(can_bitrate);
+}
+
+int CANCommClass::write(CanMsg const & msg) {
+	return _can.write(msg);
+}
+
+size_t CANCommClass::available() {
+	return _can.available();
+}
+
+CanMsg CANCommClass::read() {
+	return _can.read();
 }
 
 void CANCommClass::end() {
 	_disable();
+
+	_can.end();
 }
 
 void CANCommClass::_enable() {
-	digitalWrite(PinNameToIndex(PA_13), LOW);
+	digitalWrite(PinNameToIndex(_stb), LOW);
 }
 
 void CANCommClass::_disable() {
-	digitalWrite(PinNameToIndex(PA_13), HIGH);
+	digitalWrite(PinNameToIndex(_stb), HIGH);
 }
 
 CANCommClass MachineControl_CANComm;

src/CANCommClass.h

@@ -14,17 +14,17 @@
 #include <Arduino.h>
 #include <pinDefinitions.h>
 #include <mbed.h>
+#include <Arduino_CAN.h>
 
 /* Class ----------------------------------------------------------------------*/
 
 /**
  * @class CANCommClass
  * @brief Class for managing the CAN Bus communication protocol of the Portenta Machine Control.
  *
- * The `CANCommClass` is a subclass of `mbed::CAN` and provides methods to work with the CAN Bus communication protocol on the Portenta Machine Control board.
- * It includes initialization of the corresponding LED for CAN.
+ * The `CANCommClass` provides methods to work with the CAN Bus communication protocol on the Portenta Machine Control board.
  */
-class CANCommClass: public mbed::CAN { //TODO: Check ARDUINO API VERSION to use Arduino_CAN
+class CANCommClass {
     public:
         /**
          * @brief Construct a CANCommClass object.
@@ -33,8 +33,9 @@ class CANCommClass: public mbed::CAN { //TODO: Check ARDUINO API VERSION to use
          *
          * @param can_tx_pin The pin for transmitting data on the CAN Bus.
          * @param can_rx_pin The pin for receiving data on the CAN Bus.
+         * @param can_stb_pin The pin to control the standby (low-power) mode of the CAN transceiver.
          */
-        CANCommClass(PinName can_tx_pin = PB_8, PinName can_rx_pin = PH_13);
+        CANCommClass(PinName can_tx_pin = PB_8, PinName can_rx_pin = PH_13, PinName can_stb_pin = PA_13);
 
         /**
          * @brief Destruct the CANCommClass object.
@@ -46,12 +47,40 @@ class CANCommClass: public mbed::CAN { //TODO: Check ARDUINO API VERSION to use
         /**
          * @brief Begin the CAN communication protocol.
          *
-         * This method initializes the CAN communication protocol, including the corresponding LED for CAN.
+         * This method initializes the CAN communication protocol.
          *
          * @param can_bitrate The desired bitrate for the CAN communication protocol.
          * @return true If the initialization is successful, false otherwise.
          */
-        bool begin(int can_bitrate);
+        bool begin(CanBitRate can_bitrate);
+
+        /**
+         * @brief Write a CAN message to the bus.
+         *
+         * This method sends a CAN message over the bus.
+         *
+         * @param msg The CAN message to be sent, represented by a `CanMsg` object.
+         * @return The number of bytes sent or <=0 in case of an error.
+         */
+        int write(CanMsg const & msg);
+        
+        /**
+         * @brief Check the number of available CAN messages in the receive buffer.
+         *
+         * This method checks the number of CAN messages available to read from the bus.
+         *
+         * @return The number of available CAN messages.
+         */
+        size_t available();
+        
+        /**
+         * @brief Read a CAN message from the bus.
+         *
+         * This method reads a CAN message from the receive buffer.
+         *
+         * @return The received CAN message as a `CanMsg` object.
+         */
+        CanMsg read();
 
         /**
          * @brief Close the CAN communication protocol.
@@ -61,6 +90,11 @@ class CANCommClass: public mbed::CAN { //TODO: Check ARDUINO API VERSION to use
         void end();
 
     private:
+        Arduino_CAN _can;
+        PinName _tx;
+        PinName _rx;
+        PinName _stb;
+
         /**
          * @brief Set the CAN transceiver in Normal mode.
          *
@@ -81,4 +115,4 @@ class CANCommClass: public mbed::CAN { //TODO: Check ARDUINO API VERSION to use
 
 extern CANCommClass MachineControl_CANComm;
 
-#endif /* __CAN_COMM_CLASS_H */
+#endif /* __CAN_COMM_CLASS_H */