Merge pull request #14688 from MubeenHCLite/CAN_rxinterrupt_fix

Solution for mutex problem in CAN read ISR

Author: 0xc0170

drivers/include/drivers/RawCAN.h

@@ -0,0 +1,94 @@
+/*
+ *  Copyright (C) 2021, STMicroelectronics, All Rights Reserved
+ *  SPDX-License-Identifier: Apache-2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may
+ *  not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef RAWCAN_H
+#define RAWCAN_H
+
+#include "platform/platform.h"
+#include "drivers/CAN.h"
+
+#if DEVICE_CAN || defined(DOXYGEN_ONLY)
+
+#include "interfaces/InterfaceCAN.h"
+#include "hal/can_api.h"
+#include "platform/Callback.h"
+#include "platform/PlatformMutex.h"
+
+namespace mbed {
+#ifndef FEATURE_EXPERIMENTAL_API
+class RawCAN: public CAN {
+public:
+    /** Creates an unlocked CAN interface connected to specific pins.
+     *
+     *  @param rd read from transmitter
+     *  @param td transmit to transmitter
+     *
+     * Example:
+     * @code
+     * #include "mbed.h"
+     *
+     *
+     * Ticker ticker;
+     * DigitalOut led1(LED1);
+     * DigitalOut led2(LED2);
+     * //The constructor takes in RX, and TX pin respectively.
+     * //These pins, for this example, are defined in mbed_app.json
+     * RawCAN can1(MBED_CONF_APP_CAN1_RD, MBED_CONF_APP_CAN1_TD);
+     * RawCAN can2(MBED_CONF_APP_CAN2_RD, MBED_CONF_APP_CAN2_TD);
+     *
+     * unsigned char counter = 0;
+     *
+     * void send() {
+     *     if(can1.write(CANMessage(1337U, &counter, 1))) {
+     *         printf("Message sent: %d\n", counter);
+     *         counter++;
+     *     }
+     *     led1 = !led1;
+     * }
+     *
+     * int main() {
+     *     ticker.attach(&send, 1);
+     *     CANMessage msg;
+     *     while(1) {
+     *         if(can2.read(msg)) {
+     *             printf("Message received: %d\n\n", msg.data[0]);
+     *             led2 = !led2;
+     *         }
+     *         ThisThread::sleep_for(200);
+     *     }
+     * }
+     *
+     * @endcode
+     */
+
+    /* Note: The can apis are unlocked hence using this when multiple
+    *  threads are accessing a single instance of CAN will lead to
+    *  race conditions, can be used in single threaded CAN.
+    */
+    using CAN::CAN;
+
+
+    // override lock apis to create unlocked CAN
+    void lock() override {};
+    void unlock() override {};
+
+};
+#endif //FEATURE_EXPERIMENTAL_API
+}
+
+#endif
+#endif //RAWCAN_H

mbed.h

@@ -68,6 +68,7 @@
 #include "drivers/I2C.h"
 #include "drivers/I2CSlave.h"
 #include "drivers/CAN.h"
+#include "drivers/RawCAN.h"
 #include "drivers/UnbufferedSerial.h"
 #include "drivers/BufferedSerial.h"
 #include "drivers/FlashIAP.h"

targets/TARGET_STM/README.md

@@ -528,6 +528,63 @@ For application that require optimized maximum performance, the recommendation i
 The SPI DMA transfer support shall be implemented on a case-by-case based on below example
 https://github.com/ABOSTM/mbed-os/tree/I2C_SPI_DMA_IMPLEMENTATION_FOR_STM32L4
 
+### CAN receive interrupt problem due to mutex and resolution
+
+In bxCAN and earlier versions the receive interrupt flags can be cleared only on performing a read operation in ST MCUs
+But can_read() cannot be used in interrupt context as it is gaurded by lock operation and mbed does not allow locks in 
+interrupt context. Hence the Rx interrupt is disabled for a while and read is deferred to thread context, the interrupt is
+enabled on a successful read.
+
+As an other option RawCAN (with unlocked CAN apis) is also available and can be used directly, if only one thread is accessing
+the CAN interface.
+
+While using RxInterrupt with the CAN object the receive ISR callback registered should defer read to thread context.
+A simple example is as shown below:
+
+#include "mbed.h"
+
+Ticker ticker;
+Thread canReadThread;
+
+DigitalOut led1(LED1);
+DigitalOut led2(LED2);
+DigitalOut led3(LED3);
+
+CAN can1(PD_0 ,PD_1);
+
+EventQueue queue(32 * EVENTS_EVENT_SIZE);
+
+int counter = 0xABCD;
+CANMessage msg;
+
+void canRead(){
+        if(can1.read(msg)) {
+            if(msg.id==1100)
+                led2 = !led2;
+            if(msg.id==1102){
+                led3 = !led3;
+            }
+        }
+}
+
+void canISR(){
+    queue.call(canRead);
+    led3 = !led3;
+}
+
+int main() {
+
+    can1.frequency(100000);
+    can1.mode(CAN::Normal);
+
+    can1.attach(canISR, CAN::RxIrq);
+
+    canReadThread.start(callback(&queue, &EventQueue::dispatch_forever));
+
+    while(1) {
+    }
+}
+
 
 ## Mbed OS Wiki pages
 

targets/TARGET_STM/TARGET_STM32F0/objects.h

@@ -156,6 +156,7 @@ struct can_s {
     CAN_HandleTypeDef CanHandle;
     int index;
     int hz;
+    int rxIrqEnabled;
 };
 #endif
 

targets/TARGET_STM/TARGET_STM32F1/objects.h

@@ -145,6 +145,7 @@ struct can_s {
     CAN_HandleTypeDef CanHandle;
     int index;
     int hz;
+    int rxIrqEnabled;
 };
 #endif
 

targets/TARGET_STM/TARGET_STM32F2/objects.h

@@ -154,6 +154,7 @@ struct can_s {
     CAN_HandleTypeDef CanHandle;
     int index;
     int hz;
+    int rxIrqEnabled;
 };
 #endif
 

targets/TARGET_STM/TARGET_STM32F3/objects.h

@@ -143,6 +143,7 @@ struct can_s {
     CAN_HandleTypeDef CanHandle;
     int index;
     int hz;
+    int rxIrqEnabled;
 };
 #endif
 

targets/TARGET_STM/TARGET_STM32F4/objects.h

@@ -158,6 +158,7 @@ struct can_s {
     CAN_HandleTypeDef CanHandle;
     int index;
     int hz;
+    int rxIrqEnabled;
 };
 #endif
 

targets/TARGET_STM/TARGET_STM32F7/objects.h

@@ -167,6 +167,7 @@ struct can_s {
     CAN_HandleTypeDef CanHandle;
     int index;
     int hz;
+    int rxIrqEnabled;
 };
 #endif
 

targets/TARGET_STM/TARGET_STM32L4/objects.h

@@ -157,6 +157,7 @@ struct can_s {
     CAN_HandleTypeDef CanHandle;
     int index;
     int hz;
+    int rxIrqEnabled;
 };
 #endif