canio: mimxrt10xx: Remove unused code and merge message functions

SamantazFox · SamantazFox · commit 608211014c14 · 2025-01-20T14:36:15.000+01:00
diff --git a/ports/mimxrt10xx/common-hal/canio/CAN.c b/ports/mimxrt10xx/common-hal/canio/CAN.c
@@ -383,11 +383,38 @@ void common_hal_canio_can_send(canio_can_obj_t *self, mp_obj_t message_in) {
     }
 
     canio_message_obj_t *message = message_in;
+
     flexcan_frame_t tx_frame;
-    if (!mimxrt_canio_message_obj_to_flexcan_frame(message, &tx_frame)) {
-        mp_raise_ValueError(MP_ERROR_TEXT("Unable to send CAN Message: missing or malformed canio message object"));
+    memset(&tx_frame, 0, sizeof(tx_frame)); // Zero out output.
+
+    if (message->extended) {
+        tx_frame.id = FLEXCAN_ID_EXT(message->id);
+        tx_frame.format = kFLEXCAN_FrameFormatExtend;
+    } else {
+        tx_frame.id = FLEXCAN_ID_STD(message->id);
+        tx_frame.format = kFLEXCAN_FrameFormatStandard;
+    }
+
+    if (message->base.type == &canio_remote_transmission_request_type) {
+        tx_frame.type = kFLEXCAN_FrameTypeRemote;
+    } else {
+        tx_frame.type = kFLEXCAN_FrameTypeData;
     }
 
+    tx_frame.length = message->size;
+
+    // We can safely copy all bytes, as both flexcan_frame_t and
+    // canio_message_obj_t define the data array as 8 bytes long,
+    // even if the actual DLC is shorter.
+    tx_frame.dataByte0 = message->data[0];
+    tx_frame.dataByte1 = message->data[1];
+    tx_frame.dataByte2 = message->data[2];
+    tx_frame.dataByte3 = message->data[3];
+    tx_frame.dataByte4 = message->data[4];
+    tx_frame.dataByte5 = message->data[5];
+    tx_frame.dataByte6 = message->data[6];
+    tx_frame.dataByte7 = message->data[7];
+
     flexcan_mb_transfer_t tx_xfer;
     tx_xfer.mbIdx = mimxrt10xx_flexcan_get_free_tx_mbid(self);
     tx_xfer.frame = &tx_frame;
diff --git a/ports/mimxrt10xx/common-hal/canio/Listener.c b/ports/mimxrt10xx/common-hal/canio/Listener.c
@@ -40,14 +40,15 @@
 #include "supervisor/shared/tick.h"
 #include "sdk/drivers/flexcan/fsl_flexcan.h"
 
-/*
-typedef struct {
-    mp_obj_base_t base;
-    int id;
-    int mask;
-    bool extended;
-} canio_match_obj_t;
-*/
+
+// Convert from back from FLEXCAN IDs to normal CAN IDs.
+#define FLEXCAN_ID_TO_CAN_ID_STD(id) \
+    ((uint32_t)((((uint32_t)(id)) & CAN_ID_STD_MASK) >> CAN_ID_STD_SHIFT))
+
+#define FLEXCAN_ID_TO_CAN_ID_EXT(id) \
+    ((uint32_t)((((uint32_t)(id)) & (CAN_ID_STD_MASK | CAN_ID_EXT_MASK)) \
+    >> CAN_ID_EXT_SHIFT))
+
 
 void common_hal_canio_listener_construct(canio_listener_obj_t *self, canio_can_obj_t *can, size_t nmatch, canio_match_obj_t **matches, float timeout) {
 
@@ -140,10 +141,35 @@ mp_obj_t common_hal_canio_listener_receive(canio_listener_obj_t *self) {
     FLEXCAN_ClearMbStatusFlags(self->can->data->base, (uint32_t)kFLEXCAN_RxFifoFrameAvlFlag);
 
     canio_message_obj_t *message = m_new_obj(canio_message_obj_t);
-    if (!mimxrt_flexcan_frame_to_canio_message_obj(&rx_frame, message)) {
-        mp_raise_ValueError(MP_ERROR_TEXT("Unable to receive CAN Message: missing or malformed flexcan frame"));
+    memset(message, 0, sizeof(canio_message_obj_t));
+
+    if (rx_frame.format == kFLEXCAN_FrameFormatExtend) {
+        message->extended = true;
+        message->id = rx_frame.id;
+    } else {
+        message->extended = false;
+        message->id = rx_frame.id >> 18; // standard ids are left-aligned
     }
 
+    if (rx_frame.type == kFLEXCAN_FrameTypeRemote) {
+        message->base.type = &canio_remote_transmission_request_type;
+    } else {
+        message->base.type = &canio_message_type;
+    }
+
+    message->size = rx_frame.length;
+
+    // We can safely copy all bytes, as both flexcan_frame_t and
+    // canio_message_obj_t define the data array as 8 bytes long.
+    message->data[0] = rx_frame.dataByte0;
+    message->data[1] = rx_frame.dataByte1;
+    message->data[2] = rx_frame.dataByte2;
+    message->data[3] = rx_frame.dataByte3;
+    message->data[4] = rx_frame.dataByte4;
+    message->data[5] = rx_frame.dataByte5;
+    message->data[6] = rx_frame.dataByte6;
+    message->data[7] = rx_frame.dataByte7;
+
     return message;
 }
 
diff --git a/ports/mimxrt10xx/common-hal/canio/__init__.c b/ports/mimxrt10xx/common-hal/canio/__init__.c
@@ -25,79 +25,3 @@
  */
 
 #include "common-hal/canio/__init__.h"
-#include "shared-bindings/canio/RemoteTransmissionRequest.h"
-
-// Convert from back from FLEXCAN IDs to normal CAN IDs.
-#define FLEXCAN_ID_TO_CAN_ID_STD(id) \
-    ((uint32_t)((((uint32_t)(id)) & CAN_ID_STD_MASK) >> CAN_ID_STD_SHIFT))
-
-#define FLEXCAN_ID_TO_CAN_ID_EXT(id) \
-    ((uint32_t)((((uint32_t)(id)) & (CAN_ID_STD_MASK | CAN_ID_EXT_MASK)) \
-    >> CAN_ID_EXT_SHIFT))
-
-bool mimxrt_canio_message_obj_to_flexcan_frame(canio_message_obj_t *src, flexcan_frame_t *dst)
-{
-    memset(dst, 0, sizeof(*dst)); // Zero out output.
-    if (src == NULL) return false; // Missing input.
-
-    if (src->extended) { // CAN Frame Identifier (STD or EXT format).
-        dst->id = FLEXCAN_ID_EXT(src->id); // CAN Frame Identifier (EXT).
-        dst->format = kFLEXCAN_FrameFormatExtend;
-    } else {
-        dst->id = FLEXCAN_ID_STD(src->id); // CAN Frame Identifier (STD).
-        dst->format = kFLEXCAN_FrameFormatStandard;
-    }
-
-    bool rtr = src->base.type == &canio_remote_transmission_request_type;
-    if (rtr) { // CAN Frame Type(DATA or REMOTE).
-        dst->type = kFLEXCAN_FrameTypeRemote;
-    } else {
-        dst->type = kFLEXCAN_FrameTypeData;
-    }
-
-    dst->length = src->size; // CAN frame data length in bytes (Range: 0~8). 
-
-    dst->dataByte0 = src->data[0];
-    dst->dataByte1 = src->data[1];
-    dst->dataByte2 = src->data[2];
-    dst->dataByte3 = src->data[3];
-    dst->dataByte4 = src->data[4];
-    dst->dataByte5 = src->data[5];
-    dst->dataByte6 = src->data[6];
-    dst->dataByte7 = src->data[7];
-
-    return true;
-}
-
-bool mimxrt_flexcan_frame_to_canio_message_obj(flexcan_frame_t *src, canio_message_obj_t *dst)
-{
-    memset(dst, 0, sizeof(*dst)); // Zero out output.
-    if (src == NULL) return false; // Missing input.
-
-    if (src->format == kFLEXCAN_FrameFormatExtend) { // CAN Frame Identifier (STD or EXT format).
-        dst->extended = true;
-        dst->id = FLEXCAN_ID_TO_CAN_ID_EXT(src->id); // CAN Frame Identifier (EXT).
-    } else {
-        dst->extended = false;
-        dst->id = FLEXCAN_ID_TO_CAN_ID_STD(src->id); // CAN Frame Identifier (STD).
-    }
-
-    if (src->type == kFLEXCAN_FrameTypeRemote) { // CAN Frame Type(DATA or REMOTE).
-        dst->base.type = &canio_remote_transmission_request_type;
-    } else {
-        dst->base.type = &canio_message_type;
-    }
-
-    dst->size = src->length; // CAN frame data length in bytes (Range: 0~8). 
-
-    dst->data[0] = src->dataByte0;
-    dst->data[1] = src->dataByte1;
-    dst->data[2] = src->dataByte2;
-    dst->data[3] = src->dataByte3;
-    dst->data[4] = src->dataByte4;
-    dst->data[5] = src->dataByte5;
-    dst->data[6] = src->dataByte6;
-    dst->data[7] = src->dataByte7;
-
-    return true;
-}
diff --git a/ports/mimxrt10xx/common-hal/canio/__init__.h b/ports/mimxrt10xx/common-hal/canio/__init__.h
@@ -29,10 +29,6 @@
 #include "shared-module/canio/Message.h"
 #include "sdk/drivers/flexcan/fsl_flexcan.h"
 
-typedef struct canio_listener canio_listener_t;
-typedef struct canio_can canio_can_t;
-typedef uint32_t canio_can_filter_t;
-
 // There are 64 message buffers in each mimxrt10xx chip.
 // Rx fifo will use the message buffers at the front (from index zero).
 // As far as I can see rx fifo uses message buffer 0 to 5.
@@ -75,7 +71,3 @@ typedef struct {
     uint8_t tx_state;
     uint32_t rx_fifo_filter[MIMXRT10XX_FLEXCAN_RX_FILTER_COUNT];
 } mimxrt10xx_flexcan_data_t;
-
-bool mimxrt_canio_message_obj_to_flexcan_frame(canio_message_obj_t *src, flexcan_frame_t *dst);
-bool mimxrt_flexcan_frame_to_canio_message_obj(flexcan_frame_t *src, canio_message_obj_t *dst);
-
diff --git a/ports/mimxrt10xx/tools/gen_peripherals_data.py b/ports/mimxrt10xx/tools/gen_peripherals_data.py
@@ -182,7 +182,6 @@ def rename_instance(instance:str)-> str:
                     continue
                 alt = int(alt[3:])
                 value = int(evalue.find("value").text, 0)
-                #print(f"instance: {instance}, signal: {signal}, pin_name: {pin_name}")
                 peripheral_inputs[instance][signal][pin_name] = [alt, name, value]
         # Mux registers come before PAD registers.
         elif name.startswith("SW_MUX_CTL_PAD_GPIO"):
@@ -325,7 +324,6 @@ def rename_instance(instance:str)-> str:
         for signal in SIGNALS[ptype]:
             pin_count = 0
             for instance in instances:
-                ###print(f"instance: {instance}")
                 if instance not in peripheral_inputs or signal not in peripheral_inputs[instance]:
                     continue
                 pin_count += len(peripheral_inputs[instance][signal])
