stm32: Add can_get_state() function, use from pyb.CAN.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>

Author: projectgus

ports/stm32/can.c

@@ -307,6 +307,25 @@ HAL_StatusTypeDef can_transmit(CAN_HandleTypeDef *hcan, CanTxMsgTypeDef *txmsg,
     }
 }
 
+can_state_t can_get_state(CAN_HandleTypeDef *can) {
+    uint32_t esr;
+
+    if (can->State == HAL_CAN_STATE_RESET) {
+        return CAN_STATE_STOPPED;
+    }
+
+    esr = can->Instance->ESR;
+    if (esr & CAN_ESR_BOFF) {
+        return CAN_STATE_BUS_OFF;
+    } else if (esr & CAN_ESR_EPVF) {
+        return CAN_STATE_ERROR_PASSIVE;
+    } else if (esr & CAN_ESR_EWGF) {
+        return CAN_STATE_ERROR_WARNING;
+    } else {
+        return CAN_STATE_ERROR_ACTIVE;
+    }
+}
+
 // Workaround for the __HAL_CAN macros expecting a CAN_HandleTypeDef which we
 // don't have in the ISR. Using this "fake" struct instead of CAN_HandleTypeDef
 // so it's not possible to accidentally call an API that uses one of the other

ports/stm32/can.h

@@ -101,6 +101,8 @@ void can_disable_rx_interrupts(CAN_HandleTypeDef *can, can_rx_fifo_t fifo);
 // Interrupt for CAN_INT_MESSAGE_RECEIVED is only enabled if enable_msg_received is set.
 void can_enable_rx_interrupts(CAN_HandleTypeDef *can, can_rx_fifo_t fifo, bool enable_msg_received);
 
+can_state_t can_get_state(CAN_HandleTypeDef *can);
+
 // Implemented in pyb_can.c, called from lower layer
 extern void can_irq_handler(uint can_id,  can_int_t interrupt, can_rx_fifo_t fifo);
 

ports/stm32/fdcan.c

@@ -359,6 +359,30 @@ int can_receive(FDCAN_HandleTypeDef *can, can_rx_fifo_t fifo, FDCAN_RxHeaderType
     return 0; // success
 }
 
+can_state_t can_get_state(CAN_HandleTypeDef *can) {
+    uint32_t psr;
+
+    if (can->State != HAL_FDCAN_STATE_BUSY) {
+        // The HAL states which map to "stopped" are:
+        // HAL_FDCAN_STATE_RESET - peripheral never initialised
+        // HAL_FDCAN_STATE_READY - CAN is stopped (i.e. HAL_FDCAN_CAN_Stop() called)
+        // HAL_FDCAN_STATE_ERROR - Internal transition timeout, mostly relates to
+        //                         low-power states we currently don't use
+        return CAN_STATE_STOPPED;
+    }
+
+    psr = can->Instance->PSR;
+    if (psr & FDCAN_PSR_BO) {
+        return CAN_STATE_BUS_OFF;
+    } else if (psr & FDCAN_PSR_EP) {
+        return CAN_STATE_ERROR_PASSIVE;
+    } else if (psr & FDCAN_PSR_EW) {
+        return CAN_STATE_ERROR_WARNING;
+    } else {
+        return CAN_STATE_ERROR_ACTIVE;
+    }
+}
+
 static void can_rx_irq_handler(uint can_id, CAN_TypeDef *instance, can_rx_fifo_t fifo) {
     uint32_t ints, rx_fifo_ints, error_ints;
 

ports/stm32/pyb_can.c

@@ -408,33 +408,11 @@ static MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_restart_obj, pyb_can_restart);
 // Get the state of the controller
 static mp_obj_t pyb_can_state(mp_obj_t self_in) {
     pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_int_t state = CAN_STATE_STOPPED;
     if (self->is_enabled) {
-        CAN_TypeDef *can = self->can.Instance;
-        #if MICROPY_HW_ENABLE_FDCAN
-        uint32_t psr = can->PSR;
-        if (psr & FDCAN_PSR_BO) {
-            state = CAN_STATE_BUS_OFF;
-        } else if (psr & FDCAN_PSR_EP) {
-            state = CAN_STATE_ERROR_PASSIVE;
-        } else if (psr & FDCAN_PSR_EW) {
-            state = CAN_STATE_ERROR_WARNING;
-        } else {
-            state = CAN_STATE_ERROR_ACTIVE;
-        }
-        #else
-        if (can->ESR & CAN_ESR_BOFF) {
-            state = CAN_STATE_BUS_OFF;
-        } else if (can->ESR & CAN_ESR_EPVF) {
-            state = CAN_STATE_ERROR_PASSIVE;
-        } else if (can->ESR & CAN_ESR_EWGF) {
-            state = CAN_STATE_ERROR_WARNING;
-        } else {
-            state = CAN_STATE_ERROR_ACTIVE;
-        }
-        #endif
+        return MP_OBJ_NEW_SMALL_INT(can_get_state(&self->can));
+    } else {
+        return MP_OBJ_NEW_SMALL_INT(CAN_STATE_STOPPED);
     }
-    return MP_OBJ_NEW_SMALL_INT(state);
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_state_obj, pyb_can_state);