lib/units: Add a method to initialize CAN.

Signed-off-by: Tinyu-Zhao <[email protected]>

Author: TinyuZhao

docs/en/refs/unit.can.ref

@@ -10,6 +10,9 @@
 
 .. |init.png| image:: https://m5stack.oss-cn-shenzhen.aliyuncs.com/mpy_docs/unit/can/init.png
 
+.. |init1.png| image:: https://m5stack.oss-cn-shenzhen.aliyuncs.com/mpy_docs/unit/can/init1.png
+
+
 .. |tx_example.png| image:: https://static-cdn.m5stack.com/mpy_docs/unit/can/tx_example.png
 
 .. |stickc_plus2_can_tx_example.m5f2| raw:: html

docs/en/units/can.rst

@@ -63,5 +63,27 @@ Constructors
 
         |init.png|
 
+.. class:: CANUnit(tx, rx, mode, prescaler=32, sjw=3, bs1=15, bs2=4, triple_sampling=False)
+    :no-index:
+    
+    Initialise the CAN bus with the given parameters:
+
+        - ``tx`` is the pin to use for transmitting data
+        - ``rx`` is the pin to use for receiving data
+        - ``mode`` is one of:  NORMAL, NO_ACKNOWLEDGE, LISTEN_ONLY
+        - ``prescaler`` is the value by which the CAN input clock is divided to generate the
+          nominal bit time quanta. The prescaler can be a value between 1 and 1024 inclusive
+          for classic CAN.
+        - ``sjw`` is the resynchronisation jump width in units of time quanta for nominal bits;
+          it can be a value between 1 and 4 inclusive for classic CAN.
+        - ``bs1`` defines the location of the sample point in units of the time quanta for nominal bits;
+          it can be a value between 1 and 16 inclusive for classic CAN.
+        - ``bs2`` defines the location of the transmit point in units of the time quanta for nominal bits;
+          it can be a value between 1 and 8 inclusive for classic CAN.
+        - ``triple_sampling`` is Enables triple sampling when the TWAI controller samples a bit
+
+    UIFLOW2:
+
+        |init1.png|
 
 CANUnit class inherits CAN class, See :ref:`hardware.CAN <hardware.CAN>` for more details.

m5stack/libs/unit/can.py

@@ -2,33 +2,54 @@
 #
 # SPDX-License-Identifier: MIT
 
-from m5can import CAN
-
-
-class CANUnit(CAN):
-    def __init__(self, port, mode, baudrate=125000):
-        timing_table = {
-            25000: (128, 16, 8, 3, False),
-            50000: (80, 15, 4, 3, False),
-            100000: (40, 15, 4, 3, False),
-            125000: (32, 15, 4, 3, False),
-            250000: (16, 15, 4, 3, False),
-            500000: (8, 15, 4, 3, False),
-            800000: (4, 16, 8, 3, False),
-            1000000: (4, 15, 4, 3, False),
-        }
-        timing = timing_table.get(baudrate)
+import m5can
+import sys
+
+if sys.platform != "esp32":
+    from typing import Literal
+
+
+class CANUnit(m5can.CAN):
+    _timing_table = {
+        # prescaler, sjw, bs1, bs2, triple_sampling
+        25000: (128, 3, 16, 8, False),
+        50000: (80, 3, 15, 4, False),
+        100000: (40, 3, 15, 4, False),
+        125000: (32, 3, 15, 4, False),
+        250000: (16, 3, 15, 4, False),
+        500000: (8, 3, 15, 4, False),
+        800000: (4, 3, 16, 8, False),
+        1000000: (4, 3, 15, 4, False),
+    }
+
+    def __init__(
+        self,
+        id: Literal[0, 1],
+        port: list | tuple = None,
+        mode: int = m5can.CAN.NORMAL,
+        *args,
+        **kwargs,
+    ):
+        if len(kwargs) == 1:
+            (prescaler, sjw, bs1, bs2, triple_sampling) = self._timing_table.get(
+                kwargs.get("baudrate")
+            )
+        elif len(args) == 5:
+            (prescaler, sjw, bs1, bs2, triple_sampling) = args
         super().__init__(
             0,
             mode,
             port[1],
             port[0],
-            timing[0],  # prescaler
-            timing[3],  # sjw
-            timing[1],  # bs1
-            timing[2],  # bs2
-            timing[4],  # triple_sampling
+            prescaler,
+            sjw,
+            bs1,
+            bs2,
+            triple_sampling,
         )
 
 
+# can_0 = CANUnit(0, (33, 32), CANUnit.NORMAL, baudrate=1000000)
+# can_0 = CANUnit(0, (33, 32), CANUnit.NORMAL, 4, 3, 15, 4, False)
+
 MiniCANUnit = CANUnit