Add feature: Macro

Author: sekigon-gonnoc

keyboards/keyboard_quantizer/kqb/config.h

@@ -24,8 +24,6 @@
 
 #define QUANTIZER_REPORT_PARSER REPORT_PARSER_USER
 
-#define VIA_ENABLE
-
 #define MATRIX_ROW_PINS \
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 #define MATRIX_COL_PINS \

release.sh

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

tmk_core/nrf.mk

@@ -30,6 +30,8 @@ NRFCFLAGS += -DMATRIX_ROWS=32
 NRFCFLAGS += -DMATRIX_COLS=32
 NRFCFLAGS += -DRGBLED_NUM=128
 NRFCFLAGS += -DEEPROM_SIZE=32
+NRFCFLAGS += -DVIA_ENABLE  # Define here(not in rules.mk) to use VIA keycode definitions, and do not complie quantum/via.c
+
 
 NRF_VER_DIR = sdk$(NRFSDK_VER)
 

tmk_core/protocol/nrf.mk

@@ -24,6 +24,8 @@ NRF_DIR = $(PROTOCOL_DIR)/nrf
        $(NRF_DIR)/bmp_process_extended_keycode.c \
        $(NRF_DIR)/bmp_indicator_led.c \
        $(NRF_DIR)/bmp_encoder_actions.c \
+       $(NRF_DIR)/bmp_macro.c \
+       $(NRF_DIR)/bmp_macro_parser.c \
        $(NRF_DIR)/encoder.c \
        $(NRF_DIR)/via.c \
 

tmk_core/protocol/nrf/bmp.c

@@ -22,6 +22,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "bmp_custom_keycode.h"
 #include "bmp_process_extended_keycode.h"
 #include "bmp_indicator_led.h"
+#include "bmp_macro.h"
 #include "keycode_str_converter.h"
 
 #include <stdint.h>
@@ -265,6 +266,8 @@ void bmp_keyboard_task(void)
     if (velocikey_enabled()) { velocikey_decelerate();  }
 #endif
 
