integrate with hexpansion.config and remove duplicate api

also renamed to egpio and ePin. aligned defines with machine.Pin

drivers/tildagon/tildagon.c

@@ -5,9 +5,9 @@ extern mp_obj_module_t tildagon_pin_type;
 
 
 static const mp_rom_map_elem_t mp_module_tildagon_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_tildagon) },
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_egpio) },
     // { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&tildagon_i2c_obj) },
-    { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&tildagon_pin_type)}
+    { MP_ROM_QSTR(MP_QSTR_ePin), MP_ROM_PTR(&tildagon_pin_type)}
 };
 static MP_DEFINE_CONST_DICT(mp_module_tildagon_globals, mp_module_tildagon_globals_table);
 
@@ -16,5 +16,5 @@ const mp_obj_module_t mp_module_tildagon = {
     .globals = (mp_obj_dict_t *)&mp_module_tildagon_globals,
 };
 
-MP_REGISTER_MODULE(MP_QSTR_tildagon, mp_module_tildagon);
+MP_REGISTER_MODULE(MP_QSTR_egpio, mp_module_tildagon);
 

drivers/tildagon_pin/tildagon_pin.c

@@ -53,7 +53,8 @@
 #define PIN_OBJ_PTR_PORTPIN(self) (PIN_OBJ_PTR_INDEX(self)%16)
 #define PORTPIN_IS_VALID_LED(pin) (0 <= pin && pin < 16)
 #define PIN_OBJ_PTR_INDEX(self) ((self) - tildagon_pin_obj_table)
-
+// this is outside of machine.Pins defines
+#define EGPIO_MODE_PWM 8
 
 aw9523b_device_t ext_pin[3] = {
     {
@@ -172,15 +173,23 @@ static mp_obj_t tildagon_pin_obj_init_helper(const tildagon_pin_obj_t *self, siz
     // configure mode
     if (args[ARG_mode].u_obj != mp_const_none) {
         mp_int_t pin_io_mode = mp_obj_get_int(args[ARG_mode].u_obj);
-        if ( pin_io_mode == 2 )
+        if ( pin_io_mode == EGPIO_MODE_PWM )
         {
             aw9523b_pin_set_mode(dev, pin, AW9523B_PIN_MODE_LED);
         }
         else
         {
             // configure the pin for gpio
             aw9523b_pin_set_mode(dev, pin, AW9523B_PIN_MODE_GPIO);
-            aw9523b_pin_set_direction(dev, pin, pin_io_mode);
+
+            if ( pin_io_mode == GPIO_MODE_INPUT_OUTPUT )
+            {
+                aw9523b_pin_set_direction(dev, pin, 0);
+            }
+            else
+            {
+                aw9523b_pin_set_direction(dev, pin, 1);
+            }
         }
     }
 
@@ -288,10 +297,10 @@ static mp_obj_t tildagon_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map
 }
 //static MP_DEFINE_CONST_FUN_OBJ_KW(tildagon_pin_irq_obj, 1, tildagon_pin_irq);
 
-static mp_obj_t tildagon_pin_pwm(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_pwm_value };
+static mp_obj_t tildagon_pin_duty(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_duty };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_pwmvalue, MP_ARG_OBJ, {.u_obj = mp_const_none} },    
+        { MP_QSTR_duty, MP_ARG_OBJ, {.u_obj = mp_const_none} },    
     };
     tildagon_pin_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@@ -301,15 +310,15 @@ static mp_obj_t tildagon_pin_pwm(size_t n_args, const mp_obj_t *pos_args, mp_map
           // configure irq
         aw9523b_device_t *dev = PIN_OBJ_PTR_DEVICE(self);
         aw9523b_pin_t pin = PIN_OBJ_PTR_PORTPIN(self);
-        mp_obj_t pwm_value = args[ARG_pwm_value].u_obj;
-        uint8_t pwm = mp_obj_get_int(pwm_value);
-        aw9523b_pin_set_drive( dev, pin, pwm );
+        mp_obj_t mp_duty = args[ARG_duty].u_obj;
+        uint8_t duty = mp_obj_get_int(mp_duty);
+        aw9523b_pin_set_drive( dev, pin, duty );
     }
 
     return mp_const_none;
 }
 
-static MP_DEFINE_CONST_FUN_OBJ_KW(tildagon_pin_pwm_obj, 1, tildagon_pin_pwm);
+static MP_DEFINE_CONST_FUN_OBJ_KW(tildagon_pin_duty_obj, 1, tildagon_pin_duty);
 
 MP_DEFINE_CONST_OBJ_TYPE(
     tildagon_pin_board_pins_obj_type,
@@ -324,16 +333,17 @@ static const mp_rom_map_elem_t tildagon_pin_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&tildagon_pin_value_obj) },
     { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&tildagon_pin_off_obj) },
     { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&tildagon_pin_on_obj) },
+    //todo reinstate once triggers can be split into rising/falling edge
     //{ MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&tildagon_pin_irq_obj) },
-    { MP_ROM_QSTR(MP_QSTR_pwm), MP_ROM_PTR(&tildagon_pin_pwm_obj) },
+    { MP_ROM_QSTR(MP_QSTR_duty), MP_ROM_PTR(&tildagon_pin_duty_obj) },
 
     // class attributes
     { MP_ROM_QSTR(MP_QSTR_board), MP_ROM_PTR(&tildagon_pin_board_pins_obj_type) },
 
     // class constants
