From ca5444e6cd8b566bd4ad78e84162e03ec18e01b6 Mon Sep 17 00:00:00 2001 From: Dave Hylands Date: Fri, 14 Mar 2014 23:41:28 -0700 Subject: [PATCH] stmhal - add pin mapping, gpio, exti, usrsw --- py/mkrules.mk | 4 + stmhal/Makefile | 10 +- stmhal/boards/NETDUINO_PLUS_2/mpconfigboard.h | 4 +- stmhal/boards/PYBOARD3/mpconfigboard.h | 4 +- stmhal/boards/PYBOARD4/mpconfigboard.h | 4 +- stmhal/boards/STM32F4DISC/mpconfigboard.h | 4 +- stmhal/exti.c | 346 ++++++++++++++++++ stmhal/exti.h | 38 ++ stmhal/gpio.c | 72 ++++ stmhal/gpio.h | 7 + stmhal/main.c | 6 +- stmhal/pin_map.c | 227 ++++++++++++ stmhal/pin_named_pins.c | 67 ++++ stmhal/pybmodule.c | 22 +- stmhal/stm32f4xx_it.c | 95 ++++- stmhal/usrsw.c | 67 ++++ stmhal/usrsw.h | 4 + 17 files changed, 949 insertions(+), 32 deletions(-) create mode 100644 stmhal/exti.c create mode 100644 stmhal/exti.h create mode 100644 stmhal/gpio.c create mode 100644 stmhal/gpio.h create mode 100644 stmhal/pin_map.c create mode 100644 stmhal/pin_named_pins.c create mode 100644 stmhal/usrsw.c create mode 100644 stmhal/usrsw.h diff --git a/py/mkrules.mk b/py/mkrules.mk index 1ab3ee59ba..2730eff415 100644 --- a/py/mkrules.mk +++ b/py/mkrules.mk @@ -45,6 +45,10 @@ vpath %.c . $(TOP) $(BUILD)/%.o: %.c $(call compile_c) +$(BUILD)/%.pp: %.c + $(ECHO) "PreProcess $<" + $(Q)$(CC) $(CFLAGS) -E -Wp,-C,-dD,-dI -o $@ $< + # The following rule uses | to create an order only prereuisite. Order only # prerequisites only get built if they don't exist. They don't cause timestamp # checkng to be performed. diff --git a/stmhal/Makefile b/stmhal/Makefile index 1c044055c1..aeddca4802 100644 --- a/stmhal/Makefile +++ b/stmhal/Makefile @@ -62,6 +62,8 @@ SRC_C = \ systick.c \ led.c \ pin.c \ + pin_map.c \ + pin_named_pins.c \ usart.c \ usb.c \ printf.c \ @@ -72,8 +74,10 @@ SRC_C = \ pybmodule.c \ import.c \ lexerfatfs.c \ + gpio.c \ + exti.c \ + usrsw.c \ -# gpio.c \ # lcd.c \ # servo.c \ # flash.c \ @@ -86,10 +90,6 @@ SRC_C = \ # adc.c \ # rtc.c \ # file.c \ -# pin_named_pins.c \ -# pin_map.c \ -# exti.c \ -# usrsw.c \ # pybwlan.c \ SRC_S = \ diff --git a/stmhal/boards/NETDUINO_PLUS_2/mpconfigboard.h b/stmhal/boards/NETDUINO_PLUS_2/mpconfigboard.h index b355486e2e..412dede131 100644 --- a/stmhal/boards/NETDUINO_PLUS_2/mpconfigboard.h +++ b/stmhal/boards/NETDUINO_PLUS_2/mpconfigboard.h @@ -20,8 +20,8 @@ // USRSW is pulled low. Pressing the button makes the input go high. #define USRSW_PIN (pin_B11) -#define USRSW_PUPD (GPIO_PuPd_NOPULL) -#define USRSW_EXTI_EDGE (EXTI_Trigger_Rising) +#define USRSW_PULL (GPIO_NOPULL) +#define USRSW_EXTI_MODE (GPIO_MODE_IT_RISING) #define USRSW_PRESSED (1) /* LED */ diff --git a/stmhal/boards/PYBOARD3/mpconfigboard.h b/stmhal/boards/PYBOARD3/mpconfigboard.h index 6b15b20153..e0920f6859 100644 --- a/stmhal/boards/PYBOARD3/mpconfigboard.h +++ b/stmhal/boards/PYBOARD3/mpconfigboard.h @@ -16,8 +16,8 @@ // USRSW has no pullup or pulldown, and pressing the switch makes the input go low #define USRSW_PIN (pin_A13) -#define USRSW_PUPD (GPIO_PuPd_UP) -#define USRSW_EXTI_EDGE (EXTI_Trigger_Falling) +#define USRSW_PULL (GPIO_PULLUP) +#define USRSW_EXTI_MODE (GPIO_MODE_IT_FALLING) #define USRSW_PRESSED (0) /* LED */ diff --git a/stmhal/boards/PYBOARD4/mpconfigboard.h b/stmhal/boards/PYBOARD4/mpconfigboard.h index c255ba8ce9..c3d5e119c9 100644 --- a/stmhal/boards/PYBOARD4/mpconfigboard.h +++ b/stmhal/boards/PYBOARD4/mpconfigboard.h @@ -16,8 +16,8 @@ // USRSW has no pullup or pulldown, and pressing the switch makes the input go low #define USRSW_PIN (pin_B3) -#define USRSW_PUPD (GPIO_PuPd_UP) -#define USRSW_EXTI_EDGE (EXTI_Trigger_Falling) +#define USRSW_PULL (GPIO_PULLUP) +#define USRSW_EXTI_MODE (GPIO_MODE_IT_FALLING) #define USRSW_PRESSED (0) /* LED */ diff --git a/stmhal/boards/STM32F4DISC/mpconfigboard.h b/stmhal/boards/STM32F4DISC/mpconfigboard.h index 7c4efeb918..f713f9b756 100644 --- a/stmhal/boards/STM32F4DISC/mpconfigboard.h +++ b/stmhal/boards/STM32F4DISC/mpconfigboard.h @@ -16,8 +16,8 @@ // USRSW is pulled low. Pressing the button makes the input go high. #define USRSW_PIN (pin_A0) -#define USRSW_PUPD (GPIO_PuPd_NOPULL) -#define USRSW_EXTI_EDGE (EXTI_Trigger_Rising) +#define USRSW_PULL (GPIO_NOPULL) +#define USRSW_EXTI_MODE (GPIO_MODE_IT_RISING) #define USRSW_PRESSED (1) /* LED */ diff --git a/stmhal/exti.c b/stmhal/exti.c new file mode 100644 index 0000000000..ec6d82e4fd --- /dev/null +++ b/stmhal/exti.c @@ -0,0 +1,346 @@ +#include +#include +#include + +#include + +#include "misc.h" +#include "mpconfig.h" +#include "qstr.h" +#include "obj.h" +#include "runtime.h" +#include "nlr.h" + +#include "pin.h" +#include "exti.h" + +// Usage Model: +// +// There are a total of 22 interrupt lines. 16 of these can come from GPIO pins +// and the remaining 6 are from internal sources. +// +// For lines 0 thru 15, a given line can map to the corresponding line from an +// arbitrary port. So line 0 can map to Px0 where x is A, B, C, ... and +// line 1 can map to Px1 where x is A, B, C, ... +// +// def callback(line): +// print("line =", line) +// +// # Configure the pin as a GPIO input. +// pin = pyb.Pin.board.X1 +// pyb.gpio_in(pin, pyb.PULL_UP) +// exti = pyb.Exti(pin, pyb.Exti.MODE_IRQ_FALLING, pyb.PULLUP, callback) +// +// Now every time a falling edge is seen on the X1 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. +// +// Trying to register 2 callbacks onto the same pin will throw an exception. +// +// If pin is passed as an integer, then it is assumed to map to one of the +// internal interrupt sources, and must be in the range 16 thru 22. +// +// All other pin objects go through the pin mapper to come up with one of the +// gpio pins. +// +// exti = pyb.Exti(pin, mode, pull, callback) +// +// Valid modes are pyb.Exti.MODE_IRQ_RISING, pyb.Exti.MODE_IRQ_FALLING, +// pyb.Exti.MODE_IRQ_RISING_FALLING, pyb.Exti.MODE_EVT_RISING, +// pyb.Exti.MODE_EVT_FALLING, and pyb.Exti.MODE_EVT_RISING_FALLING. +// +// Only the MODE_IRQ_xxx modes have been tested. The MODE_EVENT_xxx modes have +// something to do with sleep mode and he WFE instruction. +// +// Valid pull values are pyb.PULL_UP, pyb.PULL_DOWN, pyb.PULL_NONE. +// +// exti.line() will return the line number that pin was mapped to. +// exti.disable() can be use to disable the interrupt associated with a given +// exti object. This could be useful for debouncing. +// exti.enable() enables a disabled interrupt +// exti.swint() will allow the callback to be triggered from software. +// +// pyb.Exti.regs() will dump the values of the EXTI registers. +// +// There is also a C API, so that drivers which require EXTI interrupt lines +// can also use this code. See exti.h for the available functions and +// usrsw.h for an example of using this. + +#define EXTI_OFFSET (EXTI_BASE - PERIPH_BASE) + +// Macro used to set/clear the bit corresponding to the line in the IMR/EMR +// register in an atomic fashion by using bitband addressing. +#define EXTI_MODE_BB(mode, line) (*(__IO uint32_t *)(PERIPH_BB_BASE + ((EXTI_OFFSET + (mode)) * 32) + ((line) * 4))) + +#define EXTI_Mode_Interrupt offsetof(EXTI_TypeDef, IMR) +#define EXTI_Mode_Event offsetof(EXTI_TypeDef, EMR) + +#define EXTI_SWIER_BB(line) (*(__IO uint32_t *)(PERIPH_BB_BASE + ((EXTI_OFFSET + offsetof(EXTI_TypeDef, SWIER)) * 32) + ((line) * 4))) + +typedef struct { + mp_obj_base_t base; + mp_small_int_t line; +} exti_obj_t; + +typedef struct { + mp_obj_t callback_obj; + void *param; + uint32_t mode; +} exti_vector_t; + +static exti_vector_t exti_vector[EXTI_NUM_VECTORS]; + +#if !defined(ETH) +#define ETH_WKUP_IRQn 62 // The 405 doesn't have ETH, but we want a value to put in our table +#endif + +static const uint8_t nvic_irq_channel[EXTI_NUM_VECTORS] = { + EXTI0_IRQn, EXTI1_IRQn, EXTI2_IRQn, EXTI3_IRQn, EXTI4_IRQn, + EXTI9_5_IRQn, EXTI9_5_IRQn, EXTI9_5_IRQn, EXTI9_5_IRQn, EXTI9_5_IRQn, + EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn, + EXTI15_10_IRQn, PVD_IRQn, RTC_Alarm_IRQn, OTG_FS_WKUP_IRQn, ETH_WKUP_IRQn, + OTG_HS_WKUP_IRQn, TAMP_STAMP_IRQn, RTC_WKUP_IRQn +}; + +// NOTE: param is for C callers. Python can use closure to get an object bound +// with the function. +uint exti_register(mp_obj_t pin_obj, mp_obj_t mode_obj, mp_obj_t pull_obj, mp_obj_t callback_obj, void *param) { + const pin_obj_t *pin = NULL; + uint v_line; + + if (MP_OBJ_IS_INT(pin_obj)) { + // If an integer is passed in, then use it to identify lines 16 thru 22 + // We expect lines 0 thru 15 to be passed in as a pin, so that we can + // get both the port number and line number. + v_line = mp_obj_get_int(pin_obj); + if (v_line < 16) { + nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "EXTI vector %d < 16, use a Pin object", v_line)); + } + if (v_line >= EXTI_NUM_VECTORS) { + nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "EXTI vector %d >= max of %d", v_line, EXTI_NUM_VECTORS)); + } + } else { + pin = pin_map_user_obj(pin_obj); + v_line = pin->pin; + } + int mode = mp_obj_get_int(mode_obj); + if (mode != GPIO_MODE_IT_RISING && + mode != GPIO_MODE_IT_FALLING && + mode != GPIO_MODE_IT_RISING_FALLING && + mode != GPIO_MODE_EVT_RISING && + mode != GPIO_MODE_EVT_FALLING && + mode != GPIO_MODE_EVT_RISING_FALLING) { + nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid EXTI Mode: %d", mode)); + } + int pull = mp_obj_get_int(pull_obj); + if (pull != GPIO_NOPULL && + pull != GPIO_PULLUP && + pull != GPIO_PULLDOWN) { + nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid EXTI Pull: %d", pull)); + } + + exti_vector_t *v = &exti_vector[v_line]; + if (v->callback_obj != mp_const_none && callback_obj != mp_const_none) { + nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "EXTI vector %d is already in use", v_line)); + } + + // We need to update callback and param atomically, so we disable the line + // before we update anything. + + exti_disable(v_line); + + v->callback_obj = callback_obj; + v->param = param; + v->mode = (mode & 0x00010000) ? // GPIO_MODE_IT == 0x00010000 + EXTI_Mode_Interrupt : EXTI_Mode_Event; + + if (v->callback_obj != mp_const_none) { + + GPIO_InitTypeDef exti; + exti.Pin = pin->pin_mask; + exti.Mode = mode; + exti.Pull = pull; + exti.Speed = GPIO_SPEED_FAST; + HAL_GPIO_Init(pin->gpio, &exti); + + // Calling HAL_GPIO_Init does an implicit exti_enable + + /* Enable and set NVIC Interrupt to the lowest priority */ + HAL_NVIC_SetPriority(nvic_irq_channel[v_line], 0x0F, 0x0F); + HAL_NVIC_EnableIRQ(nvic_irq_channel[v_line]); + } + return v_line; +} + +void exti_enable(uint line) { + if (line >= EXTI_NUM_VECTORS) { + return; + } + // Since manipulating IMR/EMR is a read-modify-write, and we want this to + // be atomic, we use the bit-band area to just affect the bit we're + // interested in. + EXTI_MODE_BB(exti_vector[line].mode, line) = 1; +} + +void exti_disable(uint line) { + if (line >= EXTI_NUM_VECTORS) { + return; + } + // Since manipulating IMR/EMR is a read-modify-write, and we want this to + // be atomic, we use the bit-band area to just affect the bit we're + // interested in. + EXTI_MODE_BB(EXTI_Mode_Interrupt, line) = 0; + EXTI_MODE_BB(EXTI_Mode_Event, line) = 0; +} + +void exti_swint(uint line) { + if (line >= EXTI_NUM_VECTORS) { + return; + } + EXTI->SWIER = (1 << line); +} + +static mp_obj_t exti_obj_line(mp_obj_t self_in) { + exti_obj_t *self = self_in; + return MP_OBJ_NEW_SMALL_INT(self->line); +} + +static mp_obj_t exti_obj_enable(mp_obj_t self_in) { + exti_obj_t *self = self_in; + exti_enable(self->line); + return mp_const_none; +} + +static mp_obj_t exti_obj_disable(mp_obj_t self_in) { + exti_obj_t *self = self_in; + exti_disable(self->line); + return mp_const_none; +} + +static mp_obj_t exti_obj_swint(mp_obj_t self_in) { + exti_obj_t *self = self_in; + exti_swint(self->line); + return mp_const_none; +} + +static MP_DEFINE_CONST_FUN_OBJ_1(exti_obj_line_obj, exti_obj_line); +static MP_DEFINE_CONST_FUN_OBJ_1(exti_obj_enable_obj, exti_obj_enable); +static MP_DEFINE_CONST_FUN_OBJ_1(exti_obj_disable_obj, exti_obj_disable); +static MP_DEFINE_CONST_FUN_OBJ_1(exti_obj_swint_obj, exti_obj_swint); + +static const mp_method_t exti_methods[] = { + { "line", &exti_obj_line_obj }, + { "enable", &exti_obj_enable_obj }, + { "disable", &exti_obj_disable_obj }, + { "swint", &exti_obj_swint_obj }, + { NULL, NULL }, +}; + +static mp_obj_t exti_regs(void) { + printf("EXTI_IMR %08lx\n", EXTI->IMR); + printf("EXTI_EMR %08lx\n", EXTI->EMR); + printf("EXTI_RTSR %08lx\n", EXTI->RTSR); + printf("EXTI_FTSR %08lx\n", EXTI->FTSR); + printf("EXTI_SWIER %08lx\n", EXTI->SWIER); + printf("EXTI_PR %08lx\n", EXTI->PR); + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_0(exti_regs_obj, exti_regs); + +typedef struct { + const char *name; + uint val; +} exti_const_t; + +static const exti_const_t exti_const[] = { + { "MODE_IRQ_RISING", GPIO_MODE_IT_RISING }, + { "MODE_IRQ_FALLING", GPIO_MODE_IT_FALLING }, + { "MODE_IRQ_RISING_FALLING", GPIO_MODE_IT_RISING_FALLING }, + { "MODE_EVT_RISING", GPIO_MODE_EVT_RISING }, + { "MODE_EVT_FALLING", GPIO_MODE_EVT_FALLING }, + { "MODE_EVT_RISING_FALLING", GPIO_MODE_EVT_RISING_FALLING }, +}; +#define EXTI_NUM_CONST (sizeof(exti_const) / sizeof(exti_const[0])) + +static void exti_load_attr(mp_obj_t self_in, qstr attr_qstr, mp_obj_t *dest) { + (void)self_in; + const char *attr = qstr_str(attr_qstr); + + if (strcmp(attr, "regs") == 0) { + dest[0] = (mp_obj_t)&exti_regs_obj; + return; + } + const exti_const_t *entry = &exti_const[0]; + for (; entry < &exti_const[EXTI_NUM_CONST]; entry++) { + if (strcmp(attr, entry->name) == 0) { + dest[0] = MP_OBJ_NEW_SMALL_INT(entry->val); + dest[1] = MP_OBJ_NULL; + return; + } + } +} + +// line_obj = pyb.Exti(pin, mode, trigger, callback) + +static mp_obj_t exti_call(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) { + // type_in == exti_obj_type + + rt_check_nargs(n_args, 4, 4, n_kw, 0); + + exti_obj_t *self = m_new_obj(exti_obj_t); + self->base.type = type_in; + mp_obj_t line_obj = args[0]; + mp_obj_t mode_obj = args[1]; + mp_obj_t trigger_obj = args[2]; + mp_obj_t callback_obj = args[3]; + self->line = exti_register(line_obj, mode_obj, trigger_obj, callback_obj, NULL); + + return self; +} + +static void exti_meta_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { + (void) self_in; + print(env, ""); +} + +static void exti_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { + exti_obj_t *self = self_in; + print(env, "", self->line); +} + +static const mp_obj_type_t exti_meta_obj_type = { + { &mp_type_type }, + .name = MP_QSTR_ExtiMeta, + .print = exti_meta_obj_print, + .call = exti_call, + .load_attr = exti_load_attr, +}; + +const mp_obj_type_t exti_obj_type = { + { &exti_meta_obj_type }, + .name = MP_QSTR_Exti, + .print = exti_obj_print, + .methods = exti_methods, +}; + +void exti_init(void) { + for (exti_vector_t *v = exti_vector; v < &exti_vector[EXTI_NUM_VECTORS]; v++) { + v->callback_obj = mp_const_none; + v->param = NULL; + v->mode = EXTI_Mode_Interrupt; + } +} + +void Handle_EXTI_Irq(uint32_t line) { + if (__HAL_GPIO_EXTI_GET_FLAG(1 << line)) { + __HAL_GPIO_EXTI_CLEAR_FLAG(1 << line); + if (line < EXTI_NUM_VECTORS) { + exti_vector_t *v = &exti_vector[line]; + if (v->callback_obj != mp_const_none) { + rt_call_function_1(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line)); + } + } + } +} diff --git a/stmhal/exti.h b/stmhal/exti.h new file mode 100644 index 0000000000..a6b50b26e8 --- /dev/null +++ b/stmhal/exti.h @@ -0,0 +1,38 @@ +// Vectors 0-15 are for regular pins +// Vectors 16-22 are for internal sources. +// +// Use the following constants for the internal sources: + +#define EXTI_PVD_OUTPUT (16) +#define EXTI_RTC_ALARM (17) +#define EXTI_USB_OTG_FS_WAKEUP (18) +#define EXTI_ETH_WAKEUP (19) +#define EXTI_USB_OTG_HS_WAKEUP (20) +#define EXTI_RTC_TIMESTAMP (21) +#define EXTI_RTC_WAKEUP (22) + +#define EXTI_NUM_VECTORS (23) + +#define EXTI_MODE_INTERRUPT (offsetof(EXTI_TypeDef, IMR)) +#define EXTI_MODE_EVENT (offsetof(EXTI_TypeDef, EMR)) + +#define EXTI_TRIGGER_RISING (offsetof(EXTI_TypeDef, RTSR)) +#define EXTI_TRIGGER_FALLING (offsetof(EXTI_TypeDef, FTSR)) +#define EXTI_TRIGGER_RISING_FALLING (EXTI_TRIGGER_RISING + EXTI_TRIGGER_FALLING) // just different from RISING or FALLING + +void exti_init(void); + +uint exti_register(mp_obj_t pin_obj, mp_obj_t mode_obj, mp_obj_t trigger_obj, mp_obj_t callback_obj, void *param); + +void exti_enable(uint line); +void exti_disable(uint line); +void exti_swint(uint line); + +void Handle_EXTI_Irq(uint32_t line); + +typedef struct { + mp_obj_t callback; + void *param; +} exti_t; + +extern const mp_obj_type_t exti_obj_type; diff --git a/stmhal/gpio.c b/stmhal/gpio.c new file mode 100644 index 0000000000..be1249b376 --- /dev/null +++ b/stmhal/gpio.c @@ -0,0 +1,72 @@ +// This is a woefully inadequate set of bindings for GPIO control, and +// needs to be replaced with something much better. + +#include +#include +#include + +#include "nlr.h" +#include "misc.h" +#include "mpconfig.h" +#include "qstr.h" +#include "misc.h" +#include "parse.h" +#include "obj.h" +#include "compile.h" +#include "runtime0.h" +#include "runtime.h" +#include "systick.h" +#include "gpio.h" +#include "pin.h" + +mp_obj_t pyb_gpio(uint n_args, mp_obj_t *args) { + const pin_obj_t *pin = pin_map_user_obj(args[0]); + if (n_args == 1) { + // get pin + return MP_OBJ_NEW_SMALL_INT(HAL_GPIO_ReadPin(pin->gpio, pin->pin_mask)); + } + + // set pin + HAL_GPIO_WritePin(pin->gpio, pin->pin_mask, rt_is_true(args[1])); + return mp_const_none; +} + +MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_gpio_obj, 1, 2, pyb_gpio); + +mp_obj_t pyb_gpio_input(uint n_args, mp_obj_t *args) { + const pin_obj_t *pin = pin_map_user_obj(args[0]); + + uint32_t pull = GPIO_NOPULL; + if (n_args > 1) { + pull = mp_obj_get_int(args[1]); + } + GPIO_InitTypeDef GPIO_InitStructure; + GPIO_InitStructure.Pin = pin->pin_mask; + GPIO_InitStructure.Mode = GPIO_MODE_INPUT; + GPIO_InitStructure.Pull = pull; + HAL_GPIO_Init(pin->gpio, &GPIO_InitStructure); + + return mp_const_none; +} + +MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_gpio_input_obj, 1, 2, pyb_gpio_input); + +mp_obj_t pyb_gpio_output(uint n_args, mp_obj_t *args) { + const pin_obj_t *pin = pin_map_user_obj(args[0]); + + uint32_t mode = GPIO_MODE_OUTPUT_PP; + if (n_args > 1) { + mode = mp_obj_get_int(args[1]) == GPIO_MODE_OUTPUT_OD ? + GPIO_MODE_OUTPUT_OD: GPIO_MODE_OUTPUT_PP; + } + GPIO_InitTypeDef GPIO_InitStructure; + GPIO_InitStructure.Pin = pin->pin_mask; + GPIO_InitStructure.Mode = mode; + GPIO_InitStructure.Speed = GPIO_SPEED_FAST; + GPIO_InitStructure.Pull = GPIO_NOPULL; + HAL_GPIO_Init(pin->gpio, &GPIO_InitStructure); + + return mp_const_none; +} + +MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_gpio_output_obj, 1, 2, pyb_gpio_output); diff --git a/stmhal/gpio.h b/stmhal/gpio.h new file mode 100644 index 0000000000..f43adfdac0 --- /dev/null +++ b/stmhal/gpio.h @@ -0,0 +1,7 @@ +mp_obj_t pyb_gpio(uint n_args, mp_obj_t *args); +mp_obj_t pyb_gpio_output(uint n_args, mp_obj_t *args); +mp_obj_t pyb_gpio_input(uint n_args, mp_obj_t *args); + +MP_DECLARE_CONST_FUN_OBJ(pyb_gpio_obj); +MP_DECLARE_CONST_FUN_OBJ(pyb_gpio_input_obj); +MP_DECLARE_CONST_FUN_OBJ(pyb_gpio_output_obj); diff --git a/stmhal/main.c b/stmhal/main.c index 3565b174b6..2c82cf030b 100644 --- a/stmhal/main.c +++ b/stmhal/main.c @@ -38,6 +38,8 @@ #include "pyexec.h" #include "pybmodule.h" #include "led.h" +#include "exti.h" +#include "usrsw.h" #include "usb.h" #if 0 #include "ff.h" @@ -49,11 +51,9 @@ #include "accel.h" #include "timer.h" #include "pybwlan.h" -#include "usrsw.h" #include "rtc.h" #include "file.h" #include "pin.h" -#include "exti.h" #endif void SystemClock_Config(void); @@ -309,13 +309,13 @@ soft_reset: def_path[2] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_lib); sys_path = mp_obj_new_list(3, def_path); -#if 0 exti_init(); #if MICROPY_HW_HAS_SWITCH switch_init(); #endif +#if 0 #if MICROPY_HW_HAS_LCD // LCD init (just creates class, init hardware by calling LCD()) lcd_init(); diff --git a/stmhal/pin_map.c b/stmhal/pin_map.c new file mode 100644 index 0000000000..c546231c80 --- /dev/null +++ b/stmhal/pin_map.c @@ -0,0 +1,227 @@ +#include +#include +#include +#include + +#include "misc.h" +#include "mpconfig.h" +#include "qstr.h" +#include "obj.h" +#include "runtime.h" +#include "nlr.h" +#include "map.h" + +#include "pin.h" + +// Usage Model: +// +// All Board Pins are predefined as pyb.Pin.board.Name +// +// x1_pin = pyb.Pin.board.X1 +// +// g = pyb.gpio(pyb.Pin.board.X1, 0) +// +// CPU pins which correspond to the board pins are available +// as pyb.cpu.Name. For the CPU pins, the names are the port letter +// followed by the pin number. On the PYBOARD4, pyb.Pin.board.X1 and +// pyb.Pin.cpu.B6 are the same pin. +// +// You can also use strings: +// +// g = pyb.gpio('X1', 0) +// +// Users can add their own names: +// +// pyb.Pin("LeftMotorDir", pyb.Pin.cpu.C12) +// g = pyb.gpio("LeftMotorDir", 0) +// +// and can query mappings +// +// pin = pyb.Pin("LeftMotorDir"); +// +// Users can also add their own mapping function: +// +// def MyMapper(pin_name): +// if pin_name == "LeftMotorDir": +// return pyb.Pin.cpu.A0 +// +// pyb.Pin.mapper(MyMapper) +// +// So, if you were to call: pyb.gpio("LeftMotorDir", 0) +// then "LeftMotorDir" is passed directly to the mapper function. +// +// To summarize, the following order determines how things get mapped into +// an ordinal pin number: +// +// 1 - Directly specify a pin object +// 2 - User supplied mapping function +// 3 - User supplied mapping (object must be usable as a dictionary key) +// 4 - Supply a string which matches a board pin +// 5 - Supply a string which matches a CPU port/pin +// +// You can set pyb.Pin.debug(True) to get some debug information about +// how a particular object gets mapped to a pin. + +static void pin_map_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { + (void)self_in; + print(env, ""); +} + +static mp_obj_t pin_map_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) { + pin_map_obj_t *self = self_in; + rt_check_nargs(n_args, 1, 2, n_kw, false); + + if (n_args > 1) { + if (!self->map_dict) { + self->map_dict = mp_obj_new_dict(1); + } + mp_obj_dict_store(self->map_dict, args[0], args[1]); + return mp_const_none; + } + + // Run an argument through the mapper and return the result. + return (mp_obj_t)pin_map_user_obj(args[0]); +} + +static mp_obj_t pin_map_obj_mapper(uint n_args, mp_obj_t *args) { + pin_map_obj_t *self = args[0]; + if (n_args > 1) { + self->mapper = args[1]; + return mp_const_none; + } + return self->mapper; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_map_obj_mapper_obj, 1, 2, pin_map_obj_mapper); + +static mp_obj_t pin_map_obj_debug(uint n_args, mp_obj_t *args) { + pin_map_obj_t *self = args[0]; + if (n_args > 1) { + self->debug = rt_is_true(args[1]); + return mp_const_none; + } + return MP_BOOL(self->debug); +} +static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_map_obj_debug_obj, 1, 2, pin_map_obj_debug); + +static void pin_map_load_attr(mp_obj_t self_in, qstr attr_qstr, mp_obj_t *dest) { + (void)self_in; + const char *attr = qstr_str(attr_qstr); + + if (strcmp(attr, "mapper") == 0) { + dest[0] = (mp_obj_t)&pin_map_obj_mapper_obj; + dest[1] = self_in; + } + if (strcmp(attr, "debug") == 0) { + dest[0] = (mp_obj_t)&pin_map_obj_debug_obj; + dest[1] = self_in; + } + if (strcmp(attr, pin_board_pins_obj.name) == 0) { + dest[0] = (mp_obj_t)&pin_board_pins_obj; + dest[1] = MP_OBJ_NULL; + } + if (strcmp(attr, pin_cpu_pins_obj.name) == 0) { + dest[0] = (mp_obj_t)&pin_cpu_pins_obj; + dest[1] = MP_OBJ_NULL; + } +} + +static const mp_obj_type_t pin_map_obj_type = { + { &mp_type_type }, + .name = MP_QSTR_PinMap, + .print = pin_map_obj_print, + .call = pin_map_call, + .load_attr = pin_map_load_attr, +}; + +static const pin_map_obj_t pin_map_obj_init = { + { &pin_map_obj_type }, + .mapper = MP_OBJ_NULL, + .map_dict = MP_OBJ_NULL, + .debug = false, +}; + +pin_map_obj_t pin_map_obj; + +void pin_map_init(void) { + pin_map_obj = pin_map_obj_init; +} + +// C API used to convert a user-supplied pin name into an ordinal pin number. +const pin_obj_t *pin_map_user_obj(mp_obj_t user_obj) { + const pin_obj_t *pin_obj; + + // If a pin was provided, then use it + if (MP_OBJ_IS_TYPE(user_obj, &pin_obj_type)) { + pin_obj = user_obj; + if (pin_map_obj.debug) { + printf("Pin map passed pin "); + mp_obj_print((mp_obj_t)pin_obj, PRINT_STR); + printf("\n"); + } + return pin_obj; + } + + if (pin_map_obj.mapper) { + pin_obj = rt_call_function_1(pin_map_obj.mapper, user_obj); + if (pin_obj != mp_const_none) { + if (!MP_OBJ_IS_TYPE(pin_obj, &pin_obj_type)) { + nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "Pin.mapper didn't return a Pin object")); + } + if (pin_map_obj.debug) { + printf("Pin.mapper maps "); + mp_obj_print(user_obj, PRINT_REPR); + printf(" to "); + mp_obj_print((mp_obj_t)pin_obj, PRINT_STR); + printf("\n"); + } + return pin_obj; + } + // The pin mapping function returned mp_const_none, fall through to + // other lookup methods. + } + + if (pin_map_obj.map_dict) { + mp_map_t *pin_map_map = mp_obj_dict_get_map(pin_map_obj.map_dict); + mp_map_elem_t *elem = mp_map_lookup(pin_map_map, user_obj, MP_MAP_LOOKUP); + if (elem != NULL && elem->value != NULL) { + pin_obj = elem->value; + if (pin_map_obj.debug) { + printf("Pin.map_dict maps "); + mp_obj_print(user_obj, PRINT_REPR); + printf(" to "); + mp_obj_print((mp_obj_t)pin_obj, PRINT_STR); + printf("\n"); + } + return pin_obj; + } + } + + // See if the pin name matches a board pin + const char *pin_name = mp_obj_str_get_str(user_obj); + pin_obj = pin_find_named_pin(pin_board_pins, pin_name); + if (pin_obj) { + if (pin_map_obj.debug) { + printf("Pin.board maps "); + mp_obj_print(user_obj, PRINT_REPR); + printf(" to "); + mp_obj_print((mp_obj_t)pin_obj, PRINT_STR); + printf("\n"); + } + return pin_obj; + } + + // See if the pin name matches a cpu pin + pin_obj = pin_find_named_pin(pin_cpu_pins, pin_name); + if (pin_obj) { + if (pin_map_obj.debug) { + printf("Pin.cpu maps "); + mp_obj_print(user_obj, PRINT_REPR); + printf(" to "); + mp_obj_print((mp_obj_t)pin_obj, PRINT_STR); + printf("\n"); + } + return pin_obj; + } + + nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "pin '%s' not a valid pin identifier", pin_name)); +} diff --git a/stmhal/pin_named_pins.c b/stmhal/pin_named_pins.c new file mode 100644 index 0000000000..48906ad800 --- /dev/null +++ b/stmhal/pin_named_pins.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include + +#include "misc.h" +#include "mpconfig.h" +#include "qstr.h" +#include "obj.h" +#include "runtime.h" + +#include "pin.h" + +static void pin_named_pins_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { + pin_named_pins_obj_t *self = self_in; + print(env, "", self->name); +} + +static void pin_named_pins_obj_load_attr(mp_obj_t self_in, qstr attr_qstr, mp_obj_t *dest) { + pin_named_pins_obj_t *self = self_in; + const char *attr = qstr_str(attr_qstr); + const pin_obj_t *pin = pin_find_named_pin(self->named_pins, attr); + if (pin) { + dest[0] = (mp_obj_t)pin; + dest[1] = MP_OBJ_NULL; + } +} + +static const mp_obj_type_t pin_named_pins_obj_type = { + { &mp_type_type }, + .name = MP_QSTR_PinNamed, + .print = pin_named_pins_obj_print, + .load_attr = pin_named_pins_obj_load_attr, +}; + +const pin_named_pins_obj_t pin_board_pins_obj = { + { &pin_named_pins_obj_type }, + .name = "board", + .named_pins = pin_board_pins, +}; + +const pin_named_pins_obj_t pin_cpu_pins_obj = { + { &pin_named_pins_obj_type }, + .name = "cpu", + .named_pins = pin_cpu_pins, +}; + +const pin_obj_t *pin_find_named_pin(const pin_named_pin_t *named_pins, const char *name) { + const pin_named_pin_t *named_pin = named_pins; + while (named_pin->name) { + if (!strcmp(name, named_pin->name)) { + return named_pin->pin; + } + named_pin++; + } + return NULL; +} + +const pin_af_obj_t *pin_find_af(const pin_obj_t *pin, uint8_t fn, uint8_t unit, uint8_t type) { + const pin_af_obj_t *af = pin->af; + for (int i = 0; i < pin->num_af; i++, af++) { + if (af->fn == fn && af->unit == unit && af->type == type) { + return af; + } + } + return NULL; +} diff --git a/stmhal/pybmodule.c b/stmhal/pybmodule.c index 2abcb23700..0d2b914ded 100644 --- a/stmhal/pybmodule.c +++ b/stmhal/pybmodule.c @@ -16,21 +16,21 @@ #include "systick.h" #include "pyexec.h" #include "led.h" +#include "gpio.h" +#include "pin.h" +#include "exti.h" +#include "usrsw.h" #if 0 #include "rtc.h" #include "servo.h" #include "storage.h" #include "usb.h" -#include "usrsw.h" #include "sdcard.h" #include "accel.h" #include "i2c.h" #include "usart.h" #include "adc.h" #include "audio.h" -#include "pin.h" -#include "gpio.h" -#include "exti.h" #endif #include "pybmodule.h" @@ -252,11 +252,13 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_servo), (mp_obj_t)&pyb_servo_set_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_Servo), (mp_obj_t)&pyb_Servo_obj }, #endif +#endif #if MICROPY_HW_HAS_SWITCH { MP_OBJ_NEW_QSTR(MP_QSTR_switch), (mp_obj_t)&pyb_switch_obj }, #endif +#if 0 #if MICROPY_HW_HAS_SDCARD { MP_OBJ_NEW_QSTR(MP_QSTR_SD), (mp_obj_t)&pyb_sdcard_obj }, #endif @@ -278,6 +280,7 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = { #if MICROPY_HW_ENABLE_AUDIO { MP_OBJ_NEW_QSTR(MP_QSTR_Audio), (mp_obj_t)&pyb_Audio_obj }, +#endif #endif // pin mapper @@ -287,15 +290,14 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_gpio), (mp_obj_t)&pyb_gpio_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_gpio_in), (mp_obj_t)&pyb_gpio_input_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_gpio_out), (mp_obj_t)&pyb_gpio_output_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_NONE), MP_OBJ_NEW_SMALL_INT(GPIO_PuPd_NOPULL) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_UP), MP_OBJ_NEW_SMALL_INT(GPIO_PuPd_UP) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_DOWN), MP_OBJ_NEW_SMALL_INT(GPIO_PuPd_DOWN) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_PUSH_PULL), MP_OBJ_NEW_SMALL_INT(GPIO_OType_PP) }, - { MP_OBJ_NEW_QSTR(MP_QSTR_OPEN_DRAIN), MP_OBJ_NEW_SMALL_INT(GPIO_OType_OD) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_NONE), MP_OBJ_NEW_SMALL_INT(GPIO_NOPULL) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_UP), MP_OBJ_NEW_SMALL_INT(GPIO_PULLUP) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_DOWN), MP_OBJ_NEW_SMALL_INT(GPIO_PULLDOWN) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_PUSH_PULL), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_OUTPUT_PP) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_OPEN_DRAIN), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_OUTPUT_OD) }, // EXTI bindings { MP_OBJ_NEW_QSTR(MP_QSTR_Exti), (mp_obj_t)&exti_obj_type }, -#endif }; STATIC const mp_map_t pyb_module_globals = { diff --git a/stmhal/stm32f4xx_it.c b/stmhal/stm32f4xx_it.c index b9651aa651..89764f07d6 100644 --- a/stmhal/stm32f4xx_it.c +++ b/stmhal/stm32f4xx_it.c @@ -43,6 +43,12 @@ #include "stm32f4xx_it.h" #include "stm32f4xx_hal.h" +#include "misc.h" +#include "mpconfig.h" +#include "qstr.h" +#include "obj.h" +#include "exti.h" + /** @addtogroup STM32F4xx_HAL_Examples * @{ */ @@ -256,13 +262,90 @@ void OTG_XX_WKUP_IRQHandler(void) { }*/ - /** - * @} - */ - -/** - * @} + * @brief These functions handle the EXTI interrupt requests. + * @param None + * @retval None */ +void EXTI0_IRQHandler(void) { + Handle_EXTI_Irq(0); +} + +void EXTI1_IRQHandler(void) { + Handle_EXTI_Irq(1); +} + +void EXTI2_IRQHandler(void) { + Handle_EXTI_Irq(2); +} + +void EXTI3_IRQHandler(void) { + Handle_EXTI_Irq(3); +} + +void EXTI4_IRQHandler(void) { + Handle_EXTI_Irq(4); +} + +void EXTI9_5_IRQHandler(void) { + Handle_EXTI_Irq(5); + Handle_EXTI_Irq(6); + Handle_EXTI_Irq(7); + Handle_EXTI_Irq(8); + Handle_EXTI_Irq(9); +} + +void EXTI15_10_IRQHandler(void) { + Handle_EXTI_Irq(10); + Handle_EXTI_Irq(11); + Handle_EXTI_Irq(12); + Handle_EXTI_Irq(13); + Handle_EXTI_Irq(14); + Handle_EXTI_Irq(15); + +#if 0 + // for CC3000 support, needs to be re-written to use new EXTI code + if (EXTI_GetITStatus(EXTI_Line14) != RESET) { + led_toggle(PYB_LED_G2); + /* these are needed for CC3000 support + extern void SpiIntGPIOHandler(void); + extern uint32_t exti14_enabled; + extern uint32_t exti14_missed; + //printf("-> EXTI14 en=%lu miss=%lu\n", exti14_enabled, exti14_missed); + if (exti14_enabled) { + exti14_missed = 0; + SpiIntGPIOHandler(); // CC3000 interrupt + } else { + exti14_missed = 1; + } + */ + EXTI_ClearITPendingBit(EXTI_Line14); + //printf("<- EXTI14 done\n"); + } +#endif +} + +void PVD_IRQHandler(void) { + Handle_EXTI_Irq(EXTI_PVD_OUTPUT); +} + +void RTC_Alarm_IRQHandler(void) { + Handle_EXTI_Irq(EXTI_RTC_ALARM); +} + + +#if defined(ETH) // The 407 has ETH, the 405 doesn't +void ETH_WKUP_IRQHandler(void) { + Handle_EXTI_Irq(EXTI_ETH_WAKEUP); +} +#endif + +void TAMP_STAMP_IRQHandler(void) { + Handle_EXTI_Irq(EXTI_RTC_TIMESTAMP); +} + +void RTC_WKUP_IRQHandler(void) { + Handle_EXTI_Irq(EXTI_RTC_WAKEUP); +} /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/stmhal/usrsw.c b/stmhal/usrsw.c new file mode 100644 index 0000000000..69a03b2cc3 --- /dev/null +++ b/stmhal/usrsw.c @@ -0,0 +1,67 @@ +#include +#include + +#include "misc.h" +#include "mpconfig.h" +#include "qstr.h" +#include "obj.h" +#include "runtime.h" +#include "usrsw.h" + +#include "exti.h" +#include "gpio.h" +#include "pin.h" +#include "build/pins.h" + +// Usage Model: +// +// pyb.switch() returns True if the user switch is pressed, False otherwise. +// +// pyb.switch(callback) will register a callback to be called when the user +// switch is pressed. +// +// pyb.switch(None) will remove the callback. +// +// Example: +// +// def switch_pressed(): +// print("User Switch pressed") +// +// pyb.switch(switch_pressed) + +static mp_obj_t switch_user_callback_obj; + +static mp_obj_t switch_callback(mp_obj_t line) { + if (switch_user_callback_obj != mp_const_none) { + rt_call_function_0(switch_user_callback_obj); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_1(switch_callback_obj, switch_callback); + +void switch_init(void) { + switch_user_callback_obj = mp_const_none; + exti_register((mp_obj_t)&USRSW_PIN, + MP_OBJ_NEW_SMALL_INT(USRSW_EXTI_MODE), + MP_OBJ_NEW_SMALL_INT(USRSW_PULL), + (mp_obj_t)&switch_callback_obj, + NULL); +} + +int switch_get(void) { + int val = ((USRSW_PIN.gpio->IDR & USRSW_PIN.pin_mask) != 0); + return val == USRSW_PRESSED; +} + +/******************************************************************************/ +/* Micro Python bindings */ + +static mp_obj_t pyb_switch(uint n_args, mp_obj_t *args) { + if (n_args == 0) { + return switch_get() ? mp_const_true : mp_const_false; + } + switch_user_callback_obj = args[0]; + return mp_const_none; +} + +MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_switch_obj, 0, 1, pyb_switch); diff --git a/stmhal/usrsw.h b/stmhal/usrsw.h new file mode 100644 index 0000000000..2da8f069ba --- /dev/null +++ b/stmhal/usrsw.h @@ -0,0 +1,4 @@ +void switch_init(void); +int switch_get(void); + +MP_DECLARE_CONST_FUN_OBJ(pyb_switch_obj);