+    bmp_macro_task();
+
     // update LED
     if (led_status != host_keyboard_leds()) {
         led_status = host_keyboard_leds();
@@ -570,6 +573,7 @@ void bmp_init()
   load_tapping_term_file();
   load_eeprom_emulation_file();
   load_encoder_config_file();
+  bmp_macro_load_file();
 
   if (config->mode == WEBNUS_CONFIG)
   {

tmk_core/protocol/nrf/bmp_config.c

@@ -15,10 +15,11 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #include "apidef.h"
 #include "bmp.h"
 #include "bmp_config.h"
+#include "bmp_macro.h"
+#include "bmp_macro_parser.h"
 
 #ifndef TAPPING_TERM
 #    define TAPPING_TERM 200
@@ -30,6 +31,7 @@ static bmp_qmk_config_t     bmp_qmk_config;
 static char                 qmk_config_string[1024];
 static bmp_encoder_config_t bmp_encoder_config;
 static char                 encoder_config_string[1024];
+static char                 macro_string[1024];
 
 bmp_ex_keycode_t bmp_ex_keycodes[BMP_EX_KC_LEN];
 uint32_t         bmp_ex_keycode_num;
@@ -201,6 +203,31 @@ int save_encoder_config(void) {
     return res;
 }
 
+int parse_macro_string(void) {
+    // skip key
+    char *src = macro_string;
+    while (*src++ != '\n') {
+        continue;
+    }
+
+    // parse
+    bmp_macro_file_parse(bmp_macro_get_file_buffer(), (const uint8_t *)src,
+                         strlen(src));
+
+    return 0;
+}
+
+int save_macro_string(void) {
+    int res = BMPAPI->app.save_file(BMP_MACRO_RECORD);
+    if (res == 0) {
+        xprintf("Succeed to save macro");
+    } else {
+        xprintf("Failed to save macro");
+    }
+
+    return res;
+}
+
 const file_string_parser_setting_t file_string_parser_setting[] = {
     {.key        = "\"config\"",
      .string_dst = config_string,
@@ -221,7 +248,13 @@ const file_string_parser_setting_t file_string_parser_setting[] = {
      .string_dst = encoder_config_string,
      .dst_len    = sizeof(encoder_config_string),
      parse_encoder_config,
-     save_encoder_config}};
+     save_encoder_config},
+    {.key        = "macro\n",
+     .string_dst = macro_string,
+     .dst_len    = sizeof(macro_string),
+     parse_macro_string,
+     save_macro_string},
+};
 
 static file_string_parser_t parser = {NULL, 0};
 
@@ -270,13 +303,20 @@ int stream_write_callback(const uint8_t *dat, uint32_t len) {
         parser.write_idx += len;
     }
 
-    if (parser.setting != NULL) {
+    if (parser.setting == &file_string_parser_setting[PARSER_MACRO]) {
+        dst[parser.write_idx] = '\0';
+        int res               = parser.setting->parse();
+        parser.write_idx      = 0;
+        BMPAPI->logger.info("text received");
+
+        return res == 0 ? 0 : 1;
+    } else if (parser.setting != NULL) {
         json_close = is_json_closed((const char *)dst, parser.write_idx);
         if (json_close == 0) {
             dst[parser.write_idx] = '\0';
             int res               = parser.setting->parse();
             parser.write_idx      = 0;
-            BMPAPI->logger.info("Received json");
+            BMPAPI->logger.info("json received");
 
             return res == 0 ? 0 : 1;
         } else if (json_close == -1) {
@@ -385,12 +425,24 @@ static inline void update_tapping_term_string(bmp_api_config_t const *config,
     BMPAPI->usb.create_file("TAPTERM JSN", (uint8_t *)str, strlen(str));
 }
 
-static inline void update_ecoder_config_string(bmp_encoder_config_t const *config,
-                                              char *str, uint32_t len) {
+static inline void update_ecoder_config_string(
+    bmp_encoder_config_t const *config, char *str, uint32_t len) {
     encoder_config_to_json(config, str, len);
     BMPAPI->usb.create_file("ENCODER JSN", (uint8_t *)str, strlen(str));
 }
 
+static inline void update_macro_string(char *str, uint32_t len) {
+    // put key
+    uint32_t toklen = strlen(file_string_parser_setting[PARSER_MACRO].key);
+    strcpy(str, file_string_parser_setting[PARSER_MACRO].key);
+
+    // stringify macro
+    uint8_t *macro = bmp_macro_get_file_buffer();
+    bmp_macro_file_stringify(macro, (uint8_t *)str + toklen, len - toklen);
+
+    BMPAPI->usb.create_file("MACRO   TXT", (uint8_t *)str, strlen(str));
+}
+
 __attribute__((weak)) void create_user_file() {}
 
 static const char bmp_version_info[] = "API version: " STR(
@@ -561,8 +613,7 @@ int load_encoder_config_file() {
 
 __attribute__((weak)) uint16_t keymap_key_to_keycode_bmp(uint8_t  layer,
                                                          keypos_t key) {
-    return BMPAPI->app.keymap_key_to_keycode(layer,
-                                                 (bmp_api_keypos_t *)&key);
+    return BMPAPI->app.keymap_key_to_keycode(layer, (bmp_api_keypos_t *)&key);
 }
 
 uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key) {
@@ -602,6 +653,7 @@ void update_config_files() {
                                sizeof(qmk_config_string));
     update_ecoder_config_string(&bmp_encoder_config, encoder_config_string,
                                 sizeof(encoder_config_string));
+    update_macro_string(macro_string, sizeof(macro_string));
     create_info_file();
     create_index_html();
     create_user_file();

tmk_core/protocol/nrf/bmp_config.h

@@ -35,6 +35,7 @@ typedef enum {
     PARSER_KEYMAP,
     PARSER_QMK,
     PARSER_ENCODER,
+    PARSER_MACRO,
     PARSER_NONE,
 } parser_type_t;
 

tmk_core/protocol/nrf/bmp_macro.c

@@ -0,0 +1,122 @@
+
+#include "bmp_macro.h"
+
+#include <string.h>
+
+#include "send_string.h"
+#include "debug.h"
+
+#include "apidef.h"
+
+static uint8_t* macro_file;
+static uint32_t macro_file_length;
+static int8_t   active_macro = -1;
+static uint16_t active_macro_offset;
+
+#define ASSERT_MACRO_FILE()       \
+    if (macro_file == NULL) {     \
+        bmp_macro_load_file();    \
+        if (macro_file == NULL) { \
+            return;               \
+        }                         \
+    }
+
+void bmp_macro_task(void) {
+    if (active_macro < 0) {
+        return;
+    }
+
+    char data[4] = {0, 0, 0, 0};
+    data[0]      = macro_file[active_macro_offset++];
+    data[1]      = 0;
+
+    if (data[0] == 0) {
+        active_macro = -1;
+        return;
+    }
+
+    if (data[0] == SS_TAP_CODE || data[0] == SS_DOWN_CODE ||
+        data[0] == SS_UP_CODE) {
+        data[1] = data[0];
+        data[0] = SS_QMK_PREFIX;
+        data[2] = macro_file[active_macro_offset++];
+        if (data[2] == 0) {
+            active_macro = -1;
+            return;
+        }
+    }
+
+    send_string(data);
+}
+
+uint8_t* bmp_macro_get_file_buffer(void) { return macro_file; }
+
+void bmp_macro_load_file(void) {
+    BMPAPI->app.get_file(BMP_MACRO_RECORD, &macro_file, &macro_file_length);
+    if (macro_file == NULL) {
+        BMPAPI->app.save_file(BMP_MACRO_RECORD);  // create file
+    }
+}
+
+void bmp_macro_save_file(void) { BMPAPI->app.save_file(BMP_MACRO_RECORD); }
+
+void bmp_macro_send(uint8_t id) {
+    ASSERT_MACRO_FILE();
+
+    if (id >= BMP_MACRO_COUNT) {
+        dprintf("[Macro] Invalid ID:%d\n", id);
+        return;
+    }
+
+    const uint8_t* end_addr = macro_file + BMP_MACRO_FILE_LEN - 1;
+
+    if (*end_addr != 0) {
+        dprintf("[Macro] Invalid macro\n");
+        return;
+    }
+
+    if (active_macro >= 0) {
+        dprintf("[Macro] Other macro running\n");
+        return;
+    }
+
+    dprintf("[Macro] Activate %d\n", id);
+
+    active_macro_offset = 0;
+
+    for (active_macro = 0; active_macro < id; active_macro++) {
+        while (macro_file[active_macro_offset++] != 0) {
+            continue;
+        }
+
+        if (active_macro_offset >= BMP_MACRO_FILE_LEN - 1) {
+            dprintf("Invalid macro file\n");
+            active_macro = -1;
+            return;
+        }
+    }
+}
+
+void bmp_macro_get_buffer(uint16_t offset, uint16_t size, uint8_t* buffer) {
+    ASSERT_MACRO_FILE();
+
+    memcpy(buffer, macro_file + offset, size);
+}
+
+void bmp_macro_set_buffer(uint16_t offset, uint16_t size, uint8_t* buffer) {
+    ASSERT_MACRO_FILE();
+
+    if (offset + size >= BMP_MACRO_FILE_LEN) {
+        dprintf("[Macro] Invalid size: %d\n", offset + size);
+        return;
+    }
+
+    memcpy(macro_file + offset, buffer, size);
+}
+
+void bmp_macro_reset(void) {
+    ASSERT_MACRO_FILE();
+
+    memset(macro_file, 0, BMP_MACRO_FILE_LEN);
+}
+

tmk_core/protocol/nrf/bmp_macro.h

@@ -0,0 +1,16 @@
+
+#pragma once
+
+#include <stdint.h>
+
+#define BMP_MACRO_COUNT (16)
+#define BMP_MACRO_FILE_LEN (1024)
+
+void     bmp_macro_task(void);
+uint8_t* bmp_macro_get_file_buffer(void);
+void     bmp_macro_load_file(void);
+void     bmp_macro_save_file(void);
+void     bmp_macro_send(uint8_t id);
+void     bmp_macro_get_buffer(uint16_t offset, uint16_t size, uint8_t* buffer);
+void     bmp_macro_set_buffer(uint16_t offset, uint16_t size, uint8_t* buffer);
+void     bmp_macro_reset(void);