Refactor CAN driver to support multiple instances

Author: ericbaril72

ports/espressif/common-hal/canio/CAN.c

@@ -16,7 +16,15 @@
 
 #include "hal/twai_types.h"
 
-static bool reserved_can;
+static byte reserved_can_instance; /* Bit assigned instances    0x01 (CAN0)  or 0x02 (CAN1)    0x00-NoneAssigned     0x03-Both Assigned*/
+
+#define TWAI0              REG_TWAI_BASE(0) /**< \brief (CAN0) APB Base Address */
+#define TWAI1              REG_TWAI_BASE(1) /**< \brief (CAN1) APB Base Address */
+#define TWAI_INST_NUM      2                          /**< \brief (CAN) Number of instances */
+
+static twai_handle_t twai_bus_0;
+static twai_handle_t twai_bus_1;
+static twai_handle_t *const twai_insts[TWAI_INST_NUM] = { &twai_bus_0, &twai_bus_1 };
 
 static twai_timing_config_t get_t_config(int baudrate) {
     switch (baudrate) {
@@ -100,18 +108,36 @@ static twai_timing_config_t get_t_config(int baudrate) {
 void common_hal_canio_can_construct(canio_can_obj_t *self, const mcu_pin_obj_t *tx, const mcu_pin_obj_t *rx, int baudrate, bool loopback, bool silent) {
 #define DIV_ROUND(a, b) (((a) + (b) / 2) / (b))
 #define DIV_ROUND_UP(a, b) (((a) + (b) - 1) / (b))
-    if (reserved_can) {
+    if (reserved_can_instance==3) {
         mp_raise_ValueError(MP_ERROR_TEXT("All CAN peripherals are in use"));
     }
 
     if (loopback && silent) {
         mp_raise_ValueError(MP_ERROR_TEXT("loopback + silent mode not supported by peripheral"));
     }
 
+    byte this_can_instance=0;
+    if (reserved_can_instance==0x00){   /* None assigned */
+        reserved_can_instance=0x01;     /* First instance is assigned*/ 
+        this_can_instance=0;            /* Idx of selected instance */
+    }
+    else if (reserved_can_instance==0x01) /* First instance allready assigned */
+    {
+        reserved_can_instance=0x03;     /* Second instance also assigned */
+        this_can_instance=1;            /* Idx of selected instance */
+
+    }else if (reserved_can_instance==0x02)  /* Second instance is assigned */
+    {
+        reserved_can_instance=0x03;     /* first instance also assigned*/ 
+        this_can_instance=0;            /* Idx of selected instance */
+    }
+    
     twai_timing_config_t t_config = get_t_config(baudrate);
-    twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(-1, -1, TWAI_MODE_NORMAL);
+    twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT_V2(this_can_instance,-1, -1, TWAI_MODE_NORMAL);
     g_config.tx_io = tx->number;
     g_config.rx_io = rx->number;
+    g_config.controller_id = this_can_instance;   /* To ease later de-initing of proper instance */
+
     if (loopback) {
         g_config.mode = TWAI_MODE_NO_ACK;
     }
@@ -120,17 +146,16 @@ void common_hal_canio_can_construct(canio_can_obj_t *self, const mcu_pin_obj_t *
     }
 
     twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();
-
-    esp_err_t result = twai_driver_install(&g_config, &t_config, &f_config);
+    esp_err_t result = twai_driver_install_v2(&g_config, &t_config, &f_config , twai_insts[this_can_instance]);
     if (result == ESP_ERR_NO_MEM) {
         mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("ESP-IDF memory allocation failed"));
     } else if (result == ESP_ERR_INVALID_ARG) {
         raise_ValueError_invalid_pins();
     } else if (result != ESP_OK) {
         mp_raise_OSError_msg_varg(MP_ERROR_TEXT("twai_driver_install returned esp-idf error #%d"), (int)result);
     }
-
-    result = twai_start();
+    
+    result = twai_start_v2(*twai_insts[this_can_instance]);
     if (result != ESP_OK) {
         mp_raise_OSError_msg_varg(MP_ERROR_TEXT("twai_start returned esp-idf error #%d"), (int)result);
     }
@@ -144,9 +169,15 @@ void common_hal_canio_can_construct(canio_can_obj_t *self, const mcu_pin_obj_t *
     claim_pin(tx);
     claim_pin(rx);
 
-    reserved_can = true;
+    self->twai_driver_handle = twai_insts[this_can_instance];
+    self->instance = this_can_instance;
+
+    
 }
 
+
+
+
 bool common_hal_canio_can_loopback_get(canio_can_obj_t *self) {
     return self->loopback;
 }
@@ -157,19 +188,21 @@ int common_hal_canio_can_baudrate_get(canio_can_obj_t *self) {
 
 int common_hal_canio_can_transmit_error_count_get(canio_can_obj_t *self) {
     twai_status_info_t info;
-    twai_get_status_info(&info);
+    twai_get_status_info_v2( *self->twai_driver_handle,&info);
     return info.tx_error_counter;
 }
 
 int common_hal_canio_can_receive_error_count_get(canio_can_obj_t *self) {
     twai_status_info_t info;
-    twai_get_status_info(&info);
+    twai_get_status_info_v2( *self->twai_driver_handle,&info);
     return info.rx_error_counter;
 }
 
+
 canio_bus_state_t common_hal_canio_can_state_get(canio_can_obj_t *self) {
     twai_status_info_t info;
-    twai_get_status_info(&info);
+    
+    twai_get_status_info_v2( *self->twai_driver_handle,&info);
     if (info.state == TWAI_STATE_BUS_OFF || info.state == TWAI_STATE_RECOVERING) {
         return BUS_STATE_OFF;
     }
@@ -182,29 +215,30 @@ canio_bus_state_t common_hal_canio_can_state_get(canio_can_obj_t *self) {
     return BUS_STATE_ERROR_ACTIVE;
 }
 
-static void can_restart(void) {
+
+static void can_restart(canio_can_obj_t *self) {
     twai_status_info_t info;
-    twai_get_status_info(&info);
+    twai_get_status_info_v2(*self->twai_driver_handle, &info);
     if (info.state != TWAI_STATE_BUS_OFF) {
         return;
     }
-    twai_initiate_recovery();
+    twai_initiate_recovery_v2(*self->twai_driver_handle);
     // wait 100ms (hard coded for now) for bus to recover
     uint64_t deadline = port_get_raw_ticks(NULL) + 100;
     do {
-        twai_get_status_info(&info);
+        twai_get_status_info_v2(*self->twai_driver_handle,&info);
     } while (port_get_raw_ticks(NULL) < deadline && (info.state == TWAI_STATE_BUS_OFF || info.state == TWAI_STATE_RECOVERING));
 }
 
 static void canio_maybe_auto_restart(canio_can_obj_t *self) {
     if (self->auto_restart) {
-        can_restart();
+        can_restart(self);
     }
 }
 
 void common_hal_canio_can_restart(canio_can_obj_t *self) {
     if (!common_hal_canio_can_auto_restart_get(self)) {
-        can_restart();
+        can_restart(self);
     }
 }
 
@@ -217,6 +251,9 @@ void common_hal_canio_can_auto_restart_set(canio_can_obj_t *self, bool value) {
     canio_maybe_auto_restart(self);
 }
 
+
+
+
 void common_hal_canio_can_send(canio_can_obj_t *self, mp_obj_t message_in) {
     canio_maybe_auto_restart(self);
     canio_message_obj_t *message = message_in;
@@ -232,7 +269,7 @@ void common_hal_canio_can_send(canio_can_obj_t *self, mp_obj_t message_in) {
         memcpy(message_out.data, message->data, message->size);
     }
     // Allow transmission to occur in background
-    twai_transmit(&message_out, 0);
+    twai_transmit_v2(*self->twai_driver_handle,&message_out, 0);
 }
 
 bool common_hal_canio_can_silent_get(canio_can_obj_t *self) {
@@ -251,18 +288,26 @@ void common_hal_canio_can_check_for_deinit(canio_can_obj_t *self) {
 
 void common_hal_canio_can_deinit(canio_can_obj_t *self) {
     if (self->tx_pin) {
-        (void)twai_stop();
-        (void)twai_driver_uninstall();
+        (void)twai_stop_v2(*self->twai_driver_handle);
+        (void)twai_driver_uninstall_v2(*self->twai_driver_handle);
         reset_pin_number(self->tx_pin->number);
         reset_pin_number(self->rx_pin->number);
-        reserved_can = false;
+
+        if (self->instance==0){
+            reserved_can_instance&=0x02; /* free first instance - clear 1st bit */
+        }else if (self->instance==1){
+            reserved_can_instance&=0x01; /* free second instance - clear 2nd bit */
+        }
+        
     }
     self->tx_pin = NULL;
     self->rx_pin = NULL;
 }
 
 void common_hal_canio_reset(void) {
-    (void)twai_stop();
-    (void)twai_driver_uninstall();
-    reserved_can = false;
+    (void)twai_stop_v2(*twai_insts[0]);
+    (void)twai_driver_uninstall_v2(*twai_insts[0]);
+    (void)twai_stop_v2(*twai_insts[1]);
+    (void)twai_driver_uninstall_v2(*twai_insts[1]);
+    reserved_can_instance=0; /* unassign both bits */
 }