esp32s2: Add canio

This works in loopback mode, though the hardware filtering only permits a
single address or mask filter.

Author: jepler

ports/esp32s2/Makefile

@@ -331,10 +331,10 @@ $(BUILD)/firmware.uf2: $(BUILD)/circuitpython-firmware.bin
 	$(Q)$(PYTHON3) $(TOP)/tools/uf2/utils/uf2conv.py -f 0xbfdd4eee -b 0x0000 -c -o $@ $^
 
 flash: $(BUILD)/firmware.bin
-	esptool.py --chip esp32s2 -p $(PORT) --no-stub -b 460800 --before=default_reset --after=hard_reset write_flash $(FLASH_FLAGS) 0x0000 $^
+	esptool.py --chip esp32s2 -p $(PORT) -b 460800 --before=default_reset --after=hard_reset write_flash $(FLASH_FLAGS) 0x0000 $^
 
 flash-circuitpython-only: $(BUILD)/circuitpython-firmware.bin
-	esptool.py --chip esp32s2 -p $(PORT) --no-stub -b 460800 --before=default_reset --after=hard_reset write_flash $(FLASH_FLAGS) 0x10000 $^
+	esptool.py --chip esp32s2 -p $(PORT) -b 460800 --before=default_reset --after=hard_reset write_flash $(FLASH_FLAGS) 0x10000 $^
 
 include $(TOP)/py/mkrules.mk
 

ports/esp32s2/boards/espressif_kaluga_1/mpconfigboard.mk

@@ -11,7 +11,7 @@ LONGINT_IMPL = MPZ
 CFLAGS += -DCFG_TUD_TASK_QUEUE_SZ=32
 
 CIRCUITPY_ESP_FLASH_MODE=dio
-CIRCUITPY_ESP_FLASH_FREQ=40m
+CIRCUITPY_ESP_FLASH_FREQ=80m
 CIRCUITPY_ESP_FLASH_SIZE=4MB
 
 CIRCUITPY_MODULE=wrover

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

