bmp-0.4.0

- Save keyboard and layout names to KEYMAP.JSN
- Change EXKC behavior

Author: sekigon-gonnoc

keyboards/ble_micro_pro/config.h

@@ -29,6 +29,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define PRODUCT         ble_micro_pro
 #define DESCRIPTION     A development board for wireless split keyboards
 
+#define BMP_BOOTPIN_AS_RESET
+
 #define TAPPING_TERM_PER_KEY
 #define PERMISSIVE_HOLD
 #define PREVENT_STUCK_MODIFIERS

tmk_core/nrf.mk

@@ -35,7 +35,7 @@ NRF_VER_DIR = sdk$(NRFSDK_VER)
 
 COMMON_VPATH += $(DRIVER_PATH)/nrf52
 
-GIT_DESCRIBE = $(shell git describe --tags --dirty="\\*")
+GIT_DESCRIBE = $(shell git describe --tags --long --dirty="\\*")
 CFLAGS += -DGIT_DESCRIBE=$(GIT_DESCRIBE)
 CFLAGS += -DTARGET=$(TARGET)
 

tmk_core/protocol/nrf/bmp.c

@@ -88,6 +88,7 @@ void bmp_action_exec(keyevent_t event)
 }
 
 static int sleep_enter_counter = -1;
+int reset_counter = -1;
 
 /** \brief Keyboard task: Do keyboard routine jobs
  *
@@ -229,6 +230,16 @@ void bmp_keyboard_task(void)
             BMPAPI->app.enter_sleep_mode();
         }
     }
+
+    // reset flag check
+    if (reset_counter > 0)
+    {
+        reset_counter--;
+        if (reset_counter == 0)
+        {
+            BMPAPI->app.reset();
+        }
+    }
 }
 
 bmp_error_t nus_rcv_callback(const uint8_t* dat, uint32_t len)
@@ -277,6 +288,20 @@ char *strnstr(const char *haystack, const char *needle, size_t len) {
   return NULL;
 }
 
+const char *strnchr(const char *haystack, char needle, size_t len) {
+  int i;
+  for (i=0; i < len; i++)
+  {
+      if (haystack[i] == needle) {
+          return &haystack[i];
+      }
+      else if (haystack[i] == '\0') {
+          return NULL;
+      }
+  }
+  return NULL;
+}
+
 void parse_and_save_config(void)
 {
     bmp_api_config_t config;
@@ -315,7 +340,8 @@ void parse_and_save_keymap(void)
     {
         xprintf("Update keymap. length:%d\r\n", inst.keymap_idx);
         xprintf("%d extended keycodes are found\r\n", inst.ek_num);
-        BMPAPI->app.set_keymap(keymap, inst.keymap_idx);
+        xprintf("keyboard:%s\r\n", inst.layout_name);
+        BMPAPI->app.set_keymap(keymap, inst.keymap_idx, inst.layout_name);
         bmp_ex_keycode_num = inst.ek_num;
         BMPAPI->app.save_file(1);
 
@@ -460,9 +486,36 @@ static inline void update_keymap_string(bmp_api_config_t const * config,
   keymap_conv_inst.use_ascii = config->keymap.use_ascii;
   keymap_conv_inst.bmp_ek = bmp_ex_keycodes;
 
-  strcpy(str, "{\"layers\":\r\n");
-  keymap_to_json_conv_layout(&keymap_conv_inst, str + 12,
-      len-12, config->matrix.layout);
+  char keyboard_name[32] = {0};
+  char layout_name[32] = {0};
+  const char* delimiter = strnchr(keymap_info->layout_name, ':', 32);
+
+  if (delimiter != NULL)
+  {
+    memcpy(keyboard_name, keymap_info->layout_name,
+        delimiter - keymap_info->layout_name);
+
+    strncpy(layout_name, delimiter + 1, sizeof(layout_name));
+  }
+  else
+  {
+    strcpy(keyboard_name, config->device_info.name);
+    strcpy(layout_name, keymap_info->layout_name);
+  }
+
+
+  strcpy(str, "{\"keyboard\":\"");
+  strcat(str, keyboard_name);
+
+  strcat(str, "\",\r\n\"keymap\":\"");
+  strcat(str, "\",\r\n\"layout\":\"");
+  strcat(str, layout_name);
+
+  strcat(str, "\",\r\n\"layers\":\r\n");
+  uint32_t header_len = strlen(str);
+
+  keymap_to_json_conv_layout(&keymap_conv_inst, str + header_len,
+      len - header_len, config->matrix.layout);
   strcat(str, "}");
   BMPAPI->usb.create_file("KEYMAP  JSN", (uint8_t*)str, strlen(str));
 }
@@ -567,7 +620,7 @@ void bmp_init()
   BMPAPI->app.get_keymap_info(&keymap_info);
   if (keymap_info.len == 0)
   {
-    BMPAPI->app.set_keymap((uint16_t*)keymaps, keymaps_len()); // load default keymap
+    BMPAPI->app.set_keymap((uint16_t*)keymaps, keymaps_len(), keymap_info.layout_name); // load default keymap
     BMPAPI->app.get_keymap_info(&keymap_info);
   }
 

tmk_core/protocol/nrf/bmp_extended_keycode_converter.c

@@ -53,6 +53,11 @@ uint8_t bmp_ex_keycode2str_locale(bmp_ex_keycode_t const* const ek, char* str, u
 }
 
 uint8_t str2bmp_ex_keycode_locale(bmp_ex_keycode_t* ek_res, const char* str, uint32_t len, KEYMAP_LOCALE locale) {
+    // Delete ANY() if contained
+    if (str[0] == 'A' && str[1] == 'N' && str[2] == 'Y') {
+        len = get_inner_element(&str, len);
+    }
+
     // Delete EX()
     len = get_inner_element(&str, len);
 

tmk_core/protocol/nrf/bmp_process_extended_keycode.c

@@ -88,6 +88,8 @@ static void state_transition_common(uint16_t exkc_idx);
 bool bmp_process_extended_keycode(uint16_t *const p_keycode, keyrecord_t *const record);
 
 static int pending_exkc_num = 0;
+static bool pending_normal_kc_flag;
+static bool process_normal_kc_flag;
 
 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
     dprintf("Process KC:%d\n", keycode);
@@ -155,9 +157,9 @@ void bmp_action_exec_impl(keyevent_t event) {
 bool bmp_process_extended_keycode(uint16_t *const p_keycode, keyrecord_t *const record) {
     uint16_t keycode = *p_keycode;
     static bool skip_next_call = false;
+    bool continue_process = true;
 
     if (skip_next_call) {
-        skip_next_call = false;
         return true;
     }
 
@@ -170,42 +172,59 @@ bool bmp_process_extended_keycode(uint16_t *const p_keycode, keyrecord_t *const
     }
 
     if (pending_exkc_num > 0) {
-        // queueing keyevent
-        //// return false;
-        return send_pending_buffer(&record->event) ? false : true;
-    } else {
+        pending_normal_kc_flag = true;
+    }
+
+    if (pending_normal_kc_flag) {
+        if ( EXKC_START >= *p_keycode || *p_keycode >= EXKC_END) {
+            // queueing keyevent
+            continue_process = send_pending_buffer(&record->event) ? false : true;
+        }
+    }
+
+    if (pending_exkc_num <= 0) {
+        pending_normal_kc_flag = false;
+        if (pending_buffer_cnt[PRESS_BUF] + pending_buffer_cnt[RELEASE_BUF] > 0) {
+            process_normal_kc_flag = true;
+        }
+    }
+
+    if (process_normal_kc_flag) {
         // process events
-        keyrecord_t record;
+        keyevent_t keyevent;
+        skip_next_call = true;
         for (int idx = 0; idx < pending_buffer_max_idx; idx++) {
             if (pending_buffer[idx][PRESS_BUF].pressed) {
-                skip_next_call = true;
-                record.event = pending_buffer[idx][PRESS_BUF];
+                keyevent = pending_buffer[idx][PRESS_BUF];
                 pending_buffer[idx][PRESS_BUF].pressed = false;
                 dprintf("[PDB] proc(p):%d\n", idx);
-                process_record(&record);
+                action_exec(keyevent);
             }
 
             if (pending_buffer[idx][RELEASE_BUF].pressed) {
-                skip_next_call = true;
-                record.event = pending_buffer[idx][RELEASE_BUF];
+                keyevent = pending_buffer[idx][RELEASE_BUF];
                 pending_buffer[idx][RELEASE_BUF].pressed = false;
-                record.event.pressed = false;
+                keyevent.pressed = false;
                 dprintf("[PDB] proc(r):%d\n", idx);
-                process_record(&record);
+                action_exec(keyevent);
             }
         }
 
+        skip_next_call = false;
+        process_normal_kc_flag = false;
         pending_buffer_max_idx = 0;
         pending_buffer_cnt[PRESS_BUF] = 0;
         pending_buffer_cnt[RELEASE_BUF] = 0;
+
+        return false;
     }
 
     // if ( keycode < EXKC_START || keycode > EXKC_END)
     // {
     //     return true;
     // }
 
-    return true;
+    return continue_process;
 }
 
 static void preprocess_exkc_common(keyevent_t const *const keyevent) {

tmk_core/protocol/nrf/config_file_util.c

@@ -26,6 +26,7 @@ void json_to_keymap_init(json_keymap_convert_inst_t * const inst,
   inst->keymap_len = keymap_len;
   inst->locale = LOCALE_US;
   memset(inst->tail, 0, sizeof(inst->tail));
+  memset(inst->layout_name, 0, sizeof(inst->layout_name));
 }
 
 
@@ -48,6 +49,8 @@ static uint16_t register_ex_kc(json_keymap_convert_inst_t* const inst,
     return KC_NO;
 }
 
+int32_t get_val_string(const char* json, const char* key,
+    const char** val, uint32_t* len);
 
 // Return quantum keycode from json strings.
 // inst->tail contains partial string if quotation is not closed
@@ -57,11 +60,42 @@ int32_t json_to_keymap_conv(json_keymap_convert_inst_t * const inst,
   const char * str;
   const char * str2;
   const char * str3;
+  uint32_t name_len;
+  uint32_t layout_name_len;
 
   inst->ek_num = 0;
 
   if ((inst->keymap_idx == 0) && inst->tail[0]=='\0')
   {
+    str = strstr(json, "keyboard");
+    if (str != NULL)
+    {
+        get_val_string(str, "keyboard", &str2, &name_len);
+        if (name_len + 1 < 32) {
+            strncat(inst->layout_name, str2, name_len);
+            strcat(inst->layout_name, ":");
+        }
+    }
+
+    str = strstr(json, "layout");
+    if (str != NULL)
+    {
+        get_val_string(str, "layout", &str2, &layout_name_len);
+        if (layout_name_len == 0 && name_len + 1 + 6 < LAYOUT_NAME_MAXLEN)
+        {
+            strcat(inst->layout_name, "LAYOUT");
+        }
+        else if (name_len + layout_name_len + 1 < LAYOUT_NAME_MAXLEN)
+        {
+            strncat(inst->layout_name, str2, layout_name_len);
+            inst->layout_name[name_len + layout_name_len + 1] = '\0';
+        }
+    }
+    else
+    {
+        strcat(inst->layout_name, "LAYOUT");
+    }
+
     str = strstr(json, "layers");
     if (str == NULL)
     {

tmk_core/protocol/nrf/config_file_util.h

@@ -12,6 +12,7 @@
 #include "bmp_custom_keycode.h"
 
 
+#define LAYOUT_NAME_MAXLEN 32
 typedef struct
 {
   uint16_t *keymap;
@@ -22,6 +23,8 @@ typedef struct
 
   bmp_ex_keycode_t *bmp_ek;
   uint16_t ek_num;
+
+  char layout_name[LAYOUT_NAME_MAXLEN];
 } json_keymap_convert_inst_t;
 
 typedef struct
@@ -33,6 +36,8 @@ typedef struct
   uint8_t use_ascii;
 
   bmp_ex_keycode_t *bmp_ek;
+
+  const char *layout_name;
 } keymap_json_convert_inst_t;
 
 typedef struct

tmk_core/protocol/nrf/matrix.c

@@ -58,6 +58,9 @@ extern const bmp_matrix_func_t matrix_func_col2row_lpme;
 extern const bmp_matrix_func_t matrix_func_row2col2row;
 extern const bmp_matrix_func_t matrix_func_col2row2col;
 
+extern int reset_counter;
+#define BOOTPIN 22
+
 __attribute__ ((weak))
 void matrix_init_quantum(void) {
     matrix_init_kb();
@@ -145,6 +148,10 @@ void matrix_init(void) {
   matrix_func->init();
 
   matrix_init_quantum();
+
+#if defined(BMP_BOOTPIN_AS_RESET)
+  setPinInputHigh(BOOTPIN);
+#endif
 }
 
 __attribute__ ((weak))
@@ -211,6 +218,14 @@ uint8_t matrix_scan(void)
 {
   uint8_t res = matrix_scan_impl(matrix);
   matrix_scan_quantum();
+
+#if defined(BMP_BOOTPIN_AS_RESET)
+  if (readPin(BOOTPIN) == 0 && reset_counter < 0)
+  {
+    reset_counter = 10;
+  }
+#endif
+
   return res;
 }
 

tmk_core/protocol/nrf/sdk15/apidef.h

@@ -5,7 +5,7 @@
 
 #include "error_def.h"
 
-#define API_VERSION 4
+#define API_VERSION 5
 #define CONFIG_VERSION 2
 #define PINS_MAX 32
 
@@ -212,6 +212,7 @@ typedef struct {
   uint16_t len;
   uint16_t keynum;
   const uint16_t* array;
+  const char* layout_name;
 } bmp_api_keymap_info_t;
 
 typedef bmp_error_t (*bmp_api_msc_write_cb_t)(const uint8_t* dat, uint32_t len);
@@ -227,7 +228,7 @@ typedef struct
   bmp_error_t (*push_keystate_change)(bmp_api_key_event_t const *  const key);
   uint32_t (*pop_keystate_change)(bmp_api_key_event_t* key, uint32_t len, uint8_t burst_threshold);
   uint16_t (*keymap_key_to_keycode)(uint8_t layer, bmp_api_keypos_t const * const key);
-  bmp_error_t (*set_keymap)(const uint16_t* keymap, uint16_t len);
+  bmp_error_t (*set_keymap)(const uint16_t* keymap, uint16_t len, const char * layout_name);
   bmp_error_t (*set_config)(bmp_api_config_t const * const);
   bmp_error_t (*get_keymap_info)(bmp_api_keymap_info_t* const keymap_info);
   const bmp_api_config_t* (*get_config)(void);