Damien George
11 years ago
13 changed files with 555 additions and 153 deletions
@ -0,0 +1,417 @@ |
|||
#include <stdio.h> |
|||
#include <stddef.h> |
|||
#include <string.h> |
|||
|
|||
#include <stm32f4xx.h> |
|||
#include <stm32f4xx_gpio.h> |
|||
|
|||
#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, param):
|
|||
// print("line =", line, "param =", param)
|
|||
//
|
|||
// # 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, pyb.Exti.TRIGGER_RISING, callback, 37)
|
|||
//
|
|||
// Now every time a rising 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.
|
|||
//
|
|||
// Valid modes are pyb.Exti.MODE_IRQ and pyb.Exti.MODE_EVENT (Only MODE_IRQ
|
|||
// has been tested. MODE_EVENT has something to do with sleep mode and the
|
|||
// WFE instruction).
|
|||
//
|
|||
// Valid edge triggers are pyb.Exti.TRIGGER_RISING, TRIGGER_FALLING, and TRIGGER_BOTH.
|
|||
//
|
|||
// 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) (*(vu32 *)(PERIPH_BB_BASE + ((EXTI_OFFSET + (mode)) * 32) + ((line) * 4))) |
|||
|
|||
// This macro will work with the EXTI_Trigger_Rising and EXTI_Trigger_Falling constants
|
|||
// but not EXTI_Trigger_Rising_Falling.
|
|||
#define EXTI_EDGE_BB(edge, line) (*(vu32 *)(PERIPH_BB_BASE + ((EXTI_OFFSET + (edge)) * 32) + ((line) * 4))) |
|||
|
|||
#define EXTI_SWIER_BB(line) (*(vu32 *)(PERIPH_BB_BASE + ((EXTI_OFFSET + offsetof(EXTI_TypeDef, SWIER)) * 32) + ((line) * 4))) |
|||
#define EXTI_PR_BB(line) (*(vu32 *)(PERIPH_BB_BASE + ((EXTI_OFFSET + offsetof(EXTI_TypeDef, PR)) * 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; |
|||
mp_obj_t param_obj; |
|||
EXTIMode_TypeDef mode; |
|||
} exti_vector_t; |
|||
|
|||
static exti_vector_t exti_vector[EXTI_NUM_VECTORS]; |
|||
|
|||
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 |
|||
}; |
|||
|
|||
uint exti_register(mp_obj_t pin_obj, mp_obj_t mode_obj, mp_obj_t trigger_obj, mp_obj_t callback_obj, mp_obj_t param_obj) { |
|||
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 (!IS_EXTI_MODE(mode)) { |
|||
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid EXTI Mode: %d", mode)); |
|||
} |
|||
int trigger = mp_obj_get_int(trigger_obj); |
|||
if (!IS_EXTI_TRIGGER(trigger)) { |
|||
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid EXTI Trigger: %d", trigger)); |
|||
} |
|||
|
|||
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); |
|||
|
|||
if (pin && callback_obj) { |
|||
// Enable SYSCFG clock
|
|||
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); |
|||
|
|||
// For EXTI lines 0 thru 15, we need to configure which port controls
|
|||
// the line.
|
|||
SYSCFG_EXTILineConfig(pin->port, v_line); |
|||
} |
|||
v->callback_obj = callback_obj; |
|||
v->param_obj = param_obj; |
|||
v->mode = mode; |
|||
|
|||
if (v->callback_obj != mp_const_none) { |
|||
// The EXTI_Init function isn't atomic. It uses |= and &=.
|
|||
// We use bit band operations to make it atomic.
|
|||
exti_disable(v_line); |
|||
EXTI_EDGE_BB(EXTI_Trigger_Rising, v_line) = |
|||
trigger == EXTI_Trigger_Rising || trigger == EXTI_Trigger_Rising_Falling; |
|||
EXTI_EDGE_BB(EXTI_Trigger_Falling, v_line) = |
|||
trigger == EXTI_Trigger_Falling || trigger == EXTI_Trigger_Rising_Falling; |
|||
exti_enable(v_line); |
|||
|
|||
/* Enable and set NVIC Interrupt to the lowest priority */ |
|||
NVIC_InitTypeDef NVIC_InitStructure; |
|||
NVIC_InitStructure.NVIC_IRQChannel = nvic_irq_channel[v_line]; |
|||
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F; |
|||
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F; |
|||
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; |
|||
NVIC_Init(&NVIC_InitStructure); |
|||
} |
|||
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_BB(line) = 1; |
|||
} |
|||
|
|||
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", EXTI_Mode_Interrupt }, |
|||
{ "MODE_EVENT", EXTI_Mode_Event }, |
|||
{ "TRIGGER_RISING", EXTI_Trigger_Rising }, |
|||
{ "TRIGGER_FALLING", EXTI_Trigger_Falling }, |
|||
{ "TRIGGER_BOTH", EXTI_Trigger_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, [param])
|
|||
|
|||
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, 5, 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]; |
|||
mp_obj_t param_obj = mp_const_none; |
|||
if (n_args > 4) { |
|||
param_obj = args[4]; |
|||
} |
|||
self->line = exti_register(line_obj, mode_obj, trigger_obj, callback_obj, param_obj); |
|||
|
|||
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, "<Exti meta>"); |
|||
} |
|||
|
|||
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, "<Exti line=%u>", 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, |
|||
}; |
|||
|
|||
static 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_early(void) { |
|||
for (exti_vector_t *v = exti_vector; v < &exti_vector[EXTI_NUM_VECTORS]; v++) { |
|||
v->callback_obj = mp_const_none; |
|||
v->param_obj = mp_const_none; |
|||
v->mode = EXTI_Mode_Interrupt; |
|||
} |
|||
} |
|||
|
|||
void exti_init(mp_obj_t mod) { |
|||
rt_store_attr(mod, MP_QSTR_Exti, (mp_obj_t)&exti_obj_type); |
|||
} |
|||
|
|||
static void Handle_EXTI_Irq(uint32_t line) { |
|||
if (EXTI_PR_BB(line)) { |
|||
EXTI_PR_BB(line) = 1; // Clears bit
|
|||
if (line < EXTI_NUM_VECTORS) { |
|||
exti_vector_t *v = &exti_vector[line]; |
|||
if (v->callback_obj != mp_const_none) { |
|||
rt_call_function_2(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line), v->param_obj); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
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); |
|||
} |
|||
|
|||
void PVD_IRQHandler(void) { |
|||
Handle_EXTI_Irq(16); |
|||
} |
|||
|
|||
void RTC_Alarm_IRQHandler(void) { |
|||
Handle_EXTI_Irq(17); |
|||
} |
|||
|
|||
#if 0 // dealt with in stm32fxxx_it.c
|
|||
void OTG_FS_WKUP_IRQHandler(void) { |
|||
Handle_EXTI_Irq(18); |
|||
} |
|||
#endif |
|||
|
|||
void ETH_WKUP_IRQHandler(void) { |
|||
Handle_EXTI_Irq(19); |
|||
} |
|||
|
|||
#if 0 // dealt with in stm32fxxx_it.c
|
|||
void OTG_HS_WKUP_IRQHandler(void) { |
|||
Handle_EXTI_Irq(20); |
|||
} |
|||
#endif |
|||
|
|||
void TAMP_STAMP_IRQHandler(void) { |
|||
Handle_EXTI_Irq(21); |
|||
} |
|||
|
|||
void RTC_WKUP_IRQHandler(void) { |
|||
Handle_EXTI_Irq(22); |
|||
} |
|||
@ -0,0 +1,29 @@ |
|||
// 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 |
|||
|
|||
void exti_init_early(void); |
|||
void exti_init(mp_obj_t mod); |
|||
|
|||
uint exti_register(mp_obj_t pin_obj, mp_obj_t mode_obj, mp_obj_t trigger_obj, mp_obj_t callback_obj, mp_obj_t param_obj); |
|||
|
|||
void exti_enable(uint line); |
|||
void exti_disable(uint line); |
|||
void exti_swint(uint line); |
|||
|
|||
typedef struct { |
|||
mp_obj_t callback; |
|||
mp_obj_t param; |
|||
} exti_t; |
|||
|
|||
@ -1 +1,4 @@ |
|||
mp_obj_t pyb_gpio(uint n_args, mp_obj_t *args); |
|||
mp_obj_t pyb_gpio_input(mp_obj_t arg_pin, mp_obj_t arg_mode); |
|||
mp_obj_t pyb_gpio_output(mp_obj_t arg_pin, mp_obj_t arg_mode); |
|||
void gpio_init(mp_obj_t mod); |
|||
|
|||
@ -1,78 +1,67 @@ |
|||
#include <stm_misc.h> |
|||
#include <stm32f4xx_gpio.h> |
|||
#include <stm32f4xx_exti.h> |
|||
#include <stm32f4xx_syscfg.h> |
|||
#include <stm32f4xx_rcc.h> |
|||
#include <stdio.h> |
|||
#include <stm32f4xx.h> |
|||
|
|||
#include "misc.h" |
|||
#include "mpconfig.h" |
|||
#include "qstr.h" |
|||
#include "obj.h" |
|||
#include "runtime.h" |
|||
#include "usrsw.h" |
|||
|
|||
void switch_init(void) { |
|||
// make it an input with pull-up
|
|||
GPIO_InitTypeDef GPIO_InitStructure; |
|||
GPIO_InitStructure.GPIO_Pin = USRSW_PIN; |
|||
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; |
|||
GPIO_InitStructure.GPIO_PuPd = USRSW_PUPD; |
|||
GPIO_Init(USRSW_PORT, &GPIO_InitStructure); |
|||
|
|||
// the rest does the EXTI interrupt
|
|||
#include "exti.h" |
|||
#include "gpio.h" |
|||
#include "pin.h" |
|||
#include "build/pins.h" |
|||
|
|||
/* Enable SYSCFG clock */ |
|||
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); |
|||
// 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 callback():
|
|||
// print("User Switch pressed")
|
|||
//
|
|||
// pyb.switch(callback)
|
|||
|
|||
/* Connect EXTI Line to GPIO pin */ |
|||
SYSCFG_EXTILineConfig(USRSW_EXTI_PORT, USRSW_EXTI_PIN); |
|||
static mp_obj_t switch_user_callback_obj; |
|||
|
|||
/* Configure EXTI Line */ |
|||
EXTI_InitTypeDef EXTI_InitStructure; |
|||
EXTI_InitStructure.EXTI_Line = USRSW_EXTI_LINE; |
|||
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; |
|||
EXTI_InitStructure.EXTI_Trigger = USRSW_EXTI_EDGE; |
|||
EXTI_InitStructure.EXTI_LineCmd = ENABLE; |
|||
EXTI_Init(&EXTI_InitStructure); |
|||
static mp_obj_t switch_callback(mp_obj_t line, mp_obj_t param) { |
|||
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_2(switch_callback_obj, switch_callback); |
|||
|
|||
/* Enable and set EXTI15_10 Interrupt to the lowest priority */ |
|||
NVIC_InitTypeDef NVIC_InitStructure; |
|||
NVIC_InitStructure.NVIC_IRQChannel = USRSW_EXTI_IRQN; |
|||
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F; |
|||
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F; |
|||
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; |
|||
NVIC_Init(&NVIC_InitStructure); |
|||
void switch_init(void) { |
|||
switch_user_callback_obj = mp_const_none; |
|||
exti_register((mp_obj_t)&USRSW_PIN, |
|||
MP_OBJ_NEW_SMALL_INT(EXTI_Mode_Interrupt), |
|||
MP_OBJ_NEW_SMALL_INT(USRSW_EXTI_EDGE), |
|||
(mp_obj_t)&switch_callback_obj, |
|||
mp_const_none); |
|||
pyb_gpio_input((mp_obj_t)&USRSW_PIN, MP_OBJ_NEW_SMALL_INT(USRSW_PUPD)); |
|||
} |
|||
|
|||
int switch_get(void) { |
|||
#if defined (PYBOARD3) || defined (PYBOARD4) |
|||
if (USRSW_PORT->IDR & USRSW_PIN) { |
|||
// pulled high, so switch is not pressed
|
|||
return 0; |
|||
} else { |
|||
// pulled low, so switch is pressed
|
|||
return 1; |
|||
} |
|||
#elif defined (STM32F4DISC) || defined(NETDUINO_PLUS_2) |
|||
/* switch pulled down */ |
|||
if (USRSW_PORT->IDR & USRSW_PIN) { |
|||
// pulled high, so switch is pressed
|
|||
return 1; |
|||
} else { |
|||
// pulled low, so switch is not pressed
|
|||
return 0; |
|||
} |
|||
#endif |
|||
int val = ((USRSW_PIN.gpio->IDR & USRSW_PIN.pin_mask) != 0); |
|||
return val == USRSW_PRESSED; |
|||
} |
|||
|
|||
/******************************************************************************/ |
|||
/* Micro Python bindings */ |
|||
|
|||
static mp_obj_t pyb_switch(void) { |
|||
if (switch_get()) { |
|||
return mp_const_true; |
|||
} else { |
|||
return mp_const_false; |
|||
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_0(pyb_switch_obj, pyb_switch); |
|||
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_switch_obj, 0, 1, pyb_switch); |
|||
|
|||
Loading…
Reference in new issue