From dc49a1cc1bc71f06cd8a1085ee1bac14fc9bf3d2 Mon Sep 17 00:00:00 2001 From: Arne Moerman Date: Thu, 26 Feb 2026 10:58:03 +0100 Subject: [PATCH] Add Cheapino keyboard support with multiple keymaps and configurations - Created default keymap for Cheapino keyboard with basic layout. - Added Lars keymap with custom mouse settings and underglow configuration. - Implemented TheArne4 keymap tailored for azerty-be layout. - Introduced Tompi keymap with extensive layer definitions. - Added VIA and VIAL support with respective keymaps and configurations. - Implemented custom matrix handling in matrix.c for improved performance. - Added mcuconf.h for MCU configuration. - Created README.md for project documentation and setup instructions. - Updated rules.mk to include necessary features and source files. --- keyboards/cheapino/cheapino.c | 75 +++++ keyboards/cheapino/config.h | 26 ++ keyboards/cheapino/encoder.c | 63 ++++ keyboards/cheapino/encoder.h | 5 + keyboards/cheapino/ghosting.c | 128 ++++++++ keyboards/cheapino/ghosting.h | 5 + keyboards/cheapino/halconf.h | 4 + keyboards/cheapino/keyboard.json | 96 ++++++ .../cheapino/keymaps/default/keymap.json | 163 +++++++++++ keyboards/cheapino/keymaps/lars/config.h | 51 ++++ keyboards/cheapino/keymaps/lars/keymap.json | 125 ++++++++ .../cheapino/keymaps/thearne4/keymap.json | 239 +++++++++++++++ keyboards/cheapino/keymaps/tompi/keymap.json | 277 ++++++++++++++++++ keyboards/cheapino/keymaps/via/keymap.json | 163 +++++++++++ keyboards/cheapino/keymaps/vial/config.h | 5 + keyboards/cheapino/keymaps/vial/keymap.json | 49 ++++ keyboards/cheapino/keymaps/vial/vial.json | 18 ++ keyboards/cheapino/matrix.c | 152 ++++++++++ keyboards/cheapino/mcuconf.h | 4 + keyboards/cheapino/readme.md | 28 ++ keyboards/cheapino/rules.mk | 8 + 21 files changed, 1684 insertions(+) create mode 100644 keyboards/cheapino/cheapino.c create mode 100644 keyboards/cheapino/config.h create mode 100644 keyboards/cheapino/encoder.c create mode 100644 keyboards/cheapino/encoder.h create mode 100644 keyboards/cheapino/ghosting.c create mode 100644 keyboards/cheapino/ghosting.h create mode 100644 keyboards/cheapino/halconf.h create mode 100644 keyboards/cheapino/keyboard.json create mode 100644 keyboards/cheapino/keymaps/default/keymap.json create mode 100644 keyboards/cheapino/keymaps/lars/config.h create mode 100644 keyboards/cheapino/keymaps/lars/keymap.json create mode 100644 keyboards/cheapino/keymaps/thearne4/keymap.json create mode 100644 keyboards/cheapino/keymaps/tompi/keymap.json create mode 100644 keyboards/cheapino/keymaps/via/keymap.json create mode 100644 keyboards/cheapino/keymaps/vial/config.h create mode 100644 keyboards/cheapino/keymaps/vial/keymap.json create mode 100644 keyboards/cheapino/keymaps/vial/vial.json create mode 100644 keyboards/cheapino/matrix.c create mode 100644 keyboards/cheapino/mcuconf.h create mode 100644 keyboards/cheapino/readme.md create mode 100644 keyboards/cheapino/rules.mk diff --git a/keyboards/cheapino/cheapino.c b/keyboards/cheapino/cheapino.c new file mode 100644 index 00000000000..5d06ac336a5 --- /dev/null +++ b/keyboards/cheapino/cheapino.c @@ -0,0 +1,75 @@ +#include "wait.h" +#include "quantum.h" + +// This is to keep state between callbacks, when it is 0 the +// initial RGB flash is finished +uint8_t _hue_countdown = 50; + +// These are to keep track of user selected color, so we +// can restore it after RGB flash +uint8_t _hue; +uint8_t _saturation; +uint8_t _value; + +// Do a little 2.5 seconds display of the different colors +// Use the deferred executor so the LED flash dance does not +// stop us from using the keyboard. +// https://docs.qmk.fm/#/custom_quantum_functions?id=deferred-executor-registration +uint32_t flash_led(uint32_t next_trigger_time, void *cb_arg) { + rgblight_sethsv(_hue_countdown * 5, 230, 70); + _hue_countdown--; + if (_hue_countdown == 0) { + // Finished, reset to user chosen led color + rgblight_sethsv(_hue, _saturation, _value); + return 0; + } else { + return 50; + } +} + +void keyboard_post_init_user(void) { + //debug_enable=true; + //debug_matrix=true; + //debug_keyboard=true; + //debug_mouse=true; + + // Store user selected rgb hsv: + _hue = rgblight_get_hue(); + _saturation = rgblight_get_sat(); + _value = rgblight_get_val(); + + // Flash a little on start + // defer_exec(50, flash_led, NULL); +} + +// Make the builtin RGB led show different colors per layer: +uint8_t get_hue(uint8_t layer) { + switch (layer) { + case 13: + return 0; + case 12: + return 20; + case 5: + return 43; + case 4: + return 43; + case 3: + return 170; + case 2: + return 213; + case 1: + return 128; + case 0: + return 85; + default: + return 255; + } +} + +layer_state_t layer_state_set_user(layer_state_t state) { + uint8_t sat = rgblight_get_sat(); + uint8_t val = rgblight_get_val(); + uint8_t hue = get_hue(get_highest_layer(state)); + rgblight_sethsv(hue, sat, val); + return state; +} \ No newline at end of file diff --git a/keyboards/cheapino/config.h b/keyboards/cheapino/config.h new file mode 100644 index 00000000000..92c74434293 --- /dev/null +++ b/keyboards/cheapino/config.h @@ -0,0 +1,26 @@ +// Copyright 2023 Thomas Haukland (@tompi) +// Copyright 2026 Arne Moerman (@thearne4) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#define BOTH_SHIFTS_TURNS_ON_CAPS_WORD +#define WS2812_PIO_USE_PIO1 // Force the usage of PIO1 peripheral, by default the WS2812 implementation uses the PIO0 peripheral +#define WS2812_BYTE_ORDER WS2812_BYTE_ORDER_RGB + + +// Pick good defaults for enabling homerow modifiers +#define TAPPING_TERM 230 + +#define WS2812_DI_PIN GP16 // The pin connected to the data pin of the LEDs +#define RGBLIGHT_LED_COUNT 1 // The number of LEDs connected + +// Max number of threads +#define MAX_DEFERRED_EXECUTORS 32 + +// #define DEBUG_MATRIX_SCAN_RATE + +// Avoid very bright default LED +#define RGBLIGHT_DEFAULT_HUE 128 // Sets the default hue value, if none has been set +#define RGBLIGHT_DEFAULT_SAT 128 // Sets the default saturation value, if none has been set +#define RGBLIGHT_DEFAULT_VAL 32 // Sets the default brightness value, if none has been set diff --git a/keyboards/cheapino/encoder.c b/keyboards/cheapino/encoder.c new file mode 100644 index 00000000000..e5920dce49a --- /dev/null +++ b/keyboards/cheapino/encoder.c @@ -0,0 +1,63 @@ +#include "matrix.h" +#include "quantum.h" + +#define COL_SHIFTER ((uint16_t)1) + +#define ENC_ROW 3 +#define ENC_A_COL 2 +#define ENC_B_COL 4 +#define ENC_BUTTON_COL 0 + +static bool colABPressed = false; +static bool encoderPressed = false; + +void clicked(void) { + tap_code(KC_MPLY); +} + +void turned(bool clockwise) { + if (IS_LAYER_ON(6)) { + tap_code(clockwise ? KC_VOLU : KC_VOLD); + } else if (IS_LAYER_ON(3)) { + tap_code16(clockwise ? LCTL(KC_TAB) : LCTL(LSFT(KC_TAB))); + } else if (IS_LAYER_ON(5)) { + tap_code16(clockwise ? LGUI(KC_Y) : LGUI(KC_Z)); + } else { + tap_code16(clockwise ? KC_PGDN : KC_PGUP); + } +} + +void fix_encoder_action(matrix_row_t current_matrix[]) { + matrix_row_t encoder_row = current_matrix[ENC_ROW]; + + if (encoder_row & (COL_SHIFTER << ENC_BUTTON_COL)) { + encoderPressed = true; + } else { + // Only trigger click on release + if (encoderPressed) { + encoderPressed = false; + clicked(); + } + } + + // Check which way the encoder is turned: + bool colA = encoder_row & (COL_SHIFTER << ENC_A_COL); + bool colB = encoder_row & (COL_SHIFTER << ENC_B_COL); + + if (colA && colB) { + colABPressed = true; + } else if (colA) { + if (colABPressed) { + // A+B followed by A means clockwise + colABPressed = false; + turned(true); + } + } else if (colB) { + if (colABPressed) { + // A+B followed by B means counter-clockwise + colABPressed = false; + turned(false); + } + } + current_matrix[ENC_ROW] = 0; +} diff --git a/keyboards/cheapino/encoder.h b/keyboards/cheapino/encoder.h new file mode 100644 index 00000000000..e393e5da2da --- /dev/null +++ b/keyboards/cheapino/encoder.h @@ -0,0 +1,5 @@ +// +// Created by Thomas Haukland on 25/03/2023. +// + +void fix_encoder_action(matrix_row_t current_matrix[]); \ No newline at end of file diff --git a/keyboards/cheapino/ghosting.c b/keyboards/cheapino/ghosting.c new file mode 100644 index 00000000000..c349b0abe19 --- /dev/null +++ b/keyboards/cheapino/ghosting.c @@ -0,0 +1,128 @@ +// +// Created by Thomas Haukland on 2024-05-05. +// + +#include "matrix.h" +#include "quantum.h" +#include "print.h" + +// This is just to be able to declare constants as they appear in the qmk console +#define rev(b) \ + ((b & 1) << 15) | \ + ((b & (1 << 1)) << 13) | \ + ((b & (1 << 2)) << 11) | \ + ((b & (1 << 3)) << 9) | \ + ((b & (1 << 4)) << 7) | \ + ((b & (1 << 5)) << 5) | \ + ((b & (1 << 6)) << 3) | \ + ((b & (1 << 7)) << 1) | \ + ((b & (1 << 8)) >> 1) | \ + ((b & (1 << 9)) >> 3) | \ + ((b & (1 << 10)) >> 5) | \ + ((b & (1 << 11)) >> 7) | \ + ((b & (1 << 12)) >> 9) | \ + ((b & (1 << 13)) >> 11) | \ + ((b & (1 << 14)) >> 13) | \ + b >> 15 + +/* This is for debugging the matrix rows +void printBits(uint16_t n) +{ + long i; + for (i = 15; i >= 0; i--) { + if ((n & (1 << i)) != 0) { + printf("1"); + } + else { + printf("0"); + } + } + printf("\n"); +} +*/ + +bool bit_pattern_set(uint16_t number, uint16_t bitPattern) { + return !(~number & bitPattern); +} + +void fix_ghosting_instance( + matrix_row_t current_matrix[], + unsigned short row_num_with_possible_error_cause, + uint16_t possible_error_cause, + unsigned short row_num_with_possible_error, + uint16_t possible_error, + uint16_t error_fix) { + if (bit_pattern_set(current_matrix[row_num_with_possible_error_cause], possible_error_cause)) { + if (bit_pattern_set(current_matrix[row_num_with_possible_error], possible_error)) { + current_matrix[row_num_with_possible_error] = current_matrix[row_num_with_possible_error] ^ error_fix; + } + } +} + +void fix_ghosting_column( + matrix_row_t matrix[], + uint16_t possible_error_cause, + uint16_t possible_error, + uint16_t error_fix) { + // First the right side + for (short i = 0; i<3; i++) { + fix_ghosting_instance(matrix, i, possible_error_cause, (i+1)%3, possible_error, error_fix); + fix_ghosting_instance(matrix, i, possible_error_cause, (i+2)%3, possible_error, error_fix); + } + + // Then exactly same procedure on the left side + for (short i = 0; i<3; i++) { + fix_ghosting_instance(matrix, i+4, possible_error_cause<<6, 4+((i+1)%3), possible_error<<6, error_fix<<6); + fix_ghosting_instance(matrix, i+4, possible_error_cause<<6, 4+((i+2)%3), possible_error<<6, error_fix<<6); + } +} + +// For QWERTY layout, key combo a+s+e also outputs q. This suppresses the q, and other similar ghosts +// These are observed ghosts(following a pattern). TODO: need to fix this for v3 +// Might need to add 2 diodes(one in each direction) for every row, to increase voltage drop. +void fix_ghosting(matrix_row_t matrix[]) { + fix_ghosting_column(matrix, + rev(0B0110000000000000), + rev(0B1010000000000000), + rev(0B0010000000000000)); + fix_ghosting_column(matrix, + rev(0B0110000000000000), + rev(0B0101000000000000), + rev(0B0100000000000000)); + + fix_ghosting_column(matrix, + rev(0B0001100000000000), + rev(0B0010100000000000), + rev(0B0000100000000000)); + fix_ghosting_column(matrix, + rev(0B0001100000000000), + rev(0B0001010000000000), + rev(0B0001000000000000)); + + fix_ghosting_column(matrix, + rev(0B1000010000000000), + rev(0B1000100000000000), + rev(0B1000000000000000)); + fix_ghosting_column(matrix, + rev(0B1000010000000000), + rev(0B0100010000000000), + rev(0B0000010000000000)); + + fix_ghosting_column(matrix, + rev(0B1001000000000000), + rev(0B0101000000000000), + rev(0B0001000000000000)); + fix_ghosting_column(matrix, + rev(0B1001000000000000), + rev(0B1010000000000000), + rev(0B1000000000000000)); + + fix_ghosting_column(matrix, + rev(0B0100100000000000), + rev(0B0100010000000000), + rev(0B0100000000000000)); + fix_ghosting_column(matrix, + rev(0B0100100000000000), + rev(0B1000100000000000), + rev(0B0000100000000000)); +} diff --git a/keyboards/cheapino/ghosting.h b/keyboards/cheapino/ghosting.h new file mode 100644 index 00000000000..1dfef2af3fd --- /dev/null +++ b/keyboards/cheapino/ghosting.h @@ -0,0 +1,5 @@ +// +// Created by Thomas Haukland on 2024-05-05. +// + +void fix_ghosting(matrix_row_t current_matrix[]); \ No newline at end of file diff --git a/keyboards/cheapino/halconf.h b/keyboards/cheapino/halconf.h new file mode 100644 index 00000000000..76f57357719 --- /dev/null +++ b/keyboards/cheapino/halconf.h @@ -0,0 +1,4 @@ + +#pragma once + +#include_next diff --git a/keyboards/cheapino/keyboard.json b/keyboards/cheapino/keyboard.json new file mode 100644 index 00000000000..af687158141 --- /dev/null +++ b/keyboards/cheapino/keyboard.json @@ -0,0 +1,96 @@ +{ + "manufacturer": "Arne Moerman", + "keyboard_name": "Cheapino2", + "maintainer": "tompi", + "bootloader": "rp2040", + "diode_direction": "ROW2COL", + "features": { + "bootmagic": true, + "command": false, + "console": false, + "extrakey": true, + "mousekey": true, + "nkro": true, + "via": true, + "vial": true + }, + "community_layouts": ["split_3x5_3"], + "matrix_pins": { + "cols": [ + "GP6", + "GP6", + "GP5", + "GP5", + "GP4", + "GP4", + + "GP14", + "GP14", + "GP15", + "GP15", + "GP26", + "GP26" + ], + "rows": ["GP3", "GP1", "GP2", "GP0", "GP27", "GP28", "GP29", "GP8"] + }, + "processor": "RP2040", + "url": "", + "usb": { + "device_version": "1.0.1", + "pid": "0x10B8", + "vid": "0xFEE3", + "force_nkro": false + }, + "layouts": { + "LAYOUT_split_3x5_3": { + "layout": [ + { "matrix": [4, 10], "x": 0, "y": 0.25 }, + { "matrix": [4, 9], "x": 1, "y": 0.125 }, + { "matrix": [4, 8], "x": 2, "y": 0 }, + { "matrix": [4, 7], "x": 3, "y": 0.125 }, + { "matrix": [4, 6], "x": 4, "y": 0.25 }, + + { "matrix": [0, 0], "x": 7, "y": 0.25 }, + { "matrix": [0, 1], "x": 8, "y": 0.125 }, + { "matrix": [0, 2], "x": 9, "y": 0 }, + { "matrix": [0, 3], "x": 10, "y": 0.125 }, + { "matrix": [0, 4], "x": 11, "y": 0.25 }, + + + { "matrix": [5, 10], "x": 0, "y": 1.25 }, + { "matrix": [5, 9], "x": 1, "y": 1.125 }, + { "matrix": [5, 8], "x": 2, "y": 1 }, + { "matrix": [5, 7], "x": 3, "y": 1.125 }, + { "matrix": [5, 6], "x": 4, "y": 1.25 }, + + { "matrix": [1, 0], "x": 7, "y": 1.25 }, + { "matrix": [1, 1], "x": 8, "y": 1.125 }, + { "matrix": [1, 2], "x": 9, "y": 1 }, + { "matrix": [1, 3], "x": 10, "y": 1.125 }, + { "matrix": [1, 4], "x": 11, "y": 1.25 }, + + + { "matrix": [6, 10], "x": 0, "y": 2.25 }, + { "matrix": [6, 9], "x": 1, "y": 2.125 }, + { "matrix": [6, 8], "x": 2, "y": 2 }, + { "matrix": [6, 7], "x": 3, "y": 2.125 }, + { "matrix": [6, 6], "x": 4, "y": 2.25 }, + + { "matrix": [2, 0], "x": 7, "y": 2.25 }, + { "matrix": [2, 1], "x": 8, "y": 2.125 }, + { "matrix": [2, 2], "x": 9, "y": 2 }, + { "matrix": [2, 3], "x": 10, "y": 2.125 }, + { "matrix": [2, 4], "x": 11, "y": 2.25 }, + + + { "matrix": [6, 11], "x": 2.5, "y": 3.25 }, + { "matrix": [5, 11], "x": 3.5, "y": 3.5 }, + { "matrix": [4, 11], "x": 4.5, "y": 3.75 }, + + { "matrix": [0, 5], "x": 6.5, "y": 3.75 }, + { "matrix": [1, 5], "x": 7.5, "y": 3.5 }, + { "matrix": [2, 5], "x": 8.5, "y": 3.25 } + ] + } + } +} diff --git a/keyboards/cheapino/keymaps/default/keymap.json b/keyboards/cheapino/keymaps/default/keymap.json new file mode 100644 index 00000000000..1f2ab54b4a2 --- /dev/null +++ b/keyboards/cheapino/keymaps/default/keymap.json @@ -0,0 +1,163 @@ +{ + "version": 1, + "notes": "Cheapino default keymap", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "keyboard": "bastardkb/skeletyl/blackpill", + "keymap": "default", + "layout": "LAYOUT_split_3x5_3", + "layers": [ + [ + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "KC_A", + "KC_S", + "KC_D", + "KC_F", + "KC_G", + "KC_H", + "KC_J", + "KC_K", + "KC_L", + "KC_SCLN", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_LGUI", + "KC_SPC", + "MO(1)", + "MO(2)", + "KC_ENT", + "KC_RALT" + ], + [ + "KC_1", + "KC_2", + "KC_3", + "KC_4", + "KC_5", + "KC_6", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_LEFT", + "KC_DOWN", + "KC_UP", + "KC_RGHT", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_LGUI", + "KC_SPC", + "KC_TRNS", + "MO(3)", + "KC_ENT", + "KC_RALT" + ], + [ + "KC_EXLM", + "KC_AT", + "KC_HASH", + "KC_DLR", + "KC_PERC", + "KC_CIRC", + "KC_AMPR", + "KC_ASTR", + "KC_LPRN", + "KC_RPRN", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_MINS", + "KC_EQL", + "KC_LBRC", + "KC_RBRC", + "KC_BSLS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_UNDS", + "KC_PLUS", + "KC_LCBR", + "KC_RCBR", + "KC_PIPE", + "KC_LGUI", + "KC_SPC", + "MO(3)", + "KC_TRNS", + "KC_ENT", + "KC_RALT" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RGB_HUI", + "RGB_SAI", + "RGB_VAI", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RGB_HUD", + "RGB_SAD", + "RGB_VAD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_LGUI", + "KC_SPC", + "KC_TRNS", + "KC_TRNS", + "KC_ENT", + "KC_RALT" + ] + ], + "author": "" +} diff --git a/keyboards/cheapino/keymaps/lars/config.h b/keyboards/cheapino/keymaps/lars/config.h new file mode 100644 index 00000000000..4e9af1f6be2 --- /dev/null +++ b/keyboards/cheapino/keymaps/lars/config.h @@ -0,0 +1,51 @@ +/* +Copyright 2020 Pierre Chevalier + +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 2 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 . +*/ + +#pragma once +// Set the mouse settings to a comfortable speed/accuracy trade-off, +// assuming a screen refresh rate of 60 Htz or higher +// The default is 50. This makes the mouse ~3 times faster and more accurate +#define MOUSEKEY_INTERVAL 16 +// The default is 20. Since we made the mouse about 3 times faster with the previous setting, +// give it more time to accelerate to max speed to retain precise control over short distances. +#define MOUSEKEY_TIME_TO_MAX 40 +// The default is 300. Let's try and make this as low as possible while keeping the cursor responsive +#define MOUSEKEY_DELAY 100 +// It makes sense to use the same delay for the mouseweel +#define MOUSEKEY_WHEEL_DELAY 100 +// The default is 100 +#define MOUSEKEY_WHEEL_INTERVAL 50 +// The default is 40 +#define MOUSEKEY_WHEEL_TIME_TO_MAX 100 + +// Pick good defaults for enabling homerow modifiers +#undef TAPPING_TERM +#define TAPPING_TERM 200 +// #define PERMISSIVE_HOLD + +#define TAPPING_FORCE_HOLD +//#define RETRO_TAPPING + +// Underglow configuration +#ifdef RGBLIGHT_ENABLE + #define RGBLIGHT_ANIMATIONS + #define RGBLIGHT_HUE_STEP 8 + #define RGBLIGHT_SAT_STEP 8 + #define RGBLIGHT_VAL_STEP 8 +#endif + +//#define UNICODE_SELECTED_MODES UC_MAC diff --git a/keyboards/cheapino/keymaps/lars/keymap.json b/keyboards/cheapino/keymaps/lars/keymap.json new file mode 100644 index 00000000000..a78df9d539e --- /dev/null +++ b/keyboards/cheapino/keymaps/lars/keymap.json @@ -0,0 +1,125 @@ +{ + "version": 1, + "notes": "My awesome keymap", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "keyboard": "bastardkb/skeletyl/blackpill", + "keymap": "default", + "layout": "LAYOUT_split_3x5_3", + "layers": [ + [ + "KC_Q", + "KC_W", + "KC_F", + "KC_P", + "KC_B", + "KC_J", + "KC_L", + "KC_U", + "KC_Y", + "KC_SCLN", + "KC_A", + "KC_R", + "KC_S", + "KC_T", + "KC_G", + "KC_M", + "KC_N", + "KC_E", + "KC_I", + "KC_O", + "LSFT_T(KC_Z)", + "LCTL_T(KC_X)", + "RALT_T(KC_C)", + "KC_D", + "KC_V", + "KC_K", + "KC_H", + "RALT_T(KC_COMM)", + "LCTL_T(KC_DOT)", + "LSFT_T(KC_SLSH)", + "TO(1)", + "KC_BSPC", + "KC_TAB", + "KC_LGUI", + "KC_SPC", + "KC_ENT" + ], + [ + "KC_TRNS", + "KC_7", + "KC_8", + "KC_9", + "KC_TRNS", + "KC_QUOT", + "KC_MINS", + "KC_EQL", + "KC_ASTR", + "KC_CIRC", + "KC_TRNS", + "KC_4", + "KC_5", + "KC_6", + "KC_0", + "KC_BSLS", + "KC_LPRN", + "KC_RPRN", + "KC_LBRC", + "KC_RBRC", + "KC_LSFT", + "KC_1", + "KC_2", + "KC_3", + "KC_TRNS", + "KC_PIPE", + "KC_GRV", + "KC_LALT", + "KC_LCTL", + "KC_RSFT", + "TO(2)", + "KC_BSPC", + "KC_TAB", + "KC_DEL", + "TO(0)", + "KC_ENT" + ], + [ + "KC_TRNS", + "KC_TRNS", + "KC_PGUP", + "KC_TRNS", + "KC_TRNS", + "ANY(UC(0xE6))", + "ANY(UC(0xF8))", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_LEFT", + "KC_UP", + "KC_DOWN", + "KC_RGHT", + "KC_TRNS", + "KC_TRNS", + "KC_LGUI", + "ANY(UC(0xE5))", + "LCTL(KC_LALT)", + "LCA(KC_LSFT)", + "KC_TRNS", + "KC_HOME", + "KC_PGDN", + "KC_END", + "KC_TRNS", + "KC_TRNS", + "KC_RBRC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TAB", + "KC_DEL", + "TO(0)", + "KC_TRNS" + ] + ], + "author": "thomas.haukland@gmail.com" +} diff --git a/keyboards/cheapino/keymaps/thearne4/keymap.json b/keyboards/cheapino/keymaps/thearne4/keymap.json new file mode 100644 index 00000000000..c81f3a13c5d --- /dev/null +++ b/keyboards/cheapino/keymaps/thearne4/keymap.json @@ -0,0 +1,239 @@ +{ + "documentation": "\"This file is a QMK Configurator export. It is based around Windows being set to azerty-be . You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "notes": "TheArne4 keymap", + "version": 1, + "keyboard": "bastardkb/skeletyl/blackpill", + "keymap": "thearne4", + "layout": "LAYOUT_split_3x5_3", + "layers": [ + [ + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "LGUI_T(KC_A)", + "LALT_T(KC_S)", + "LSFT_T(KC_D)", + "LCTL_T(KC_F)", + "KC_G", + "KC_H", + "LCTL_T(KC_J)", + "RSFT_T(KC_K)", + "LALT_T(KC_L)", + "LGUI_T(KC_SCLN)", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "LT(5,KC_B)", + "LT(1,KC_N)", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "LT(4,KC_ESC)", + "LT(3,KC_ENT)", + "LT(2,KC_TAB)", + "LT(2,KC_BSPC)", + "LT(3,KC_SPC)", + "LT(4,KC_DEL)" + ], + [ + "KC_A", + "KC_Z", + "KC_F", + "KC_P", + "KC_B", + "KC_J", + "KC_L", + "KC_U", + "KC_Y", + "KC_SLSH", + "LGUI_T(KC_Q)", + "LALT_T(KC_R)", + "LSFT(KC_S)", + "LCTL(KC_T)", + "KC_G", + "KC_SCLN", + "RCTL_T(KC_N)", + "RSFT_T(KC_E)", + "LALT_T(KC_I)", + "RGUI_T(KC_O)", + "KC_W", + "KC_X", + "KC_C", + "KC_D", + "RALT_T(KC_V)", + "RALT_T(KC_K)", + "KC_H", + "KC_M", + "KC_COMM", + "KC_DOT", + "LT(4,KC_ESC)", + "LT(3,KC_ENT)", + "LT(2,KC_TAB)", + "LT(2,KC_BSPC)", + "LT(3,KC_SPC)", + "LT(4,KC_DEL)" + ], + [ + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F6", + "KC_F7", + "KC_F8", + "KC_F9", + "KC_F10", + "LGUI_T(KC_1)", + "LALT_T(KC_2)", + "LSFT_T(KC_3)", + "LCTL_T(KC_4)", + "KC_5", + "KC_6", + "RCTL_T(KC_7)", + "RSFT_T(KC_8)", + "LALT_T(KC_9)", + "RGUI_T(KC_0)", + "KC_GRV", + "KC_LBRC", + "KC_RBRC", + "KC_QUOT", + "RALT_T(KC_NUHS)", + "RALT_T(KC_CAPS)", + "KC_MINS", + "KC_EQL", + "KC_F11", + "KC_F12", + "KC_ESC", + "KC_ENT", + "KC_TAB", + "KC_BSPC", + "KC_SPC", + "KC_DEL" + ], + [ + "LSFT(KC_NUBS)", + "RALT(KC_1)", + "RALT(KC_LBRC)", + "RALT(KC_RBRC)", + "RALT(KC_NUBS)", + "KC_INS", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "KC_PAUS", + "LGUI_T(KC_NUBS)", + "LALT_T(KC_1)", + "LSFT_T(KC_5)", + "LCTL_T(KC_MINS)", + "RALT(KC_2)", + "KC_HASH", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "KC_SCRL", + "RALT(KC_QUOT)", + "RALT(KC_NUHS)", + "RALT(KC_9)", + "RALT(KC_0)", + "RALT(KC_3)", + "RSFT(KC_RBRC)", + "KC_QUOT", + "RSFT(KC_EQL)", + "KC_PGDN", + "TO(5)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO" + ], + [ + "KC_WBAK", + "MS_WHLU", + "MS_UP", + "MS_BTN2", + "KC_WFWD", + "KC_PAST", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PPLS", + "MS_WHLL", + "MS_LEFT", + "MS_BTN1", + "MS_RGHT", + "MS_WHLR", + "KC_PSLS", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PMNS", + "KC_TRNS", + "MS_WHLD", + "MS_DOWN", + "MS_BTN3", + "TO(0)", + "KC_P0", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PDOT", + "KC_ESC", + "KC_ENT", + "KC_TAB", + "KC_BSPC", + "KC_SPC", + "KC_DEL" + ], + [ + "KC_F13", + "KC_F14", + "KC_F15", + "KC_F16", + "KC_F17", + "KC_F18", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F22", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_MSTP", + "KC_MPLY", + "KC_VOLU", + "KC_MUTE", + "KC_NO", + "TO(4)", + "KC_NO", + "KC_CALC", + "KC_MAIL", + "TO(0)", + "KC_MPRV", + "KC_MNXT", + "KC_VOLD", + "KC_F23", + "KC_F24", + "KC_ESC", + "KC_ENT", + "KC_TAB", + "KC_BSPC", + "KC_SPC", + "KC_DEL" + ] + ], + "author": "cheapino@arnemoerman.be" +} \ No newline at end of file diff --git a/keyboards/cheapino/keymaps/tompi/keymap.json b/keyboards/cheapino/keymaps/tompi/keymap.json new file mode 100644 index 00000000000..6930a239cec --- /dev/null +++ b/keyboards/cheapino/keymaps/tompi/keymap.json @@ -0,0 +1,277 @@ +{ + "version": 1, + "notes": "Tompi keymap", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "keyboard": "bastardkb/skeletyl/blackpill", + "keymap": "tompi", + "layout": "LAYOUT_split_3x5_3", + "layers": [ + [ + "KC_Q", + "KC_W", + "KC_F", + "KC_P", + "KC_B", + "KC_J", + "KC_L", + "KC_U", + "KC_Y", + "KC_SCLN", + "LGUI_T(KC_A)", + "LALT_T(KC_R)", + "LCTL_T(KC_S)", + "LSFT_T(KC_T)", + "KC_G", + "KC_M", + "RSFT_T(KC_N)", + "LCTL_T(KC_E)", + "LALT_T(KC_I)", + "LGUI_T(KC_O)", + "KC_Z", + "KC_X", + "KC_C", + "KC_D", + "LT(5,KC_V)", + "LT(1,KC_K)", + "KC_H", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "LT(6,KC_ESC)", + "LT(3,KC_SPC)", + "LT(5,KC_TAB)", + "LT(1,KC_DEL)", + "LT(2,KC_BSPC)", + "LT(4,KC_ENT)" + ], + [ + "KC_VOLU", + "KC_WH_L", + "KC_NO", + "KC_WH_U", + "KC_WH_R", + "KC_NO", + "KC_NO", + "KC_NO", + "QK_CLEAR_EEPROM", + "ANY(QK_RBT)", + "KC_NO", + "KC_MS_L", + "KC_MS_U", + "KC_MS_R", + "KC_MUTE", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_VOLD", + "KC_MNXT", + "KC_MS_D", + "KC_WH_D", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "NK_TOGG", + "KC_HOME", + "KC_DEL", + "KC_PGUP", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_LEFT", + "KC_UP", + "KC_RGHT", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "KC_NO", + "KC_NO", + "KC_BTN1", + "KC_BTN2", + "KC_BTN3", + "KC_BTN4", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_WH_U", + "KC_AT", + "KC_UNDS", + "KC_PIPE", + "KC_GRV", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "RGB_TOG", + "KC_HASH", + "KC_TAB", + "KC_EXLM", + "KC_DQUO", + "KC_DLR", + "KC_BTN4", + "KC_BTN3", + "KC_BTN2", + "KC_BTN1", + "KC_WH_D", + "KC_TILD", + "KC_QUOT", + "KC_BSLS", + "KC_SLSH", + "KC_AMPR", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO" + ], + [ + "KC_GRV", + "KC_CIRC", + "KC_LT", + "KC_GT", + "KC_SCLN", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_LCBR", + "KC_RCBR", + "KC_LPRN", + "KC_RPRN", + "KC_AT", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_MINS", + "KC_EXLM", + "KC_LBRC", + "KC_RBRC", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_NO" + ], + [ + "ANY(QK_RBT)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_F7", + "KC_F8", + "KC_F9", + "KC_F10", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_F4", + "KC_F5", + "KC_F6", + "KC_F11", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F12", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "RGB_SPI", + "RGB_VAI", + "RGB_SAI", + "RGB_HUI", + "RGB_MOD", + "KC_PPLS", + "KC_7", + "KC_8", + "KC_9", + "KC_PAST", + "EE_CLR", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "RGB_TOG", + "KC_PMNS", + "KC_4", + "KC_5", + "KC_6", + "KC_PSLS", + "RGB_SPD", + "RGB_VAD", + "RGB_SAD", + "RGB_HUD", + "RGB_RMOD", + "KC_PDOT", + "KC_1", + "KC_2", + "KC_3", + "KC_PEQL", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_0", + "KC_COMM", + "KC_0" + ] + ], + "author": "thomas.haukland@gmail.com" +} diff --git a/keyboards/cheapino/keymaps/via/keymap.json b/keyboards/cheapino/keymaps/via/keymap.json new file mode 100644 index 00000000000..5167b7956c4 --- /dev/null +++ b/keyboards/cheapino/keymaps/via/keymap.json @@ -0,0 +1,163 @@ +{ + "version": 1, + "notes": "Cheapino default keymap", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "keyboard": "bastardkb/skeletyl/blackpill", + "keymap": "via", + "layout": "LAYOUT_split_3x5_3", + "layers": [ + [ + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "LGUI_T(KC_A)", + "LALT_T(KC_S)", + "LCTL_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "LCTL_T(KC_K)", + "LALT_T(KC_L)", + "LGUI_T(KC_SCLN)", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "LT(5,KC_B)", + "LT(1,KC_N)", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "LT(6,KC_ESC)", + "LT(3,KC_SPC)", + "LT(5,KC_TAB)", + "LT(1,KC_DEL)", + "LT(2,KC_BSPC)", + "LT(4,KC_ENT)" + ], + [ + "KC_VOLU", + "KC_WH_L", + "KC_MS_U", + "KC_WH_U", + "KC_WH_R", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "ANY(QK_RBT)", + "KC_MS_L", + "KC_BTN2", + "KC_BTN1", + "KC_MS_R", + "KC_MUTE", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_VOLD", + "KC_MNXT", + "KC_MS_D", + "KC_WH_D", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_HOME", + "KC_DEL", + "KC_PGUP", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_LEFT", + "KC_UP", + "KC_RGHT", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "KC_NO", + "KC_NO", + "KC_BTN1", + "KC_BTN2", + "KC_BTN3", + "KC_BTN4", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_WH_U", + "KC_AT", + "KC_UNDS", + "KC_PIPE", + "KC_GRV", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "RGB_TOG", + "KC_HASH", + "KC_TAB", + "KC_EXLM", + "KC_DQUO", + "KC_DLR", + "KC_BTN4", + "KC_BTN3", + "KC_BTN2", + "KC_BTN1", + "KC_WH_D", + "KC_TILD", + "KC_QUOT", + "KC_BSLS", + "KC_SLSH", + "KC_AMPR", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO" + ] + ], + "author": "thomas.haukland@gmail.com" +} diff --git a/keyboards/cheapino/keymaps/vial/config.h b/keyboards/cheapino/keymaps/vial/config.h new file mode 100644 index 00000000000..30395037582 --- /dev/null +++ b/keyboards/cheapino/keymaps/vial/config.h @@ -0,0 +1,5 @@ +#pragma once + +#define VIAL_KEYBOARD_UID {0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6} +#define VIAL_UNLOCK_COMBO_ROWS {0, 0} +#define VIAL_UNLOCK_COMBO_COLS {0, 1} \ No newline at end of file diff --git a/keyboards/cheapino/keymaps/vial/keymap.json b/keyboards/cheapino/keymaps/vial/keymap.json new file mode 100644 index 00000000000..ad38b2e0289 --- /dev/null +++ b/keyboards/cheapino/keymaps/vial/keymap.json @@ -0,0 +1,49 @@ +{ + "documentation": "\"This file is a QMK Configurator export. It is based around Windows being set to azerty-be . You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "notes": "TheArne4 keymap", + "version": 1, + "keyboard": "bastardkb/skeletyl/blackpill", + "keymap": "vial", + "layout": "LAYOUT_split_3x5_3", + "layers": [ + [ + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "LGUI_T(KC_A)", + "LALT_T(KC_S)", + "LSFT_T(KC_D)", + "LCTL_T(KC_F)", + "KC_G", + "KC_H", + "LCTL_T(KC_J)", + "RSFT_T(KC_K)", + "LALT_T(KC_L)", + "LGUI_T(KC_SCLN)", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "RALT_T(KC_B)", + "RALT_T(KC_N)", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_ESC", + "KC_ENT", + "KC_TAB", + "KC_BSPC", + "KC_SPC", + "KC_DEL" + ] + ], + "author": "cheapino@arnemoerman.be" +} \ No newline at end of file diff --git a/keyboards/cheapino/keymaps/vial/vial.json b/keyboards/cheapino/keymaps/vial/vial.json new file mode 100644 index 00000000000..00f96259488 --- /dev/null +++ b/keyboards/cheapino/keymaps/vial/vial.json @@ -0,0 +1,18 @@ +{ + "name": "TheArne4 Cheapino2", + "vendorId": "0xFEE3", + "productId": "0x10B8", + "lighting": "vialrgb", + "matrix": { + "rows": 8, + "cols": 12 + }, + "layouts": { + "keymap": [ + ["0,0", "0,1", "0,2", "0,3", "0,4", {"x": 2}, "4,10", "4,9", "4,8", "4,7", "4,6"], + ["1,0", "1,1", "1,2", "1,3", "1,4", {"x": 2}, "5,10", "5,9", "5,8", "5,7", "5,6"], + ["2,0", "2,1", "2,2", "2,3", "2,4", {"x": 2}, "6,10", "6,9", "6,8", "6,7", "6,6"], + [{"x": 1.5}, "0,5", "1,5", "2,5", {"x": 1}, "6,11", "5,11", "4,11"] + ] + } +} \ No newline at end of file diff --git a/keyboards/cheapino/matrix.c b/keyboards/cheapino/matrix.c new file mode 100644 index 00000000000..f6f518318b2 --- /dev/null +++ b/keyboards/cheapino/matrix.c @@ -0,0 +1,152 @@ +/* +Copyright 2012 Jun Wako +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 2 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 . + + Copied from here: https://github.com/e3w2q/qmk_firmware/blob/762fe3e0a7cbea768245a75520f06ff5a2f00b9f/keyboards/2x3test/matrix.c +*/ + +/* + * scan matrix + */ +#include +#include +#include "wait.h" +#include "util.h" +#include "matrix.h" +#include "config.h" +#include "quantum.h" +#include "debounce.h" +#include "encoder.h" +#include "ghosting.h" +#include "print.h" + +// How long the scanning code waits for changed io to settle. +// Adjust from default 30 to weigh up for increased time spent ghost-hunting. +// (the rp2040 does not seem to have any problems with this value...) +#define MATRIX_IO_DELAY 25 + +#define COL_SHIFTER ((uint16_t)1) + +static const pin_t row_pins[] = MATRIX_ROW_PINS; +static const pin_t col_pins[] = MATRIX_COL_PINS; +static matrix_row_t previous_matrix[MATRIX_ROWS]; + +static void select_row(uint8_t row) { + setPinOutput(row_pins[row]); + writePinLow(row_pins[row]); +} + +static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); } + +static void unselect_rows(void) { + for (uint8_t x = 0; x < MATRIX_ROWS; x++) { + setPinInputHigh(row_pins[x]); + } +} + +static void select_col(uint8_t col) { + setPinOutput(col_pins[col]); + writePinLow(col_pins[col]); +} + +static void unselect_col(uint8_t col) { + setPinInputHigh(col_pins[col]); +} + +static void unselect_cols(void) { + for (uint8_t x = 0; x < MATRIX_COLS/2; x++) { + setPinInputHigh(col_pins[x*2]); + } +} + +static void read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { + // Select row and wait for row selection to stabilize + select_row(current_row); + wait_us(MATRIX_IO_DELAY); + + // For each col... + for (uint8_t col_index = 0; col_index < MATRIX_COLS / 2; col_index++) { + uint16_t column_index_bitmask = COL_SHIFTER << ((col_index * 2) + 1); + // Check row pin state + if (readPin(col_pins[col_index*2])) { + // Pin HI, clear col bit + current_matrix[current_row] &= ~column_index_bitmask; + } else { + // Pin LO, set col bit + current_matrix[current_row] |= column_index_bitmask; + } + } + + // Unselect row + unselect_row(current_row); +} + +static void read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) { + // Select col and wait for col selection to stabilize + select_col(current_col*2); + wait_us(MATRIX_IO_DELAY); + + uint16_t column_index_bitmask = COL_SHIFTER << (current_col * 2); + // For each row... + for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) { + // Check row pin state + if (readPin(row_pins[row_index])) { + // Pin HI, clear col bit + current_matrix[row_index] &= ~column_index_bitmask; + } else { + // Pin LO, set col bit + current_matrix[row_index] |= column_index_bitmask; + } + } + // Unselect col + unselect_col(current_col*2); +} + + +void matrix_init_custom(void) { + // initialize key pins + unselect_cols(); + unselect_rows(); + debounce_init(MATRIX_ROWS); +} + +void store_old_matrix(matrix_row_t current_matrix[]) { + for (uint8_t i = 0; i < MATRIX_ROWS; i++) { + previous_matrix[i] = current_matrix[i]; + } +} + +bool has_matrix_changed(matrix_row_t current_matrix[]) { + for (uint8_t i = 0; i < MATRIX_ROWS; i++) { + if (previous_matrix[i] != current_matrix[i]) return true; + } + return false; +} + +bool matrix_scan_custom(matrix_row_t current_matrix[]) { + store_old_matrix(current_matrix); + // Set row, read cols + for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) { + read_cols_on_row(current_matrix, current_row); + } + // Set col, read rows + for (uint8_t current_col = 0; current_col < MATRIX_COLS/2; current_col++) { + read_rows_on_col(current_matrix, current_col); + } + + fix_encoder_action(current_matrix); + + fix_ghosting(current_matrix); + + return has_matrix_changed(current_matrix); +} + diff --git a/keyboards/cheapino/mcuconf.h b/keyboards/cheapino/mcuconf.h new file mode 100644 index 00000000000..fce64fa805d --- /dev/null +++ b/keyboards/cheapino/mcuconf.h @@ -0,0 +1,4 @@ +#pragma once + +#include_next + diff --git a/keyboards/cheapino/readme.md b/keyboards/cheapino/readme.md new file mode 100644 index 00000000000..c65c6f2bcde --- /dev/null +++ b/keyboards/cheapino/readme.md @@ -0,0 +1,28 @@ +# cheapino + +![cheapino](imgur.com image replace me!) + +*A short description of the keyboard/project* + +* Keyboard Maintainer: [Thomas Haukland](https://github.com/tompi) +* Keyboard Builder: [Arne Moerman](https://github.com/thearne4) +* Hardware Supported: *The PCBs, controllers supported* +* Hardware Availability: *Links to where you can find this hardware* + +Make example for this keyboard (after setting up your build environment): + + make cheapino:default + +Flashing example for this keyboard: + + make cheapino:default:flash + +See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). + +## Bootloader + +Enter the bootloader in 3 ways: + +* **Bootmagic reset**: Hold down the key at (0,0) in the matrix (usually the top left key or Escape) and plug in the keyboard +* **Physical reset button**: Briefly press the button on the back of the PCB - some may have pads you must short instead +* **Keycode in layout**: Press the key mapped to `QK_BOOT` if it is available diff --git a/keyboards/cheapino/rules.mk b/keyboards/cheapino/rules.mk new file mode 100644 index 00000000000..70ed45868bc --- /dev/null +++ b/keyboards/cheapino/rules.mk @@ -0,0 +1,8 @@ +CAPS_WORD_ENABLE = yes +CUSTOM_MATRIX = lite +WS2812_DRIVER = vendor +RGBLIGHT_ENABLE = yes +DEFERRED_EXEC_ENABLE = yes +SRC += encoder.c +SRC += ghosting.c +SRC += matrix.c \ No newline at end of file