diff --git a/cc3200/application.mk b/cc3200/application.mk index 7f8a4fafc3..d5b575fa40 100644 --- a/cc3200/application.mk +++ b/cc3200/application.mk @@ -89,7 +89,6 @@ APP_MODS_SRC_C = $(addprefix mods/,\ modutime.c \ modwlan.c \ pybadc.c \ - pybextint.c \ pybi2c.c \ pybpin.c \ pybrtc.c \ diff --git a/cc3200/boards/cc3200_prefix.c b/cc3200/boards/cc3200_prefix.c index 26afba9a27..2b60134b52 100644 --- a/cc3200/boards/cc3200_prefix.c +++ b/cc3200/boards/cc3200_prefix.c @@ -43,6 +43,7 @@ { \ { &pin_type }, \ .name = MP_QSTR_ ## p_pin_name, \ + .callback = NULL, \ .port = PORT_A ## p_port, \ .type = PIN_TYPE_STD, \ .bit = (p_bit), \ diff --git a/cc3200/misc/pin_named_pins.c b/cc3200/misc/pin_named_pins.c index b2a12900e6..67f75c3302 100644 --- a/cc3200/misc/pin_named_pins.c +++ b/cc3200/misc/pin_named_pins.c @@ -67,3 +67,14 @@ const pin_obj_t *pin_find_pin(const mp_obj_dict_t *named_pins, uint pin_num) { } return NULL; } + +const pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit) { + mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins); + for (uint i = 0; i < named_map->used; i++) { + if ((((pin_obj_t *)named_map->table[i].value)->port == port) && + (((pin_obj_t *)named_map->table[i].value)->bit == bit)) { + return named_map->table[i].value; + } + } + return NULL; +} diff --git a/cc3200/mods/modpyb.c b/cc3200/mods/modpyb.c index 0315901138..0caea7b3d5 100644 --- a/cc3200/mods/modpyb.c +++ b/cc3200/mods/modpyb.c @@ -54,7 +54,6 @@ #include "task.h" #include "mpexception.h" #include "random.h" -#include "pybextint.h" #include "pybadc.h" #include "pybi2c.h" #include "pybsd.h" @@ -312,7 +311,6 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = { #endif { MP_OBJ_NEW_QSTR(MP_QSTR_Pin), (mp_obj_t)&pin_type }, - { MP_OBJ_NEW_QSTR(MP_QSTR_ExtInt), (mp_obj_t)&extint_type }, { MP_OBJ_NEW_QSTR(MP_QSTR_ADC), (mp_obj_t)&pyb_adc_type }, { MP_OBJ_NEW_QSTR(MP_QSTR_I2C), (mp_obj_t)&pyb_i2c_type }, { MP_OBJ_NEW_QSTR(MP_QSTR_UART), (mp_obj_t)&pyb_uart_type }, diff --git a/cc3200/mods/pybextint.c b/cc3200/mods/pybextint.c deleted file mode 100644 index 09eaeee1c4..0000000000 --- a/cc3200/mods/pybextint.c +++ /dev/null @@ -1,353 +0,0 @@ -/* - * This file is part of the Micro Python project, http://micropython.org/ - * - * The MIT License (MIT) - * - * Copyright (c) 2013, 2014 Damien P. George - * Copyright (c) 2015 Daniel Campora - * - * 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 -#include -#include - -#include "py/mpstate.h" -#include MICROPY_HAL_H -#include "py/runtime.h" -#include "py/gc.h" -#include "py/objlist.h" -#include "inc/hw_types.h" -#include "inc/hw_gpio.h" -#include "inc/hw_ints.h" -#include "inc/hw_memmap.h" -#include "rom_map.h" -#include "pin.h" -#include "gpio.h" -#include "pybpin.h" -#include "pybextint.h" -#include "mpexception.h" -#include "interrupt.h" -#include "cc3200_asm.h" -#include "mperror.h" - -/// \moduleref pyb -/// \class ExtInt - configure I/O pins to interrupt on external events -/// -/// There are a maximum of 25 gpio interrupt lines. -/// -/// Example callback: -/// -/// def callback(line): -/// print(line.pin()) -/// -/// Note: ExtInt will automatically configure the gpio line as an input. -/// -/// extint = pyb.ExtInt('GPIO10', pyb.ExtInt.IRQ_FALLING, pyb.GPIO.STD_PU, callback) -/// -/// Now every time a falling edge is seen on the gpio pin, the callback will be -/// called. Caution: mechanical pushbuttons have "bounce" and pushing or -/// releasing a switch will often generate multiple edges. -/// See: http://www.eng.utah.edu/~cs5780/debouncing.pdf for a detailed -/// explanation, along with various techniques for debouncing. -/// -/// All pin objects go through the pin mapper to come up with one of the -/// gpio pins. -/// -/// extint = pyb.ExtInt(pin, mode, pull, callback) -/// -/// There is also a C API, so that drivers which require EXTI interrupt lines -/// can also use this code. See pybextint.h for the available functions. - -STATIC void ExecuteIntCallback (extint_obj_t *self); -STATIC void GPIOA0IntHandler (void); -STATIC void GPIOA1IntHandler (void); -STATIC void GPIOA2IntHandler (void); -STATIC void GPIOA3IntHandler (void); -STATIC void EXTI_Handler(uint port); - -STATIC extint_obj_t* extint_add (uint pin_num, uint port, uint bit) { - extint_obj_t *self = m_new_obj(extint_obj_t); - - self->port = port; - self->bit = bit; - self->callback = NULL; - self->pin_num = pin_num; - // add it to the list - mp_obj_list_append(&MP_STATE_PORT(pyb_extint_list), self); - - return self; -} - -STATIC extint_obj_t* extint_find (uint port, uint8_t bit) { - for (mp_uint_t i = 0; i < MP_STATE_PORT(pyb_extint_list).len; i++) { - extint_obj_t *self = (extint_obj_t *)MP_STATE_PORT(pyb_extint_list).items[i]; - if (self->port == port && self->bit == bit) { - return self; - } - } - return NULL; -} - -/// \method line() -/// Return the pin number to which this external interrupt is mapped to. -STATIC mp_obj_t extint_obj_pin(mp_obj_t self_in) { - extint_obj_t *self = self_in; - return MP_OBJ_NEW_SMALL_INT(self->pin_num); -} -STATIC MP_DEFINE_CONST_FUN_OBJ_1(extint_obj_pin_obj, extint_obj_pin); - -/// \method enable() -/// Enable a disabled interrupt. -STATIC mp_obj_t extint_obj_enable(mp_obj_t self_in) { - extint_obj_t *self = self_in; - extint_enable(self); - return mp_const_none; -} -STATIC MP_DEFINE_CONST_FUN_OBJ_1(extint_obj_enable_obj, extint_obj_enable); - -/// \method disable() -/// Disable the interrupt associated with the ExtInt object. -/// This could be useful for debouncing. -STATIC mp_obj_t extint_obj_disable(mp_obj_t self_in) { - extint_obj_t *self = self_in; - extint_disable(self); - return mp_const_none; -} -STATIC MP_DEFINE_CONST_FUN_OBJ_1(extint_obj_disable_obj, extint_obj_disable); - -/// \method swint() -/// Trigger the callback from software. -STATIC mp_obj_t extint_obj_swint(mp_obj_t self_in) { - extint_obj_t *self = self_in; - extint_swint(self); - return mp_const_none; -} -STATIC MP_DEFINE_CONST_FUN_OBJ_1(extint_obj_swint_obj, extint_obj_swint); - -/// \classmethod \constructor(pin, mode, pull, callback) -/// Create an ExtInt object: -/// -/// - `pin` is the pin on which to enable the interrupt (can be a pin object or any valid pin name). -/// - `mode` can be one of: -/// - `ExtInt.IRQ_RISING` - trigger on a rising edge; -/// - `ExtInt.IRQ_FALLING` - trigger on a falling edge; -/// - `ExtInt.IRQ_RISING_FALLING` - trigger on a rising or falling edge. -/// - `pull` can be one of: -/// - `pyb.Pin.PULL_NONE` - no pull up or down resistors; -/// - `pyb.Pin.PULL_UP` - enable the pull-up resistor; -/// - `pyb.Pin.PULL_DOWN` - enable the pull-down resistor. -/// - `callback` is the function to call when the interrupt triggers. The -/// callback function must accept exactly 1 argument, which is the line that -/// triggered the interrupt. -STATIC const mp_arg_t pyb_extint_make_new_args[] = { - { MP_QSTR_pin, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, - { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_pull, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_callback, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, -}; -#define PYB_EXTINT_MAKE_NEW_NUM_ARGS MP_ARRAY_SIZE(pyb_extint_make_new_args) - -STATIC mp_obj_t extint_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) { - // parse args - mp_arg_val_t vals[PYB_EXTINT_MAKE_NEW_NUM_ARGS]; - mp_arg_parse_all_kw_array(n_args, n_kw, args, PYB_EXTINT_MAKE_NEW_NUM_ARGS, pyb_extint_make_new_args, vals); - - extint_obj_t *self = extint_register(vals[0].u_obj, vals[1].u_int, vals[2].u_int, vals[3].u_obj); - self->base.type = type_in; - - return self; -} - -STATIC void extint_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { - extint_obj_t *self = self_in; - print(env, "", self->pin_num); -} - -STATIC const mp_map_elem_t extint_locals_dict_table[] = { - { MP_OBJ_NEW_QSTR(MP_QSTR_pin), (mp_obj_t)&extint_obj_pin_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_enable), (mp_obj_t)&extint_obj_enable_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_disable), (mp_obj_t)&extint_obj_disable_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_swint), (mp_obj_t)&extint_obj_swint_obj }, - - // class constants - /// \constant IRQ_RISING - interrupt on a rising edge - /// \constant IRQ_FALLING - interrupt on a falling edge - /// \constant IRQ_RISING_FALLING - interrupt on a rising or falling edge - /// \constant IRQ_LOW_LEVEL - interrupt on a low level - /// \constant IRQ_HIGH_LEVEL - interrupt on a high level - { MP_OBJ_NEW_QSTR(MP_QSTR_IRQ_FALLING), MP_OBJ_NEW_SMALL_INT(GPIO_FALLING_EDGE) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_IRQ_RISING), MP_OBJ_NEW_SMALL_INT(GPIO_RISING_EDGE) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_IRQ_RISING_FALLING), MP_OBJ_NEW_SMALL_INT(GPIO_BOTH_EDGES) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_IRQ_LOW_LEVEL), MP_OBJ_NEW_SMALL_INT(GPIO_LOW_LEVEL) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_IRQ_HIGH_LEVEL), MP_OBJ_NEW_SMALL_INT(GPIO_HIGH_LEVEL) }, -}; - -STATIC MP_DEFINE_CONST_DICT(extint_locals_dict, extint_locals_dict_table); - -STATIC void ExecuteIntCallback (extint_obj_t *self) { - if (self->callback != mp_const_none) { - // disable interrupts to avoid nesting - uint primsk = disable_irq(); - // when executing code within a handler we must lock the GC to prevent - // any memory allocations. We must also catch any exceptions. - gc_lock(); - nlr_buf_t nlr; - if (nlr_push(&nlr) == 0) { - mp_call_function_1(self->callback, self); - nlr_pop(); - } else { - // uncaught exception; disable the callback so it doesn't run again - self->callback = mp_const_none; - extint_disable(self); - // printing an exception here will cause a stack overflow that ends up in a - // hard fault so, is better to signal the uncaught (probably non-recoverable) - // exception by blinkg the system led - mperror_signal_error(); - } - gc_unlock(); - enable_irq(primsk); - } -} - -STATIC void GPIOA0IntHandler (void) { - EXTI_Handler(GPIOA0_BASE); -} - -STATIC void GPIOA1IntHandler (void) { - EXTI_Handler(GPIOA1_BASE); -} - -STATIC void GPIOA2IntHandler (void) { - EXTI_Handler(GPIOA2_BASE); -} - -STATIC void GPIOA3IntHandler (void) { - EXTI_Handler(GPIOA3_BASE); -} - -// common interrupt handler -STATIC void EXTI_Handler(uint port) { - extint_obj_t *self; - uint32_t bit = MAP_GPIOIntStatus(port, true); - - MAP_GPIOIntClear(port, bit); - if (NULL != (self = extint_find(port, bit))) { - ExecuteIntCallback(self); - } -} - -const mp_obj_type_t extint_type = { - { &mp_type_type }, - .name = MP_QSTR_ExtInt, - .print = extint_obj_print, - .make_new = extint_make_new, - .locals_dict = (mp_obj_t)&extint_locals_dict, -}; - -void extint_init0(void) { - mp_obj_list_init(&MP_STATE_PORT(pyb_extint_list), 0); -} - -extint_obj_t* extint_register(mp_obj_t pin_obj, uint32_t intmode, uint32_t pull, mp_obj_t callback) { - const pin_obj_t *pin; - extint_obj_t* self; - void *handler; - uint32_t intnum; - - pin = pin_find(pin_obj); - - if (intmode != GPIO_FALLING_EDGE && - intmode != GPIO_RISING_EDGE && - intmode != GPIO_BOTH_EDGES && - intmode != GPIO_LOW_LEVEL && - intmode != GPIO_HIGH_LEVEL) { - nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); - } - if (pull != PIN_TYPE_STD && - pull != PIN_TYPE_STD_PU && - pull != PIN_TYPE_STD_PD && - pull != PIN_TYPE_OD && - pull != PIN_TYPE_OD_PU && - pull != PIN_TYPE_OD_PD) { - nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); - } - - if (NULL == (self = extint_find(pin->port, pin->bit))) { - self = extint_add(pin->pin_num, pin->port, pin->bit); - } - else { - // we need to update the callback atomically, so we disable the line - // before we update anything. - extint_disable(self); - } - - // invalidate the callback - self->callback = NULL; - - // before enabling the interrupt, configure the gpio pin - pin_config ((pin_obj_t *)pin, PIN_MODE_0, GPIO_DIR_MODE_IN, pull, PIN_STRENGTH_4MA); - - MAP_GPIOIntTypeSet(pin->port, pin->bit, intmode); - switch (pin->port) { - case GPIOA0_BASE: - handler = GPIOA0IntHandler; - intnum = INT_GPIOA0; - break; - case GPIOA1_BASE: - handler = GPIOA1IntHandler; - intnum = INT_GPIOA1; - break; - case GPIOA2_BASE: - handler = GPIOA2IntHandler; - intnum = INT_GPIOA2; - break; - case GPIOA3_BASE: - default: - handler = GPIOA3IntHandler; - intnum = INT_GPIOA3; - break; - } - - MAP_GPIOIntRegister(pin->port, handler); - // set the interrupt to the lowest priority, to make sure that no ther - // isr will be preemted by this one - MAP_IntPrioritySet(intnum, INT_PRIORITY_LVL_7); - - // set the new callback - self->callback = callback; - // enable the interrupt just before leaving - extint_enable(self); - - return self; -} - -void extint_enable(extint_obj_t *self) { - MAP_GPIOIntClear(self->port, self->bit); - MAP_GPIOIntEnable(self->port, self->bit); -} - -void extint_disable(extint_obj_t *self) { - MAP_GPIOIntDisable(self->port, self->bit); -} - -void extint_swint(extint_obj_t *self) { - ExecuteIntCallback(self); -} diff --git a/cc3200/mods/pybextint.h b/cc3200/mods/pybextint.h deleted file mode 100644 index b479403b29..0000000000 --- a/cc3200/mods/pybextint.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - * This file is part of the Micro Python project, http://micropython.org/ - * - * The MIT License (MIT) - * - * Copyright (c) 2013, 2014 Damien P. George - * Copyright (c) 2015 Daniel Campora - * - * 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 PYBEXTINT_H_ -#define PYBEXTINT_H_ - -typedef struct { - mp_obj_base_t base; - mp_obj_t callback; - uint32_t port; - uint8_t pin_num; - uint8_t bit; -} extint_obj_t; - -extern const mp_obj_type_t extint_type; - -void extint_init0(void); -extint_obj_t* extint_register(mp_obj_t pin_obj, uint32_t intmode, uint32_t pull, mp_obj_t callback); -void extint_enable(extint_obj_t *self); -void extint_disable(extint_obj_t *self); -void extint_swint(extint_obj_t *self); - -#endif /* PYBEXTINT_H_ */ diff --git a/cc3200/mods/pybpin.c b/cc3200/mods/pybpin.c index 095440f79c..493446d533 100644 --- a/cc3200/mods/pybpin.c +++ b/cc3200/mods/pybpin.c @@ -33,6 +33,7 @@ #include MICROPY_HAL_H #include "py/obj.h" #include "py/runtime.h" +#include "py/gc.h" #include "inc/hw_types.h" #include "inc/hw_gpio.h" #include "inc/hw_ints.h" @@ -41,9 +42,11 @@ #include "pin.h" #include "prcm.h" #include "gpio.h" +#include "interrupt.h" #include "pybpin.h" #include "pybsleep.h" #include "mpexception.h" +#include "mperror.h" /// \moduleref pyb @@ -78,12 +81,46 @@ /// 1. Directly specify a Pin object /// 2. Supply a string which matches a CPU pin name /// 3. Provide a pin number - - -STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *pin, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args); +/// +/// \Interrupts: +//// You can also configure the Pin to generate interrupts +/// +/// Example callback: +/// +/// def pincb(pin): +/// print(pin.pin()) +/// +/// extint = pyb.Pin('GPIO10', 0, pyb.Pin.INT_FALLING, pyb.GPIO.STD_PU, pyb.S2MA, callback=pincb) +/// +/// Now every time a falling edge is seen on the gpio pin, the callback will be +/// called. Caution: mechanical pushbuttons have "bounce" and pushing or +/// releasing a switch will often generate multiple edges. +/// See: http://www.eng.utah.edu/~cs5780/debouncing.pdf for a detailed +/// explanation, along with various techniques for debouncing. +/// +/// All pin objects go through the pin mapper to come up with one of the +/// gpio pins. +/// +/// extint = pyb.Pin(pin, af, mode, pull, strength, callback) +/// +/// There is also a C API, so that drivers which require Pin interrupts +/// can also use this code. See pybextint.h for the available functions. +/****************************************************************************** +DECLARE PRIVATE FUNCTIONS +******************************************************************************/ +STATIC void ExecuteIntCallback (pin_obj_t *self); +STATIC void GPIOA0IntHandler (void); +STATIC void GPIOA1IntHandler (void); +STATIC void GPIOA2IntHandler (void); +STATIC void GPIOA3IntHandler (void); +STATIC void EXTI_Handler(uint port); +STATIC mp_obj_t pin_obj_init_helper(pin_obj_t *pin, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args); STATIC void pin_obj_configure (const pin_obj_t *self); +/****************************************************************************** + DEFINE PUBLIC FUNCTIONS + ******************************************************************************/ void pin_init0(void) { } @@ -136,6 +173,61 @@ void pin_config (pin_obj_t *self, uint af, uint mode, uint type, uint strength) pybsleep_add (self, (WakeUpCB_t)pin_obj_configure); } +void pin_extint_register(pin_obj_t *self, uint32_t intmode, mp_obj_t callback) { + void *handler; + uint32_t intnum; + + // we need to update the callback atomically, so we disable the line + // before we update anything. + pin_extint_disable(self); + + // configure the interrupt type + MAP_GPIOIntTypeSet(self->port, self->bit, intmode); + switch (self->port) { + case GPIOA0_BASE: + handler = GPIOA0IntHandler; + intnum = INT_GPIOA0; + break; + case GPIOA1_BASE: + handler = GPIOA1IntHandler; + intnum = INT_GPIOA1; + break; + case GPIOA2_BASE: + handler = GPIOA2IntHandler; + intnum = INT_GPIOA2; + break; + case GPIOA3_BASE: + default: + handler = GPIOA3IntHandler; + intnum = INT_GPIOA3; + break; + } + MAP_GPIOIntRegister(self->port, handler); + // set the interrupt to the lowest priority, to make sure that + // no other ISRs will be preemted by this one + MAP_IntPrioritySet(intnum, INT_PRIORITY_LVL_7); + // set the callback + self->callback = callback; + // enable the interrupt just before leaving + pin_extint_enable(self); +} + +void pin_extint_enable(pin_obj_t *self) { + MAP_GPIOIntClear(self->port, self->bit); + MAP_GPIOIntEnable(self->port, self->bit); +} + +void pin_extint_disable(pin_obj_t *self) { + MAP_GPIOIntDisable(self->port, self->bit); +} + +void pin_extint_swint(pin_obj_t *self) { + ExecuteIntCallback(self); +} + +/****************************************************************************** +DEFINE PRIVATE FUNCTIONS + ******************************************************************************/ STATIC void pin_obj_configure (const pin_obj_t *self) { // Skip all this if the pin is to be used in analog mode if (self->type != PYBPIN_ANALOG_TYPE) { @@ -228,7 +320,7 @@ STATIC mp_obj_t pin_make_new(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); // Run an argument through the mapper and return the result. - const pin_obj_t *pin = pin_find(args[0]); + pin_obj_t *pin = (pin_obj_t *)pin_find(args[0]); if (n_args > 1) { // pin af given, so configure it @@ -263,42 +355,58 @@ STATIC mp_obj_t pin_make_new(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, /// /// Returns: `None`. STATIC const mp_arg_t pin_init_args[] = { - { MP_QSTR_af, MP_ARG_REQUIRED | MP_ARG_INT }, - { MP_QSTR_mode, MP_ARG_INT, {.u_int = GPIO_DIR_MODE_OUT} }, - { MP_QSTR_type, MP_ARG_INT, {.u_int = PIN_TYPE_STD} }, - { MP_QSTR_str, MP_ARG_INT, {.u_int = PIN_STRENGTH_4MA} }, + { MP_QSTR_af, MP_ARG_REQUIRED | MP_ARG_INT }, + { MP_QSTR_mode, MP_ARG_INT, {.u_int = GPIO_DIR_MODE_OUT} }, + { MP_QSTR_type, MP_ARG_INT, {.u_int = PIN_TYPE_STD} }, + { MP_QSTR_str, MP_ARG_INT, {.u_int = PIN_STRENGTH_4MA} }, + { MP_QSTR_callback, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, }; #define pin_INIT_NUM_ARGS MP_ARRAY_SIZE(pin_init_args) -STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) { +STATIC mp_obj_t pin_obj_init_helper(pin_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) { // parse args - mp_arg_val_t vals[pin_INIT_NUM_ARGS]; - mp_arg_parse_all(n_args, args, kw_args, pin_INIT_NUM_ARGS, pin_init_args, vals); + mp_arg_val_t args[pin_INIT_NUM_ARGS]; + mp_arg_parse_all(n_args, pos_args, kw_args, pin_INIT_NUM_ARGS, pin_init_args, args); // get the af - uint af = vals[0].u_int; + uint af = args[0].u_int; if (af < PIN_MODE_0 || af > PIN_MODE_15) { nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); } // get the io mode - uint mode = vals[1].u_int; - if (mode != GPIO_DIR_MODE_IN && mode != GPIO_DIR_MODE_OUT) { - nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); + uint mode = args[1].u_int; + uint intmode = 0xFF; + // checking the mode only makes sense if af == GPIO + if (af == PIN_MODE_0) { + if (mode != GPIO_DIR_MODE_IN && mode != GPIO_DIR_MODE_OUT) { + if (mode != GPIO_FALLING_EDGE && mode != GPIO_RISING_EDGE && mode != GPIO_BOTH_EDGES && + mode != GPIO_LOW_LEVEL && mode != GPIO_HIGH_LEVEL) { + nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); + } + // select input mode for interrupt triggering + intmode = mode; + mode = GPIO_DIR_MODE_IN; + } } // get the type - uint type = vals[2].u_int; + uint type = args[2].u_int; if (type != PIN_TYPE_STD && type != PIN_TYPE_STD_PU && type != PIN_TYPE_STD_PD && - type != PIN_TYPE_OD && type != PIN_TYPE_OD_PU && type != PIN_TYPE_OD_PD) { + type != PIN_TYPE_OD && type != PIN_TYPE_OD_PU && type != PIN_TYPE_OD_PD) { nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); } // get the strenght - uint strength = vals[3].u_int; + uint strength = args[3].u_int; if (strength != PIN_STRENGTH_2MA && strength != PIN_STRENGTH_4MA && strength != PIN_STRENGTH_6MA) { nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); } // configure the pin as requested - pin_config ((pin_obj_t *)self, af, mode, type, strength); + pin_config (self, af, mode, type, strength); + + // register the interrupt if the mode says so + if (intmode != 0xFF) { + pin_extint_register(self, intmode, args[4].u_obj); + } return mp_const_none; } @@ -419,48 +527,108 @@ STATIC mp_obj_t pin_af(mp_obj_t self_in) { } STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_af_obj, pin_af); +/// \method int_enable() +/// Enable a disabled interrupt. +STATIC mp_obj_t pin_int_enable(mp_obj_t self_in) { + pin_obj_t *self = self_in; + pin_extint_enable(self); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_int_enable_obj, pin_int_enable); + +/// \method int_disable() +/// Disable the interrupt associated with the Pin object. +/// This could be useful for debouncing. +STATIC mp_obj_t pin_int_disable(mp_obj_t self_in) { + pin_obj_t *self = self_in; + pin_extint_disable(self); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_int_disable_obj, pin_int_disable); + +/// \method intmode([mode]) +/// Get or set the interrupt mode of the pin: +/// +/// - With no argument, returns the configured interrupt mode +/// - With `mode` given, sets the interrupt mode of the pin +STATIC mp_obj_t pin_intmode(mp_uint_t n_args, const mp_obj_t *args) { + pin_obj_t *self = args[0]; + if (n_args == 1) { + // get the interrupt mode + return MP_OBJ_NEW_SMALL_INT(MAP_GPIOIntTypeGet(self->port, self->bit)); + } else { + // set the interrupt mode + MAP_GPIOIntTypeSet(self->port, self->bit, mp_obj_get_int(args[1])); + return mp_const_none; + } +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_intmode_obj, 1, 2, pin_intmode); + +/// \method swint() +/// Trigger the interrupt callback from software. +STATIC mp_obj_t pin_swint(mp_obj_t self_in) { + pin_obj_t *self = self_in; + pin_extint_swint(self); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_swint_obj, pin_swint); + STATIC const mp_map_elem_t pin_locals_dict_table[] = { // instance methods - { MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&pin_init_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_value), (mp_obj_t)&pin_value_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_low), (mp_obj_t)&pin_low_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_high), (mp_obj_t)&pin_high_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_toggle), (mp_obj_t)&pin_toggle_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_name), (mp_obj_t)&pin_name_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_port), (mp_obj_t)&pin_port_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_pin), (mp_obj_t)&pin_pin_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_mode), (mp_obj_t)&pin_mode_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_type), (mp_obj_t)&pin_type_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_strength), (mp_obj_t)&pin_strenght_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_af), (mp_obj_t)&pin_af_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&pin_init_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_value), (mp_obj_t)&pin_value_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_low), (mp_obj_t)&pin_low_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_high), (mp_obj_t)&pin_high_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_toggle), (mp_obj_t)&pin_toggle_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_name), (mp_obj_t)&pin_name_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_port), (mp_obj_t)&pin_port_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_pin), (mp_obj_t)&pin_pin_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_mode), (mp_obj_t)&pin_mode_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_type), (mp_obj_t)&pin_type_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_strength), (mp_obj_t)&pin_strenght_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_af), (mp_obj_t)&pin_af_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_intenable), (mp_obj_t)&pin_int_enable_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_intdisable), (mp_obj_t)&pin_int_disable_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_intmode), (mp_obj_t)&pin_intmode_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_swint), (mp_obj_t)&pin_swint_obj }, // class attributes - { MP_OBJ_NEW_QSTR(MP_QSTR_cpu), (mp_obj_t)&pin_cpu_pins_obj_type }, + { MP_OBJ_NEW_QSTR(MP_QSTR_cpu), (mp_obj_t)&pin_cpu_pins_obj_type }, // class constants - /// \constant IN - set the pin to input mode - /// \constant OUT - set the pin to output mode - /// \constant STD - set the pin to standard mode without pull-up or pull-down - /// \constant STD_PU - set the pin to standard mode with pull-up - /// \constant STD_PD - set the pin to standard mode with pull-down - /// \constant OD - set the pin to open drain mode without pull-up or pull-down - /// \constant OD_PU - set the pin to open drain mode with pull-up - /// \constant OD_PD - set the pin to open drain mode with pull-down - /// \constant 2MA - set the drive strength to 2ma - /// \constant 4MA - set the drive strength to 4ma - /// \constant 6MA - set the drive strength to 6ma - { MP_OBJ_NEW_QSTR(MP_QSTR_IN), MP_OBJ_NEW_SMALL_INT(GPIO_DIR_MODE_IN) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_OUT), MP_OBJ_NEW_SMALL_INT(GPIO_DIR_MODE_OUT) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_STD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_STD) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_STD_PU), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_STD_PU) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_STD_PD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_STD_PD) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_OD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_OD) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_OD_PU), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_OD_PU) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_OD_PD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_OD_PD) }, + /// \constant IN - set the pin to input mode + /// \constant OUT - set the pin to output mode + /// \constant STD - set the pin to standard mode without pull-up or pull-down + /// \constant STD_PU - set the pin to standard mode with pull-up + /// \constant STD_PD - set the pin to standard mode with pull-down + /// \constant OD - set the pin to open drain mode without pull-up or pull-down + /// \constant OD_PU - set the pin to open drain mode with pull-up + /// \constant OD_PD - set the pin to open drain mode with pull-down + /// \constant IRQ_RISING - interrupt on a rising edge + /// \constant IRQ_FALLING - interrupt on a falling edge + /// \constant IRQ_RISING_FALLING - interrupt on a rising or falling edge + /// \constant IRQ_LOW_LEVEL - interrupt on a low level + /// \constant IRQ_HIGH_LEVEL - interrupt on a high level + /// \constant 2MA - set the drive strength to 2ma + /// \constant 4MA - set the drive strength to 4ma + /// \constant 6MA - set the drive strength to 6ma + { MP_OBJ_NEW_QSTR(MP_QSTR_IN), MP_OBJ_NEW_SMALL_INT(GPIO_DIR_MODE_IN) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_OUT), MP_OBJ_NEW_SMALL_INT(GPIO_DIR_MODE_OUT) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_STD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_STD) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_STD_PU), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_STD_PU) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_STD_PD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_STD_PD) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_OD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_OD) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_OD_PU), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_OD_PU) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_OD_PD), MP_OBJ_NEW_SMALL_INT(PIN_TYPE_OD_PD) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_INT_FALLING), MP_OBJ_NEW_SMALL_INT(GPIO_FALLING_EDGE) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_INT_RISING), MP_OBJ_NEW_SMALL_INT(GPIO_RISING_EDGE) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_INT_RISING_FALLING), MP_OBJ_NEW_SMALL_INT(GPIO_BOTH_EDGES) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_INT_LOW_LEVEL), MP_OBJ_NEW_SMALL_INT(GPIO_LOW_LEVEL) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_INT_HIGH_LEVEL), MP_OBJ_NEW_SMALL_INT(GPIO_HIGH_LEVEL) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_S2MA), MP_OBJ_NEW_SMALL_INT(PIN_STRENGTH_2MA) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_S4MA), MP_OBJ_NEW_SMALL_INT(PIN_STRENGTH_4MA) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_S6MA), MP_OBJ_NEW_SMALL_INT(PIN_STRENGTH_6MA) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_S2MA), MP_OBJ_NEW_SMALL_INT(PIN_STRENGTH_2MA) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_S4MA), MP_OBJ_NEW_SMALL_INT(PIN_STRENGTH_4MA) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_S6MA), MP_OBJ_NEW_SMALL_INT(PIN_STRENGTH_6MA) }, }; STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table); @@ -472,3 +640,55 @@ const mp_obj_type_t pin_type = { .make_new = pin_make_new, .locals_dict = (mp_obj_t)&pin_locals_dict, }; + +STATIC void ExecuteIntCallback (pin_obj_t *self) { + if (self->callback != mp_const_none) { + // disable interrupts to avoid nesting + uint primsk = disable_irq(); + // when executing code within a handler we must lock the GC to prevent + // any memory allocations. We must also catch any exceptions. + gc_lock(); + nlr_buf_t nlr; + if (nlr_push(&nlr) == 0) { + mp_call_function_1(self->callback, self); + nlr_pop(); + } else { + // uncaught exception; disable the callback so that it doesn't run again + self->callback = mp_const_none; + pin_extint_disable(self); + // printing an exception here will cause a stack overflow that ends up in a + // hard fault so, is better to signal the uncaught (probably non-recoverable) + // exception by blinkg the system led + mperror_signal_error(); + } + gc_unlock(); + enable_irq(primsk); + } +} + +STATIC void GPIOA0IntHandler (void) { + EXTI_Handler(GPIOA0_BASE); +} + +STATIC void GPIOA1IntHandler (void) { + EXTI_Handler(GPIOA1_BASE); +} + +STATIC void GPIOA2IntHandler (void) { + EXTI_Handler(GPIOA2_BASE); +} + +STATIC void GPIOA3IntHandler (void) { + EXTI_Handler(GPIOA3_BASE); +} + +// common interrupt handler +STATIC void EXTI_Handler(uint port) { + pin_obj_t *self; + uint32_t bit = MAP_GPIOIntStatus(port, true); + + MAP_GPIOIntClear(port, bit); + if (NULL != (self = (pin_obj_t *)pin_find_pin_by_port_bit(&pin_cpu_pins_locals_dict, port, bit))) { + ExecuteIntCallback(self); + } +} diff --git a/cc3200/mods/pybpin.h b/cc3200/mods/pybpin.h index 0759022f1a..6228fa2ec3 100644 --- a/cc3200/mods/pybpin.h +++ b/cc3200/mods/pybpin.h @@ -35,6 +35,7 @@ typedef struct { mp_obj_base_t base; qstr name; + mp_obj_t callback; uint32_t port; uint16_t type; uint8_t bit; @@ -66,9 +67,14 @@ MP_DECLARE_CONST_FUN_OBJ(pin_init_obj); void pin_init0(void); void pin_verify_af (uint af); void pin_config(pin_obj_t *self, uint af, uint mode, uint type, uint strength); +void pin_extint_register(pin_obj_t *self, uint32_t intmode, mp_obj_t callback); +void pin_extint_enable(pin_obj_t *self); +void pin_extint_disable(pin_obj_t *self); +void pin_extint_swint(pin_obj_t *self); const pin_obj_t *pin_find(mp_obj_t user_obj); const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name); const pin_obj_t *pin_find_pin(const mp_obj_dict_t *named_pins, uint pin_num); +const pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit); uint32_t pin_get_mode(const pin_obj_t *self); uint32_t pin_get_type(const pin_obj_t *self); uint32_t pin_get_strenght(const pin_obj_t *self); diff --git a/cc3200/mpconfigport.h b/cc3200/mpconfigport.h index a32e9b9dc6..344e8249c9 100644 --- a/cc3200/mpconfigport.h +++ b/cc3200/mpconfigport.h @@ -120,7 +120,6 @@ extern const struct _mp_obj_module_t mp_module_network; const char *readline_hist[8]; \ mp_obj_t mp_const_user_interrupt; \ mp_obj_t pyb_config_main; \ - mp_obj_list_t pyb_extint_list; \ mp_obj_list_t pyb_uart_list; \ mp_obj_list_t mod_network_nic_list; \ mp_obj_list_t pybsleep_obj_list; \ diff --git a/cc3200/mptask.c b/cc3200/mptask.c index 53468f79c9..3e51199fb2 100644 --- a/cc3200/mptask.c +++ b/cc3200/mptask.c @@ -43,7 +43,6 @@ #include "gccollect.h" #include "gchelper.h" #include "readline.h" -#include "mptask.h" #include "mperror.h" #include "simplelink.h" #include "modnetwork.h" @@ -56,7 +55,6 @@ #include "sflash_diskio.h" #include "mpexception.h" #include "random.h" -#include "pybextint.h" #include "pybi2c.h" #include "pybsd.h" #include "pins.h" @@ -138,7 +136,6 @@ soft_reset: pyb_stdio_uart = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args); readline_init0(); - extint_init0(); mod_network_init0(); wlan_init0(); #if MICROPY_HW_ENABLE_RNG @@ -286,7 +283,7 @@ STATIC void mptask_init_sflash_filesystem (void) { if (res == FR_OK) { // success creating fresh LFS } else { - __fatal_error("could not create /SFLASH file system"); + __fatal_error("failed to create /SFLASH"); } // create empty main.py mptask_create_main_py(); @@ -298,7 +295,7 @@ STATIC void mptask_init_sflash_filesystem (void) { mptask_create_main_py(); } } else { - __fatal_error("could not create /SFLASH file system"); + __fatal_error("failed to create /SFLASH"); } // The current directory is used as the boot up directory. diff --git a/cc3200/qstrdefsport.h b/cc3200/qstrdefsport.h index f71ad597b8..1ae4b0b172 100644 --- a/cc3200/qstrdefsport.h +++ b/cc3200/qstrdefsport.h @@ -85,6 +85,11 @@ Q(pull) Q(index) Q(strength) Q(af) +Q(callback) +Q(intenable) +Q(intdisable) +Q(intmode) +Q(swint) Q(IN) Q(OUT) Q(STD) @@ -93,23 +98,15 @@ Q(STD_PD) Q(OD) Q(OD_PU) Q(OD_PD) +Q(INT_RISING) +Q(INT_FALLING) +Q(INT_RISING_FALLING) +Q(INT_LOW_LEVEL) +Q(INT_HIGH_LEVEL) Q(S2MA) Q(S4MA) Q(S6MA) -// for ExtInt class -Q(ExtInt) -Q(pin) -Q(mode) -Q(pull) -Q(callback) -Q(swint) -Q(IRQ_RISING) -Q(IRQ_FALLING) -Q(IRQ_RISING_FALLING) -Q(IRQ_LOW_LEVEL) -Q(IRQ_HIGH_LEVEL) - // for UART class Q(UART) Q(baudrate) diff --git a/cc3200/telnet/telnet.c b/cc3200/telnet/telnet.c index 31037aed2b..694145cc25 100644 --- a/cc3200/telnet/telnet.c +++ b/cc3200/telnet/telnet.c @@ -36,7 +36,6 @@ #include "debug.h" #include "mpexception.h" #include "serverstask.h" -#include "mperror.h" #include "genhdr/py-version.h" @@ -429,7 +428,7 @@ static void telnet_parse_input (uint8_t *str, int16_t *len) { for (uint8_t *_str = b_str; _str < b_str + b_len; ) { if (*_str <= 127) { if (telnet_data.state == E_TELNET_STE_LOGGED_IN && *_str == user_interrupt_char) { - // raise keyboard exception + // raise a keyboard exception mpexception_keyboard_nlr_jump(); (*len)--; _str++; @@ -461,10 +460,6 @@ static bool telnet_send_with_retries (int16_t sd, const void *pBuf, int16_t len) HAL_Delay (TELNET_WAIT_TIME_MS); } while (++retries <= TELNET_TX_RETRIES_MAX); } - else { - // blink the system led - mperror_signal_error(); - } return false; }