github
/
micropython
mirror of https://github.com/micropython/micropython.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

esp32/machine_uart: Implement UART.RX_IDLE based on machine.Timer. 

The UART.IRQ_IDLE callback is called about two character times after the
last byte, or 1 ms, whichever is larger.  For the irq, timer 0 is used.

machine_timer.c had to be reworked to make it's mechanisms available for
machine_uart.c.

The irq.flags() value is change only at a requested event.  Otherwise keep
the state.

Signed-off-by: robert-hh <robert@hammelrath.com>
pull/14041/head
robert-hh 4 months ago
committed by Damien George
parent
7045975d04
commit
a38b4f4287
3 changed files with 173 additions and 35 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 49
      ports/esp32/machine_timer.c
  2. 66
      ports/esp32/machine_timer.h
  3. 93
      ports/esp32/machine_uart.c

49
ports/esp32/machine_timer.c
View File

@ -38,6 +38,7 @@
#include "hal/timer_hal.h"
#include "hal/timer_ll.h"
#include "soc/timer_periph.h"
#include "machine_timer.h"
#define TIMER_DIVIDER 8
@ -46,27 +47,8 @@
#define TIMER_FLAGS 0
typedef struct _machine_timer_obj_t {
mp_obj_base_t base;
timer_hal_context_t hal_context;
mp_uint_t group;
mp_uint_t index;
mp_uint_t repeat;
// ESP32 timers are 64 or 54-bit
uint64_t period;
mp_obj_t callback;
intr_handle_t handle;
struct _machine_timer_obj_t *next;
} machine_timer_obj_t;
const mp_obj_type_t machine_timer_type;
static void machine_timer_disable(machine_timer_obj_t *self);
static mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
void machine_timer_deinit_all(void) {
@ -91,18 +73,17 @@ static void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_pr
#endif
}
static mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
machine_timer_obj_t *machine_timer_create(mp_uint_t timer) {
machine_timer_obj_t *self = NULL;
#if CONFIG_IDF_TARGET_ESP32C3
mp_uint_t group = mp_obj_get_int(args[0]) & 1;
mp_uint_t group = timer & 1;
mp_uint_t index = 0;
#else
mp_uint_t group = (mp_obj_get_int(args[0]) >> 1) & 1;
mp_uint_t index = mp_obj_get_int(args[0]) & 1;
mp_uint_t group = (timer >> 1) & 1;
mp_uint_t index = timer & 1;
#endif
machine_timer_obj_t *self = NULL;
// Check whether the timer is already initialized, if so use it
for (machine_timer_obj_t *t = MP_STATE_PORT(machine_timer_obj_head); t; t = t->next) {
if (t->group == group && t->index == index) {
@ -120,6 +101,14 @@ static mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
self->next = MP_STATE_PORT(machine_timer_obj_head);
MP_STATE_PORT(machine_timer_obj_head) = self;
}
return self;
}
static mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
// Create the new timer.
machine_timer_obj_t *self = machine_timer_create(mp_obj_get_int(args[0]));
if (n_args > 1 || n_kw > 0) {
mp_map_t kw_args;
@ -130,7 +119,7 @@ static mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
return self;
}
static void machine_timer_disable(machine_timer_obj_t *self) {
void machine_timer_disable(machine_timer_obj_t *self) {
if (self->hal_context.dev != NULL) {
// Disable the counter and alarm.
timer_ll_enable_counter(self->hal_context.dev, self->index, false);
@ -162,7 +151,7 @@ static void machine_timer_isr(void *self_in) {
}
}
static void machine_timer_enable(machine_timer_obj_t *self) {
void machine_timer_enable(machine_timer_obj_t *self, void (*timer_isr)) {
// Initialise the timer.
timer_hal_init(&self->hal_context, self->group, self->index);
timer_ll_enable_counter(self->hal_context.dev, self->index, false);
@ -176,7 +165,7 @@ static void machine_timer_enable(machine_timer_obj_t *self) {
timer_ll_clear_intr_status(self->hal_context.dev, TIMER_LL_EVENT_ALARM(self->index));
ESP_ERROR_CHECK(
esp_intr_alloc(timer_group_periph_signals.groups[self->group].timer_irq_id[self->index],
TIMER_FLAGS, machine_timer_isr, self, &self->handle)
TIMER_FLAGS, timer_isr, self, &self->handle)
);
timer_ll_enable_intr(self->hal_context.dev, TIMER_LL_EVENT_ALARM(self->index), true);
@ -234,7 +223,7 @@ static mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n
self->callback = args[ARG_callback].u_obj;
self->handle = NULL;
machine_timer_enable(self);
machine_timer_enable(self, machine_timer_isr);
return mp_const_none;
}

66
ports/esp32/machine_timer.h
View File

@ -0,0 +1,66 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2013-2015 Damien P. George
* Copyright (c) 2016 Paul Sokolovsky
*
* 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.
*/
#ifndef MICROPY_INCLUDED_ESP32_MACHINE_TIMER_H
#define MICROPY_INCLUDED_ESP32_MACHINE_TIMER_H
#include "hal/timer_hal.h"
#include "hal/timer_ll.h"
#include "soc/timer_periph.h"
#define TIMER_DIVIDER 8
// TIMER_BASE_CLK is normally 80MHz. TIMER_DIVIDER ought to divide this exactly
#define TIMER_SCALE (APB_CLK_FREQ / TIMER_DIVIDER)
#define TIMER_FLAGS 0
typedef struct _machine_timer_obj_t {
mp_obj_base_t base;
timer_hal_context_t hal_context;
mp_uint_t group;
mp_uint_t index;
mp_uint_t repeat;
// ESP32 timers are 64-bit
uint64_t period;
mp_obj_t callback;
intr_handle_t handle;
struct _machine_timer_obj_t *next;
} machine_timer_obj_t;
machine_timer_obj_t *machine_timer_create(mp_uint_t timer);
void machine_timer_enable(machine_timer_obj_t *self, void (*timer_isr));
void machine_timer_disable(machine_timer_obj_t *self);
#endif // MICROPY_INCLUDED_ESP32_MACHINE_TIMER_H

93
ports/esp32/machine_uart.c
View File

@ -39,6 +39,7 @@
#include "py/mperrno.h"
#include "py/mphal.h"
#include "uart.h"
#include "machine_timer.h"
#if SOC_UART_SUPPORT_XTAL_CLK
// Works independently of APB frequency, on ESP32C3, ESP32S3.
@ -54,8 +55,17 @@
#define UART_INV_MASK (UART_INV_TX | UART_INV_RX | UART_INV_RTS | UART_INV_CTS)
#define UART_IRQ_RX (1 << UART_DATA)
#define UART_IRQ_RXIDLE (0x1000)
#define UART_IRQ_BREAK (1 << UART_BREAK)
#define MP_UART_ALLOWED_FLAGS (UART_IRQ_RX | UART_IRQ_BREAK)
#define MP_UART_ALLOWED_FLAGS (UART_IRQ_RX | UART_IRQ_RXIDLE | UART_IRQ_BREAK)
#define RXIDLE_TIMER_MIN (5000) // 500 us
enum {
RXIDLE_INACTIVE,
RXIDLE_STANDBY,
RXIDLE_ARMED,
RXIDLE_ALERT,
};
typedef struct _machine_uart_obj_t {
mp_obj_base_t base;
@ -78,6 +88,9 @@ typedef struct _machine_uart_obj_t {
uint16_t mp_irq_trigger; // user IRQ trigger mask
uint16_t mp_irq_flags; // user IRQ active IRQ flags
mp_irq_obj_t *mp_irq_obj; // user IRQ object
machine_timer_obj_t *rxidle_timer;
uint8_t rxidle_state;
uint16_t rxidle_period;
} machine_uart_obj_t;
static const char *_parity_name[] = {"None", "1", "0"};
@ -93,28 +106,67 @@ static const char *_parity_name[] = {"None", "1", "0"};
{ MP_ROM_QSTR(MP_QSTR_RTS), MP_ROM_INT(UART_HW_FLOWCTRL_RTS) }, \
{ MP_ROM_QSTR(MP_QSTR_CTS), MP_ROM_INT(UART_HW_FLOWCTRL_CTS) }, \
{ MP_ROM_QSTR(MP_QSTR_IRQ_RX), MP_ROM_INT(UART_IRQ_RX) }, \
{ MP_ROM_QSTR(MP_QSTR_IRQ_RXIDLE), MP_ROM_INT(UART_IRQ_RXIDLE) }, \
{ MP_ROM_QSTR(MP_QSTR_IRQ_BREAK), MP_ROM_INT(UART_IRQ_BREAK) }, \
static void uart_timer_callback(void *self_in) {
machine_timer_obj_t *self = self_in;
uint32_t intr_status = timer_ll_get_intr_status(self->hal_context.dev);
if (intr_status & TIMER_LL_EVENT_ALARM(self->index)) {
timer_ll_clear_intr_status(self->hal_context.dev, TIMER_LL_EVENT_ALARM(self->index));
if (self->repeat) {
timer_ll_enable_alarm(self->hal_context.dev, self->index, true);
}
}
// The UART object is referred here by the callback field.
machine_uart_obj_t *uart = (machine_uart_obj_t *)self->callback;
if (uart->rxidle_state == RXIDLE_ALERT) {
// At the first call, just switch the state
uart->rxidle_state = RXIDLE_ARMED;
} else if (uart->rxidle_state == RXIDLE_ARMED) {
// At the second call, run the irq callback and stop the timer
uart->rxidle_state = RXIDLE_STANDBY;
uart->mp_irq_flags = UART_IRQ_RXIDLE;
mp_irq_handler(uart->mp_irq_obj);
mp_hal_wake_main_task_from_isr();
machine_timer_disable(uart->rxidle_timer);
}
}
static void uart_event_task(void *self_in) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
uart_event_t event;
for (;;) {
// Waiting for an UART event.
if (xQueueReceive(self->uart_queue, (void *)&event, (TickType_t)portMAX_DELAY)) {
self->mp_irq_flags = 0;
uint16_t mp_irq_flags = 0;
switch (event.type) {
// Event of UART receiving data
case UART_DATA:
self->mp_irq_flags |= UART_IRQ_RX;
if (self->mp_irq_trigger & UART_IRQ_RXIDLE) {
if (self->rxidle_state != RXIDLE_INACTIVE) {
if (self->rxidle_state == RXIDLE_STANDBY) {
self->rxidle_timer->repeat = true;
self->rxidle_timer->handle = NULL;
machine_timer_enable(self->rxidle_timer, uart_timer_callback);
}
}
self->rxidle_state = RXIDLE_ALERT;
}
mp_irq_flags |= UART_IRQ_RX;
break;
case UART_BREAK:
self->mp_irq_flags |= UART_IRQ_BREAK;
mp_irq_flags |= UART_IRQ_BREAK;
break;
default:
break;
}
// Check the flags to see if the user handler should be called
if (self->mp_irq_trigger & self->mp_irq_flags) {
if (self->mp_irq_trigger & mp_irq_flags) {
self->mp_irq_flags = mp_irq_flags;
mp_irq_handler(self->mp_irq_obj);
mp_hal_wake_main_task_from_isr();
}
@ -390,6 +442,7 @@ static mp_obj_t mp_machine_uart_make_new(const mp_obj_type_t *type, size_t n_arg
self->invert = 0;
self->flowcontrol = 0;
self->uart_event_task = 0;
self->rxidle_state = RXIDLE_INACTIVE;
switch (uart_num) {
case UART_NUM_0:
@ -464,8 +517,35 @@ static void mp_machine_uart_sendbreak(machine_uart_obj_t *self) {
check_esp_err(uart_set_baudrate(self->uart_num, baudrate));
}
// Configure the timer used for IRQ_RXIDLE
static void uart_irq_configure_timer(machine_uart_obj_t *self, mp_uint_t trigger) {
self->rxidle_state = RXIDLE_INACTIVE;
if (trigger & UART_IRQ_RXIDLE) {
// The RXIDLE event is always a soft IRQ.
self->mp_irq_obj->ishard = false;
uint32_t baudrate;
uart_get_baudrate(self->uart_num, &baudrate);
mp_int_t period = TIMER_SCALE * 20 / baudrate + 1;
if (period < RXIDLE_TIMER_MIN) {
period = RXIDLE_TIMER_MIN;
}
self->rxidle_period = period;
self->rxidle_timer->period = period;
// The Python callback is not used. So use this
// data field to hold a reference to the UART object.
self->rxidle_timer->callback = self;
self->rxidle_timer->repeat = true;
self->rxidle_timer->handle = NULL;
self->rxidle_state = RXIDLE_STANDBY;
}
}
static mp_uint_t uart_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
uart_irq_configure_timer(self, new_trigger);
self->mp_irq_trigger = new_trigger;
return 0;
}
@ -511,6 +591,9 @@ static mp_irq_obj_t *mp_machine_uart_irq(machine_uart_obj_t *self, bool any_args
}
self->mp_irq_obj->ishard = false;
self->mp_irq_trigger = trigger;
self->rxidle_timer = machine_timer_create(0);
uart_irq_configure_timer(self, trigger);
// Start a task for handling events
if (handler != mp_const_none && self->uart_event_task == NULL) {
xTaskCreatePinnedToCore(uart_event_task, "uart_event_task", 2048, self,

Write Preview
Loading…
Cancel
Save