-    { MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_INT(1) },
-    { MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_INT(0) },
-    { MP_ROM_QSTR(MP_QSTR_PWM), MP_ROM_INT(2) },
+    { MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_INT(GPIO_MODE_INPUT) },
+    { MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_INT(GPIO_MODE_INPUT_OUTPUT) },
+    { MP_ROM_QSTR(MP_QSTR_PWM), MP_ROM_INT(EGPIO_MODE_PWM) },
     //{ MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(GPIO_INTR_POSEDGE) },
     //{ MP_ROM_QSTR(MP_QSTR_IRQ_FALLING), MP_ROM_INT(GPIO_INTR_NEGEDGE) },
 };
@@ -364,7 +374,7 @@ static const mp_pin_p_t tildagon_pin_pin_p = {
 
 MP_DEFINE_CONST_OBJ_TYPE(
     tildagon_pin_type,
-    MP_QSTR_Pin,
+    MP_QSTR_ePin,
     MP_TYPE_FLAG_NONE,
     make_new, mp_tildagon_pin_make_new,
     print, tildagon_pin_print,

modules/frontboards/twentyfour.py

@@ -4,7 +4,7 @@
 from events.input import Button, BUTTON_TYPES, ButtonDownEvent, ButtonUpEvent
 import machine
 from system.eventbus import eventbus
-import tildagon
+from tildagon import ePin
 from . import FrontBoard
 from system.hexpansion.events import HexpansionInsertionEvent, HexpansionRemovalEvent
 import time
@@ -43,7 +43,7 @@ async def background_task(self):
                     map(lambda i: self.BUTTON_PINS[BUTTONS[i]], "ABCDEF")
                 ):
                     state = hexpansion_states[i + 1]
-                    button_down = not tildagon.Pin(gpio).value()
+                    button_down = not ePin(gpio).value()
                     # print(i, now, state)
                     if button_down and state is None:
                         hexpansion_states[i + 1] = now
@@ -54,7 +54,7 @@ async def background_task(self):
                         await eventbus.emit_async(HexpansionRemovalEvent(port=i + 1))
             else:
                 for button, pin in self.BUTTON_PINS.items():
-                    button_down = not tildagon.Pin(pin).value()
+                    button_down = not ePin(pin).value()
                     if button_down and not button_states[button]:
                         await eventbus.emit_async(ButtonDownEvent(button=button))
                     if not button_down and button_states[button]:

modules/lib/simple_tildagon.py

@@ -1,7 +1,7 @@
 # A easy to use module for the basic components of the tildagon badge
 
 from tildagonos import tildagonos
-import tildagon
+from egpio import ePin
 import imu as tilda_imu
 import math
 import time
@@ -38,7 +38,7 @@ def get(button_letter):
         }
         if button_letter in button_letters.keys():
             # Note the button must be flipped, as will return True when not pressed
-            return not tildagon.Pin(button_letters[button_letter]).value()
+            return not ePin(button_letters[button_letter]).value()
         else:
             raise ValueError(
                 "button_letter must be a string of a single letter from a to f"

modules/system/hexpansion/app.py

@@ -22,7 +22,7 @@
 from tildagonos import EPIN_ND_A, EPIN_ND_B, EPIN_ND_C, EPIN_ND_D, EPIN_ND_E, EPIN_ND_F
 from tildagonos import led_colours
 from tildagonos import tildagonos
-import tildagon
+from egpio import ePin
 from system.eventbus import eventbus
 from machine import I2C
 from events.input import Buttons
@@ -232,7 +232,7 @@ async def background_task(self):
                 for i, n in enumerate(
                     [EPIN_ND_A, EPIN_ND_B, EPIN_ND_C, EPIN_ND_D, EPIN_ND_E, EPIN_ND_F]
                 ):
-                    hexpansion_present = not tildagon.Pin(n).value()
+                    hexpansion_present = not ePin(n).value()
                     if hexpansion_present:
                         if settings.get("pattern_mirror_hexpansions", False):
                             tildagonos.leds[13 + i] = tildagonos.leds[1 + (i * 2)]

modules/tildagon/pins.py

@@ -1,5 +1,4 @@
-import machine
-from tildagonos import tildagonos
+from egpio import ePin
 
 HEXPANSION_GPIOS = {
     "1_LS_A": (2, 3),
@@ -37,26 +36,30 @@
 
 class Pin:
     def __init__(self, pin_name, mode=-1):
+        self.OUT = ePin.OUT
+        self.IN = ePin.IN
+        self.PWM = ePin.PWM
         self.name = pin_name
-        self.pin = HEXPANSION_GPIOS[pin_name]
+        self.pin = ePin(HEXPANSION_GPIOS[pin_name], mode)
         self.mode = mode
-        if self.mode in (machine.Pin.IN, -1):
-            tildagonos.set_pin_mode(self.pin, machine.Pin.IN)
-        elif self.mode == machine.Pin.OUT:
-            tildagonos.set_pin_mode(self.pin, machine.Pin.OUT)
-        else:
-            raise ValueError("Invalid pin mode")
+
+    def init(self, mode):
+        self.pin.init(mode)
+        self.mode = mode
+
+    def duty(self, value):
+        self.pin.duty(value & 0xFF)
 
     def on(self):
-        self.value(1)
+        self.pin.on()
 
     def off(self):
-        self.value(0)
+        self.pin.off()
 
     def value(self, value=None, read=True):
-        if self.mode in (machine.Pin.IN, -1) and value is None:
-            return tildagonos.check_egpio_state(self.pin, readgpios=read)
-        elif self.mode in (machine.Pin.OUT, -1):
-            return tildagonos.set_egpio_pin(self.pin, value)
+        if self.mode in (self.IN, -1) and value is None:
+            return self.pin.value()
+        elif self.mode in (self.OUT, -1):
+            return self.pin.value(value)
         else:
             raise ValueError("Wrong pin state")