mirror of
https://github.com/licsber/micropython.git
synced 2024-09-20 09:00:23 +08:00
04b9147e15
Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
426 lines
15 KiB
C
426 lines
15 KiB
C
/*
|
|
* This file is part of the Micro Python project, http://micropython.org/
|
|
*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
|
*
|
|
* 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>
|
|
|
|
#include "stm32f4xx_hal.h"
|
|
|
|
#include "mpconfig.h"
|
|
#include "nlr.h"
|
|
#include "misc.h"
|
|
#include "qstr.h"
|
|
#include "obj.h"
|
|
#include "runtime.h"
|
|
#include "pin.h"
|
|
|
|
/// \moduleref pyb
|
|
/// \class Pin - control I/O pins
|
|
///
|
|
/// A pin is the basic object to control I/O pins. It has methods to set
|
|
/// the mode of the pin (input, output, etc) and methods to get and set the
|
|
/// digital logic level. For analog control of a pin, see the ADC class.
|
|
///
|
|
/// Usage Model:
|
|
///
|
|
/// All Board Pins are predefined as pyb.Pin.board.Name
|
|
///
|
|
/// x1_pin = pyb.Pin.board.X1
|
|
///
|
|
/// g = pyb.Pin(pyb.Pin.board.X1, pyb.Pin.IN)
|
|
///
|
|
/// 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 PYBv1.0, `pyb.Pin.board.X1` and
|
|
/// `pyb.Pin.cpu.B6` are the same pin.
|
|
///
|
|
/// You can also use strings:
|
|
///
|
|
/// g = pyb.Pin('X1', pyb.Pin.OUT_PP)
|
|
///
|
|
/// Users can add their own names:
|
|
///
|
|
/// pyb.Pin.dict["LeftMotorDir"] = pyb.Pin.cpu.C12
|
|
/// g = pyb.Pin("LeftMotorDir", pyb.Pin.OUT_OD)
|
|
///
|
|
/// 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.Pin("LeftMotorDir", pyb.Pin.OUT_PP)`
|
|
/// then `"LeftMotorDir"` is passed directly to the mapper function.
|
|
///
|
|
/// To summarise, 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.
|
|
|
|
// Pin class variables
|
|
STATIC mp_obj_t pin_class_mapper;
|
|
STATIC mp_obj_t pin_class_map_dict;
|
|
STATIC bool pin_class_debug;
|
|
|
|
void pin_init(void) {
|
|
pin_class_mapper = MP_OBJ_NULL;
|
|
pin_class_map_dict = MP_OBJ_NULL;
|
|
pin_class_debug = false;
|
|
}
|
|
|
|
// C API used to convert a user-supplied pin name into an ordinal pin number.
|
|
const pin_obj_t *pin_find(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_type)) {
|
|
pin_obj = user_obj;
|
|
if (pin_class_debug) {
|
|
printf("Pin map passed pin ");
|
|
mp_obj_print((mp_obj_t)pin_obj, PRINT_STR);
|
|
printf("\n");
|
|
}
|
|
return pin_obj;
|
|
}
|
|
|
|
if (pin_class_mapper != MP_OBJ_NULL) {
|
|
pin_obj = mp_call_function_1(pin_class_mapper, user_obj);
|
|
if (pin_obj != mp_const_none) {
|
|
if (!MP_OBJ_IS_TYPE(pin_obj, &pin_type)) {
|
|
nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "Pin.mapper didn't return a Pin object"));
|
|
}
|
|
if (pin_class_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_class_map_dict != MP_OBJ_NULL) {
|
|
mp_map_t *pin_map_map = mp_obj_dict_get_map(pin_class_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_class_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_class_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_class_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_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "pin '%s' not a valid pin identifier", pin_name));
|
|
}
|
|
|
|
/// \method __str__()
|
|
/// Return a string describing the pin object.
|
|
STATIC void pin_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
|
|
pin_obj_t *self = self_in;
|
|
print(env, "<Pin %s>", self->name);
|
|
}
|
|
|
|
STATIC mp_obj_t pin_obj_init(uint n_args, mp_obj_t *args);
|
|
|
|
/// \classmethod \constructor(id, ...)
|
|
/// Create a new Pin object associated with the id. If additional arguments are given,
|
|
/// they are used to initialise the pin. See `init`.
|
|
STATIC mp_obj_t pin_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
|
|
mp_arg_check_num(n_args, n_kw, 1, 3, false);
|
|
|
|
// Run an argument through the mapper and return the result.
|
|
const pin_obj_t *pin = pin_find(args[0]);
|
|
|
|
if (n_args >= 2) {
|
|
// pin mode given, so configure this GPIO
|
|
mp_obj_t args2[3] = {(mp_obj_t)pin, args[1], MP_OBJ_NULL};
|
|
if (n_args == 3) {
|
|
args2[2] = args[2];
|
|
}
|
|
pin_obj_init(n_args, args2);
|
|
}
|
|
|
|
return (mp_obj_t)pin;
|
|
}
|
|
|
|
/// \classmethod mapper([fun])
|
|
/// Get or set the pin mapper function.
|
|
STATIC mp_obj_t pin_mapper(uint n_args, mp_obj_t *args) {
|
|
if (n_args > 1) {
|
|
pin_class_mapper = args[1];
|
|
return mp_const_none;
|
|
}
|
|
return pin_class_mapper;
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_mapper_fun_obj, 1, 2, pin_mapper);
|
|
STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pin_mapper_obj, (mp_obj_t)&pin_mapper_fun_obj);
|
|
|
|
/// \classmethod dict([dict])
|
|
/// Get or set the pin mapper dictionary.
|
|
STATIC mp_obj_t pin_map_dict(uint n_args, mp_obj_t *args) {
|
|
if (n_args > 1) {
|
|
pin_class_map_dict = args[1];
|
|
return mp_const_none;
|
|
}
|
|
return pin_class_map_dict;
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_map_dict_fun_obj, 1, 2, pin_map_dict);
|
|
STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pin_map_dict_obj, (mp_obj_t)&pin_map_dict_fun_obj);
|
|
|
|
/// \classmethod debug([state])
|
|
/// Get or set the debugging state (`True` or `False` for on or off).
|
|
STATIC mp_obj_t pin_debug(uint n_args, mp_obj_t *args) {
|
|
if (n_args > 1) {
|
|
pin_class_debug = mp_obj_is_true(args[1]);
|
|
return mp_const_none;
|
|
}
|
|
return MP_BOOL(pin_class_debug);
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_debug_fun_obj, 1, 2, pin_debug);
|
|
STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pin_debug_obj, (mp_obj_t)&pin_debug_fun_obj);
|
|
|
|
/// \method init(mode, pull=Pin.PULL_NONE)
|
|
/// Initialise the pin:
|
|
///
|
|
/// - `mode` can be one of:
|
|
/// - `Pin.IN` - configure the pin for input;
|
|
/// - `Pin.OUT_PP` - configure the pin for output, with push-pull control;
|
|
/// - `Pin.OUT_OD` - configure the pin for output, with open-drain control;
|
|
/// - `Pin.AF_PP` - configure the pin for alternate function, pull-pull;
|
|
/// - `Pin.AF_OD` - configure the pin for alternate function, open-drain;
|
|
/// - `Pin.ANALOG` - configure the pin for analog.
|
|
/// - `pull` can be one of:
|
|
/// - `Pin.PULL_NONE` - no pull up or down resistors;
|
|
/// - `Pin.PULL_UP` - enable the pull-up resistor;
|
|
/// - `Pin.PULL_DOWN` - enable the pull-down resistor.
|
|
///
|
|
/// Returns: `None`.
|
|
// TODO allow keyword args
|
|
STATIC mp_obj_t pin_obj_init(uint n_args, mp_obj_t *args) {
|
|
pin_obj_t *self = args[0];
|
|
|
|
// get io mode
|
|
uint mode = mp_obj_get_int(args[1]);
|
|
if (!IS_GPIO_MODE(mode)) {
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid pin mode: %d", mode));
|
|
}
|
|
|
|
// get pull mode
|
|
uint pull = GPIO_NOPULL;
|
|
if (n_args >= 3) {
|
|
pull = mp_obj_get_int(args[2]);
|
|
if (!IS_GPIO_PULL(pull)) {
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid pin pull: %d", pull));
|
|
}
|
|
}
|
|
|
|
// configure the GPIO as requested
|
|
GPIO_InitTypeDef GPIO_InitStructure;
|
|
GPIO_InitStructure.Pin = self->pin_mask;
|
|
GPIO_InitStructure.Mode = mode;
|
|
GPIO_InitStructure.Pull = pull;
|
|
GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
|
|
GPIO_InitStructure.Alternate = 0;
|
|
HAL_GPIO_Init(self->gpio, &GPIO_InitStructure);
|
|
|
|
return mp_const_none;
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_init_obj, 2, 3, pin_obj_init);
|
|
|
|
/// \method value([value])
|
|
/// Get or set the digital logic level of the pin:
|
|
///
|
|
/// - With no argument, return 0 or 1 depending on the logic level of the pin.
|
|
/// - With `value` given, set the logic level of the pin. `value` can be
|
|
/// anything that converts to a boolean. If it converts to `True`, the pin
|
|
/// is set high, otherwise it is set low.
|
|
STATIC mp_obj_t pin_value(uint n_args, mp_obj_t *args) {
|
|
pin_obj_t *self = args[0];
|
|
if (n_args == 1) {
|
|
// get pin
|
|
return MP_OBJ_NEW_SMALL_INT((self->gpio->IDR >> self->pin) & 1);
|
|
} else {
|
|
// set pin
|
|
if (mp_obj_is_true(args[1])) {
|
|
self->gpio->BSRRL = self->pin_mask;
|
|
} else {
|
|
self->gpio->BSRRH = self->pin_mask;
|
|
}
|
|
return mp_const_none;
|
|
}
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_value_obj, 1, 2, pin_value);
|
|
|
|
/// \method low()
|
|
/// Set the pin to a low logic level.
|
|
STATIC mp_obj_t pin_low(mp_obj_t self_in) {
|
|
pin_obj_t *self = self_in;
|
|
self->gpio->BSRRH = self->pin_mask;
|
|
return mp_const_none;
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_low_obj, pin_low);
|
|
|
|
/// \method high()
|
|
/// Set the pin to a high logic level.
|
|
STATIC mp_obj_t pin_high(mp_obj_t self_in) {
|
|
pin_obj_t *self = self_in;
|
|
self->gpio->BSRRL = self->pin_mask;
|
|
return mp_const_none;
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_high_obj, pin_high);
|
|
|
|
/// \method name()
|
|
/// Get the pin name.
|
|
STATIC mp_obj_t pin_name(mp_obj_t self_in) {
|
|
pin_obj_t *self = self_in;
|
|
return MP_OBJ_NEW_QSTR(qstr_from_str(self->name));
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_name_obj, pin_name);
|
|
|
|
/// \method port()
|
|
/// Get the pin port.
|
|
STATIC mp_obj_t pin_port(mp_obj_t self_in) {
|
|
pin_obj_t *self = self_in;
|
|
return MP_OBJ_NEW_SMALL_INT((mp_small_int_t)self->port);
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_port_obj, pin_port);
|
|
|
|
/// \method pin()
|
|
/// Get the pin number.
|
|
STATIC mp_obj_t pin_pin(mp_obj_t self_in) {
|
|
pin_obj_t *self = self_in;
|
|
return MP_OBJ_NEW_SMALL_INT((mp_small_int_t)self->pin);
|
|
}
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_pin_obj, pin_pin);
|
|
|
|
STATIC const mp_map_elem_t pin_locals_dict_table[] = {
|
|
// instance methods
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&pin_init_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_value), (mp_obj_t)&pin_value_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_low), (mp_obj_t)&pin_low_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_high), (mp_obj_t)&pin_high_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_name), (mp_obj_t)&pin_name_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_port), (mp_obj_t)&pin_port_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_pin), (mp_obj_t)&pin_pin_obj },
|
|
|
|
// class methods
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_mapper), (mp_obj_t)&pin_mapper_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_dict), (mp_obj_t)&pin_map_dict_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_debug), (mp_obj_t)&pin_debug_obj },
|
|
|
|
// class attributes
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_board), (mp_obj_t)&pin_board_pins_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_cpu), (mp_obj_t)&pin_cpu_pins_obj },
|
|
|
|
// class constants
|
|
/// \constant IN - initialise the pin to input mode
|
|
/// \constant OUT_PP - initialise the pin to output mode with a push-pull drive
|
|
/// \constant OUT_OD - initialise the pin to output mode with an open-drain drive
|
|
/// \constant PULL_NONE - don't enable any pull up or down resistors on the pin
|
|
/// \constant PULL_UP - enable the pull-up resistor on the pin
|
|
/// \constant PULL_DOWN - enable the pull-down resistor on the pin
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_IN), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_INPUT) },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_OUT_PP), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_OUTPUT_PP) },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_OUT_OD), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_OUTPUT_OD) },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_AF_PP), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_AF_PP) },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_AF_OD), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_AF_OD) },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_ANALOG), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_ANALOG) },
|
|
{ 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) },
|
|
};
|
|
|
|
STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table);
|
|
|
|
const mp_obj_type_t pin_type = {
|
|
{ &mp_type_type },
|
|
.name = MP_QSTR_Pin,
|
|
.print = pin_print,
|
|
.make_new = pin_make_new,
|
|
.locals_dict = (mp_obj_t)&pin_locals_dict,
|
|
};
|
|
|
|
STATIC void pin_af_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
|
|
pin_af_obj_t *self = self_in;
|
|
print(env, "<Pin AF %d fn:%d unit:%d typ:%d>", self->idx, self->fn,
|
|
self->unit, self->type);
|
|
}
|
|
|
|
const mp_obj_type_t pin_af_type = {
|
|
{ &mp_type_type },
|
|
.name = MP_QSTR_PinAF,
|
|
.print = pin_af_obj_print,
|
|
};
|