diff --git a/cc3200/application.mk b/cc3200/application.mk index 6d8a869ed0..d8e7a1ee17 100644 --- a/cc3200/application.mk +++ b/cc3200/application.mk @@ -74,7 +74,7 @@ APP_HAL_SRC_C = $(addprefix hal/,\ APP_MISC_SRC_C = $(addprefix misc/,\ FreeRTOSHooks.c \ - gpio_named_pins.c \ + pin_named_pins.c \ help.c \ mperror.c \ mpexception.c \ @@ -89,7 +89,7 @@ APP_MODS_SRC_C = $(addprefix mods/,\ modutime.c \ modwlan.c \ pybextint.c \ - pybgpio.c \ + pybpin.c \ pybrtc.c \ pybstdio.c \ pybsystick.c \ diff --git a/cc3200/boards/cc3200_prefix.c b/cc3200/boards/cc3200_prefix.c index 1d0748c6a2..38814706cd 100644 --- a/cc3200/boards/cc3200_prefix.c +++ b/cc3200/boards/cc3200_prefix.c @@ -36,13 +36,13 @@ #include "obj.h" #include "inc/hw_types.h" #include "inc/hw_memmap.h" -#include "pybgpio.h" +#include "pybpin.h" -#define GPIO(p_gpio_name, p_port, p_bit, p_pin_num) \ +#define PIN(p_pin_name, p_port, p_bit, p_pin_num) \ { \ - { &gpio_type }, \ - .name = MP_QSTR_ ## p_gpio_name, \ + { &pin_type }, \ + .name = MP_QSTR_ ## p_pin_name, \ .port = PORT_A ## p_port, \ .bit = (p_bit), \ .pin_num = (p_pin_num) \ diff --git a/cc3200/boards/make-pins.py b/cc3200/boards/make-pins.py index ad0c9b7b8e..8d47171337 100644 --- a/cc3200/boards/make-pins.py +++ b/cc3200/boards/make-pins.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -"""Creates the pin file for the CC3200.""" +"""Generates the pins files for the CC3200.""" from __future__ import print_function @@ -40,11 +40,11 @@ class Pin(object): self.board_pin = True def print(self): - print('const gpio_obj_t pin_{:6s} = GPIO({:6s}, {:1d}, {:3d}, {:2d});'.format( + print('const pin_obj_t pin_{:6s} = PIN({:6s}, {:1d}, {:3d}, {:2d});'.format( self.name, self.name, self.port, self.gpio_bit, self.pin_num)) def print_header(self, hdr_file): - hdr_file.write('extern const gpio_obj_t pin_{:s};\n'. + hdr_file.write('extern const pin_obj_t pin_{:s};\n'. format(self.name)) @@ -89,12 +89,12 @@ class Pins(object): def print_named(self, label, pins): print('') - print('STATIC const mp_map_elem_t gpio_{:s}_pins_locals_dict_table[] = {{'.format(label)) + print('STATIC const mp_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{'.format(label)) for pin in pins: if pin.is_board_pin(): print(' {{ MP_OBJ_NEW_QSTR(MP_QSTR_{:6s}), (mp_obj_t)&pin_{:6s} }},'.format(pin.cpu_pin_name(), pin.cpu_pin_name())) print('};') - print('MP_DEFINE_CONST_DICT(gpio_{:s}_pins_locals_dict, gpio_{:s}_pins_locals_dict_table);'.format(label, label)); + print('MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);'.format(label, label)); def print(self): for pin in self.cpu_pins: diff --git a/cc3200/bootmgr/bootmgr.h b/cc3200/bootmgr/bootmgr.h index fa1d7c3619..4b314335c0 100644 --- a/cc3200/bootmgr/bootmgr.h +++ b/cc3200/bootmgr/bootmgr.h @@ -3,7 +3,6 @@ * * 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 diff --git a/cc3200/bootmgr/flc.h b/cc3200/bootmgr/flc.h index 7023bc68c8..869c4cd49f 100644 --- a/cc3200/bootmgr/flc.h +++ b/cc3200/bootmgr/flc.h @@ -3,7 +3,6 @@ * * 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 diff --git a/cc3200/misc/pin_defs_cc3200.c b/cc3200/misc/pin_defs_cc3200.c index a9fb793c51..a1f0bd2641 100644 --- a/cc3200/misc/pin_defs_cc3200.c +++ b/cc3200/misc/pin_defs_cc3200.c @@ -37,18 +37,18 @@ #include "rom_map.h" #include "gpio.h" #include "pin.h" -#include "pybgpio.h" +#include "pybpin.h" #include "runtime.h" #include MICROPY_HAL_H // Returns the pin mode. This value returned by this macro should be one of: // GPIO_DIR_MODE_IN or GPIO_DIR_MODE_OUT -uint32_t gpio_get_mode(const gpio_obj_t *self) { +uint32_t pin_get_mode(const pin_obj_t *self) { return MAP_GPIODirModeGet(self->port, self->bit); } -uint32_t gpio_get_type(const gpio_obj_t *self) { +uint32_t pin_get_type(const pin_obj_t *self) { uint32_t strenght; uint32_t type; @@ -58,7 +58,7 @@ uint32_t gpio_get_type(const gpio_obj_t *self) { return type; } -uint32_t gpio_get_strenght (const gpio_obj_t *self) { +uint32_t pin_get_strenght (const pin_obj_t *self) { uint32_t strenght; uint32_t type; diff --git a/cc3200/misc/gpio_named_pins.c b/cc3200/misc/pin_named_pins.c similarity index 81% rename from cc3200/misc/gpio_named_pins.c rename to cc3200/misc/pin_named_pins.c index 884a462936..5ed4896fec 100644 --- a/cc3200/misc/gpio_named_pins.c +++ b/cc3200/misc/pin_named_pins.c @@ -36,23 +36,23 @@ #include "inc/hw_types.h" #include "inc/hw_ints.h" #include "inc/hw_memmap.h" -#include "pybgpio.h" +#include "pybpin.h" #include "runtime.h" #include MICROPY_HAL_H -STATIC void gpio_named_pins_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { - gpio_named_pins_obj_t *self = self_in; +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, "", qstr_str(self->name)); } -const mp_obj_type_t gpio_cpu_pins_obj_type = { +const mp_obj_type_t pin_cpu_pins_obj_type = { { &mp_type_type }, .name = MP_QSTR_cpu, - .print = gpio_named_pins_obj_print, - .locals_dict = (mp_obj_t)&gpio_cpu_pins_locals_dict, + .print = pin_named_pins_obj_print, + .locals_dict = (mp_obj_t)&pin_cpu_pins_locals_dict, }; -const gpio_obj_t *gpio_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) { +const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) { mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins); mp_map_elem_t *named_elem = mp_map_lookup(named_map, name, MP_MAP_LOOKUP); if (named_elem != NULL && named_elem->value != NULL) { diff --git a/cc3200/mods/modpyb.c b/cc3200/mods/modpyb.c index f17d6a257e..fe6ccc561e 100644 --- a/cc3200/mods/modpyb.c +++ b/cc3200/mods/modpyb.c @@ -47,7 +47,7 @@ #include "prcm.h" #include "pyexec.h" #include "pybuart.h" -#include "pybgpio.h" +#include "pybpin.h" #include "pybstdio.h" #include "pybrtc.h" #include "pybsystick.h" @@ -303,7 +303,7 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_RTC), (mp_obj_t)&pyb_rtc_type }, #endif - { MP_OBJ_NEW_QSTR(MP_QSTR_GPIO), (mp_obj_t)&gpio_type }, + { MP_OBJ_NEW_QSTR(MP_QSTR_Pin), (mp_obj_t)&pin_type }, { MP_OBJ_NEW_QSTR(MP_QSTR_ExtInt), (mp_obj_t)&extint_type }, { MP_OBJ_NEW_QSTR(MP_QSTR_UART), (mp_obj_t)&pyb_uart_type }, diff --git a/cc3200/mods/pybextint.c b/cc3200/mods/pybextint.c index abfec5572d..df55d88612 100644 --- a/cc3200/mods/pybextint.c +++ b/cc3200/mods/pybextint.c @@ -45,7 +45,7 @@ #include "rom_map.h" #include "pin.h" #include "gpio.h" -#include "pybgpio.h" +#include "pybpin.h" #include "pybextint.h" #include "mpexception.h" #include "interrupt.h" @@ -55,7 +55,7 @@ /// \moduleref pyb /// \class ExtInt - configure I/O pins to interrupt on external events /// -/// There are a maximum of 25 GPIO interrupt lines. +/// There are a maximum of 25 gpio interrupt lines. /// /// Example callback: /// @@ -72,10 +72,10 @@ /// See: http://www.eng.utah.edu/~cs5780/debouncing.pdf for a detailed /// explanation, along with various techniques for debouncing. /// -/// All gpio objects go through the gpio mapper to come up with one of the +/// All pin objects go through the pin mapper to come up with one of the /// gpio pins. /// -/// extint = pyb.ExtInt(gpio, mode, pull, callback) +/// extint = pyb.ExtInt(pin, mode, pull, callback) /// /// There is also a C API, so that drivers which require EXTI interrupt lines /// can also use this code. See pybextint.h for the available functions. @@ -149,7 +149,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(extint_obj_swint_obj, extint_obj_swint); /// \classmethod \constructor(pin, mode, pull, callback) /// Create an ExtInt object: /// -/// - `gpio` is the gpio on which to enable the interrupt (can be a gpio object or any valid gpio name). +/// - `pin` is the pin on which to enable the interrupt (can be a pin object or any valid pin name). /// - `mode` can be one of: /// - `ExtInt.IRQ_RISING` - trigger on a rising edge; /// - `ExtInt.IRQ_FALLING` - trigger on a falling edge; @@ -162,7 +162,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(extint_obj_swint_obj, extint_obj_swint); /// callback function must accept exactly 1 argument, which is the line that /// triggered the interrupt. STATIC const mp_arg_t pyb_extint_make_new_args[] = { - { MP_QSTR_gpio, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, + { MP_QSTR_pin, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, { MP_QSTR_pull, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, { MP_QSTR_callback, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, @@ -271,12 +271,12 @@ void extint_init0(void) { } extint_obj_t* extint_register(mp_obj_t pin_obj, uint32_t intmode, uint32_t pull, mp_obj_t callback) { - const gpio_obj_t *gpio = NULL; + const pin_obj_t *pin = NULL; extint_obj_t* self; void *handler; uint32_t intnum; - gpio = gpio_find(pin_obj); + pin = pin_find(pin_obj); if (intmode != GPIO_FALLING_EDGE && intmode != GPIO_RISING_EDGE && @@ -294,8 +294,8 @@ extint_obj_t* extint_register(mp_obj_t pin_obj, uint32_t intmode, uint32_t pull, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_value_invalid_arguments)); } - if (NULL == (self = extint_find(gpio->port, gpio->bit))) { - self = extint_add(gpio->pin_num, gpio->port, gpio->bit); + if (NULL == (self = extint_find(pin->port, pin->bit))) { + self = extint_add(pin->pin_num, pin->port, pin->bit); } else { // we need to update the callback atomically, so we disable the line @@ -307,10 +307,10 @@ extint_obj_t* extint_register(mp_obj_t pin_obj, uint32_t intmode, uint32_t pull, self->callback = NULL; // before enabling the interrupt, configure the gpio pin - gpio_config(gpio, PIN_MODE_0, GPIO_DIR_MODE_IN, pull, PIN_STRENGTH_4MA); + pin_config(pin, PIN_MODE_0, GPIO_DIR_MODE_IN, pull, PIN_STRENGTH_4MA); - MAP_GPIOIntTypeSet(gpio->port, gpio->bit, intmode); - switch (gpio->port) { + MAP_GPIOIntTypeSet(pin->port, pin->bit, intmode); + switch (pin->port) { case GPIOA0_BASE: handler = GPIOA0IntHandler; intnum = INT_GPIOA0; @@ -330,7 +330,7 @@ extint_obj_t* extint_register(mp_obj_t pin_obj, uint32_t intmode, uint32_t pull, break; } - MAP_GPIOIntRegister(gpio->port, handler); + MAP_GPIOIntRegister(pin->port, handler); // set the interrupt to the lowest priority, to make sure that no ther // isr will be preemted by this one MAP_IntPrioritySet(intnum, INT_PRIORITY_LVL_7); diff --git a/cc3200/mods/pybgpio.c b/cc3200/mods/pybpin.c similarity index 56% rename from cc3200/mods/pybgpio.c rename to cc3200/mods/pybpin.c index cf52b501db..6acd3082bf 100644 --- a/cc3200/mods/pybgpio.c +++ b/cc3200/mods/pybpin.c @@ -45,12 +45,12 @@ #include "pin.h" #include "prcm.h" #include "gpio.h" -#include "pybgpio.h" +#include "pybpin.h" #include "mpexception.h" /// \moduleref pyb -/// \class GPIO - control I/O pins +/// \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 or output) and methods to get and set the @@ -58,95 +58,49 @@ /// /// Usage Model: /// -/// All CPU Pins are predefined as pyb.GPIO.cpu.Name +/// All CPU Pins are predefined as pyb.Pin.cpu.Name /// -/// GPIO9_pin = pyb.GPIO.cpu.GPIO9 +/// GPIO9_pin = pyb.Pin.cpu.GPIO9 /// -/// g = pyb.GPIO(pyb.GPIO.cpu.GPIO9, 0, pyb.GPIO.IN) +/// g = pyb.Pin(pyb.Pin.cpu.GPIO9, 0, pyb.Pin.IN) /// /// CPU pins which correspond to the board pins are available /// as `pyb.cpu.Name`. /// /// You can also use strings: /// -/// g = pyb.GPIO('GPIO9', 0) -/// -/// Users can add their own names: -/// -/// MyMapperDict = { 'LeftMotorDir' : pyb.GPIO.cpu.GPIO11 } -/// pyb.GPIO.dict(MyMapperDict) -/// g = pyb.GPIO("LeftMotorDir", 0) -/// -/// and can query mappings -/// -/// g = pyb.GPIO("LeftMotorDir") -/// -/// Users can also add their own mapping function: -/// -/// def MyMapper(gpio_name): -/// if gpio_name == "LeftMotorDir": -/// return pyb.GPIO.cpu.GPIO11 -/// -/// pyb.GPIO.mapper(MyMapper) -/// -/// So, if you were to call: `pyb.GPIO("LeftMotorDir", pyb.GPIO.OUT)` -/// then `"LeftMotorDir"` is passed directly to the mapper function. +/// g = pyb.Pin('GPIO9', 0) /// /// To summarise, the following order determines how things get mapped into /// an ordinal pin number: /// -/// 1. Directly specify a GPIO 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 CPU port/pin +/// 1. Directly specify a Pin object +/// 2. Supply a string which matches a CPU port/pin -void gpio_init0(void) { - MP_STATE_PORT(gpio_class_mapper) = mp_const_none; - MP_STATE_PORT(gpio_class_map_dict) = mp_const_none; +void pin_init0(void) { } // C API used to convert a user-supplied pin name into an ordinal pin number. -const gpio_obj_t *gpio_find(mp_obj_t user_obj) { - const gpio_obj_t *gpio_obj; +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, &gpio_type)) { - gpio_obj = user_obj; - return gpio_obj; - } - - if (MP_STATE_PORT(gpio_class_mapper) != mp_const_none) { - gpio_obj = mp_call_function_1(MP_STATE_PORT(gpio_class_mapper), user_obj); - if (gpio_obj != mp_const_none) { - if (!MP_OBJ_IS_TYPE(gpio_obj, &gpio_type)) { - nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable)); - } - return gpio_obj; - } - // The pin mapping function returned mp_const_none, fall through to - // other lookup methods. - } - - if (MP_STATE_PORT(gpio_class_map_dict) != mp_const_none) { - mp_map_t *gpio_map_map = mp_obj_dict_get_map(MP_STATE_PORT(gpio_class_map_dict)); - mp_map_elem_t *elem = mp_map_lookup(gpio_map_map, user_obj, MP_MAP_LOOKUP); - if (elem != NULL && elem->value != NULL) { - gpio_obj = elem->value; - return gpio_obj; - } + if (MP_OBJ_IS_TYPE(user_obj, &pin_type)) { + pin_obj = user_obj; + return pin_obj; } // See if the pin name matches a cpu pin - gpio_obj = gpio_find_named_pin(&gpio_cpu_pins_locals_dict, user_obj); - if (gpio_obj) { - return gpio_obj; + pin_obj = pin_find_named_pin(&pin_cpu_pins_locals_dict, user_obj); + if (pin_obj) { + return pin_obj; } nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); } -void gpio_config(const gpio_obj_t *self, uint af, uint mode, uint type, uint strength) { - // PIN_MODE_0 means it stays as a GPIO, else, another peripheral will take control of it +void pin_config(const pin_obj_t *self, uint af, uint mode, uint type, uint strength) { + // PIN_MODE_0 means it stays as a Pin, else, another peripheral will take control of it if (af == PIN_MODE_0) { // enable the peripheral clock for the GPIO port of this pin switch (self->port) { @@ -176,25 +130,25 @@ void gpio_config(const gpio_obj_t *self, uint af, uint mode, uint type, uint str /// \method print() /// Return a string describing the pin object. -STATIC void gpio_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { - gpio_obj_t *self = self_in; +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; uint32_t af = MAP_PinModeGet(self->pin_num); - uint32_t type = gpio_get_type(self); - uint32_t strength = gpio_get_strenght(self); + uint32_t type = pin_get_type(self); + uint32_t strength = pin_get_strenght(self); // pin name - print(env, "GPIO(GPIO.cpu.%s, af=%u", qstr_str(self->name), af); + print(env, "Pin(Pin.cpu.%s, af=%u", qstr_str(self->name), af); if (af == PIN_MODE_0) { // IO mode qstr mode_qst; - uint32_t mode = gpio_get_mode(self); + uint32_t mode = pin_get_mode(self); if (mode == GPIO_DIR_MODE_IN) { mode_qst = MP_QSTR_IN; } else { mode_qst = MP_QSTR_OUT; } - print(env, ", mode=GPIO.%s", qstr_str(mode_qst)); // safe because mode_qst has no formatting chars + print(env, ", mode=Pin.%s", qstr_str(mode_qst)); // safe because mode_qst has no formatting chars } // pin type @@ -212,7 +166,7 @@ STATIC void gpio_print(void (*print)(void *env, const char *fmt, ...), void *env } else { type_qst = MP_QSTR_OD_PD; } - print(env, ", pull=GPIO.%s", qstr_str(type_qst)); + print(env, ", pull=Pin.%s", qstr_str(type_qst)); // Strength qstr str_qst; @@ -223,54 +177,30 @@ STATIC void gpio_print(void (*print)(void *env, const char *fmt, ...), void *env } else { str_qst = MP_QSTR_S6MA; } - print(env, ", strength=GPIO.%s)", qstr_str(str_qst)); + print(env, ", strength=Pin.%s)", qstr_str(str_qst)); } -STATIC mp_obj_t gpio_obj_init_helper(const gpio_obj_t *pin, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args); +STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *pin, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args); /// \classmethod \constructor(id, ...) -/// Create a new GPIO object associated with the id. If additional arguments are given, +/// 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 gpio_make_new(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) { +STATIC mp_obj_t pin_make_new(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) { mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); // Run an argument through the mapper and return the result. - const gpio_obj_t *pin = gpio_find(args[0]); + const pin_obj_t *pin = pin_find(args[0]); if (n_args > 1) { // pin af given, so configure it mp_map_t kw_args; mp_map_init_fixed_table(&kw_args, n_kw, args + n_args); - gpio_obj_init_helper(pin, n_args - 1, args + 1, &kw_args); + pin_obj_init_helper(pin, n_args - 1, args + 1, &kw_args); } return (mp_obj_t)pin; } -/// \classmethod mapper([fun]) -/// Get or set the pin mapper function. -STATIC mp_obj_t gpio_mapper(mp_uint_t n_args, const mp_obj_t *args) { - if (n_args > 1) { - MP_STATE_PORT(gpio_class_mapper) = args[1]; - return mp_const_none; - } - return MP_STATE_PORT(gpio_class_mapper); -} -STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(gpio_mapper_fun_obj, 1, 2, gpio_mapper); -STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(gpio_mapper_obj, (mp_obj_t)&gpio_mapper_fun_obj); - -/// \classmethod dict([dict]) -/// Get or set the pin mapper dictionary. -STATIC mp_obj_t gpio_map_dict(mp_uint_t n_args, const mp_obj_t *args) { - if (n_args > 1) { - MP_STATE_PORT(gpio_class_map_dict) = args[1]; - return mp_const_none; - } - return MP_STATE_PORT(gpio_class_map_dict); -} -STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(gpio_map_dict_fun_obj, 1, 2, gpio_map_dict); -STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(gpio_map_dict_obj, (mp_obj_t)&gpio_map_dict_fun_obj); - /// \method init(mode, pull=Pin.PULL_NONE, af=-1) /// Initialise the pin: /// @@ -293,18 +223,18 @@ STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(gpio_map_dict_obj, (mp_obj_t)&gpio_map_di /// - `Pin.6MA` - 6ma drive strength; /// /// Returns: `None`. -STATIC const mp_arg_t gpio_init_args[] = { +STATIC const mp_arg_t pin_init_args[] = { { MP_QSTR_af, MP_ARG_REQUIRED | MP_ARG_INT }, { MP_QSTR_mode, MP_ARG_INT, {.u_int = GPIO_DIR_MODE_OUT} }, { MP_QSTR_type, MP_ARG_INT, {.u_int = PIN_TYPE_STD} }, { MP_QSTR_str, MP_ARG_INT, {.u_int = PIN_STRENGTH_4MA} }, }; -#define gpio_INIT_NUM_ARGS MP_ARRAY_SIZE(gpio_init_args) +#define pin_INIT_NUM_ARGS MP_ARRAY_SIZE(pin_init_args) -STATIC mp_obj_t gpio_obj_init_helper(const gpio_obj_t *self, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) { +STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) { // parse args - mp_arg_val_t vals[gpio_INIT_NUM_ARGS]; - mp_arg_parse_all(n_args, args, kw_args, gpio_INIT_NUM_ARGS, gpio_init_args, vals); + mp_arg_val_t vals[pin_INIT_NUM_ARGS]; + mp_arg_parse_all(n_args, args, kw_args, pin_INIT_NUM_ARGS, pin_init_args, vals); // get the af uint af = vals[0].u_int; @@ -329,15 +259,15 @@ STATIC mp_obj_t gpio_obj_init_helper(const gpio_obj_t *self, mp_uint_t n_args, c } // configure the pin as requested - gpio_config (self, af, mode, type, strength); + pin_config (self, af, mode, type, strength); return mp_const_none; } -STATIC mp_obj_t gpio_obj_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) { - return gpio_obj_init_helper(args[0], n_args - 1, args + 1, kw_args); +STATIC mp_obj_t pin_obj_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) { + return pin_obj_init_helper(args[0], n_args - 1, args + 1, kw_args); } -MP_DEFINE_CONST_FUN_OBJ_KW(gpio_init_obj, 1, gpio_obj_init); +MP_DEFINE_CONST_FUN_OBJ_KW(pin_init_obj, 1, pin_obj_init); /// \method value([value]) /// Get or set the digital logic level of the pin: @@ -346,8 +276,8 @@ MP_DEFINE_CONST_FUN_OBJ_KW(gpio_init_obj, 1, gpio_obj_init); /// - 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 gpio_value(mp_uint_t n_args, const mp_obj_t *args) { - gpio_obj_t *self = args[0]; +STATIC mp_obj_t pin_value(mp_uint_t n_args, const mp_obj_t *args) { + pin_obj_t *self = args[0]; if (n_args == 1) { // get the pin value return MP_OBJ_NEW_SMALL_INT(MAP_GPIOPinRead(self->port, self->bit) ? 1 : 0); @@ -361,136 +291,112 @@ STATIC mp_obj_t gpio_value(mp_uint_t n_args, const mp_obj_t *args) { return mp_const_none; } } -STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(gpio_value_obj, 1, 2, gpio_value); +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 gpio_low(mp_obj_t self_in) { - gpio_obj_t *self = self_in; +STATIC mp_obj_t pin_low(mp_obj_t self_in) { + pin_obj_t *self = self_in; MAP_GPIOPinWrite(self->port, self->bit, 0); return mp_const_none; } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_low_obj, gpio_low); +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 gpio_high(mp_obj_t self_in) { - gpio_obj_t *self = self_in; +STATIC mp_obj_t pin_high(mp_obj_t self_in) { + pin_obj_t *self = self_in; MAP_GPIOPinWrite(self->port, self->bit, self->bit); return mp_const_none; } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_high_obj, gpio_high); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_high_obj, pin_high); /// \method toggle() /// Toggles the value of the pin -STATIC mp_obj_t gpio_toggle(mp_obj_t self_in) { - gpio_obj_t *self = self_in; +STATIC mp_obj_t pin_toggle(mp_obj_t self_in) { + pin_obj_t *self = self_in; MAP_GPIOPinWrite(self->port, self->bit, ~MAP_GPIOPinRead(self->port, self->bit)); return mp_const_none; } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_toggle_obj, gpio_toggle); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_toggle_obj, pin_toggle); /// \method name() /// Get the pin name. -STATIC mp_obj_t gpio_name(mp_obj_t self_in) { - gpio_obj_t *self = self_in; +STATIC mp_obj_t pin_name(mp_obj_t self_in) { + pin_obj_t *self = self_in; return MP_OBJ_NEW_QSTR(self->name); } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_name_obj, gpio_name); - -/// \method name() -/// Returns the cpu name for this pin. -STATIC mp_obj_t gpio_cpu_name(mp_obj_t self_in) { - gpio_obj_t *self = self_in; - mp_obj_t result = mp_obj_new_list(0, NULL); - mp_obj_list_append(result, MP_OBJ_NEW_QSTR(self->name)); - - mp_map_t *map = mp_obj_dict_get_map((mp_obj_t)&gpio_cpu_pins_locals_dict); - mp_map_elem_t *elem = map->table; - - for (mp_uint_t i = 0; i < map->used; i++, elem++) { - if (elem->value == self) { - mp_obj_list_append(result, elem->key); - } - } - return result; -} -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_cpu_name_obj, gpio_cpu_name); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_name_obj, pin_name); /// \method port() /// Get the pin port. -STATIC mp_obj_t gpio_port(mp_obj_t self_in) { - gpio_obj_t *self = self_in; +STATIC mp_obj_t pin_port(mp_obj_t self_in) { + pin_obj_t *self = self_in; return mp_obj_new_int(self->port); } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_port_obj, gpio_port); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_port_obj, pin_port); /// \method pin() /// Get the pin number. -STATIC mp_obj_t gpio_pin(mp_obj_t self_in) { - gpio_obj_t *self = self_in; +STATIC mp_obj_t pin_pin(mp_obj_t self_in) { + pin_obj_t *self = self_in; return MP_OBJ_NEW_SMALL_INT(self->pin_num); } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_pin_obj, gpio_pin); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_pin_obj, pin_pin); /// \method mode() /// Returns the currently configured mode of the gpio pin. The integer returned /// will match one of the allowed constants for the mode argument to the init /// function. -STATIC mp_obj_t gpio_mode(mp_obj_t self_in) { - return MP_OBJ_NEW_SMALL_INT(gpio_get_mode(self_in)); +STATIC mp_obj_t pin_mode(mp_obj_t self_in) { + return MP_OBJ_NEW_SMALL_INT(pin_get_mode(self_in)); } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_mode_obj, gpio_mode); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_mode_obj, pin_mode); /// \method type() /// Returns the currently configured type of the pin. The integer returned /// will match one of the allowed constants for the type argument to the init /// function. -STATIC mp_obj_t gpio_type_get(mp_obj_t self_in) { - return MP_OBJ_NEW_SMALL_INT(gpio_get_type(self_in)); +STATIC mp_obj_t pin_type_get(mp_obj_t self_in) { + return MP_OBJ_NEW_SMALL_INT(pin_get_type(self_in)); } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_type_obj, gpio_type_get); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_type_obj, pin_type_get); /// \method strength() /// Returns the currently configured drive strength of the pin. The integer returned /// will match one of the allowed constants for the strength argument to the init /// function. -STATIC mp_obj_t gpio_strength(mp_obj_t self_in) { - return MP_OBJ_NEW_SMALL_INT(gpio_get_strenght(self_in)); +STATIC mp_obj_t pin_strength(mp_obj_t self_in) { + return MP_OBJ_NEW_SMALL_INT(pin_get_strenght(self_in)); } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_strenght_obj, gpio_strength); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_strenght_obj, pin_strength); /// \method af() /// Returns the currently configured alternate function of the gpio pin. The integer returned /// will match one of the allowed constants for the af argument to the init function. -STATIC mp_obj_t gpio_af(mp_obj_t self_in) { - gpio_obj_t *self = self_in; +STATIC mp_obj_t pin_af(mp_obj_t self_in) { + pin_obj_t *self = self_in; return MP_OBJ_NEW_SMALL_INT(MAP_PinModeGet(self->pin_num)); } -STATIC MP_DEFINE_CONST_FUN_OBJ_1(gpio_af_obj, gpio_af); +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_af_obj, pin_af); -STATIC const mp_map_elem_t gpio_locals_dict_table[] = { +STATIC const mp_map_elem_t pin_locals_dict_table[] = { // instance methods - { MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&gpio_init_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_value), (mp_obj_t)&gpio_value_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_low), (mp_obj_t)&gpio_low_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_high), (mp_obj_t)&gpio_high_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_toggle), (mp_obj_t)&gpio_toggle_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_name), (mp_obj_t)&gpio_name_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_names), (mp_obj_t)&gpio_cpu_name_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_port), (mp_obj_t)&gpio_port_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_pin), (mp_obj_t)&gpio_pin_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_mode), (mp_obj_t)&gpio_mode_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_type), (mp_obj_t)&gpio_type_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_strength), (mp_obj_t)&gpio_strenght_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_af), (mp_obj_t)&gpio_af_obj }, - - // class methods - { MP_OBJ_NEW_QSTR(MP_QSTR_mapper), (mp_obj_t)&gpio_mapper_obj }, - { MP_OBJ_NEW_QSTR(MP_QSTR_dict), (mp_obj_t)&gpio_map_dict_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&pin_init_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_value), (mp_obj_t)&pin_value_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_low), (mp_obj_t)&pin_low_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_high), (mp_obj_t)&pin_high_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_toggle), (mp_obj_t)&pin_toggle_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_name), (mp_obj_t)&pin_name_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_port), (mp_obj_t)&pin_port_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_pin), (mp_obj_t)&pin_pin_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_mode), (mp_obj_t)&pin_mode_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_type), (mp_obj_t)&pin_type_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_strength), (mp_obj_t)&pin_strenght_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_af), (mp_obj_t)&pin_af_obj }, // class attributes - { MP_OBJ_NEW_QSTR(MP_QSTR_cpu), (mp_obj_t)&gpio_cpu_pins_obj_type }, + { MP_OBJ_NEW_QSTR(MP_QSTR_cpu), (mp_obj_t)&pin_cpu_pins_obj_type }, // class constants /// \constant IN - set the pin to input mode @@ -518,12 +424,12 @@ STATIC const mp_map_elem_t gpio_locals_dict_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_S6MA), MP_OBJ_NEW_SMALL_INT(PIN_STRENGTH_6MA) }, }; -STATIC MP_DEFINE_CONST_DICT(gpio_locals_dict, gpio_locals_dict_table); +STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table); -const mp_obj_type_t gpio_type = { +const mp_obj_type_t pin_type = { { &mp_type_type }, - .name = MP_QSTR_GPIO, - .print = gpio_print, - .make_new = gpio_make_new, - .locals_dict = (mp_obj_t)&gpio_locals_dict, + .name = MP_QSTR_Pin, + .print = pin_print, + .make_new = pin_make_new, + .locals_dict = (mp_obj_t)&pin_locals_dict, }; diff --git a/cc3200/mods/pybgpio.h b/cc3200/mods/pybpin.h similarity index 69% rename from cc3200/mods/pybgpio.h rename to cc3200/mods/pybpin.h index 08a495803e..9b4f2e7874 100644 --- a/cc3200/mods/pybgpio.h +++ b/cc3200/mods/pybpin.h @@ -36,33 +36,31 @@ typedef struct { uint32_t port; uint32_t bit : 8; uint32_t pin_num : 7; -} gpio_obj_t; +} pin_obj_t; -extern const mp_obj_type_t gpio_type; +extern const mp_obj_type_t pin_type; typedef struct { const char *name; - const gpio_obj_t *gpio; -} gpio_named_pin_t; - -extern const gpio_named_pin_t gpio_cpu_pins[]; + const pin_obj_t *pin; +} pin_named_pin_t; typedef struct { mp_obj_base_t base; qstr name; - const gpio_named_pin_t *named_pins; -} gpio_named_pins_obj_t; + const pin_named_pin_t *named_pins; +} pin_named_pins_obj_t; -extern const mp_obj_type_t gpio_cpu_pins_obj_type; -extern const mp_obj_dict_t gpio_cpu_pins_locals_dict; +extern const mp_obj_type_t pin_cpu_pins_obj_type; +extern const mp_obj_dict_t pin_cpu_pins_locals_dict; -MP_DECLARE_CONST_FUN_OBJ(gpio_init_obj); +MP_DECLARE_CONST_FUN_OBJ(pin_init_obj); -void gpio_init0(void); -void gpio_config(const gpio_obj_t *self, uint af, uint mode, uint type, uint strength); -const gpio_obj_t *gpio_find(mp_obj_t user_obj); -const gpio_obj_t *gpio_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name); -uint32_t gpio_get_mode(const gpio_obj_t *self); -uint32_t gpio_get_type(const gpio_obj_t *self); -uint32_t gpio_get_strenght(const gpio_obj_t *self); +void pin_init0(void); +void pin_config(const pin_obj_t *self, uint af, uint mode, uint type, uint strength); +const pin_obj_t *pin_find(mp_obj_t user_obj); +const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name); +uint32_t pin_get_mode(const pin_obj_t *self); +uint32_t pin_get_type(const pin_obj_t *self); +uint32_t pin_get_strenght(const pin_obj_t *self); diff --git a/cc3200/mods/pybuart.c b/cc3200/mods/pybuart.c index 8fad7eaa48..359d97d701 100644 --- a/cc3200/mods/pybuart.c +++ b/cc3200/mods/pybuart.c @@ -52,7 +52,6 @@ #include "uart.h" #include "pin.h" #include "pybuart.h" -#include "pybgpio.h" #include "pybioctl.h" #include "pybstdio.h" #include "mpexception.h" diff --git a/cc3200/mpconfigport.h b/cc3200/mpconfigport.h index 02afef0ba8..a29bce26d4 100644 --- a/cc3200/mpconfigport.h +++ b/cc3200/mpconfigport.h @@ -120,8 +120,6 @@ extern const struct _mp_obj_module_t mp_module_network; const char *readline_hist[8]; \ mp_obj_t mp_const_user_interrupt; \ mp_obj_t pyb_config_main; \ - mp_obj_t gpio_class_mapper; \ - mp_obj_t gpio_class_map_dict; \ mp_obj_list_t pyb_extint_list; \ struct _pyb_uart_obj_t *pyb_stdio_uart; \ struct _pyb_uart_obj_t *pyb_uart_obj_all[2]; \ diff --git a/cc3200/mptask.c b/cc3200/mptask.c index ed69fb2f23..03cac6ed33 100644 --- a/cc3200/mptask.c +++ b/cc3200/mptask.c @@ -42,7 +42,7 @@ #include "repl.h" #include "inc/hw_memmap.h" #include "pybuart.h" -#include "pybgpio.h" +#include "pybpin.h" #include "pybrtc.h" #include "pybstdio.h" #include "pyexec.h" @@ -152,7 +152,7 @@ soft_reset: MP_STATE_PORT(pyb_stdio_uart) = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args); readline_init0(); - gpio_init0(); + pin_init0(); extint_init0(); mod_network_init(); wlan_init0(); diff --git a/cc3200/qstrdefsport.h b/cc3200/qstrdefsport.h index cfc07105c1..9ea8c24d37 100644 --- a/cc3200/qstrdefsport.h +++ b/cc3200/qstrdefsport.h @@ -69,19 +69,15 @@ Q(urandom) Q(seek) Q(tell) -// for GPIO class -Q(GPIO) +// for Pin class +Q(Pin) Q(init) Q(value) Q(low) Q(high) Q(name) -Q(names) Q(port) Q(pin) -Q(gpio) -Q(mapper) -Q(dict) Q(cpu) Q(mode) Q(pull) @@ -115,7 +111,6 @@ Q(IRQ_RISING_FALLING) Q(IRQ_LOW_LEVEL) Q(IRQ_HIGH_LEVEL) - // for UART class Q(UART) Q(UART1)