API v11: Sleep mode for Corne ECWL

Author: sekigon-gonnoc

keyboards/crkbd_ecwl/bmp/bmp.c

@@ -19,6 +19,7 @@
 #include "crkbd_ecwl.h"
 #include "quantum.h"
 #include "bmp_matrix.h"
+#include "bmp.h"
 
 #include "debug.h"
 #include "i2c_master.h"
@@ -35,10 +36,24 @@ const uint8_t row_pins[] = {7, 8, 9};
 const uint8_t col_pins[] = {15, 14, 13};
 const uint8_t col_sels[] = {6, 4, 3, 0, 1, 2, 5};
 
+// Switch scan threthold
 #define ERROR_TH 3000
 #define HIGH_TH 1000
 #define LOW_TH 800
 
+// Sleep count threthold(x17ms)
+#define STANBY_COUNT (10 * 1000 / 17)         // 10sec
+#define SCAN_RATE_STANBY (2)                  // 2count
+#define SCAN_RATE_DEEP_SLEEP (1 * 1000 / 17)  // 1sec
+
+typedef enum {
+    SCAN_MODE_ACTIVE,
+    SCAN_MODE_STANBY,
+    SCAN_MODE_DEEP_SLEEP,
+} scan_mode_t;
+
+static scan_mode_t scan_mode = SCAN_MODE_ACTIVE;
+
 #define LEN(x) (sizeof(x) / sizeof(x[0]))
 
 bool bmp_config_overwrite(bmp_api_config_t const *const config_on_storage,
@@ -92,7 +107,30 @@ uint16_t sw_read[32] = {0};
 uint32_t ecs_get_device_row() { return MATRIX_ROWS_DEFAULT; }
 uint32_t ecs_get_device_col() { return MATRIX_COLS_DEFAULT; }
 uint32_t ecs_matrix_scan(matrix_row_t *matrix_raw) {
-    uint16_t sw_idx = 0;
+    static uint32_t sleep_count = 0;
+    uint16_t        sw_idx      = 0;
+
+    if (scan_mode == SCAN_MODE_DEEP_SLEEP) {
+        if (sleep_count % SCAN_RATE_DEEP_SLEEP == SCAN_RATE_DEEP_SLEEP - 1) {
+            sleep_count++;
+            BMPAPI->ecs.schedule_next_scan();
+            return 0;
+        } else if (sleep_count % SCAN_RATE_DEEP_SLEEP != 0) {
+            sleep_count++;
+            BMPAPI->ecs.shutdown_amp();
+            return 0;
+        }
+    } else if (scan_mode == SCAN_MODE_STANBY) {
+        if (sleep_count % SCAN_RATE_STANBY == SCAN_RATE_STANBY - 1) {
+            sleep_count++;
+            BMPAPI->ecs.schedule_next_scan();
+            return 0;
+        } else if (sleep_count % SCAN_RATE_STANBY != 0) {
+            sleep_count++;
+            BMPAPI->ecs.shutdown_amp();
+            return 0;
+        }
+    }
 
     for (int col_sel_idx = 0; col_sel_idx < LEN(col_sels); col_sel_idx++) {
         BMPAPI->ecs.discharge_capacitor();
@@ -180,6 +218,19 @@ uint32_t ecs_matrix_scan(matrix_row_t *matrix_raw) {
         dprintf("\n");
     }
 
+    if (matrix_changed) {
+        if (scan_mode == SCAN_MODE_DEEP_SLEEP) {
+            BMPAPI->app.reset(0);
+        }
+        sleep_count = 0;
+        scan_mode   = SCAN_MODE_ACTIVE;
+    } else {
+        if ((!is_usb_connected()) && scan_mode == SCAN_MODE_ACTIVE && sleep_count > STANBY_COUNT) {
+            scan_mode = SCAN_MODE_STANBY;
+        }
+        sleep_count++;
+    }
+
     return matrix_changed;
 }
 
@@ -188,6 +239,11 @@ static const bmp_matrix_func_t matrix_func = {
 
 const bmp_matrix_func_t *get_matrix_func_user() { return &matrix_func; }
 
+void bmp_enter_sleep() {
+    scan_mode = SCAN_MODE_DEEP_SLEEP;
+    BMPAPI->ble.disconnect(1);
+}
+
 void bmp_before_sleep() {}
 
 bool checkSafemodeFlag(bmp_api_config_t const *const config) { return false; }

release.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-version=0_8_0
+version=0_9_0
 
 for keyboard in ble_micro_pro kugel toybox/bmp crkbd_ecwl/bmp keyboard_quantizer/bmp
     do

tmk_core/protocol/nrf/bmp.c

@@ -123,8 +123,7 @@ void bmp_mode_transition_check(void) {
         sleep_enter_counter--;
         if (sleep_enter_counter == 0)
         {
-            bmp_before_sleep();
-            BMPAPI->app.enter_sleep_mode();
+            bmp_enter_sleep();
         }
     }
 
@@ -274,6 +273,7 @@ void bmp_keyboard_task(void)
     static uint32_t last_event_time = 0;
     uint32_t auto_sleep_timeout = BMPAPI->app.get_config()->reserved[2] * 10 *
                                   60 * 1000;  // * 10min * 60s/min * 1000ms/s
+
     if (auto_sleep_timeout && key_event_cnt == 0 && !is_usb_connected()) {
         if (timer_elapsed32(last_event_time) > auto_sleep_timeout) {
             sleep_enter_counter = 1;
@@ -682,4 +682,9 @@ bool process_record_user_bmp(uint16_t keycode, keyrecord_t* record) {
 
 __attribute__((weak)) uint32_t keymaps_len() { return 0; }
 
+__attribute__((weak)) void bmp_enter_sleep(void) {
+    bmp_before_sleep();
+    BMPAPI->app.enter_sleep_mode();
+}
+
 __attribute__((weak)) void bmp_before_sleep() {}

tmk_core/protocol/nrf/bmp.h

@@ -32,5 +32,6 @@ bool is_ble_connected();
 bool is_usb_connected();
 
 extern int sleep_enter_counter;
+void bmp_enter_sleep();
 void bmp_before_sleep();
 

tmk_core/protocol/nrf/bmp_config.c

@@ -308,6 +308,7 @@ bmp_error_t msc_write_callback(const uint8_t *dat, uint32_t len) {
 }
 
 bmp_error_t webnus_write_callback(const uint8_t *dat, uint32_t len) {
+    tfp_printf("[web config]%s\n", dat);
     if (strnstr((const char *)dat, "show keymap", len) != NULL) {
         BMPAPI->web_config.set_send_buffer(
             (uint8_t *)keymap_string,

tmk_core/protocol/nrf/sdk15/apidef.h

@@ -5,7 +5,7 @@
 
 #include "error_def.h"
 
-#define API_VERSION 10
+#define API_VERSION 11
 #define CONFIG_VERSION 2
 #define PINS_MAX 32
 
@@ -212,8 +212,8 @@ typedef struct {
 } bmp_api_keymap_info_t;
 
 typedef struct {
-    uint8_t tx_pin;
-    uint8_t rx_pin;
+    uint8_t  tx_pin;
+    uint8_t  rx_pin;
     uint32_t baudrate;
     void (*rx_callback)(uint8_t recv);
 } bmp_uart_config_t;
@@ -266,8 +266,8 @@ typedef struct {
     char (*serial_getc)(void);
     void (*serial_puts)(uint8_t const*, uint8_t);
     int (*serial_byte_to_read)(void);
-    void (*set_raw_receive_cb)(void (*raw_receive_cb)(const uint8_t *data, uint8_t length));
-    int (*raw_send)(const uint8_t *data, uint8_t length);
+    void (*set_raw_receive_cb)(void (*raw_receive_cb)(const uint8_t* data, uint8_t length));
+    int (*raw_send)(const uint8_t* data, uint8_t length);
     bmp_error_t (*create_file)(const char* sfn, const uint8_t* dat, uint32_t size);
     bmp_error_t (*set_msc_write_cb)(bmp_api_msc_write_cb_t);
 } bmp_api_usb_t;
@@ -276,6 +276,7 @@ typedef struct {
     void (*init)(bmp_api_config_t const* const);
     void (*advertise)(uint8_t);
     void (*scan)(void);
+    void (*disconnect)(uint8_t disconect_all);
     bmp_error_t (*get_bonding_info)(bmp_api_bonding_info_t* info, uint32_t* len);
     void (*delete_bond)(uint8_t);
     void (*send_key)(bmp_api_key_report_t*);
@@ -392,6 +393,7 @@ typedef struct {
     void (*assign_drive_pin)(uint32_t pin);
     void (*sw_read)(uint16_t* res);
     void (*clear_drive_pins)(bmp_ecs_config_t const* const config);
+    void (*shutdown_amp)();
     void (*schedule_next_scan)();
     void (*discharge_capacitor)();
 } bmp_api_ecs_t;

tmk_core/protocol/nrf/sdk15/cli.c

@@ -35,6 +35,7 @@ void cli_puts(const char *str);
 static MSCMD_USER_RESULT usrcmd_version(MSOPT *msopt, MSCMD_USER_OBJECT usrobj);
 static MSCMD_USER_RESULT usrcmd_reset(MSOPT *msopt, MSCMD_USER_OBJECT usrobj);
 static MSCMD_USER_RESULT usrcmd_advertise(MSOPT *msopt, MSCMD_USER_OBJECT usrobj);
+static MSCMD_USER_RESULT usrcmd_disconnect(MSOPT *msopt, MSCMD_USER_OBJECT usrobj);
 static MSCMD_USER_RESULT usrcmd_bootloader(MSOPT *msopt, MSCMD_USER_OBJECT usrobj);
 static MSCMD_USER_RESULT usrcmd_bonding_information(MSOPT *msopt, MSCMD_USER_OBJECT usrobj);
 static MSCMD_USER_RESULT usrcmd_delete_bonding(MSOPT *msopt, MSCMD_USER_OBJECT usrobj);
@@ -63,6 +64,7 @@ static const MSCMD_COMMAND_TABLE table[] = {
     {"version", usrcmd_version, "Show version"},
     {"reset", usrcmd_reset, "Reset system"},
     {"adv", usrcmd_advertise, "Start advertising"},
+    {"dis", usrcmd_disconnect, "Disconnect BLE"},
     {"dfu", usrcmd_bootloader, "Jump to bootloader"},
     {"show", usrcmd_bonding_information, "Show bonded devices"},
     {"del", usrcmd_delete_bonding, "Delete bond information"},
@@ -135,6 +137,17 @@ static MSCMD_USER_RESULT usrcmd_advertise(MSOPT *msopt, MSCMD_USER_OBJECT usrobj
     return 0;
 }
 
+static MSCMD_USER_RESULT usrcmd_disconnect(MSOPT *msopt, MSCMD_USER_OBJECT usrobj) {
+    if (msopt->argc >= 2) {
+        print("disconnect all\n");
+        BMPAPI->ble.disconnect(1);
+    } else {
+        print("disconnect device\n");
+        BMPAPI->ble.disconnect(0);
+    }
+    return 0;
+}
+
 static MSCMD_USER_RESULT usrcmd_bootloader(MSOPT *msopt, MSCMD_USER_OBJECT usrobj) {
     //  bootloader_jump();
     BMPAPI->bootloader_jump();