stmhal/pin.c - lite/micropython - Linaro Git Browser

 /*
  * 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 "mpconfig.h"
 #include "nlr.h"
 #include "misc.h"
 #include "qstr.h"
 #include "obj.h"
 #include "runtime.h"
 #include MICROPY_HAL_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_const_none;
     pin_class_map_dict = mp_const_none;
     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_const_none) {
         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_const_none) {
         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(GPIO_read_pin(self->gpio, self->pin));
     } else {
         // set pin
         if (mp_obj_is_true(args[1])) {
             GPIO_set_pin(self->gpio, self->pin_mask);
         } else {
             GPIO_clear_pin(self->gpio, 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;
     GPIO_clear_pin(self->gpio, 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;
     GPIO_set_pin(self->gpio, 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(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(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,
 };
	/*
	* 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 "mpconfig.h"
	#include "nlr.h"
	#include "misc.h"
	#include "qstr.h"
	#include "obj.h"
	#include "runtime.h"
	#include MICROPY_HAL_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_const_none;
	pin_class_map_dict = mp_const_none;
	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_const_none) {
	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_const_none) {
	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(GPIO_read_pin(self->gpio, self->pin));
	} else {
	// set pin
	if (mp_obj_is_true(args[1])) {
	GPIO_set_pin(self->gpio, self->pin_mask);
	} else {
	GPIO_clear_pin(self->gpio, 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;
	GPIO_clear_pin(self->gpio, 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;
	GPIO_set_pin(self->gpio, 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(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(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,
	};