From 14ad7c4cc2e510576d7362ba3e86a9736d656b83 Mon Sep 17 00:00:00 2001 From: Dave Date: Fri, 19 Feb 2021 14:10:25 -0600 Subject: [PATCH] More keymap updates toward [#23] amd [#25] App code now compiles clean, but test code still needs to be updated to set up the test keymaps. So, no passing tests yet. --- firmware/asdf/src/ARCHITECTURE-keymaps.org | 11 +- firmware/asdf/src/asdf.c | 13 +- firmware/asdf/src/asdf_config.h | 3 + firmware/asdf/src/asdf_hook.c | 22 +-- firmware/asdf/src/asdf_hook.h | 16 +- firmware/asdf/src/asdf_keymaps.c | 155 +++++++++++++----- firmware/asdf/src/asdf_keymaps.h | 43 ++++- .../asdf/test/asdf_all_keymap_defs_test.h | 68 -------- firmware/asdf/test/test_asdf_keymap_defs.c | 59 +++---- firmware/asdf/test/test_asdf_keymap_defs.h | 69 +------- firmware/asdf/test/test_asdf_keymaps.c | 44 ++--- 11 files changed, 245 insertions(+), 258 deletions(-) delete mode 100644 firmware/asdf/test/asdf_all_keymap_defs_test.h diff --git a/firmware/asdf/src/ARCHITECTURE-keymaps.org b/firmware/asdf/src/ARCHITECTURE-keymaps.org index 3146207..485e59c 100644 --- a/firmware/asdf/src/ARCHITECTURE-keymaps.org +++ b/firmware/asdf/src/ARCHITECTURE-keymaps.org @@ -27,5 +27,14 @@ * Eliminate keymaps table and instead have table of keymap init routines with MAX_KEYMAPS entries * keymap setup routine adds maps for each modifier to the keymap, now only rxcxMODIFIERS instead of rxcxmodifiersxkeymaps * remove the keymap index from the add_map() call. -* select_keymap() will call setup routine for the given keymap. +* select_keymap() will call setup routine for the g +iven keymap. * Each keymap sets its own num_rows and num_columns, per matrix for each modifier + +* DIP SWITCHES + Note that the DIP switches are keys in the key matrix, which is initialized to + the all unpressed state at startup. Since the keymap is initialized to 0, the + keymap is consistent with the presumed initial state of the DIP switches. If + the DIP switches are not set to Keymap 0, then their position will be detected + as keypresses, and the correct keymap will be set. + diff --git a/firmware/asdf/src/asdf.c b/firmware/asdf/src/asdf.c index 6238b6d..89a9873 100644 --- a/firmware/asdf/src/asdf.c +++ b/firmware/asdf/src/asdf.c @@ -44,7 +44,7 @@ // The key scanner keeps track of the last stable (debounced) state of each key // in the matrix, one bit per key, 8 bits per row. -static asdf_cols_t last_stable_key_state[ASDF_NUM_ROWS]; +static asdf_cols_t last_stable_key_state[ASDF_MAX_ROWS]; // Each key is debounced separately, supporting true N-key rollover, allowing a // new key to be pressed when the previously pressed key is still debouncing. @@ -55,7 +55,7 @@ static asdf_cols_t last_stable_key_state[ASDF_NUM_ROWS]; // key presses and releases, and special handling for modifier keys, perhaps // including separate debounce logic in the handlers for toggle keys such as // CAPS_LOCK. -static uint8_t debounce_counters[ASDF_NUM_ROWS][ASDF_NUM_COLS]; +static uint8_t debounce_counters[ASDF_MAX_ROWS][ASDF_MAX_COLS]; // Stores the last key pressed static asdf_keycode_t last_key; @@ -401,9 +401,9 @@ void asdf_init(void) // Initialize all the keys to the unpressed state, and initialze the debounce // counters. - for (uint8_t row = 0; row < ASDF_NUM_ROWS; row++) { + for (uint8_t row = 0; row < ASDF_MAX_ROWS; row++) { last_stable_key_state[row] = 0; - for (uint8_t col = 0; col < ASDF_NUM_COLS; col++) { + for (uint8_t col = 0; col < ASDF_MAX_COLS; col++) { debounce_counters[row][col] = ASDF_DEBOUNCE_TIME_MS; } } @@ -509,18 +509,17 @@ static void asdf_handle_key_held_pressed(uint8_t row, uint8_t col) // void asdf_keyscan(void) { - asdf_cols_t (*row_reader)(uint8_t) = (asdf_cols_t(*)(uint8_t)) asdf_hook_get(ASDF_HOOK_SCANNER); asdf_hook_execute(ASDF_HOOK_EACH_SCAN); - for (uint8_t row = 0; row < ASDF_NUM_ROWS; row++) { + for (uint8_t row = 0; row < asdf_keymaps_num_rows(); row++) { asdf_cols_t row_key_state = (*row_reader)(row); asdf_cols_t changed = row_key_state ^ last_stable_key_state[row]; // loop over the bits until all changed or pressed keys in the row are handled. - for (uint8_t col = 0; (changed || row_key_state) && col < ASDF_NUM_COLS; col++) { + for (uint8_t col = 0; (changed || row_key_state) && col < asdf_keymaps_num_cols(); col++) { if (changed & 1) { // key state is different from last stable state asdf_handle_key_press_or_release(row, col, row_key_state & 1); diff --git a/firmware/asdf/src/asdf_config.h b/firmware/asdf/src/asdf_config.h index 7e3b613..039fa80 100644 --- a/firmware/asdf/src/asdf_config.h +++ b/firmware/asdf/src/asdf_config.h @@ -49,6 +49,9 @@ // Data structure sizes: +// Max number of keymaps supported (defines size of keymap setup routine array) +#define ASDF_NUM_KEYMAPS 32 + // Size of keymap initializer sequence. These sequences are defined in the // keymap modules. This should be large enough to accommodate the largest // initializer sequence among the included keymaps diff --git a/firmware/asdf/src/asdf_hook.c b/firmware/asdf/src/asdf_hook.c index bf13d1a..4988248 100644 --- a/firmware/asdf/src/asdf_hook.c +++ b/firmware/asdf/src/asdf_hook.c @@ -132,11 +132,11 @@ asdf_hook_function_t asdf_hook_get(asdf_hook_id_t hook_id) // // NOTES: // -// SCOPE: private +// SCOPE: public // // COMPLEXITY: 2 // -static void asdf_hook_assign(asdf_hook_id_t hook_id, asdf_hook_function_t func) +void asdf_hook_assign(asdf_hook_id_t hook_id, asdf_hook_function_t func) { if (asdf_hook_valid_id(hook_id)) { hook_map[hook_id] = func; @@ -144,9 +144,7 @@ static void asdf_hook_assign(asdf_hook_id_t hook_id, asdf_hook_function_t func) } // PROCEDURE: asdf_hook_init -// INPUTS: (asdf_hook_initializer_t *) initializer_list - contains the hook -// initializer list for the selected keymap. -// +// INPUTS: none // OUTPUTS: none // // DESCRIPTION: Initializes function hooks for the selected keymap. If a @@ -161,7 +159,7 @@ static void asdf_hook_assign(asdf_hook_id_t hook_id, asdf_hook_function_t func) // // COMPLEXITY: 4 // -void asdf_hook_init(asdf_hook_initializer_t *const initializer_list) +void asdf_hook_init(void) { // initialize hooks to null function for (uint8_t i = 0; i < ASDF_NUM_HOOKS; i++) { @@ -170,18 +168,6 @@ void asdf_hook_init(asdf_hook_initializer_t *const initializer_list) hook_map[ASDF_HOOK_SCANNER] = (asdf_hook_function_t) ASDF_ARCH_DEFAULT_SCANNER; hook_map[ASDF_HOOK_OUTPUT] = (asdf_hook_function_t) ASDF_ARCH_DEFAULT_OUTPUT; - - // run through the keymap specific setup - for (uint8_t i = 0; i < ASDF_KEYMAP_HOOK_INITIALIZER_LENGTH; i++) { - asdf_hook_id_t id = initializer_list[i].hook_id; - - if (ASDF_HOOK_KEYMAP_SETUP == id) { - initializer_list[i].hook_func(); - } - else { - asdf_hook_assign(initializer_list[i].hook_id, initializer_list[i].hook_func); - } - } } //-------|---------|---------+---------+---------+---------+---------+---------+ diff --git a/firmware/asdf/src/asdf_hook.h b/firmware/asdf/src/asdf_hook.h index 1f05509..0546053 100644 --- a/firmware/asdf/src/asdf_hook.h +++ b/firmware/asdf/src/asdf_hook.h @@ -45,7 +45,7 @@ typedef void (*asdf_hook_function_t)(void); typedef struct { asdf_hook_id_t hook_id; asdf_hook_function_t hook_func; -b} asdf_hook_initializer_t; +} asdf_hook_initializer_t; // PROCEDURE: asdf_hook_execute @@ -64,13 +64,21 @@ void asdf_hook_execute(asdf_hook_id_t hook_id); asdf_hook_function_t asdf_hook_get(asdf_hook_id_t hook_id); // PROCEDURE: asdf_hook_init -// INPUTS: (asdf_hook_initializer_t *) initializer_list - contains the hook -// initializer list for the selected keymap. +// INPUTS: none // OUTPUTS: none // DESCRIPTION: Initializes function hooks for the selected keymap. If a // function is assigned to the "KEYMAP_SETUP" hook, then execute the function. // There is no actual slot where KEYMAP_SETUP functions are stored. -void asdf_hook_init(asdf_hook_initializer_t *const initializer_list); +void asdf_hook_init(void); + +// PROCEDURE: asdf_hook_assign +// INPUTS: (asdf_hook_id_t) hook_id: The hook for which to execute attache functions. +// (asdf_hook_function_t) func: function to be attached to the hook. +// OUTPUTS: none +// DESCRIPTION: If the hook ID is valid, map the function to the hook ID. +// Ignore if not valid. +void asdf_hook_assign(asdf_hook_id_t hook_id, asdf_hook_function_t func); + #endif /* !defined (ASDF_HOOKS_H) */ diff --git a/firmware/asdf/src/asdf_keymaps.c b/firmware/asdf/src/asdf_keymaps.c index e4e7c60..b21002a 100644 --- a/firmware/asdf/src/asdf_keymaps.c +++ b/firmware/asdf/src/asdf_keymaps.c @@ -22,6 +22,7 @@ #include #include +#include "asdf_config.h" #include "asdf.h" #include "asdf_arch.h" #include "asdf_physical.h" @@ -31,24 +32,22 @@ #include "asdf_modifiers.h" // The keymap arrays organized as follows: -// * `xm`Each keymap matrix is a NUM_ROWS x NUM_COLS mapping of key to code for a given modifier. -// * Each keymap contains a set of keymap matrices, one for each unique -// combination of modifier keys. -// * All the keymaps (NUM_KEYMAPS) are gathered in the keymap_matrixp[] array. -static asdf_keycode_matrix_t *keymap_matrix[ASDF_MOD_NUM_MODIFIERS] = {}; +// * keymap_matrix - matrix of code mapppings for each physical keymap +// * rows = number of rows in the matrix +// * cols = number of cols in the matrix +// * one map structure for each modifier state. +static asdf_keycode_map_t keymaps[ASDF_MOD_NUM_MODIFIERS] = {}; -// Index of the currently active keymap, initialized to zero in the init -// routine. -static uint8_t current_keymap_index = 0; +// List of keymap setup routines. Each keymap setup routine is responsible for +// populating the keymap matrices, setting up virtual devices, and setting up +// keymap-specific function hooks and initial conditions for the keymap. +static asdf_keymap_setup_function_t keymap_setup_function_lookup_table[ASDF_NUM_KEYMAPS]; -// index of the current virtual device initializer entry while building virtual -// device initializer struct. -static uint8_t vdev_index = 0; -// index of the current hook entry while building hook initializer table. -static uint8_t hook_index = 0; +// The current keymap index. This is stored so bitwise operators on the keymap index can be performed. +static uint8_t current_keymap_index; -// PROCEDURE: asdf_keymaps_register_keymap +// PROCEDURE: asdf_keymaps_register // INPUTS: (uint8_t) keymap_index - index of the keymap to be modified // (asdf_keymap_setup_function_t) keymap setup function - called on // keymap change to setup up the keymap @@ -66,17 +65,19 @@ static uint8_t hook_index = 0; // SCOPE: public // // COMPLEXITY: 1 -void asdf_keymaps_register(uint8_t keymap_index, asdf_keymap_setup_function_t keymap_setup_function); +void asdf_keymaps_register(uint8_t keymap_index, asdf_keymap_setup_function_t keymap_setup_function) { if (keymap_index < ASDF_NUM_KEYMAPS) { - keymap_setup_functions[keymap_index] = keymap_setup_function; + keymap_setup_function_lookup_table[keymap_index] = keymap_setup_function; } } // PROCEDURE: asdf_keymaps_add_map -// INPUTS: (asdf_keycode_matrix_t *) matrix - pointer to the keycode matrix to add in to map -// (uint8_t) keymap_modifier - the modifier value for the keycode matrix being added +// INPUTS: (asdf_keycode_matrix_t) matrix - pointer to the keycode matrix to add in to map +// (uint8_t) modifier_index - the modifier value for the keycode matrix being added +// (uint8_t) rows - number of rows in the keymap +// (uint8_t) cols - number of columns in the keymap // // OUTPUTS: none // @@ -85,23 +86,84 @@ void asdf_keymaps_register(uint8_t keymap_index, asdf_keymap_setup_function_t ke // // SIDE EFFECTS: // -// NOTES: If the keymap modifier index is not a valid keymap index then no +// NOTES: If the keymap modifier index, num_rows, or num_cols are not valid then no // action is performed. // // SCOPE: public // // COMPLEXITY: 1 -void asdf_keymaps_add_map(uint8_t num_rows, uint8_t num_cols, asdf_keycode_matrix_t *matrix, modifier_index_t modifier_index); +void asdf_keymaps_add_map(asdf_keycode_matrix_t matrix, + modifier_index_t modifier_index, + uint8_t num_rows, uint8_t num_cols) { - if (modifier_index < ASDF_MOD_NUM_MODIFIERS) + if ((modifier_index < ASDF_MOD_NUM_MODIFIERS) + && (num_rows <= ASDF_MAX_ROWS) + && (num_cols <= ASDF_MAX_COLS)) { - keymaps[modifier_index].map = matrix; + keymaps[modifier_index].matrix_ptr = matrix; keymaps[modifier_index].rows = num_rows; keymaps[modifier_index].cols = num_cols; } } -asdf_ +// PROCEDURE: asdf_keymaps_num_rows +// INPUTS: none +// OUTPUTS: uint8_t - returns number of rows in keymap for current modifier state +// +// DESCRIPTION: See OUTPUTS +// +// SIDE EFFECTS: none +// +// NOTES: +// +// SCOPE: publice +// +// COMPLEXITY: 1 +// +uint8_t asdf_keymaps_num_rows(void) +{ + return keymaps[asdf_modifier_index()].rows; +} + +// PROCEDURE: asdf_keymaps_num_cols +// INPUTS: none +// OUTPUTS: uint8_t - returns number of columns in keymap for current modifier state +// +// DESCRIPTION: See OUTPUTS +// +// SIDE EFFECTS: none +// +// NOTES: +// +// SCOPE: publice +// +// COMPLEXITY: 1 +// +uint8_t asdf_keymaps_num_cols(void) +{ + return keymaps[asdf_modifier_index()].cols; +} + + +// PROCEDURE: asdf_keymaps_new +// INPUTS: none +// OUTPUTS: none +// +// DESCRIPTION: Clear all keycode mapping matrices. +// +// SIDE EFFECTS: see DESCRIPTION +// +// SCOPE: private +// +// COMPLEXITY: 2 +// +static void asdf_keymaps_new(void) +{ + for (uint8_t i = 0; i < ASDF_MOD_NUM_MODIFIERS; i++) { + asdf_keymaps_add_map(NULL, i, 0, 0); + } +} + // PROCEDURE: asdf_keymaps_select_keymap // INPUTS: (uint8_t) index - index of the keymap number to select // OUTPUTS: none @@ -111,12 +173,9 @@ asdf_ // 1) assign the value to the global (to the module) current_keymap_index variable // 2) execute the architecture-dependent init routine, to undo any settings // from the previous keymap -// 3) initialize the virtual outputs for the selected keymap. -// 4) initialize the modifier key states. +// 3) execute the keymap-specific setup routine. // -// SIDE EFFECTS: -// - May change the module-global current_keymap_index variable. -// - Architecture is initialized to default configuration. +// SIDE EFFECTS: See DESCRIPTION // // NOTES: If the requested index is not valid, then no action is performed. // @@ -128,40 +187,48 @@ void asdf_keymaps_select_keymap(uint8_t index) { if (index < ASDF_NUM_KEYMAPS) { asdf_arch_init(); - // asdf_virtual_init((asdf_virtual_initializer_t *const) keymap_initializer_list[current_keymap_index]); - // asdf_hook_init((asdf_hook_initializer_t *const) keymap_hook_initializer_list[current_keymap_index]); + asdf_keymaps_new(); + current_keymap_index = index; + keymap_setup_function_lookup_table[index](); } - } +// PROCEDURE: ASDF_KEYMAPS_DUMMY_FUNCTION +// INPUTS: none +// OUTPUTS: none +// +// DESCRIPTION: null function to populate the keymap setup function table. Since +// this function does nothing, then selecting an unregistered keymap has no +// effect (i.e., the previous keymap persisits) +// +// SIDE EFFECTS: See Description +// +// SCOPE: private +// +// COMPLEXITY: 1 +// +void asdf_keymaps_dummy_function(void) {} + // PROCEDURE: asdf_keymaps_init // INPUTS: none // OUTPUTS: none // -// DESCRIPTION: initialize the keymap list +// DESCRIPTION: initialize the keymap list. Called at startup. // // SIDE EFFECTS: See DESCRIPTION // // SCOPE: public // -// NOTES: Note that the DIP switches are keys in the key matrix, which is -// initialized to the all unpressed state at startup. Since the keymap is -// initialized to 0, the keymap is consistent with the presumed initial state of -// the DIP switches. If the DIP switches are not set to Keymap 0, then their -// position will be detected as keypresses, and the correct keymap will be set. - // COMPLEXITY: 1 // void asdf_keymaps_init(void) { for (uint8_t i = 0; i < ASDF_NUM_KEYMAPS; i++) { - keymaps[i].setup_function = NULL; - keymaps[i].rows = 0; - keymaps[i].cols = 0; + keymap_setup_function_lookup_table[i] = &asdf_keymaps_dummy_function; } + current_keymap_index = 0; } - // PROCEDURE: asdf_keymaps_map_select_0_clear // INPUTS: none // OUTPUTS: none @@ -342,8 +409,8 @@ void asdf_keymaps_map_select_3_set(void) asdf_keycode_t asdf_keymaps_get_code(const uint8_t row, const uint8_t col, const uint8_t modifier_index) { - asdf_keycode_matrix_t *matrix = keymap_matrix[current_keymap_index][modifier_index]; - return FLASH_READ_MATRIX_ELEMENT(*matrix, row, col); + asdf_keycode_matrix_t matrix = keymaps[modifier_index].matrix_ptr; + return FLASH_READ_MATRIX_ELEMENT(matrix, row, col); } //-------|---------|---------+---------+---------+---------+---------+---------+ diff --git a/firmware/asdf/src/asdf_keymaps.h b/firmware/asdf/src/asdf_keymaps.h index 1140d8b..c49fa67 100644 --- a/firmware/asdf/src/asdf_keymaps.h +++ b/firmware/asdf/src/asdf_keymaps.h @@ -31,6 +31,7 @@ #include "asdf_hook.h" #include "asdf_virtual.h" #include "asdf_physical.h" +#include "asdf_modifiers.h" // Define the bit position of each keymap DIP switch. The DIP switch values at // each bit position can be used to select the current keymap. This requires the @@ -41,10 +42,12 @@ #define ASDF_KEYMAP_BIT_2 4 #define ASDF_KEYMAP_BIT_3 8 +#define ASDF_MAX_ROWS 16 +#define ASDF_MAX_COLS 8 // define the keycode matrices to be used by the keymaps. Each matrix is a // mapping of row,column to keycode. -typedef asdf_keycode_t asdf_keycode_matrix_t[][]; +typedef asdf_keycode_t **asdf_keycode_matrix_t; // define the type for a keymap setup function. Keymaps are registerd by storing // a keymap setup function in the keymap setup array. @@ -53,21 +56,48 @@ typedef void (*asdf_keymap_setup_function_t)(void); // define the struct for each keymap matrix in the keymap array. One per // modifier state. Each keymap can have it's own row and column count. typedef struct { - asdf_keycode_matrix_t *matrix; + asdf_keycode_matrix_t matrix_ptr; uint8_t rows; uint8_t cols; -}; +} asdf_keycode_map_t; -// PROCEDURE: asdf_keymaps_add_map +// PROCEDURE: asdf_keymaps_register // INPUTS: (uint8_t) keymap_index - index of the keymap to be modified -// (asdf_keymap_setup_function) setup_function - pointer to keymap setup function +// (asdf_keymap_setup_function_t) keymap setup function - called on +// keymap change to setup up the keymap // OUTPUTS: none // DESCRIPTION: Called by keymap building modules. This routine adds a keymap // setup function into the keymap setup array. // NOTES: If the keymap modifier index is not a valid keymap index then no // action is performed. -void asdf_keymaps_add_map(uint8_t keymap_index, asdf_keymap_setup_function_t); +void asdf_keymaps_register(uint8_t keymap_index, asdf_keymap_setup_function_t keymap_setup_function); + +// PROCEDURE: asdf_keymaps_add_map +// INPUTS: (asdf_keycode_matrix_t *) matrix - pointer to the keycode matrix to add in to map +// (uint8_t) modifier_index - the modifier value for the keycode matrix being added +// (uint8_t) rows - number of rows in the keymap +// (uint8_t) cols - number of columns in the keymap +// OUTPUTS: none +// DESCRIPTION: Called by keymap building modules. This routine adds a keymap to the current +// setup function into the keymap setup array. +// NOTES: If the keymap modifier index, num_rows, or num_cols are not valid then no +// action is performed. +void asdf_keymaps_add_map(asdf_keycode_matrix_t matrix, + modifier_index_t modifier_index, + uint8_t num_rows, uint8_t num_cols); + +// PROCEDURE: asdf_keymaps_num_rows +// INPUTS: none +// OUTPUTS: uint8_t - returns number of rows in keymap for current modifier state +// DESCRIPTION: See OUTPUTS +uint8_t asdf_keymaps_num_rows(void); + +// PROCEDURE: asdf_keymaps_num_cols +// INPUTS: none +// OUTPUTS: uint8_t - returns number of columns in keymap for current modifier state +// DESCRIPTION: See OUTPUTS +uint8_t asdf_keymaps_num_cols(void); // PROCEDURE: asdf_keymaps_select_keymap // INPUTS: (uint8_t) index - index of the keymap number to select @@ -84,7 +114,6 @@ void asdf_keymaps_select_keymap(uint8_t index); // keymap index. void asdf_keymaps_map_select_0_clear(void); - // PROCEDURE: asdf_keymaps_map_select_0_set // INPUTS: none // OUTPUTS: none diff --git a/firmware/asdf/test/asdf_all_keymap_defs_test.h b/firmware/asdf/test/asdf_all_keymap_defs_test.h deleted file mode 100644 index 1ee4747..0000000 --- a/firmware/asdf/test/asdf_all_keymap_defs_test.h +++ /dev/null @@ -1,68 +0,0 @@ -// -*- mode: C; tab-width: 4 ; indent-tabs-mode: nil -*- -// -// Unfified Keyboard Project -// ASDF keyboard firmware -// -// asdf_keymap_defs.h -// -// gathers up all the keymap definitions to be included in the firmware. -// -// Copyright 2019 David Fenyes -// -// This program is free software: you can redistribute it and/or modify it under -// the terms of the GNU General Public License as published by the Free Software -// Foundation, either version 3 of the License, or (at your option) any later -// version. -// -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more -// details. -// -// You should have received a copy of the GNU General Public License along with -// this program. If not, see . - -// While there is nothing preventing a standard keyboard from having both a -// "Shift Lock" key and a "Caps Lock" key, usually only one will be present. For -// testing, both must be present to test their functionality. - -#if !defined(ASDF_KEYMAP_DEFS_H) -#define ASDF_KEYMAP_DEFS_H - -#include "asdf.h" -#include "test_asdf_lib.h" -#include "asdf_ascii.h" -#include "asdf_modifiers.h" -#include "Keymaps/asdf_keymap_defs_test.h" -#include "Keymaps/asdf_keymap_defs_test2.h" - - -#define ASDF_TEST_BASE 0 -#define ASDF_TEST2_BASE (ASDF_TEST_BASE + ASDF_TEST_KEYMAPS_COUNT) - -#define ASDF_NUM_KEYMAPS (ASDF_TEST_BASE + ASDF_TEST_KEYMAPS_COUNT + ASDF_TEST2_KEYMAPS_COUNT) - -#define ASDF_KEYMAP_DEFS \ - { \ - ASDF_TEST_KEYMAPS, ASDF_TEST2_KEYMAPS \ - } - -#define ASDF_KEYMAP_DECLARATIONS ASDF_TEST_DECLARATIONS ASDF_TEST2_DECLARATIONS - -#define ASDF_KEYMAP_INITIALIZERS \ - { \ - ASDF_TEST_KEYMAP_INITIALIZER, ASDF_TEST2_KEYMAP_INITIALIZER \ - } - -#define ASDF_KEYMAP_HOOK_INITIALIZERS \ - { \ - ASDF_TEST_KEYMAP_HOOK_INITIALIZER, ASDF_TEST2_KEYMAP_HOOK_INITIALIZER \ - } - -typedef asdf_keycode_t keycode_matrix_t[ASDF_NUM_ROWS][ASDF_NUM_COLS]; - - -#endif /* !defined (ASDF_KEYMAP_DEFS_H) */ - -//-------|---------|---------+---------+---------+---------+---------+---------+ -// Above line is 80 columns, and should display completely in the editor. diff --git a/firmware/asdf/test/test_asdf_keymap_defs.c b/firmware/asdf/test/test_asdf_keymap_defs.c index 085e027..1a2f527 100644 --- a/firmware/asdf/test/test_asdf_keymap_defs.c +++ b/firmware/asdf/test/test_asdf_keymap_defs.c @@ -29,15 +29,15 @@ #include "asdf_keymaps.h" -static const asdf_keycode_matrix_t test_PLAIN_matrix = ASDF_TEST_PLAIN_MAP; -static const asdf_keycode_matrix_t test_SHIFT_matrix = ASDF_TEST_SHIFT_MAP; -static const asdf_keycode_matrix_t test_CAPS_matrix = ASDF_TEST_CAPS_MAP; -static const asdf_keycode_matrix_t test_CTRL_matrix = ASDF_TEST_CTRL_MAP; +static const asdf_keycode_t test_PLAIN_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_PLAIN_MAP; +static const asdf_keycode_t test_SHIFT_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_SHIFT_MAP; +static const asdf_keycode_t test_CAPS_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_CAPS_MAP; +static const asdf_keycode_t test_CTRL_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_CTRL_MAP; -static const asdf_keycode_matrix_t test2_PLAIN_matrix = ASDF_TEST2_PLAIN_MAP; -static const asdf_keycode_matrix_t test2_SHIFT_matrix = ASDF_TEST2_SHIFT_MAP; -static const asdf_keycode_matrix_t test2_CAPS_matrix = ASDF_TEST2_CAPS_MAP; -static const asdf_keycode_matrix_t test2_CTRL_matrix = ASDF_TEST2_CTRL_MAP; +static const asdf_keycode_t test2_PLAIN_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_PLAIN_MAP; +static const asdf_keycode_t test2_SHIFT_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_SHIFT_MAP; +static const asdf_keycode_t test2_CAPS_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_CAPS_MAP; +static const asdf_keycode_t test2_CTRL_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_CTRL_MAP; // PROCEDURE: @@ -56,46 +56,49 @@ static const asdf_keycode_matrix_t test2_CTRL_matrix = ASDF_TEST2_CTRL_MAP; // +void test_keymaps_add_map(asdf_keycode_matrix_t matrix, + modifier_index_t modifier_index) +{ + asdf_keymaps_add_map(matrix, modifier_index, (uint8_t) TEST_NUM_ROWS, (uint8_t) TEST_NUM_COLS); +} + + void setup_test_plain_map(void) { - asdf_keymaps_add_map(ASDF_TEST_PLAIN_MAP_INDEX, &test_PLAIN_matrix, MOD_PLAIN_MAP); - asdf_keymaps_add_map(ASDF_TEST_PLAIN_MAP_INDEX, &test_CAPS_matrix, MOD_CAPS_MAP); - asdf_keymaps_add_map(ASDF_TEST_PLAIN_MAP_INDEX, &test_SHIFT_matrix, MOD_SHIFT_MAP); - asdf_keymaps_add_map(ASDF_TEST_PLAIN_MAP_INDEX, &test_CTRL_matrix, MOD_CTRL_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_PLAIN_matrix, MOD_PLAIN_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_CAPS_matrix, MOD_CAPS_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_SHIFT_matrix, MOD_SHIFT_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_CTRL_matrix, MOD_CTRL_MAP); } void setup_test_caps_map(void) { - asdf_keymaps_add_map(ASDF_TEST_CAPS_MAP_INDEX, &test_PLAIN_matrix, MOD_PLAIN_MAP); - asdf_keymaps_add_map(ASDF_TEST_CAPS_MAP_INDEX, &test_CAPS_matrix, MOD_CAPS_MAP); - asdf_keymaps_add_map(ASDF_TEST_CAPS_MAP_INDEX, &test_SHIFT_matrix, MOD_SHIFT_MAP); - asdf_keymaps_add_map(ASDF_TEST_CAPS_MAP_INDEX, &test_CTRL_matrix, MOD_CTRL_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_PLAIN_matrix, MOD_PLAIN_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_CAPS_matrix, MOD_CAPS_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_SHIFT_matrix, MOD_SHIFT_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test_CTRL_matrix, MOD_CTRL_MAP); } void setup_test2_plain_map(void) { - asdf_keymaps_add_map(ASDF_TEST2_PLAIN_MAP_INDEX, &test2_PLAIN_matrix, MOD_PLAIN_MAP); - asdf_keymaps_add_map(ASDF_TEST2_PLAIN_MAP_INDEX, &test2_CAPS_matrix, MOD_CAPS_MAP); - asdf_keymaps_add_map(ASDF_TEST2_PLAIN_MAP_INDEX, &test2_SHIFT_matrix, MOD_SHIFT_MAP); - asdf_keymaps_add_map(ASDF_TEST2_PLAIN_MAP_INDEX, &test2_CTRL_matrix, MOD_CTRL_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_PLAIN_matrix, MOD_PLAIN_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_CAPS_matrix, MOD_CAPS_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_SHIFT_matrix, MOD_SHIFT_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_CTRL_matrix, MOD_CTRL_MAP); } void setup_test2_caps_map(void) { - asdf_keymaps_add_map(ASDF_TEST2_CAPS_MAP_INDEX, &test2_PLAIN_matrix, MOD_PLAIN_MAP); - asdf_keymaps_add_map(ASDF_TEST2_CAPS_MAP_INDEX, &test2_CAPS_matrix, MOD_CAPS_MAP); - asdf_keymaps_add_map(ASDF_TEST2_CAPS_MAP_INDEX, &test2_SHIFT_matrix, MOD_SHIFT_MAP); - asdf_keymaps_add_map(ASDF_TEST2_CAPS_MAP_INDEX, &test2_CTRL_matrix, MOD_CTRL_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_PLAIN_matrix, MOD_PLAIN_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_CAPS_matrix, MOD_CAPS_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_SHIFT_matrix, MOD_SHIFT_MAP); + test_keymaps_add_map((asdf_keycode_matrix_t) test2_CTRL_matrix, MOD_CTRL_MAP); } void setup_test_devs1(void) { #define ASDF_TEST_KEYMAP_INITIALIZER_1 \ { \ - - asdf_virtual_init(); - /* Single assignment */ \ - .virtual_device = VOUT1, \ .physical_device = PHYSICAL_OUT1, \ .function = V_NOFUNC, \ diff --git a/firmware/asdf/test/test_asdf_keymap_defs.h b/firmware/asdf/test/test_asdf_keymap_defs.h index 8254ec0..962b362 100644 --- a/firmware/asdf/test/test_asdf_keymap_defs.h +++ b/firmware/asdf/test/test_asdf_keymap_defs.h @@ -54,11 +54,14 @@ #define SHIFT_MATRIX_1 RESERVED_3 #define CTRL_MATRIX_1 RESERVED_4 -#define ASDF_LAST_ROW (ASDF_NUM_ROWS - 1) -#define ASDF_TEST_MAP_DIP_SWITCHES \ - [ASDF_LAST_ROW] = { ACTION_MAPSEL_0, ACTION_MAPSEL_1, ACTION_MAPSEL_2, ACTION_MAPSEL_3 } +#define TEST_NUM_ROWS 9 +#define TEST_NUM_COLS 8 -#define ASDF_TEST_PLAIN_MAP \ +#define ASDF_TEST_MAP_DIP_SWITCHES \ + [TEST_NUM_ROWS-1] = { ACTION_MAPSEL_0, ACTION_MAPSEL_1, ACTION_MAPSEL_2, ACTION_MAPSEL_3 } + + +#define ASDF_TEST_PLAIN_MAP \ { \ { PLAIN_MATRIX_1, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \ ACTION_CAPS, ASCII_ESC, ACTION_CTRL, ASCII_BACKSLASH }, \ @@ -137,59 +140,6 @@ #define TRIPLE_TESTS_KEYMAP ASDF_TEST_CAPS_MAP_INDEX #define ASDF_TEST_KEYMAP_INITIALIZER_LENGTH 5 -#define ASDF_TEST_KEYMAP_INITIALIZER_1 \ - { \ - { \ - /* Single assignment */ \ - .virtual_device = VOUT1, \ - .physical_device = PHYSICAL_OUT1, \ - .function = V_NOFUNC, \ - .initial_value = 0, \ - }, \ - { \ - /* single toggle */ \ - .virtual_device = VOUT2, \ - .physical_device = PHYSICAL_OUT2, \ - .function = V_TOGGLE, \ - .initial_value = 0, \ - }, \ - { \ - /* single pulse */ \ - .virtual_device = VOUT3, \ - .physical_device = PHYSICAL_OUT3, \ - .function = V_PULSE_SHORT, \ - .initial_value = 0, \ - }, \ - { /* first of double assignment attempt */ \ - .virtual_device = VOUT4, \ - .physical_device = PHYSICAL_LED1, \ - .initial_value = 0 \ - }, \ - { /* second of double assignment attempt */ \ - .virtual_device = VOUT5, .physical_device = PHYSICAL_LED1, .initial_value = 1 \ - } \ - } - -#define ASDF_TEST_KEYMAP_INITIALIZER_2 \ - { \ - { \ - /* Triple assignment */ \ - .virtual_device = VOUT1, \ - .physical_device = PHYSICAL_OUT1, \ - .function = V_TOGGLE, \ - .initial_value = 0, \ - }, \ - { \ - .virtual_device = VOUT1, \ - .physical_device = PHYSICAL_OUT2, \ - .function = V_TOGGLE, \ - .initial_value = 1, \ - }, \ - { \ - .virtual_device = VOUT1, .physical_device = PHYSICAL_OUT3, .function = V_TOGGLE, \ - .initial_value = 0, \ - } \ - } #define ASDF_TEST_KEYMAP_INITIALIZER ASDF_TEST_KEYMAP_INITIALIZER_1, ASDF_TEST_KEYMAP_INITIALIZER_2 @@ -231,11 +181,6 @@ #define SHIFT_MATRIX_2 RESERVED_7 #define CTRL_MATRIX_2 RESERVED_8 -#define ASDF_LAST_ROW (ASDF_NUM_ROWS - 1) - -#define ASDF_TEST_MAP_DIP_SWITCHES \ - [ASDF_LAST_ROW] = { ACTION_MAPSEL_0, ACTION_MAPSEL_1, ACTION_MAPSEL_2, ACTION_MAPSEL_3 } - #define ASDF_TEST2_PLAIN_MAP \ { \ { PLAIN_MATRIX_2, ACTION_SHIFT, ACTION_SHIFT, ACTION_NOTHING, \ diff --git a/firmware/asdf/test/test_asdf_keymaps.c b/firmware/asdf/test/test_asdf_keymaps.c index 108dd71..e24a20d 100644 --- a/firmware/asdf/test/test_asdf_keymaps.c +++ b/firmware/asdf/test/test_asdf_keymaps.c @@ -14,15 +14,15 @@ #define TESTKEYMAP_TAG PLAIN_MATRIX_1 #define NUM_DIPSWITCHES 4 -static const FLASH asdf_keycode_matrix_t test_PLAIN_matrix = ASDF_TEST_PLAIN_MAP; -static const FLASH asdf_keycode_matrix_t test_SHIFT_matrix = ASDF_TEST_SHIFT_MAP; -static const FLASH asdf_keycode_matrix_t test_CAPS_matrix = ASDF_TEST_CAPS_MAP; -static const FLASH asdf_keycode_matrix_t test_CTRL_matrix = ASDF_TEST_CTRL_MAP; +static const FLASH asdf_keycode_t test_PLAIN_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_PLAIN_MAP; +static const FLASH asdf_keycode_t test_SHIFT_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_SHIFT_MAP; +static const FLASH asdf_keycode_t test_CAPS_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_CAPS_MAP; +static const FLASH asdf_keycode_t test_CTRL_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST_CTRL_MAP; -static const FLASH asdf_keycode_matrix_t test2_PLAIN_matrix = ASDF_TEST2_PLAIN_MAP; -static const FLASH asdf_keycode_matrix_t test2_SHIFT_matrix = ASDF_TEST2_SHIFT_MAP; -static const FLASH asdf_keycode_matrix_t test2_CAPS_matrix = ASDF_TEST2_CAPS_MAP; -static const FLASH asdf_keycode_matrix_t test2_CTRL_matrix = ASDF_TEST2_CTRL_MAP; +static const FLASH asdf_keycode_t test2_PLAIN_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_PLAIN_MAP; +static const FLASH asdf_keycode_t test2_SHIFT_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_SHIFT_MAP; +static const FLASH asdf_keycode_t test2_CAPS_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_CAPS_MAP; +static const FLASH asdf_keycode_t test2_CTRL_matrix[TEST_NUM_ROWS][TEST_NUM_COLS] = ASDF_TEST2_CTRL_MAP; // row: row number // col: column number @@ -96,8 +96,8 @@ coord_t *find_code(asdf_keycode_t code) uint32_t done = 0; static coord_t location = { .row = -1, .col = -1 }; - for (uint32_t row = 0; !done && (row < ASDF_NUM_ROWS); row++) { - for (uint32_t col = 0; !done && (col < ASDF_NUM_COLS); col++) { + for (uint32_t row = 0; !done && (row < TEST_NUM_ROWS); row++) { + for (uint32_t col = 0; !done && (col < TEST_NUM_COLS); col++) { if (test_PLAIN_matrix[row][col] == code) { done = 1; location.row = row; @@ -113,7 +113,7 @@ void setUp(void) { coord_t *temp; - asdf_setup_test_plain_map(); + setup_test_plain_map(); setup_test_caps_map(); setup_test2_plain_map(); setup_test2_caps_map(); @@ -128,6 +128,12 @@ void setUp(void) temp = find_code(TESTKEYMAP_TAG); keymap_tag = *temp; + + setup_test_plain_map(); + setup_test_caps_map(); + setup_test2_plain_map(); + setup_test2_caps_map(); + } void tearDown(void) {} @@ -220,10 +226,10 @@ void keymap1_capsmap_plain_maps_to_caps(void) void dip_switch_codes_are_in_last_row_test1_map(void) { - coord_t dip_switches[NUM_DIPSWITCHES] = { { .row = ASDF_LAST_ROW, .col = 0 }, - { .row = ASDF_LAST_ROW, .col = 1 }, - { .row = ASDF_LAST_ROW, .col = 2 }, - { .row = ASDF_LAST_ROW, .col = 3 } }; + coord_t dip_switches[NUM_DIPSWITCHES] = { { .row = (TEST_NUM_ROWS - 1), .col = 0 }, + { .row = (TEST_NUM_ROWS - 1), .col = 1 }, + { .row = (TEST_NUM_ROWS - 1), .col = 2 }, + { .row = (TEST_NUM_ROWS - 1), .col = 3 } }; for (uint8_t i = 0; i < NUM_DIPSWITCHES; i++) { asdf_keycode_t code = asdf_keymaps_get_code(dip_switches[i].row, dip_switches[i].col, ASDF_TEST_PLAIN_MAP_INDEX); @@ -233,10 +239,10 @@ void dip_switch_codes_are_in_last_row_test1_map(void) void dip_switch_codes_are_in_last_row_test2_map(void) { - coord_t dip_switches[NUM_DIPSWITCHES] = { { .row = ASDF_LAST_ROW, .col = 0 }, - { .row = ASDF_LAST_ROW, .col = 1 }, - { .row = ASDF_LAST_ROW, .col = 2 }, - { .row = ASDF_LAST_ROW, .col = 3 } }; + coord_t dip_switches[NUM_DIPSWITCHES] = { { .row = (TEST_NUM_ROWS - 1), .col = 0 }, + { .row = (TEST_NUM_ROWS - 1), .col = 1 }, + { .row = (TEST_NUM_ROWS - 1), .col = 2 }, + { .row = (TEST_NUM_ROWS - 1), .col = 3 } }; for (uint8_t i = 0; i < NUM_DIPSWITCHES; i++) { asdf_keycode_t code = asdf_keymaps_get_code(dip_switches[i].row, dip_switches[i].col, ASDF_TEST2_PLAIN_MAP_INDEX);