277 lines
8.9 KiB
C
277 lines
8.9 KiB
C
/*
|
|
* 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_types.h"
|
|
|
|
STATIC bool reserved_can;
|
|
|
|
twai_timing_config_t get_t_config(int baudrate) {
|
|
switch (baudrate) {
|
|
case 1000000: {
|
|
// TWAI_TIMING_CONFIG_abc expands to a C designated initializer list
|
|
// { .brp = 4, ...}. This is only acceptable to the compiler as an
|
|
// initializer and 'return TWAI_TIMING_CONFIG_1MBITS()` is not valid.
|
|
// Instead, introduce a temporary, named variable and return it.
|
|
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"));
|
|
}
|
|
}
|
|
|
|
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"));
|
|
}
|
|
|
|
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);
|
|
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;
|
|
}
|
|
|
|
twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();
|
|
|
|
esp_err_t result = twai_driver_install(&g_config, &t_config, &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;
|
|
}
|