Frontboard2026

components/st3m/st3m_imu.c

@@ -70,19 +70,15 @@ int st3m_imu_write(uint8_t reg_addr, uint8_t *reg_data, uint8_t len) {
     return bmi2_i2c_write(reg_addr, reg_data, len, &_imu );
 }
 
-void st3m_imu_task(void *data) {
-    TickType_t last_wake = xTaskGetTickCount();
+void st3m_imu_task(void) {
+
     esp_err_t ret;
     float a, b, c, temperature;
     uint32_t steps;
-    while (1) {
-        vTaskDelayUntil(&last_wake, pdMS_TO_TICKS(10));  // 100 Hz
-
-        ret = flow3r_bsp_imu_update(&_imu);
-        if (ret != ESP_OK) {
-            continue;
-        }
 
+    ret = flow3r_bsp_imu_update(&_imu);
+    if (ret == ESP_OK) 
+    {    
         LOCK;
         ret = flow3r_bsp_imu_read_acc_mps(&_imu, &a, &b, &c);
         if (ret == ESP_OK) {

components/st3m/st3m_imu.h

@@ -7,7 +7,7 @@
 
 esp_err_t st3m_imu_init(void);
 
-extern void st3m_imu_task(void *data);
+extern void st3m_imu_task(void);
 extern void st3m_imu_read_acc_mps(float *x, float *y, float *z);
 extern void st3m_imu_read_gyro_dps(float *x, float *y, float *z);
 extern void st3m_imu_read_pressure(float *pressure, float *temperature);

drivers/micropython.cmake

@@ -27,5 +27,8 @@ include(${CMAKE_CURRENT_LIST_DIR}/tildagon_pin/micropython.cmake)
 
 include(${CMAKE_CURRENT_LIST_DIR}/tildagon/micropython.cmake)
 
+# Add frontboard drivers
+include(${CMAKE_CURRENT_LIST_DIR}/tildagon_frontboard/micropython.cmake)
+
 # Add burnt-in HMAC
 include(${CMAKE_CURRENT_LIST_DIR}/tildagon_hmac/micropython.cmake)

drivers/tildagon_frontboard/cy8cmbrx/cy8cmbrx.c

@@ -0,0 +1,93 @@
+#include "tildagon_i2c_mpless.h"
+#include "cy8cmbrx.h"
+#include <stdint.h>
+
+
+#define READ ( MP_MACHINE_I2C_FLAG_WRITE1 | MP_MACHINE_I2C_FLAG_READ | MP_MACHINE_I2C_FLAG_STOP )
+#define WRITE MP_MACHINE_I2C_FLAG_STOP
+
+tildagon_mux_i2c_obj_t* cy8_mux_port;
+uint16_t button_prev_status = 0U;
+uint16_t prox_prev_status = 0U;
+
+void send_command( uint8_t cmd );
+static int write_bytes( tildagon_mux_i2c_obj_t* mux_port, uint8_t reg_adr, uint8_t* data, uint8_t length );
+
+void cy8cmbrx_init( tildagon_mux_i2c_obj_t* new_port )
+{
+    cy8_mux_port = new_port;
+}
+
+cy8cmbrx_status_t cy8cmbrx_run( void )
+{
+    cy8cmbrx_status_t result = {0};
+    /* read touch and prox current and latched status  */
+    uint8_t raw_buf[6] = { 0U };
+    /* check we have the device present */
+    if( tildagon_i2c_reg_read(TILDAGON_TOP_I2C_PORT, CY8CMBRX_ADDRESS, CY8CMBRX_BUTTON_STAT_ADR, raw_buf, 6) == ESP_OK )
+    {
+        uint16_t button_state = ((uint16_t)raw_buf[1] << 8) +  raw_buf[0];
+        uint16_t button_latch = ((uint16_t)raw_buf[3] << 8) +  raw_buf[2];
+        uint8_t prox_state = raw_buf[4];
+        uint8_t prox_latch = raw_buf[5];
+        /* button detection */
+        for( uint8_t i = 3U; i < 15U; i++ )
+        {
+            if ( ( button_latch & ( 1 << i ) ) && ( ( button_prev_status & ( 1 << i ) ) == 0U ) )
+            {
+                if ( ( button_state & ( 1 << i ) ) == 0U )
+                {
+                    result.buttons[i-3] = CY8CMBRX_PULSE;
+                }
+                else
+                {
+                    result.buttons[i-3] = CY8CMBRX_RISING_EDGE;
+                }
+            }
+            else if ( ( button_prev_status & ( 1 << i ) ) && ( ( button_state & ( 1 << i ) ) == 0 ) )
+            {
+                result.buttons[i-3] = CY8CMBRX_FALLING_EDGE;
+            }
+        }
+        button_prev_status = button_state;
+        /* prox detection */
+        for( uint8_t i = 0U; i < 2U; i++ )
+        {
+            if ( ( prox_latch & ( 1 << i ) ) && ( ( prox_prev_status & ( 1 << i ) ) == 0U ) )
+            {
+                if ( ( prox_state & ( 1 << i ) ) == 0U )
+                {
+                    result.prox[i] = CY8CMBRX_PULSE;
+                }
+                else
+                {
+                    result.prox[i] = CY8CMBRX_RISING_EDGE;
+                }
+            }
+            else if ( ( prox_prev_status & ( 1 << i ) ) && ( ( prox_state & ( 1 << i ) ) == 0 ) )
+            {
+                result.prox[i] = CY8CMBRX_FALLING_EDGE;
+            }
+        }
+        prox_prev_status = prox_state;
+    }
+    /* reset latch status */
+    uint8_t cmd = CY8CMBRX_CMD_RESET_LATCH;
+    write_bytes( cy8_mux_port, CY8CMBRX_CTRL_CMD_ADR, &cmd, 1 );
+    return result; 
+}
+
+
+int write_bytes( tildagon_mux_i2c_obj_t* mux_port, uint8_t reg_adr, uint8_t* data, uint8_t length )
+{
+    uint8_t i2c_buffer[length+1];
+    i2c_buffer[0] = reg_adr;
+    for ( uint8_t i = 0; i < length; i++)
+    {
+        i2c_buffer[i+1] = data[i];
+    }
+    mp_machine_i2c_buf_t buffer[2] = { { .len = 1, .buf = &reg_adr },
+                                       { .len = length + 1, .buf = i2c_buffer } };
+    tildagon_mux_i2c_transaction( mux_port, CY8CMBRX_ADDRESS, 1, &buffer[0], WRITE );
+    return tildagon_mux_i2c_transaction( mux_port, CY8CMBRX_ADDRESS, 1, &buffer[1], WRITE );
+}

drivers/tildagon_frontboard/cy8cmbrx/cy8cmbrx.h

@@ -0,0 +1,43 @@
+#ifndef CY8CMBRX_H
+#define CY8CMBRX_H
+
+
+#include "tildagon_i2c.h"
+
+#define CY8CMBRX_ADDRESS 0x37U
+#define CY8CMBRX_BUTTON_STAT_ADR 0xAAU
+#define CY8CMBRX_CTRL_CMD_ADR 0x86U
+
+#define CY8CMBRX_CMD_CMP_CRC_SAVE 0x02U
+#define CY8CMBRX_CMD_CALC_CRC 0x03U
+#define CY8CMBRX_CMD_LOW_POWER 0x07U
+#define CY8CMBRX_CMD_RESET_LATCH 0x08U
+#define CY8CMBRX_CMD_RESET_PS0_FILTER 0x09U
+#define CY8CMBRX_CMD_RESET_PS1_FILTER 0x0AU
+#define CY8CMBRX_CMD_RESET 0xFFU
+
+#define CY8CMBRX_CMD_ERR_OK 0x00U
+#define CY8CMBRX_CMD_ERR_SAVE_FAILED 0x0DU
+#define CY8CMBRX_CMD_ERR_CRC_MISMATCH 0xFEU
+#define CY8CMBRX_CMD_ERR_INVALID_CMD 0xFFU
+
+typedef enum
+{
+    CY8CMBRX_NO_CHANGE,
+    CY8CMBRX_RISING_EDGE,
+    CY8CMBRX_FALLING_EDGE,
+    CY8CMBRX_PULSE
+} cy8cmbrx_event_t;
+
+typedef struct 
+{
+    cy8cmbrx_event_t buttons[16];
+    cy8cmbrx_event_t prox[2];
+} cy8cmbrx_status_t;
+
+
+extern void cy8cmbrx_init( tildagon_mux_i2c_obj_t* mux_port);
+extern cy8cmbrx_status_t cy8cmbrx_run( void );
+extern void cy8cmbrx_read_differences( uint16_t buffer[16] );
+
+#endif

drivers/tildagon_frontboard/micropython.cmake

@@ -0,0 +1,21 @@
+# Create an INTERFACE library for our C module.
+add_library(usermod_tildagon_frontboard INTERFACE)
+
+
+# Add our source files to the lib
+target_sources(usermod_tildagon_frontboard INTERFACE
+    ${CMAKE_CURRENT_LIST_DIR}/tildagon_frontboard.c
+    ${CMAKE_CURRENT_LIST_DIR}/cy8cmbrx/cy8cmbrx.c
+    ${CMAKE_CURRENT_LIST_DIR}/mp_frontboard.c
+)
+
+# Add the current directory as an include directory.
+target_include_directories(usermod_tildagon_frontboard INTERFACE
+    ${CMAKE_CURRENT_LIST_DIR}
+    ${CMAKE_CURRENT_LIST_DIR}/cy8cmbrx
+    ${CMAKE_CURRENT_LIST_DIR}/../tildagon_imu/qmc6309
+    ${CMAKE_CURRENT_LIST_DIR}/../tildagon_imu
+)
+
+# Link our INTERFACE library to the usermod target.
+target_link_libraries(usermod INTERFACE usermod_tildagon_frontboard)

drivers/tildagon_frontboard/mp_frontboard.c

@@ -0,0 +1,92 @@
+
+#include "py/runtime.h"
+#include "py/obj.h"
+#include "py/builtin.h"
+#include "mp_frontboard.h"
+#include "tildagon_frontboard.h"
+#include "cy8cmbrx.h"
+
+/**
+ * @brief schedule the micropython callback for the event
+ */ 
+void mp_frontboard2026_push_event( uint8_t event, uint8_t trigger )
+{
+    if ( MP_STATE_PORT(callbacks)[event+(trigger*MP_FB_EVENT_MAX)] != NULL )
+    {
+        mp_sched_schedule(MP_STATE_PORT(callbacks)[event+(trigger*MP_FB_EVENT_MAX)], mp_obj_new_int(event) );
+    }
+}
+
+/**
+ * @brief initialise the frontboard, setting up touch and 
+ * proximity and creating the additinal port expander
+ */
+static mp_obj_t mp_frontboard2026_init( mp_obj_t frontboard_id ) 
+{
+    uint16_t id = mp_obj_get_int( frontboard_id );
+    tildagon_frontboard_init(id);
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(mp_frontboard2026_init_obj, mp_frontboard2026_init);
+
+
+/**
+ * @brief set the callback for both rising and falling 
+ * edge of each proximity and touch event
+ */
+static mp_obj_t mp_frontboard2026_set_cb( mp_obj_t index, mp_obj_t cb, mp_obj_t trigger) 
+{
+    uint8_t i = mp_obj_get_int( index );
+    uint8_t trigger_type = mp_obj_get_int(trigger);
+    if ( i < MP_FB_EVENT_MAX )
+    {
+        MP_STATE_PORT(callbacks)[i+(trigger_type*MP_FB_EVENT_MAX)] = cb;
+        return mp_const_none;
+    }
+    return mp_obj_new_int(-1);
+}
+static MP_DEFINE_CONST_FUN_OBJ_3(mp_frontboard2026_set_cb_obj, mp_frontboard2026_set_cb);
+
+static mp_obj_t mp_frontboard2026_run( void ) 
+{
+    cy8cmbrx_cb(NULL, 0);
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(mp_frontboard2026_run_obj, mp_frontboard2026_run);
+
+static const mp_rom_map_elem_t frontboard2026_globals_table[] = 
+{
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_frontboard2026) },
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&mp_frontboard2026_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_cb), MP_ROM_PTR(&mp_frontboard2026_set_cb_obj) },
+    { MP_ROM_QSTR(MP_QSTR_run), MP_ROM_PTR(&mp_frontboard2026_run_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_TOUCH1), MP_ROM_INT(MP_TOUCH_EVENT_11) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH2), MP_ROM_INT(MP_TOUCH_EVENT_12) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH3), MP_ROM_INT(MP_TOUCH_EVENT_10) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH4), MP_ROM_INT(MP_TOUCH_EVENT_9) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH5), MP_ROM_INT(MP_TOUCH_EVENT_8) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH6), MP_ROM_INT(MP_TOUCH_EVENT_7) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH7), MP_ROM_INT(MP_TOUCH_EVENT_6) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH8), MP_ROM_INT(MP_TOUCH_EVENT_5) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH9), MP_ROM_INT(MP_TOUCH_EVENT_4) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH10), MP_ROM_INT(MP_TOUCH_EVENT_3) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH11), MP_ROM_INT(MP_TOUCH_EVENT_2) },
+    { MP_ROM_QSTR(MP_QSTR_TOUCH12), MP_ROM_INT(MP_TOUCH_EVENT_1) },
+    { MP_ROM_QSTR(MP_QSTR_PROX1), MP_ROM_INT(MP_PROX_EVENT_1) },
+    { MP_ROM_QSTR(MP_QSTR_PROX2), MP_ROM_INT(MP_PROX_EVENT_2) },
+
+    { MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(0) },
+    { MP_ROM_QSTR(MP_QSTR_IRQ_FALLING), MP_ROM_INT(1) },
+};
+
+static MP_DEFINE_CONST_DICT(frontboard2026_globals, frontboard2026_globals_table);
+
+const mp_obj_module_t mp_frontboard2026_cmodule = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&frontboard2026_globals,
+};
+
+MP_REGISTER_MODULE(MP_QSTR_frontboard2026, mp_frontboard2026_cmodule);
+
+MP_REGISTER_ROOT_POINTER(mp_obj_t callbacks[MP_FB_EVENT_MAX*2]);

drivers/tildagon_frontboard/mp_frontboard.h

@@ -0,0 +1,28 @@
+
+#ifndef MP_FRONTBOARD_H
+#define MP_FRONTBOARD_H
+
+#include <stdint.h>
+
+#define MP_TOUCH_EVENT_1 0         
+#define MP_TOUCH_EVENT_2 1           
+#define MP_TOUCH_EVENT_3 2     
+#define MP_TOUCH_EVENT_4 3     
+#define MP_TOUCH_EVENT_5 4
+#define MP_TOUCH_EVENT_6 5   
+#define MP_TOUCH_EVENT_7 6  
+#define MP_TOUCH_EVENT_8 7
+#define MP_TOUCH_EVENT_9 8
+#define MP_TOUCH_EVENT_10 9
+#define MP_TOUCH_EVENT_11 10
+#define MP_TOUCH_EVENT_12 11
+#define MP_PROX_EVENT_1 12
+#define MP_PROX_EVENT_2 13
+#define MP_FB_EVENT_MAX 14   
+
+#define MP_FB_RISING_EDGE 0
+#define MP_FB_FALLING_EDGE 1
+
+extern void mp_frontboard2026_push_event( uint8_t event, uint8_t trigger );
+
+#endif