2015-02-06 15:35:48 +01:00
|
|
|
/*
|
2017-06-30 09:22:17 +02:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2015-02-06 15:35:48 +01:00
|
|
|
*
|
|
|
|
* 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 <stdio.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2015-02-21 19:58:43 +01:00
|
|
|
#include "py/runtime.h"
|
2015-03-04 13:51:01 +01:00
|
|
|
#include "py/gc.h"
|
2015-02-06 15:35:48 +01:00
|
|
|
#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 "prcm.h"
|
|
|
|
#include "gpio.h"
|
2015-03-04 13:51:01 +01:00
|
|
|
#include "interrupt.h"
|
2015-02-09 19:38:02 +01:00
|
|
|
#include "pybpin.h"
|
2015-09-22 23:20:29 +02:00
|
|
|
#include "mpirq.h"
|
2015-03-16 13:46:11 +01:00
|
|
|
#include "pins.h"
|
2015-02-27 16:50:06 +01:00
|
|
|
#include "pybsleep.h"
|
2015-03-04 13:51:01 +01:00
|
|
|
#include "mperror.h"
|
2015-02-06 15:35:48 +01:00
|
|
|
|
|
|
|
|
|
|
|
/// \moduleref pyb
|
2015-02-09 19:38:02 +01:00
|
|
|
/// \class Pin - control I/O pins
|
2015-02-06 15:35:48 +01:00
|
|
|
///
|
2015-03-04 13:51:01 +01:00
|
|
|
/******************************************************************************
|
|
|
|
DECLARE PRIVATE FUNCTIONS
|
|
|
|
******************************************************************************/
|
2015-09-03 11:25:44 +02:00
|
|
|
STATIC pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name);
|
|
|
|
STATIC pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit);
|
2015-09-07 21:19:11 +02:00
|
|
|
STATIC int8_t pin_obj_find_af (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type);
|
2015-09-08 15:07:42 +02:00
|
|
|
STATIC void pin_free_af_from_pins (uint8_t fn, uint8_t unit, uint8_t type);
|
2015-09-07 21:19:11 +02:00
|
|
|
STATIC void pin_deassign (pin_obj_t* pin);
|
2015-07-01 19:36:57 +02:00
|
|
|
STATIC void pin_obj_configure (const pin_obj_t *self);
|
|
|
|
STATIC void pin_get_hibernate_pin_and_idx (const pin_obj_t *self, uint *wake_pin, uint *idx);
|
2015-09-22 23:20:29 +02:00
|
|
|
STATIC void pin_irq_enable (mp_obj_t self_in);
|
|
|
|
STATIC void pin_irq_disable (mp_obj_t self_in);
|
2015-07-01 19:36:57 +02:00
|
|
|
STATIC void pin_extint_register(pin_obj_t *self, uint32_t intmode, uint32_t priority);
|
2015-08-18 14:07:19 +02:00
|
|
|
STATIC void pin_validate_mode (uint mode);
|
|
|
|
STATIC void pin_validate_pull (uint pull);
|
|
|
|
STATIC void pin_validate_drive (uint strength);
|
2015-09-07 21:19:11 +02:00
|
|
|
STATIC void pin_validate_af(const pin_obj_t* pin, int8_t idx, uint8_t *fn, uint8_t *unit, uint8_t *type);
|
2015-10-25 19:23:51 +01:00
|
|
|
STATIC uint8_t pin_get_value(const pin_obj_t* self);
|
2015-03-04 13:51:01 +01:00
|
|
|
STATIC void GPIOA0IntHandler (void);
|
|
|
|
STATIC void GPIOA1IntHandler (void);
|
|
|
|
STATIC void GPIOA2IntHandler (void);
|
|
|
|
STATIC void GPIOA3IntHandler (void);
|
|
|
|
STATIC void EXTI_Handler(uint port);
|
2015-02-27 16:50:06 +01:00
|
|
|
|
2015-03-12 16:14:55 +01:00
|
|
|
/******************************************************************************
|
|
|
|
DEFINE CONSTANTS
|
|
|
|
******************************************************************************/
|
|
|
|
#define PYBPIN_NUM_WAKE_PINS (6)
|
|
|
|
#define PYBPIN_WAKES_NOT (-1)
|
|
|
|
|
2015-08-18 14:07:19 +02:00
|
|
|
#define GPIO_DIR_MODE_ALT 0x00000002 // Pin is NOT controlled by the PGIO module
|
|
|
|
#define GPIO_DIR_MODE_ALT_OD 0x00000003 // Pin is NOT controlled by the PGIO module and is in open drain mode
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
#define PYB_PIN_FALLING_EDGE 0x01
|
|
|
|
#define PYB_PIN_RISING_EDGE 0x02
|
|
|
|
#define PYB_PIN_LOW_LEVEL 0x04
|
|
|
|
#define PYB_PIN_HIGH_LEVEL 0x08
|
|
|
|
|
2015-03-12 16:14:55 +01:00
|
|
|
/******************************************************************************
|
|
|
|
DEFINE TYPES
|
|
|
|
******************************************************************************/
|
|
|
|
typedef struct {
|
|
|
|
bool active;
|
|
|
|
int8_t lpds;
|
|
|
|
int8_t hib;
|
|
|
|
} pybpin_wake_pin_t;
|
|
|
|
|
2015-03-04 13:52:39 +01:00
|
|
|
/******************************************************************************
|
|
|
|
DECLARE PRIVATE DATA
|
|
|
|
******************************************************************************/
|
2015-09-22 23:20:29 +02:00
|
|
|
STATIC const mp_irq_methods_t pin_irq_methods;
|
2015-03-12 16:14:55 +01:00
|
|
|
STATIC pybpin_wake_pin_t pybpin_wake_pin[PYBPIN_NUM_WAKE_PINS] =
|
|
|
|
{ {.active = false, .lpds = PYBPIN_WAKES_NOT, .hib = PYBPIN_WAKES_NOT},
|
|
|
|
{.active = false, .lpds = PYBPIN_WAKES_NOT, .hib = PYBPIN_WAKES_NOT},
|
|
|
|
{.active = false, .lpds = PYBPIN_WAKES_NOT, .hib = PYBPIN_WAKES_NOT},
|
|
|
|
{.active = false, .lpds = PYBPIN_WAKES_NOT, .hib = PYBPIN_WAKES_NOT},
|
|
|
|
{.active = false, .lpds = PYBPIN_WAKES_NOT, .hib = PYBPIN_WAKES_NOT},
|
|
|
|
{.active = false, .lpds = PYBPIN_WAKES_NOT, .hib = PYBPIN_WAKES_NOT} } ;
|
2015-02-27 16:50:06 +01:00
|
|
|
|
2015-03-04 13:51:01 +01:00
|
|
|
/******************************************************************************
|
|
|
|
DEFINE PUBLIC FUNCTIONS
|
|
|
|
******************************************************************************/
|
2015-02-09 19:38:02 +01:00
|
|
|
void pin_init0(void) {
|
2015-09-03 11:25:44 +02:00
|
|
|
// this initalization also reconfigures the JTAG/SWD pins
|
|
|
|
#ifndef DEBUG
|
2015-09-07 09:23:46 +02:00
|
|
|
// assign all pins to the GPIO module so that peripherals can be connected to any
|
|
|
|
// pins without conflicts after a soft reset
|
2018-07-08 14:08:24 +02:00
|
|
|
const mp_map_t *named_map = &pin_board_pins_locals_dict.map;
|
2015-09-03 11:25:44 +02:00
|
|
|
for (uint i = 0; i < named_map->used - 1; i++) {
|
|
|
|
pin_obj_t * pin = (pin_obj_t *)named_map->table[i].value;
|
2015-09-07 21:19:11 +02:00
|
|
|
pin_deassign (pin);
|
2015-09-03 11:25:44 +02:00
|
|
|
}
|
|
|
|
#endif
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// C API used to convert a user-supplied pin name into an ordinal pin number.
|
2015-03-04 13:52:39 +01:00
|
|
|
pin_obj_t *pin_find(mp_obj_t user_obj) {
|
|
|
|
pin_obj_t *pin_obj;
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2015-05-02 22:57:51 +02:00
|
|
|
// if a pin was provided, use it
|
2019-01-30 12:05:48 +01:00
|
|
|
if (mp_obj_is_type(user_obj, &pin_type)) {
|
2015-02-09 19:38:02 +01:00
|
|
|
pin_obj = user_obj;
|
|
|
|
return pin_obj;
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
2015-05-02 22:57:51 +02:00
|
|
|
// otherwise see if the pin name matches a cpu pin
|
2015-08-18 14:07:19 +02:00
|
|
|
pin_obj = pin_find_named_pin(&pin_board_pins_locals_dict, user_obj);
|
2015-02-09 19:38:02 +01:00
|
|
|
if (pin_obj) {
|
|
|
|
return pin_obj;
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
2015-08-18 14:07:19 +02:00
|
|
|
void pin_config (pin_obj_t *self, int af, uint mode, uint pull, int value, uint strength) {
|
|
|
|
self->mode = mode, self->pull = pull, self->strength = strength;
|
|
|
|
// if af is -1, then we want to keep it as it is
|
|
|
|
if (af != -1) {
|
|
|
|
self->af = af;
|
|
|
|
}
|
2015-09-07 21:19:11 +02:00
|
|
|
|
2015-08-18 14:07:19 +02:00
|
|
|
// if value is -1, then we want to keep it as it is
|
|
|
|
if (value != -1) {
|
|
|
|
self->value = value;
|
|
|
|
}
|
2015-09-07 21:19:11 +02:00
|
|
|
|
2015-02-27 16:50:06 +01:00
|
|
|
// mark the pin as used
|
2015-09-03 11:25:44 +02:00
|
|
|
self->used = true;
|
|
|
|
pin_obj_configure ((const pin_obj_t *)self);
|
|
|
|
|
2015-02-27 16:50:06 +01:00
|
|
|
// register it with the sleep module
|
2015-09-27 13:45:48 +02:00
|
|
|
pyb_sleep_add ((const mp_obj_t)self, (WakeUpCB_t)pin_obj_configure);
|
2015-02-27 16:50:06 +01:00
|
|
|
}
|
|
|
|
|
2015-09-08 15:07:42 +02:00
|
|
|
void pin_assign_pins_af (mp_obj_t *pins, uint32_t n_pins, uint32_t pull, uint32_t fn, uint32_t unit) {
|
|
|
|
for (int i = 0; i < n_pins; i++) {
|
|
|
|
pin_free_af_from_pins(fn, unit, i);
|
|
|
|
if (pins[i] != mp_const_none) {
|
|
|
|
pin_obj_t *pin = pin_find(pins[i]);
|
|
|
|
pin_config (pin, pin_find_af_index(pin, fn, unit, i), 0, pull, -1, PIN_STRENGTH_2MA);
|
2015-09-03 11:25:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-11 09:33:19 +02:00
|
|
|
uint8_t pin_find_peripheral_unit (const mp_obj_t pin, uint8_t fn, uint8_t type) {
|
|
|
|
pin_obj_t *pin_o = pin_find(pin);
|
|
|
|
for (int i = 0; i < pin_o->num_afs; i++) {
|
|
|
|
if (pin_o->af_list[i].fn == fn && pin_o->af_list[i].type == type) {
|
|
|
|
return pin_o->af_list[i].unit;
|
|
|
|
}
|
|
|
|
}
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-09-11 09:33:19 +02:00
|
|
|
}
|
|
|
|
|
2015-09-14 20:03:32 +02:00
|
|
|
uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit) {
|
|
|
|
pin_obj_t *pin_o = pin_find(pin);
|
|
|
|
for (int i = 0; i < pin_o->num_afs; i++) {
|
|
|
|
if (pin_o->af_list[i].fn == fn && pin_o->af_list[i].unit == unit) {
|
|
|
|
return pin_o->af_list[i].type;
|
|
|
|
}
|
|
|
|
}
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-09-14 20:03:32 +02:00
|
|
|
}
|
|
|
|
|
2016-02-14 13:46:04 +01:00
|
|
|
int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type) {
|
|
|
|
int8_t af = pin_obj_find_af(pin, fn, unit, type);
|
|
|
|
if (af < 0) {
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2016-02-14 13:46:04 +01:00
|
|
|
}
|
|
|
|
return af;
|
|
|
|
}
|
|
|
|
|
2015-03-04 13:51:01 +01:00
|
|
|
/******************************************************************************
|
|
|
|
DEFINE PRIVATE FUNCTIONS
|
|
|
|
******************************************************************************/
|
2015-09-03 11:25:44 +02:00
|
|
|
STATIC pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
|
2018-07-08 14:08:24 +02:00
|
|
|
const mp_map_t *named_map = &named_pins->map;
|
|
|
|
mp_map_elem_t *named_elem = mp_map_lookup((mp_map_t*)named_map, name, MP_MAP_LOOKUP);
|
2015-09-03 11:25:44 +02:00
|
|
|
if (named_elem != NULL && named_elem->value != NULL) {
|
|
|
|
return named_elem->value;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit) {
|
2018-07-08 14:08:24 +02:00
|
|
|
const mp_map_t *named_map = &named_pins->map;
|
2015-09-03 11:25:44 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-09-07 21:19:11 +02:00
|
|
|
STATIC int8_t pin_obj_find_af (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type) {
|
|
|
|
for (int i = 0; i < pin->num_afs; i++) {
|
|
|
|
if (pin->af_list[i].fn == fn && pin->af_list[i].unit == unit && pin->af_list[i].type == type) {
|
|
|
|
return pin->af_list[i].idx;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-09-08 15:07:42 +02:00
|
|
|
STATIC void pin_free_af_from_pins (uint8_t fn, uint8_t unit, uint8_t type) {
|
2018-07-08 14:08:24 +02:00
|
|
|
const mp_map_t *named_map = &pin_board_pins_locals_dict.map;
|
2015-09-08 15:07:42 +02:00
|
|
|
for (uint i = 0; i < named_map->used - 1; i++) {
|
|
|
|
pin_obj_t * pin = (pin_obj_t *)named_map->table[i].value;
|
|
|
|
// af is different than GPIO
|
|
|
|
if (pin->af > PIN_MODE_0) {
|
|
|
|
// check if the pin supports the target af
|
|
|
|
int af = pin_obj_find_af(pin, fn, unit, type);
|
|
|
|
if (af > 0 && af == pin->af) {
|
2016-02-14 13:46:04 +01:00
|
|
|
// the pin supports the target af, de-assign it
|
2015-09-08 15:07:42 +02:00
|
|
|
pin_deassign (pin);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-07 21:19:11 +02:00
|
|
|
STATIC void pin_deassign (pin_obj_t* pin) {
|
|
|
|
pin_config (pin, PIN_MODE_0, GPIO_DIR_MODE_IN, PIN_TYPE_STD, -1, PIN_STRENGTH_4MA);
|
|
|
|
pin->used = false;
|
|
|
|
}
|
|
|
|
|
2015-02-27 16:50:06 +01:00
|
|
|
STATIC void pin_obj_configure (const pin_obj_t *self) {
|
2015-08-18 14:07:19 +02:00
|
|
|
uint32_t type;
|
|
|
|
if (self->mode == PIN_TYPE_ANALOG) {
|
|
|
|
type = PIN_TYPE_ANALOG;
|
|
|
|
} else {
|
|
|
|
type = self->pull;
|
|
|
|
uint32_t direction = self->mode;
|
|
|
|
if (direction == PIN_TYPE_OD || direction == GPIO_DIR_MODE_ALT_OD) {
|
|
|
|
direction = GPIO_DIR_MODE_OUT;
|
|
|
|
type |= PIN_TYPE_OD;
|
|
|
|
}
|
|
|
|
if (self->mode != GPIO_DIR_MODE_ALT && self->mode != GPIO_DIR_MODE_ALT_OD) {
|
2015-02-19 21:03:21 +01:00
|
|
|
// enable the peripheral clock for the GPIO port of this pin
|
|
|
|
switch (self->port) {
|
|
|
|
case PORT_A0:
|
|
|
|
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
|
|
|
|
break;
|
|
|
|
case PORT_A1:
|
|
|
|
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
|
|
|
|
break;
|
|
|
|
case PORT_A2:
|
|
|
|
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
|
|
|
|
break;
|
|
|
|
case PORT_A3:
|
|
|
|
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA3, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2015-10-26 21:46:36 +01:00
|
|
|
// configure the direction
|
|
|
|
MAP_GPIODirModeSet(self->port, self->bit, direction);
|
2015-08-18 14:07:19 +02:00
|
|
|
// set the pin value
|
|
|
|
if (self->value) {
|
|
|
|
MAP_GPIOPinWrite(self->port, self->bit, self->bit);
|
|
|
|
} else {
|
|
|
|
MAP_GPIOPinWrite(self->port, self->bit, 0);
|
|
|
|
}
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
// now set the alternate function
|
2015-02-27 16:50:06 +01:00
|
|
|
MAP_PinModeSet (self->pin_num, self->af);
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
MAP_PinConfigSet(self->pin_num, self->strength, type);
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
2015-03-12 16:14:55 +01:00
|
|
|
STATIC void pin_get_hibernate_pin_and_idx (const pin_obj_t *self, uint *hib_pin, uint *idx) {
|
|
|
|
// pin_num is actually : (package_pin - 1)
|
|
|
|
switch (self->pin_num) {
|
2015-07-28 23:03:53 +02:00
|
|
|
case 56: // GP2
|
2015-03-12 16:14:55 +01:00
|
|
|
*hib_pin = PRCM_HIB_GPIO2;
|
|
|
|
*idx = 0;
|
|
|
|
break;
|
2015-07-28 23:03:53 +02:00
|
|
|
case 58: // GP4
|
2015-03-12 16:14:55 +01:00
|
|
|
*hib_pin = PRCM_HIB_GPIO4;
|
|
|
|
*idx = 1;
|
|
|
|
break;
|
2015-07-28 23:03:53 +02:00
|
|
|
case 3: // GP13
|
2015-03-12 16:14:55 +01:00
|
|
|
*hib_pin = PRCM_HIB_GPIO13;
|
|
|
|
*idx = 2;
|
|
|
|
break;
|
2015-07-28 23:03:53 +02:00
|
|
|
case 7: // GP17
|
2015-03-12 16:14:55 +01:00
|
|
|
*hib_pin = PRCM_HIB_GPIO17;
|
|
|
|
*idx = 3;
|
|
|
|
break;
|
2015-07-28 23:03:53 +02:00
|
|
|
case 1: // GP11
|
2015-03-12 16:14:55 +01:00
|
|
|
*hib_pin = PRCM_HIB_GPIO11;
|
|
|
|
*idx = 4;
|
|
|
|
break;
|
2015-07-28 23:03:53 +02:00
|
|
|
case 16: // GP24
|
2015-03-12 16:14:55 +01:00
|
|
|
*hib_pin = PRCM_HIB_GPIO24;
|
|
|
|
*idx = 5;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*idx = 0xFF;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
STATIC void pin_irq_enable (mp_obj_t self_in) {
|
2015-03-12 16:14:55 +01:00
|
|
|
const pin_obj_t *self = self_in;
|
|
|
|
uint hib_pin, idx;
|
|
|
|
|
|
|
|
pin_get_hibernate_pin_and_idx (self, &hib_pin, &idx);
|
|
|
|
if (idx < PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
if (pybpin_wake_pin[idx].lpds != PYBPIN_WAKES_NOT) {
|
|
|
|
// enable GPIO as a wake source during LPDS
|
|
|
|
MAP_PRCMLPDSWakeUpGPIOSelect(idx, pybpin_wake_pin[idx].lpds);
|
|
|
|
MAP_PRCMLPDSWakeupSourceEnable(PRCM_LPDS_GPIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pybpin_wake_pin[idx].hib != PYBPIN_WAKES_NOT) {
|
|
|
|
// enable GPIO as a wake source during hibernate
|
|
|
|
MAP_PRCMHibernateWakeUpGPIOSelect(hib_pin, pybpin_wake_pin[idx].hib);
|
|
|
|
MAP_PRCMHibernateWakeupSourceEnable(hib_pin);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
MAP_PRCMHibernateWakeupSourceDisable(hib_pin);
|
|
|
|
}
|
|
|
|
}
|
2015-03-18 21:49:48 +01:00
|
|
|
// if idx is invalid, the pin supports active interrupts for sure
|
2015-03-12 16:14:55 +01:00
|
|
|
if (idx >= PYBPIN_NUM_WAKE_PINS || pybpin_wake_pin[idx].active) {
|
|
|
|
MAP_GPIOIntClear(self->port, self->bit);
|
|
|
|
MAP_GPIOIntEnable(self->port, self->bit);
|
|
|
|
}
|
2015-03-18 21:49:48 +01:00
|
|
|
// in case it was enabled before
|
2015-03-17 13:22:01 +01:00
|
|
|
else if (idx < PYBPIN_NUM_WAKE_PINS && !pybpin_wake_pin[idx].active) {
|
|
|
|
MAP_GPIOIntDisable(self->port, self->bit);
|
|
|
|
}
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
STATIC void pin_irq_disable (mp_obj_t self_in) {
|
2015-03-12 16:14:55 +01:00
|
|
|
const pin_obj_t *self = self_in;
|
|
|
|
uint hib_pin, idx;
|
|
|
|
|
|
|
|
pin_get_hibernate_pin_and_idx (self, &hib_pin, &idx);
|
|
|
|
if (idx < PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
if (pybpin_wake_pin[idx].lpds != PYBPIN_WAKES_NOT) {
|
|
|
|
// disable GPIO as a wake source during LPDS
|
|
|
|
MAP_PRCMLPDSWakeupSourceDisable(PRCM_LPDS_GPIO);
|
|
|
|
}
|
|
|
|
if (pybpin_wake_pin[idx].hib != PYBPIN_WAKES_NOT) {
|
|
|
|
// disable GPIO as a wake source during hibernate
|
|
|
|
MAP_PRCMHibernateWakeupSourceDisable(hib_pin);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// not need to check for the active flag, it's safe to disable it anyway
|
2015-03-04 13:52:39 +01:00
|
|
|
MAP_GPIOIntDisable(self->port, self->bit);
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
STATIC int pin_irq_flags (mp_obj_t self_in) {
|
|
|
|
const pin_obj_t *self = self_in;
|
|
|
|
return self->irq_flags;
|
|
|
|
}
|
|
|
|
|
2015-07-01 19:36:57 +02:00
|
|
|
STATIC void pin_extint_register(pin_obj_t *self, uint32_t intmode, uint32_t priority) {
|
|
|
|
void *handler;
|
|
|
|
uint32_t intnum;
|
|
|
|
|
|
|
|
// 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, priority);
|
|
|
|
}
|
|
|
|
|
2015-08-18 14:07:19 +02:00
|
|
|
STATIC void pin_validate_mode (uint mode) {
|
|
|
|
if (mode != GPIO_DIR_MODE_IN && mode != GPIO_DIR_MODE_OUT && mode != PIN_TYPE_OD &&
|
|
|
|
mode != GPIO_DIR_MODE_ALT && mode != GPIO_DIR_MODE_ALT_OD) {
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-08-18 14:07:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
STATIC void pin_validate_pull (uint pull) {
|
|
|
|
if (pull != PIN_TYPE_STD && pull != PIN_TYPE_STD_PU && pull != PIN_TYPE_STD_PD) {
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-08-18 14:07:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void pin_validate_drive(uint strength) {
|
|
|
|
if (strength != PIN_STRENGTH_2MA && strength != PIN_STRENGTH_4MA && strength != PIN_STRENGTH_6MA) {
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-08-18 14:07:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-07 21:19:11 +02:00
|
|
|
STATIC void pin_validate_af(const pin_obj_t* pin, int8_t idx, uint8_t *fn, uint8_t *unit, uint8_t *type) {
|
|
|
|
for (int i = 0; i < pin->num_afs; i++) {
|
|
|
|
if (pin->af_list[i].idx == idx) {
|
|
|
|
*fn = pin->af_list[i].fn;
|
|
|
|
*unit = pin->af_list[i].unit;
|
|
|
|
*type = pin->af_list[i].type;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-09-07 21:19:11 +02:00
|
|
|
}
|
|
|
|
|
2015-10-25 19:23:51 +01:00
|
|
|
STATIC uint8_t pin_get_value (const pin_obj_t* self) {
|
|
|
|
uint32_t value;
|
|
|
|
bool setdir = false;
|
|
|
|
if (self->mode == PIN_TYPE_OD || self->mode == GPIO_DIR_MODE_ALT_OD) {
|
|
|
|
setdir = true;
|
|
|
|
// configure the direction to IN for a moment in order to read the pin value
|
|
|
|
MAP_GPIODirModeSet(self->port, self->bit, GPIO_DIR_MODE_IN);
|
|
|
|
}
|
|
|
|
// now get the value
|
|
|
|
value = MAP_GPIOPinRead(self->port, self->bit);
|
|
|
|
if (setdir) {
|
|
|
|
// set the direction back to output
|
|
|
|
MAP_GPIODirModeSet(self->port, self->bit, GPIO_DIR_MODE_OUT);
|
|
|
|
if (self->value) {
|
|
|
|
MAP_GPIOPinWrite(self->port, self->bit, self->bit);
|
|
|
|
} else {
|
|
|
|
MAP_GPIOPinWrite(self->port, self->bit, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// return it
|
|
|
|
return value ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2015-07-01 19:36:57 +02:00
|
|
|
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) {
|
|
|
|
uint32_t bits = MAP_GPIOIntStatus(port, true);
|
|
|
|
MAP_GPIOIntClear(port, bits);
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
// might be that we have more than one pin interrupt pending
|
2015-07-01 19:36:57 +02:00
|
|
|
// therefore we must loop through all of the 8 possible bits
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
|
|
uint32_t bit = (1 << i);
|
|
|
|
if (bit & bits) {
|
2015-08-18 14:07:19 +02:00
|
|
|
pin_obj_t *self = (pin_obj_t *)pin_find_pin_by_port_bit(&pin_board_pins_locals_dict, port, bit);
|
2015-09-22 23:20:29 +02:00
|
|
|
if (self->irq_trigger == (PYB_PIN_FALLING_EDGE | PYB_PIN_RISING_EDGE)) {
|
|
|
|
// read the pin value (hoping that the pin level has remained stable)
|
|
|
|
self->irq_flags = MAP_GPIOPinRead(self->port, self->bit) ? PYB_PIN_RISING_EDGE : PYB_PIN_FALLING_EDGE;
|
|
|
|
} else {
|
|
|
|
// same as the triggers
|
|
|
|
self->irq_flags = self->irq_trigger;
|
|
|
|
}
|
|
|
|
mp_irq_handler(mp_irq_find(self));
|
|
|
|
// always clear the flags after leaving the user handler
|
|
|
|
self->irq_flags = 0;
|
2015-07-01 19:36:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-03-04 13:52:39 +01:00
|
|
|
/******************************************************************************/
|
2017-06-30 09:22:17 +02:00
|
|
|
// MicroPython bindings
|
2015-03-04 13:52:39 +01:00
|
|
|
|
2015-02-09 19:38:02 +01:00
|
|
|
STATIC const mp_arg_t pin_init_args[] = {
|
2015-09-22 23:20:29 +02:00
|
|
|
{ MP_QSTR_mode, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
|
2015-09-13 15:31:17 +02:00
|
|
|
{ MP_QSTR_pull, MP_ARG_OBJ, {.u_obj = mp_const_none} },
|
2015-08-18 14:07:19 +02:00
|
|
|
{ MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
|
|
|
|
{ MP_QSTR_drive, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PIN_STRENGTH_4MA} },
|
2015-08-23 13:52:31 +02:00
|
|
|
{ MP_QSTR_alt, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
|
2015-02-06 15:35:48 +01:00
|
|
|
};
|
2015-02-09 19:38:02 +01:00
|
|
|
#define pin_INIT_NUM_ARGS MP_ARRAY_SIZE(pin_init_args)
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2017-08-30 02:59:58 +02:00
|
|
|
STATIC mp_obj_t pin_obj_init_helper(pin_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
2015-02-06 15:35:48 +01:00
|
|
|
// parse args
|
2015-03-04 13:51:01 +01:00
|
|
|
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);
|
2015-02-06 15:35:48 +01:00
|
|
|
|
|
|
|
// get the io mode
|
2015-09-22 23:20:29 +02:00
|
|
|
uint mode;
|
|
|
|
// default is input
|
|
|
|
if (args[0].u_obj == MP_OBJ_NULL) {
|
|
|
|
mode = GPIO_DIR_MODE_IN;
|
|
|
|
} else {
|
|
|
|
mode = mp_obj_get_int(args[0].u_obj);
|
|
|
|
pin_validate_mode (mode);
|
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
|
|
|
|
// get the pull type
|
2015-09-13 15:31:17 +02:00
|
|
|
uint pull;
|
|
|
|
if (args[1].u_obj == mp_const_none) {
|
|
|
|
pull = PIN_TYPE_STD;
|
|
|
|
} else {
|
|
|
|
pull = mp_obj_get_int(args[1].u_obj);
|
|
|
|
pin_validate_pull (pull);
|
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
|
|
|
|
// get the value
|
|
|
|
int value = -1;
|
|
|
|
if (args[2].u_obj != MP_OBJ_NULL) {
|
|
|
|
if (mp_obj_is_true(args[2].u_obj)) {
|
|
|
|
value = 1;
|
|
|
|
} else {
|
|
|
|
value = 0;
|
2015-03-04 13:51:01 +01:00
|
|
|
}
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
|
2015-02-06 15:35:48 +01:00
|
|
|
// get the strenght
|
2015-03-04 13:51:01 +01:00
|
|
|
uint strength = args[3].u_int;
|
2015-08-18 14:07:19 +02:00
|
|
|
pin_validate_drive(strength);
|
|
|
|
|
2015-09-03 11:25:44 +02:00
|
|
|
// get the alternate function
|
2015-08-23 13:52:31 +02:00
|
|
|
int af = args[4].u_int;
|
2015-09-03 11:25:44 +02:00
|
|
|
if (mode != GPIO_DIR_MODE_ALT && mode != GPIO_DIR_MODE_ALT_OD) {
|
|
|
|
if (af == -1) {
|
|
|
|
af = 0;
|
|
|
|
} else {
|
|
|
|
goto invalid_args;
|
|
|
|
}
|
|
|
|
} else if (af < -1 || af > 15) {
|
|
|
|
goto invalid_args;
|
2015-08-23 13:52:31 +02:00
|
|
|
}
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2015-09-07 21:19:11 +02:00
|
|
|
// check for a valid af and then free it from any other pins
|
|
|
|
if (af > PIN_MODE_0) {
|
|
|
|
uint8_t fn, unit, type;
|
|
|
|
pin_validate_af (self, af, &fn, &unit, &type);
|
|
|
|
pin_free_af_from_pins(fn, unit, type);
|
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
pin_config (self, af, mode, pull, value, strength);
|
2015-03-04 13:51:01 +01:00
|
|
|
|
2015-03-04 13:52:39 +01:00
|
|
|
return mp_const_none;
|
2015-09-03 11:25:44 +02:00
|
|
|
|
|
|
|
invalid_args:
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-03-04 13:52:39 +01:00
|
|
|
}
|
|
|
|
|
2015-04-10 00:56:15 +02:00
|
|
|
STATIC void pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
2015-03-04 13:52:39 +01:00
|
|
|
pin_obj_t *self = self_in;
|
2015-08-18 14:07:19 +02:00
|
|
|
uint32_t pull = self->pull;
|
|
|
|
uint32_t drive = self->strength;
|
2015-03-04 13:52:39 +01:00
|
|
|
|
|
|
|
// pin name
|
2015-09-03 11:25:44 +02:00
|
|
|
mp_printf(print, "Pin('%q'", self->name);
|
2015-03-04 13:52:39 +01:00
|
|
|
|
2015-05-02 22:57:51 +02:00
|
|
|
// pin mode
|
2015-08-18 14:07:19 +02:00
|
|
|
qstr mode_qst;
|
|
|
|
uint32_t mode = self->mode;
|
|
|
|
if (mode == GPIO_DIR_MODE_IN) {
|
|
|
|
mode_qst = MP_QSTR_IN;
|
|
|
|
} else if (mode == GPIO_DIR_MODE_OUT) {
|
|
|
|
mode_qst = MP_QSTR_OUT;
|
|
|
|
} else if (mode == GPIO_DIR_MODE_ALT) {
|
|
|
|
mode_qst = MP_QSTR_ALT;
|
|
|
|
} else if (mode == GPIO_DIR_MODE_ALT_OD) {
|
|
|
|
mode_qst = MP_QSTR_ALT_OPEN_DRAIN;
|
|
|
|
} else {
|
|
|
|
mode_qst = MP_QSTR_OPEN_DRAIN;
|
2015-03-04 13:51:01 +01:00
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
mp_printf(print, ", mode=Pin.%q", mode_qst);
|
|
|
|
|
|
|
|
// pin pull
|
|
|
|
qstr pull_qst;
|
|
|
|
if (pull == PIN_TYPE_STD) {
|
2015-09-13 15:31:17 +02:00
|
|
|
mp_printf(print, ", pull=%q", MP_QSTR_None);
|
2015-03-04 13:52:39 +01:00
|
|
|
} else {
|
2015-09-13 15:31:17 +02:00
|
|
|
if (pull == PIN_TYPE_STD_PU) {
|
|
|
|
pull_qst = MP_QSTR_PULL_UP;
|
|
|
|
} else {
|
|
|
|
pull_qst = MP_QSTR_PULL_DOWN;
|
|
|
|
}
|
|
|
|
mp_printf(print, ", pull=Pin.%q", pull_qst);
|
2015-03-04 13:52:39 +01:00
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
|
|
|
|
// pin drive
|
|
|
|
qstr drv_qst;
|
|
|
|
if (drive == PIN_STRENGTH_2MA) {
|
|
|
|
drv_qst = MP_QSTR_LOW_POWER;
|
|
|
|
} else if (drive == PIN_STRENGTH_4MA) {
|
|
|
|
drv_qst = MP_QSTR_MED_POWER;
|
2015-03-04 13:52:39 +01:00
|
|
|
} else {
|
2015-08-18 14:07:19 +02:00
|
|
|
drv_qst = MP_QSTR_HIGH_POWER;
|
2015-03-04 13:52:39 +01:00
|
|
|
}
|
2015-09-03 11:25:44 +02:00
|
|
|
mp_printf(print, ", drive=Pin.%q", drv_qst);
|
|
|
|
|
|
|
|
// pin af
|
|
|
|
int alt = (self->af == 0) ? -1 : self->af;
|
|
|
|
mp_printf(print, ", alt=%d)", alt);
|
2015-03-04 13:52:39 +01:00
|
|
|
}
|
|
|
|
|
2017-01-04 14:10:42 +01:00
|
|
|
STATIC mp_obj_t pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2015-03-04 13:52:39 +01:00
|
|
|
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.
|
|
|
|
pin_obj_t *pin = (pin_obj_t *)pin_find(args[0]);
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
mp_map_t kw_args;
|
|
|
|
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
|
|
|
|
pin_obj_init_helper(pin, n_args - 1, args + 1, &kw_args);
|
2015-03-04 13:52:39 +01:00
|
|
|
|
|
|
|
return (mp_obj_t)pin;
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
|
|
|
|
2017-08-30 02:59:58 +02:00
|
|
|
STATIC mp_obj_t pin_obj_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
|
2015-02-09 19:38:02 +01:00
|
|
|
return pin_obj_init_helper(args[0], n_args - 1, args + 1, kw_args);
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
2015-02-09 19:38:02 +01:00
|
|
|
MP_DEFINE_CONST_FUN_OBJ_KW(pin_init_obj, 1, pin_obj_init);
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2017-08-30 02:59:58 +02:00
|
|
|
STATIC mp_obj_t pin_value(size_t n_args, const mp_obj_t *args) {
|
2015-02-09 19:38:02 +01:00
|
|
|
pin_obj_t *self = args[0];
|
2015-02-06 15:35:48 +01:00
|
|
|
if (n_args == 1) {
|
2015-10-25 19:23:51 +01:00
|
|
|
// get the value
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(pin_get_value(self));
|
2015-02-06 15:35:48 +01:00
|
|
|
} else {
|
|
|
|
// set the pin value
|
|
|
|
if (mp_obj_is_true(args[1])) {
|
2015-08-18 14:07:19 +02:00
|
|
|
self->value = 1;
|
2015-02-06 15:35:48 +01:00
|
|
|
MAP_GPIOPinWrite(self->port, self->bit, self->bit);
|
|
|
|
} else {
|
2015-08-18 14:07:19 +02:00
|
|
|
self->value = 0;
|
2015-02-06 15:35:48 +01:00
|
|
|
MAP_GPIOPinWrite(self->port, self->bit, 0);
|
|
|
|
}
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
}
|
2015-02-09 19:38:02 +01:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_value_obj, 1, 2, pin_value);
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2015-08-18 14:07:19 +02:00
|
|
|
STATIC mp_obj_t pin_id(mp_obj_t self_in) {
|
2015-06-28 12:53:37 +02:00
|
|
|
pin_obj_t *self = self_in;
|
|
|
|
return MP_OBJ_NEW_QSTR(self->name);
|
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_id_obj, pin_id);
|
2015-06-28 12:53:37 +02:00
|
|
|
|
2017-08-30 02:59:58 +02:00
|
|
|
STATIC mp_obj_t pin_mode(size_t n_args, const mp_obj_t *args) {
|
2015-08-18 14:07:19 +02:00
|
|
|
pin_obj_t *self = args[0];
|
|
|
|
if (n_args == 1) {
|
|
|
|
return mp_obj_new_int(self->mode);
|
|
|
|
} else {
|
|
|
|
uint32_t mode = mp_obj_get_int(args[1]);
|
|
|
|
pin_validate_mode (mode);
|
|
|
|
self->mode = mode;
|
|
|
|
pin_obj_configure(self);
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_mode_obj, 1, 2, pin_mode);
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2017-08-30 02:59:58 +02:00
|
|
|
STATIC mp_obj_t pin_pull(size_t n_args, const mp_obj_t *args) {
|
2015-08-18 14:07:19 +02:00
|
|
|
pin_obj_t *self = args[0];
|
|
|
|
if (n_args == 1) {
|
2015-09-13 15:31:17 +02:00
|
|
|
if (self->pull == PIN_TYPE_STD) {
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
return mp_obj_new_int(self->pull);
|
|
|
|
} else {
|
2015-09-13 15:31:17 +02:00
|
|
|
uint32_t pull;
|
|
|
|
if (args[1] == mp_const_none) {
|
|
|
|
pull = PIN_TYPE_STD;
|
|
|
|
} else {
|
|
|
|
pull = mp_obj_get_int(args[1]);
|
|
|
|
pin_validate_pull (pull);
|
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
self->pull = pull;
|
|
|
|
pin_obj_configure(self);
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
2015-02-06 15:35:48 +01:00
|
|
|
}
|
2015-08-18 14:07:19 +02:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_pull_obj, 1, 2, pin_pull);
|
|
|
|
|
2017-08-30 02:59:58 +02:00
|
|
|
STATIC mp_obj_t pin_drive(size_t n_args, const mp_obj_t *args) {
|
2015-08-18 14:07:19 +02:00
|
|
|
pin_obj_t *self = args[0];
|
|
|
|
if (n_args == 1) {
|
|
|
|
return mp_obj_new_int(self->strength);
|
|
|
|
} else {
|
|
|
|
uint32_t strength = mp_obj_get_int(args[1]);
|
|
|
|
pin_validate_drive (strength);
|
|
|
|
self->strength = strength;
|
|
|
|
pin_obj_configure(self);
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_drive_obj, 1, 2, pin_drive);
|
|
|
|
|
2017-01-04 14:10:42 +01:00
|
|
|
STATIC mp_obj_t pin_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2015-09-07 09:23:46 +02:00
|
|
|
mp_arg_check_num(n_args, n_kw, 0, 1, false);
|
|
|
|
mp_obj_t _args[2] = {self_in, *args};
|
|
|
|
return pin_value (n_args + 1, _args);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC mp_obj_t pin_alt_list(mp_obj_t self_in) {
|
|
|
|
pin_obj_t *self = self_in;
|
|
|
|
mp_obj_t af[2];
|
|
|
|
mp_obj_t afs = mp_obj_new_list(0, NULL);
|
|
|
|
|
|
|
|
for (int i = 0; i < self->num_afs; i++) {
|
|
|
|
af[0] = MP_OBJ_NEW_QSTR(self->af_list[i].name);
|
|
|
|
af[1] = mp_obj_new_int(self->af_list[i].idx);
|
|
|
|
mp_obj_list_append(afs, mp_obj_new_tuple(MP_ARRAY_SIZE(af), af));
|
|
|
|
}
|
|
|
|
return afs;
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_alt_list_obj, pin_alt_list);
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
/// \method irq(trigger, priority, handler, wake)
|
2017-08-30 02:59:58 +02:00
|
|
|
STATIC mp_obj_t pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
2015-09-22 23:20:29 +02:00
|
|
|
mp_arg_val_t args[mp_irq_INIT_NUM_ARGS];
|
|
|
|
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, mp_irq_INIT_NUM_ARGS, mp_irq_init_args, args);
|
2015-03-04 13:52:39 +01:00
|
|
|
pin_obj_t *self = pos_args[0];
|
2015-03-04 13:51:01 +01:00
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
// convert the priority to the correct value
|
|
|
|
uint priority = mp_irq_translate_priority (args[1].u_int);
|
|
|
|
|
|
|
|
// verify and translate the interrupt mode
|
|
|
|
uint mp_trigger = mp_obj_get_int(args[0].u_obj);
|
|
|
|
uint trigger;
|
|
|
|
if (mp_trigger == (PYB_PIN_FALLING_EDGE | PYB_PIN_RISING_EDGE)) {
|
|
|
|
trigger = GPIO_BOTH_EDGES;
|
|
|
|
} else {
|
|
|
|
switch (mp_trigger) {
|
|
|
|
case PYB_PIN_FALLING_EDGE:
|
|
|
|
trigger = GPIO_FALLING_EDGE;
|
|
|
|
break;
|
|
|
|
case PYB_PIN_RISING_EDGE:
|
|
|
|
trigger = GPIO_RISING_EDGE;
|
|
|
|
break;
|
|
|
|
case PYB_PIN_LOW_LEVEL:
|
|
|
|
trigger = GPIO_LOW_LEVEL;
|
|
|
|
break;
|
|
|
|
case PYB_PIN_HIGH_LEVEL:
|
|
|
|
trigger = GPIO_HIGH_LEVEL;
|
|
|
|
break;
|
|
|
|
default:
|
2015-03-12 16:14:55 +01:00
|
|
|
goto invalid_args;
|
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
}
|
2015-03-04 13:51:01 +01:00
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
uint8_t pwrmode = (args[3].u_obj == mp_const_none) ? PYB_PWR_MODE_ACTIVE : mp_obj_get_int(args[3].u_obj);
|
|
|
|
if (pwrmode > (PYB_PWR_MODE_ACTIVE | PYB_PWR_MODE_LPDS | PYB_PWR_MODE_HIBERNATE)) {
|
|
|
|
goto invalid_args;
|
|
|
|
}
|
2015-03-04 13:52:39 +01:00
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
// get the wake info from this pin
|
|
|
|
uint hib_pin, idx;
|
|
|
|
pin_get_hibernate_pin_and_idx ((const pin_obj_t *)self, &hib_pin, &idx);
|
|
|
|
if (pwrmode & PYB_PWR_MODE_LPDS) {
|
|
|
|
if (idx >= PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
goto invalid_args;
|
2015-03-12 16:14:55 +01:00
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
// wake modes are different in LDPS
|
|
|
|
uint wake_mode;
|
|
|
|
switch (trigger) {
|
|
|
|
case GPIO_FALLING_EDGE:
|
|
|
|
wake_mode = PRCM_LPDS_FALL_EDGE;
|
|
|
|
break;
|
|
|
|
case GPIO_RISING_EDGE:
|
|
|
|
wake_mode = PRCM_LPDS_RISE_EDGE;
|
|
|
|
break;
|
|
|
|
case GPIO_LOW_LEVEL:
|
|
|
|
wake_mode = PRCM_LPDS_LOW_LEVEL;
|
|
|
|
break;
|
|
|
|
case GPIO_HIGH_LEVEL:
|
|
|
|
wake_mode = PRCM_LPDS_HIGH_LEVEL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto invalid_args;
|
|
|
|
break;
|
2015-03-12 16:14:55 +01:00
|
|
|
}
|
2015-03-04 13:52:39 +01:00
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
// first clear the lpds value from all wake-able pins
|
|
|
|
for (uint i = 0; i < PYBPIN_NUM_WAKE_PINS; i++) {
|
|
|
|
pybpin_wake_pin[i].lpds = PYBPIN_WAKES_NOT;
|
2015-03-12 16:14:55 +01:00
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
|
|
|
|
// enable this pin as a wake-up source during LPDS
|
|
|
|
pybpin_wake_pin[idx].lpds = wake_mode;
|
|
|
|
} else if (idx < PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
// this pin was the previous LPDS wake source, so disable it completely
|
|
|
|
if (pybpin_wake_pin[idx].lpds != PYBPIN_WAKES_NOT) {
|
|
|
|
MAP_PRCMLPDSWakeupSourceDisable(PRCM_LPDS_GPIO);
|
2015-03-04 13:52:39 +01:00
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
pybpin_wake_pin[idx].lpds = PYBPIN_WAKES_NOT;
|
|
|
|
}
|
2015-03-04 13:52:39 +01:00
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
if (pwrmode & PYB_PWR_MODE_HIBERNATE) {
|
|
|
|
if (idx >= PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
goto invalid_args;
|
2015-03-12 16:14:55 +01:00
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
// wake modes are different in hibernate
|
|
|
|
uint wake_mode;
|
|
|
|
switch (trigger) {
|
|
|
|
case GPIO_FALLING_EDGE:
|
|
|
|
wake_mode = PRCM_HIB_FALL_EDGE;
|
|
|
|
break;
|
|
|
|
case GPIO_RISING_EDGE:
|
|
|
|
wake_mode = PRCM_HIB_RISE_EDGE;
|
|
|
|
break;
|
|
|
|
case GPIO_LOW_LEVEL:
|
|
|
|
wake_mode = PRCM_HIB_LOW_LEVEL;
|
|
|
|
break;
|
|
|
|
case GPIO_HIGH_LEVEL:
|
|
|
|
wake_mode = PRCM_HIB_HIGH_LEVEL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto invalid_args;
|
|
|
|
break;
|
2015-03-12 16:14:55 +01:00
|
|
|
}
|
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
// enable this pin as wake-up source during hibernate
|
|
|
|
pybpin_wake_pin[idx].hib = wake_mode;
|
|
|
|
} else if (idx < PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
pybpin_wake_pin[idx].hib = PYBPIN_WAKES_NOT;
|
|
|
|
}
|
|
|
|
|
|
|
|
// we need to update the callback atomically, so we disable the
|
|
|
|
// interrupt before we update anything.
|
|
|
|
pin_irq_disable(self);
|
|
|
|
if (pwrmode & PYB_PWR_MODE_ACTIVE) {
|
|
|
|
// register the interrupt
|
|
|
|
pin_extint_register((pin_obj_t *)self, trigger, priority);
|
|
|
|
if (idx < PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
pybpin_wake_pin[idx].active = true;
|
2015-03-12 16:14:55 +01:00
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
} else if (idx < PYBPIN_NUM_WAKE_PINS) {
|
|
|
|
pybpin_wake_pin[idx].active = false;
|
|
|
|
}
|
2015-03-12 16:14:55 +01:00
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
// all checks have passed, we can create the irq object
|
|
|
|
mp_obj_t _irq = mp_irq_new (self, args[2].u_obj, &pin_irq_methods);
|
|
|
|
if (pwrmode & PYB_PWR_MODE_LPDS) {
|
2015-09-27 13:45:48 +02:00
|
|
|
pyb_sleep_set_gpio_lpds_callback (_irq);
|
2015-03-04 13:52:39 +01:00
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
|
|
|
|
// save the mp_trigge for later
|
|
|
|
self->irq_trigger = mp_trigger;
|
|
|
|
|
|
|
|
// enable the interrupt just before leaving
|
|
|
|
pin_irq_enable(self);
|
|
|
|
|
|
|
|
return _irq;
|
2015-03-12 16:14:55 +01:00
|
|
|
|
|
|
|
invalid_args:
|
2020-03-02 12:35:22 +01:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
|
2015-03-04 13:51:01 +01:00
|
|
|
}
|
2015-09-22 23:20:29 +02:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pin_irq_obj, 1, pin_irq);
|
2015-03-04 13:51:01 +01:00
|
|
|
|
2017-08-21 13:34:23 +02:00
|
|
|
STATIC const mp_rom_map_elem_t pin_locals_dict_table[] = {
|
2015-02-06 15:35:48 +01:00
|
|
|
// instance methods
|
2017-08-21 13:34:23 +02:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&pin_init_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&pin_value_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_id), MP_ROM_PTR(&pin_id_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_mode), MP_ROM_PTR(&pin_mode_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_pull), MP_ROM_PTR(&pin_pull_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_drive), MP_ROM_PTR(&pin_drive_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_alt_list), MP_ROM_PTR(&pin_alt_list_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&pin_irq_obj) },
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2015-06-28 12:53:37 +02:00
|
|
|
// class attributes
|
2017-08-21 13:34:23 +02:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_board), MP_ROM_PTR(&pin_board_pins_obj_type) },
|
2015-06-28 12:53:37 +02:00
|
|
|
|
2015-02-06 15:35:48 +01:00
|
|
|
// class constants
|
2017-08-21 13:34:23 +02:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_INT(GPIO_DIR_MODE_IN) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_INT(GPIO_DIR_MODE_OUT) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_OPEN_DRAIN), MP_ROM_INT(PIN_TYPE_OD) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_ALT), MP_ROM_INT(GPIO_DIR_MODE_ALT) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_ALT_OPEN_DRAIN), MP_ROM_INT(GPIO_DIR_MODE_ALT_OD) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_PULL_UP), MP_ROM_INT(PIN_TYPE_STD_PU) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(PIN_TYPE_STD_PD) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_LOW_POWER), MP_ROM_INT(PIN_STRENGTH_2MA) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_MED_POWER), MP_ROM_INT(PIN_STRENGTH_4MA) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_HIGH_POWER), MP_ROM_INT(PIN_STRENGTH_6MA) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_IRQ_FALLING), MP_ROM_INT(PYB_PIN_FALLING_EDGE) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(PYB_PIN_RISING_EDGE) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_IRQ_LOW_LEVEL), MP_ROM_INT(PYB_PIN_LOW_LEVEL) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_IRQ_HIGH_LEVEL), MP_ROM_INT(PYB_PIN_HIGH_LEVEL) },
|
2015-02-06 15:35:48 +01:00
|
|
|
};
|
|
|
|
|
2015-02-09 19:38:02 +01:00
|
|
|
STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table);
|
2015-02-06 15:35:48 +01:00
|
|
|
|
2021-07-14 06:38:38 +02:00
|
|
|
MP_DEFINE_CONST_OBJ_TYPE(
|
|
|
|
pin_type,
|
|
|
|
MP_QSTR_Pin,
|
|
|
|
MP_TYPE_FLAG_NONE,
|
|
|
|
pin_make_new,
|
|
|
|
print, pin_print,
|
|
|
|
call, pin_call,
|
2022-06-24 08:27:46 +02:00
|
|
|
locals_dict, &pin_locals_dict
|
2021-07-14 06:38:38 +02:00
|
|
|
);
|
2015-03-04 13:51:01 +01:00
|
|
|
|
2015-09-22 23:20:29 +02:00
|
|
|
STATIC const mp_irq_methods_t pin_irq_methods = {
|
|
|
|
.init = pin_irq,
|
|
|
|
.enable = pin_irq_enable,
|
|
|
|
.disable = pin_irq_disable,
|
|
|
|
.flags = pin_irq_flags,
|
2015-03-04 13:52:39 +01:00
|
|
|
};
|
2015-03-04 13:51:01 +01:00
|
|
|
|
2015-09-03 11:25:44 +02:00
|
|
|
STATIC void pin_named_pins_obj_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
|
|
|
pin_named_pins_obj_t *self = self_in;
|
|
|
|
mp_printf(print, "<Pin.%q>", self->name);
|
|
|
|
}
|
|
|
|
|
2021-07-14 06:38:38 +02:00
|
|
|
MP_DEFINE_CONST_OBJ_TYPE(
|
|
|
|
pin_board_pins_obj_type,
|
|
|
|
MP_QSTR_board,
|
|
|
|
MP_TYPE_FLAG_NONE,
|
|
|
|
MP_TYPE_NULL_MAKE_NEW,
|
|
|
|
print, pin_named_pins_obj_print,
|
2022-06-24 08:27:46 +02:00
|
|
|
locals_dict, &pin_board_pins_locals_dict
|
2021-07-14 06:38:38 +02:00
|
|
|
);
|
2015-09-03 11:25:44 +02:00
|
|
|
|