@@ -0,0 +1,297 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+#include "common-hal/canio/CAN.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared-bindings/util.h"
+#include "supervisor/port.h"
+#include "hal/twai_ll.h"
+
+#include "hal/twai_types.h"
+
+STATIC bool reserved_can;
+
+twai_timing_config_t get_t_config(int baudrate) {
+    switch(baudrate) {
+    case 1000000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_1MBITS();
+        return t_config;
+    }
+    case 800000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_800KBITS();
+        return t_config;
+    }
+    case 500000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();
+        return t_config;
+    }
+    case 250000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_250KBITS();
+        return t_config;
+    }
+    case 125000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_125KBITS();
+        return t_config;
+    }
+    case 100000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_100KBITS();
+        return t_config;
+    }
+    case 50000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_50KBITS();
+        return t_config;
+    }
+    case 25000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_25KBITS();
+        return t_config;
+    }
+    case 20000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_20KBITS();
+        return t_config;
+    }
+    case 16000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_16KBITS();
+        return t_config;
+    }
+    case 12500:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_12_5KBITS();
+        return t_config;
+    }
+    case 10000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_10KBITS();
+        return t_config;
+    }
+    case 5000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_5KBITS();
+        return t_config;
+    }
+    case 1000:
+    {
+        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_1KBITS();
+        return t_config;
+    }
+    default:
+        mp_raise_ValueError(translate("Baudrate not supported by peripheral"));
+    }
+}
+
+__attribute__((optimize("O0")))
+void common_hal_canio_can_construct(canio_can_obj_t *self, mcu_pin_obj_t *tx, 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) {
+        mp_raise_ValueError(translate("All CAN peripherals are in use"));
+    }
+
+    if (loopback && silent) {
+        mp_raise_ValueError(translate("loopback + silent mode not supported by peripheral"));
+    }
+
+    self->t_config = get_t_config(baudrate);;
+    twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(-1, -1, TWAI_MODE_NORMAL);
+    g_config.tx_io = tx->number;
+    g_config.rx_io = rx->number;
+    if (loopback) {
+        g_config.mode = TWAI_MODE_NO_ACK;
+    }
+    if (silent) {
+        g_config.mode = TWAI_MODE_LISTEN_ONLY;
+    }
+    self->g_config = g_config;
+
+    {
+    twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();
+    self->f_config = f_config;
+    }
+
+    esp_err_t result = twai_driver_install(&self->g_config, &self->t_config, &self->f_config);
+    if (result == ESP_ERR_NO_MEM) {
+        mp_raise_msg(&mp_type_MemoryError, translate("ESP-IDF memory allocation failed"));
+    } else if (result == ESP_ERR_INVALID_ARG) {
+        mp_raise_ValueError(translate("Invalid pins"));
+    } else if (result != ESP_OK) {
+        mp_raise_OSError_msg_varg(translate("twai_driver_install returned esp-idf error #%d"), (int)result);
+    }
+
+    result = twai_start();
+    if (result != ESP_OK) {
+        mp_raise_OSError_msg_varg(translate("twai_start returned esp-idf error #%d"), (int)result);
+    }
+
+    self->silent = silent;
+    self->loopback = loopback;
+    self->baudrate = baudrate;
+    self->tx_pin = tx;
+    self->rx_pin = rx;
+
+    claim_pin(tx);
+    claim_pin(rx);
+
+    reserved_can = true;
+}
+
+bool common_hal_canio_can_loopback_get(canio_can_obj_t *self)
+{
+    return self->loopback;
+}
+
+int common_hal_canio_can_baudrate_get(canio_can_obj_t *self)
+{
+    return self->baudrate;
+}
+
+int common_hal_canio_can_transmit_error_count_get(canio_can_obj_t *self)
+{
+    twai_status_info_t info;
+    twai_get_status_info(&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);
+    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);
+    if (info.state == TWAI_STATE_BUS_OFF || info.state == TWAI_STATE_RECOVERING) {
+        return BUS_STATE_OFF;
+    }
+    if (info.tx_error_counter > 127 || info.rx_error_counter > 127) {
+        return BUS_STATE_ERROR_PASSIVE;
+    }
+    if (info.tx_error_counter > 96 || info.rx_error_counter > 96) {
+        return BUS_STATE_ERROR_WARNING;
+    }
+    return BUS_STATE_ERROR_ACTIVE;
+}
+
+static void can_restart(void) {
+    twai_status_info_t info;
+    twai_get_status_info(&info);
+    if (info.state != TWAI_STATE_BUS_OFF) {
+        return;
+    }
+    twai_initiate_recovery();
+    // 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);
+    } while (port_get_raw_ticks(NULL) < deadline && (info.state == TWAI_STATE_BUS_OFF || info.state == TWAI_STATE_RECOVERING));
+}
+
+void canio_maybe_auto_restart(canio_can_obj_t *self) {
+    if (self->auto_restart) can_restart();
+}
+
+void common_hal_canio_can_restart(canio_can_obj_t *self) {
+    if (!common_hal_canio_can_auto_restart_get(self)) {
+        can_restart();
+    }
+}
+
+bool common_hal_canio_can_auto_restart_get(canio_can_obj_t *self) {
+    return self->auto_restart;
+}
+
+void common_hal_canio_can_auto_restart_set(canio_can_obj_t *self, bool value) {
+    self->auto_restart = 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;
+    bool rtr = message->base.type == &canio_remote_transmission_request_type;
+    twai_message_t message_out = {
+        .extd = message->extended,
+        .rtr = rtr,
+        .self = self->loopback,
+        .identifier = message->id,
+        .data_length_code = message->size,
+    };
+    if (!rtr) {
+        memcpy(message_out.data, message->data, message->size);
+    }
+    // Allow transmission to occur in background
+    twai_transmit(&message_out, 0);
+}
+
+bool common_hal_canio_can_silent_get(canio_can_obj_t *self) {
+    return self->silent;
+}
+
+bool common_hal_canio_can_deinited(canio_can_obj_t *self) {
+    return !self->tx_pin;
+}
+
+void common_hal_canio_can_check_for_deinit(canio_can_obj_t *self) {
+    if (common_hal_canio_can_deinited(self)) {
+        raise_deinited_error();
+    }
+}
+
+void common_hal_canio_can_deinit(canio_can_obj_t *self)
+{
+    if (self->tx_pin) {
+        (void)twai_stop();
+        (void)twai_driver_uninstall();
+        reset_pin_number(self->tx_pin->number);
+        reset_pin_number(self->rx_pin->number);
+        reserved_can = false;
+    }
+    self->tx_pin = NULL;
+    self->rx_pin = NULL;
+}
+
+void common_hal_canio_reset(void) {
+    (void)twai_stop();
+    (void)twai_driver_uninstall();
+    reserved_can = false;
+}

ports/esp32s2/common-hal/canio/CAN.h

@@ -0,0 +1,52 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#pragma once
+
+#include "py/obj.h"
+#include "shared-bindings/canio/__init__.h"
+#include "shared-bindings/canio/CAN.h"
+#include "common-hal/microcontroller/Pin.h"
+#include "common-hal/canio/__init__.h"
+#include "shared-module/canio/Message.h"
+
+#include "driver/twai.h"
+
+#define FILTER_BANK_COUNT (28)
+
+typedef struct canio_can_obj {
+    mp_obj_base_t base;
+    int baudrate;
+    const mcu_pin_obj_t *rx_pin;
+    const mcu_pin_obj_t *tx_pin;
+    bool loopback:1;
+    bool silent:1;
+    bool auto_restart:1;
+    bool fifo_in_use:1;
+    twai_filter_config_t f_config;
+    twai_general_config_t g_config;
+    twai_timing_config_t t_config;
+} canio_can_obj_t;