andrejl
/
qmk-dactyl-manuform-a
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

dumbpad refactor - adding support for various PCB revisions (#9259) 

* Placeholder commit - Refactored to support different PCB revisions

Individual revision folders still need:
-  info.json
-  readme.md

all v0x folders support up to two LEDs for layer indication

all v1x folders support up to two LEDs for layer indication
plus one extra LED for numlock indication

v0x - supports single-encoder v0.x PCB revisions

v0x_right - supports reversible, single-encoder v0.x PCB revisions

v0x_dualencoder - supports dual-encoder v0.x PCB revisions

v1x - supports single-encoder v1.x PCB revisiions

v1x_right - supports reversible, single-encoder v1.x PCB revisions

* Added info.json and readme.md files for all dumbpad revisions

* More refactoring, adding shared config.h and rules.mk

Removed config.h from default keymap folders - defining TAPPING_TOGGLE in config.h

* Minor formatting fix

* MATRIX_COL_PINS for v1x_right was not reversed - changed to match v0x_right

* adding support for v1x dual encoder PCB

* adding alt-f2 tapdance routine for personal keymaps

* adding dumbpad build using teensy 2.0 instead of Pro Micro

* matched v1x dumbpad encoder and led pins to latest PCB revisions

* updated readme, removed v1x_teensy until someone requests it

* changed device name to match tmk udev rules, removed unnecessary ifdef

* removed user keymaps and folders

* missed hotdox keymap - removing

* fixing info.json keyboard_names for all versions

* Changed biton32 to get_highest_layer in keyboards/dumbpad/v0x/v0x.c

* keyboards/dumbpad/v0x/v0x.c - remove matrix_scan_kb, process_record_kb

* /dumbpad/v0x/keymaps/default/keymap.c - remove empty functions

* /dumbpad/v0x/keymaps/default/keymap.c - changed biton32 to get_highest_layer

* keyboards/dumbpad/v0x_dualencoder/keymaps/default/keymap.c - remove empty functions

* keyboards/dumbpad/v0x_right/readme.md - smaller board layout image

* keyboards/dumbpad/v1x_dualencoder/readme.md - smaller board image

* keyboards/dumbpad/v1x/readme.md - smaller board image

* keyboards/dumbpad/v1x_right/readme.md - smaller board image

* Update keyboards/dumbpad/rules.mk

* Apply suggestions from code review

Batch applying suggestions from review

* fixed removal of led_set_kb

* Implementing requested changes from old pull request 9259

* removing unused rules

* removed rules.mk from dumbpad base folder

* adding templates for each layout

* testing default keymap json

* Testing applying default keymap for dumbpad

* Layout correction: v1.x are 17 position pcb's

* Update keyboards/dumbpad/v0x/rules.mk

* Update keyboards/dumbpad/v0x/rules.mk

* Update keyboards/dumbpad/v0x_dualencoder/keymaps/default/keymap.c

* Update keyboards/dumbpad/v0x_dualencoder/rules.mk

* Update keyboards/dumbpad/v0x_dualencoder/rules.mk

* Update keyboards/dumbpad/v1x_dualencoder/rules.mk

* Update keyboards/dumbpad/v1x_dualencoder/templates/keymap.c

* Update keyboards/dumbpad/v1x_right/rules.mk

* Update keyboards/dumbpad/v1x_right/rules.mk

* Update keyboards/dumbpad/rules.mk

* Update keyboards/dumbpad/v0x_dualencoder/templates/keymap.c

* Update keyboards/dumbpad/v0x_right/rules.mk

* Update keyboards/dumbpad/v1x/rules.mk

* Update keyboards/dumbpad/v1x/rules.mk

* Update keyboards/dumbpad/v1x_dualencoder/keymaps/default/keymap.c

* Update keyboards/dumbpad/v1x_dualencoder/rules.mk

* Update keyboards/dumbpad/v0x_right/rules.mk

* Removing binary files
master
imchipwood 2021-03-04 20:25:19 -08:00 committed by GitHub
parent 2cb0b41ce7
commit d7aa245c33
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
57 changed files with 2106 additions and 665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
keyboards/dumbpad/config.h
View File

@ -1,5 +1,5 @@
/*
Copyright 2019 imchipwood
Copyright 2020 imchipwood
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
@ -14,218 +14,21 @@ 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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define VENDOR_ID 0xDEAF
#define VENDOR_ID 0xFEED
#define PRODUCT_ID 0x0913
#define DEVICE_VER 0x0001
#define MANUFACTURER imchipwood
#define PRODUCT dumbpad
/*
* Keyboard Matrix Assignments
*
* Change this to how you wired your keyboard
* COLS: AVR pins used for columns, left to right
* ROWS: AVR pins used for rows, top to bottom
* DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
*
*/
#define MATRIX_ROWS 4
#define MATRIX_COLS 5
#define MATRIX_ROW_PINS { F4, F5, F6, F7 }
#define MATRIX_COL_PINS { C6, D7, E6, B4, B5 }
#define UNUSED_PINS
/* COL2ROW, ROW2COL*/
/* Column/Row IO definitions */
#define DIODE_DIRECTION COL2ROW
/* Rotary encoder */
#define ENCODERS_PAD_A { D0 }
#define ENCODERS_PAD_B { D4 }
/* LED layer indicators */
#define LAYER_INDICATOR_LED_0 B3
#define LAYER_INDICATOR_LED_1 B1
/* Bootmagic - hold down rotary encoder pushbutton while plugging in to enter bootloader */
#define BOOTMAGIC_LITE_ROW 3
#define BOOTMAGIC_LITE_COLUMN 0
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5
/* define if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST
/* number of backlight levels */
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
//#define LOCKING_SUPPORT_ENABLE
/* Locking resynchronize hack */
//#define LOCKING_RESYNC_ENABLE
/*
* Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN.
*/
//#define SOFT_SERIAL_PIN D0 // or D1, D2, D3, E6
// #define BACKLIGHT_PIN B7
// #define BACKLIGHT_BREATHING
// #define BACKLIGHT_LEVELS 3
// #define RGB_DI_PIN E2
// #ifdef RGB_DI_PIN
// #define RGBLED_NUM 16
// #define RGBLIGHT_HUE_STEP 8
// #define RGBLIGHT_SAT_STEP 8
// #define RGBLIGHT_VAL_STEP 8
// #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
// #define RGBLIGHT_SLEEP /* If defined, the RGB lighting will be switched off when the host goes to sleep */
// /*== all animations enable ==*/
// #define RGBLIGHT_ANIMATIONS
// /*== or choose animations ==*/
// #define RGBLIGHT_EFFECT_BREATHING
// #define RGBLIGHT_EFFECT_RAINBOW_MOOD
// #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
// #define RGBLIGHT_EFFECT_SNAKE
// #define RGBLIGHT_EFFECT_KNIGHT
// #define RGBLIGHT_EFFECT_CHRISTMAS
// #define RGBLIGHT_EFFECT_STATIC_GRADIENT
// #define RGBLIGHT_EFFECT_RGB_TEST
// #define RGBLIGHT_EFFECT_ALTERNATING
// /*== customize breathing effect ==*/
// /*==== (DEFAULT) use fixed table instead of exp() and sin() ====*/
// #define RGBLIGHT_BREATHE_TABLE_SIZE 256 // 256(default) or 128 or 64
// /*==== use exp() and sin() ====*/
// #define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85 // 1 to 2.7
// #define RGBLIGHT_EFFECT_BREATHE_MAX 255 // 0 to 255
// #endif
/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
* This is userful for the Windows task manager shortcut (ctrl+shift+esc).
*/
// #define GRAVE_ESC_CTRL_OVERRIDE
/*
* Force NKRO
*
* Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
* state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
* makefile for this to work.)
*
* If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
* until the next keyboard reset.
*
* NKRO may prevent your keystrokes from being detected in the BIOS, but it is
* fully operational during normal computer usage.
*
* For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
* or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
* bootmagic, NKRO mode will always be enabled until it is toggled again during a
* power-up.
*
*/
//#define FORCE_NKRO
/*
* Magic Key Options
*
* Magic keys are hotkey commands that allow control over firmware functions of
* the keyboard. They are best used in combination with the HID Listen program,
* found here: https://www.pjrc.com/teensy/hid_listen.html
*
* The options below allow the magic key functionality to be changed. This is
* useful if your keyboard/keypad is missing keys and you want magic key support.
*
*/
/* key combination for magic key command */
/* defined by default; to change, uncomment and set to the combination you want */
// #define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
/* control how magic key switches layers */
//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS true
//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS true
//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
/* override magic key keymap */
//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
//#define MAGIC_KEY_HELP H
//#define MAGIC_KEY_HELP_ALT SLASH
//#define MAGIC_KEY_DEBUG D
//#define MAGIC_KEY_DEBUG_MATRIX X
//#define MAGIC_KEY_DEBUG_KBD K
//#define MAGIC_KEY_DEBUG_MOUSE M
//#define MAGIC_KEY_VERSION V
//#define MAGIC_KEY_STATUS S
//#define MAGIC_KEY_CONSOLE C
//#define MAGIC_KEY_LAYER0 0
//#define MAGIC_KEY_LAYER0_ALT GRAVE
//#define MAGIC_KEY_LAYER1 1
//#define MAGIC_KEY_LAYER2 2
//#define MAGIC_KEY_LAYER3 3
//#define MAGIC_KEY_LAYER4 4
//#define MAGIC_KEY_LAYER5 5
//#define MAGIC_KEY_LAYER6 6
//#define MAGIC_KEY_LAYER7 7
//#define MAGIC_KEY_LAYER8 8
//#define MAGIC_KEY_LAYER9 9
//#define MAGIC_KEY_BOOTLOADER B
//#define MAGIC_KEY_BOOTLOADER_ALT ESC
//#define MAGIC_KEY_LOCK CAPS
//#define MAGIC_KEY_EEPROM E
//#define MAGIC_KEY_EEPROM_CLEAR BSPACE
//#define MAGIC_KEY_NKRO N
//#define MAGIC_KEY_SLEEP_LED Z
/*
* Feature disable options
* These options are also useful to firmware size reduction.
*/
/* disable debug print */
//#define NO_DEBUG
/* disable print */
//#define NO_PRINT
/* disable action features */
//#define NO_ACTION_LAYER
//#define NO_ACTION_TAPPING
//#define NO_ACTION_ONESHOT
//#define NO_ACTION_MACRO
//#define NO_ACTION_FUNCTION
/*
* MIDI options
*/
/* enable basic MIDI features:
- MIDI notes can be sent when in Music mode is on
*/
//#define MIDI_BASIC
/* enable advanced MIDI features:
- MIDI notes can be added to the keymap
- Octave shift and transpose
- Virtual sustain, portamento, and modulation wheel
- etc.
*/
//#define MIDI_ADVANCED
/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
//#define MIDI_TONE_KEYCODE_OCTAVES 1
/* Bootmagic Lite key configuration */
// #define BOOTMAGIC_LITE_ROW 0
// #define BOOTMAGIC_LITE_COLUMN 0
/* Reduce tapdance required taps from 5 to 2 */
#define TAPPING_TOGGLE 2

83
keyboards/dumbpad/dumbpad.c
View File

@ -1,83 +0,0 @@
/* Copyright 2019 Chip
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "dumbpad.h"
void keyboard_pre_init_kb(void) {
// Set the layer LED IO as outputs
setPinOutput(LAYER_INDICATOR_LED_0);
setPinOutput(LAYER_INDICATOR_LED_1);
keyboard_pre_init_user();
}
void shutdown_user() {
// Shutdown the layer LEDs
writePinLow(LAYER_INDICATOR_LED_0);
writePinLow(LAYER_INDICATOR_LED_1);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = biton32(state);
writePin(LAYER_INDICATOR_LED_0, layer & 0b1);
writePin(LAYER_INDICATOR_LED_1, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
for (int i = 0; i < 2; i++) {
writePin(LAYER_INDICATOR_LED_0, true);
writePin(LAYER_INDICATOR_LED_1, false);
wait_ms(100);
writePin(LAYER_INDICATOR_LED_0, true);
writePin(LAYER_INDICATOR_LED_1, true);
wait_ms(100);
writePin(LAYER_INDICATOR_LED_0, false);
writePin(LAYER_INDICATOR_LED_1, true);
wait_ms(100);
writePin(LAYER_INDICATOR_LED_0, false);
writePin(LAYER_INDICATOR_LED_1, false);
wait_ms(100);
}
matrix_init_user();
}
void matrix_scan_kb(void) {
// put your looping keyboard code here
// runs every cycle (a lot)
matrix_scan_user();
}
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here
// runs for every action, just before processing by the firmware
return process_record_user(keycode, record);
}
void led_set_kb(uint8_t usb_led) {
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
led_set_user(usb_led);
}

30
keyboards/dumbpad/info.json
View File

@ -1,30 +0,0 @@
{
"keyboard_name": "dumbpad",
"url": "",
"maintainer": "qmk",
"width": 5,
"height": 4,
"layouts": {
"LAYOUT": {
"layout": [
{"label":"7", "x":1, "y":0},
{"label":"8", "x":2, "y":0},
{"label":"9", "x":3, "y":0},
{"label":"BSPC", "x":4, "y":0},
{"label":"4", "x":1, "y":1},
{"label":"5", "x":2, "y":1},
{"label":"6", "x":3, "y":1},
{"label":"ESC", "x":4, "y":1},
{"label":"1", "x":1, "y":2},
{"label":"2", "x":2, "y":2},
{"label":"3", "x":3, "y":2},
{"label":"TAB", "x":4, "y":2},
{"label":"LMOUSE", "x":0, "y":3},
{"label":"TT(2)", "x":1, "y":3},
{"label":"0", "x":2, "y":3},
{"label":".", "x":3, "y":3},
{"label":"ENT", "x":4, "y":3}
]
}
}
}

2
keyboards/dumbpad/keymaps/default/config.h
View File

@ -1,2 +0,0 @@
#pragma once
#define TAPPING_TOGGLE 2

121
keyboards/dumbpad/keymaps/default/keymap.c
View File

@ -1,121 +0,0 @@
/* Copyright 2019 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
#define _BASE 0
#define _SUB 1
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/-----------------------------------------------------`
| | 7 | 8 | 9 | Bkspc |
| |---------|---------|---------|---------|
| | 4 | 5 | 6 | Esc |
| |---------|---------|---------|---------|
| | 1 | 2 | 3 | Tab |
|-------------|---------|---------|---------|---------|
| Left mouse | TT(SUB) | 0 | . | Enter |
\-----------------------------------------------------'
*/
[_BASE] = LAYOUT(
KC_7, KC_8, KC_9, KC_BSPC,
KC_4, KC_5, KC_6, KC_ESC,
KC_1, KC_2, KC_3, KC_TAB,
KC_BTN1, TT(_SUB), KC_0, KC_DOT, KC_ENTER
),
/*
SUB LAYER
/-----------------------------------------------------`
| | | | | Reset |
| |---------|---------|---------|---------|
| | | | | + |
| |---------|---------|---------|---------|
| | | | | - |
|-------------|---------|---------|---------|---------|
| LOCK | | | | = |
\-----------------------------------------------------'
*/
[_SUB] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, KC_KP_PLUS,
_______, _______, _______, KC_KP_MINUS,
KC_LOCK, _______, _______, _______, KC_EQL
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
//debug_enable = true;
//debug_matrix = true;
//debug_keyboard = true;
//debug_mouse = true;
}
void matrix_init_user(void) {
}
void matrix_scan_user(void) {
}
void led_set_user(uint8_t usb_led) {
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Default behavior:
* main layer:
* CW: move mouse right
* CCW: move mouse left
* other layers:
* CW: = (equals/plus - increase slider in Adobe products)
* CCW: - (minus/underscore - decrease slider in adobe products)
*/
if (index == 0) {
switch (biton32(layer_state)) {
case _BASE:
// main layer - move mouse right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
// other layers - =/+ (quals/plus) (CW) and -/_ (minus/underscore) (CCW)
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

2
keyboards/dumbpad/keymaps/imchipwood/config.h
View File

@ -1,2 +0,0 @@
#pragma once
#define TAPPING_TOGGLE 2

163
keyboards/dumbpad/keymaps/imchipwood/keymap.c
View File

@ -1,163 +0,0 @@
/* Copyright 2019 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
#define _BASE 0
#define _SUB 1
#define _DBG 2
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/-----------------------------------------------------`
| | 7 | 8 | 9 | Bkspc |
| |---------|---------|---------|---------|
| | 4 | 5 | 6 | + |
| |---------|---------|---------|---------|
| | 1 | 2 | 3 | * |
|-------------|---------|---------|---------|---------|
| Play/Pause | TT(SUB) | 0 | . | Enter |
\-----------------------------------------------------'
*/
[_BASE] = LAYOUT(
KC_P7, KC_P8, KC_P9, KC_BSPC,
KC_P4, KC_P5, KC_P6, KC_KP_PLUS,
KC_P1, KC_P2, KC_P3, KC_KP_ASTERISK,
KC_MPLY, TT(_SUB), KC_P0, KC_PDOT, KC_KP_ENTER
),
/*
SUB LAYER
/-----------------------------------------------------`
| | | | | Numlock |
| |---------|---------|---------|---------|
| | | | | - |
| |---------|---------|---------|---------|
| | | | | / |
|-------------|---------|---------|---------|---------|
| MO(_DBG) | | | | = |
\-----------------------------------------------------'
*/
[_SUB] = LAYOUT(
_______, _______, _______, KC_NLCK,
_______, _______, _______, KC_KP_MINUS,
_______, _______, _______, KC_KP_SLASH,
MO(_DBG), _______, _______, _______, KC_KP_EQUAL
),
/*
DEBUG LAYER
/-----------------------------------------------------`
| | | | | Reset |
| |---------|---------|---------|---------|
| | | | | |
| |---------|---------|---------|---------|
| | | | | |
|-------------|---------|---------|---------|---------|
| | | | | |
\-----------------------------------------------------'
*/
[_DBG] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, _______,
_______, _______, _______, _______,
_______, _______, _______, _______, _______
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
//debug_enable = true;
//debug_matrix = true;
//debug_keyboard = true;
//debug_mouse = true;
}
void matrix_init_user(void) {
}
void matrix_scan_user(void) {
}
void led_set_user(uint8_t usb_led) {
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Cusotom behavior:
* main layer:
* CW: volume up
* CCW: volume down
* sub layer:
* CW: next media track
* CCW: prev media track
* debug layer:
* CW: brightness up
* CCW: brightness down
*/
if (index == 0) {
switch (biton32(layer_state)) {
case _BASE:
// main layer - volume up (CW) and down (CCW)
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
break;
case _SUB:
// sub layer - next track (CW) and previous track (CCW)
if (clockwise) {
tap_code(KC_MNXT);
} else {
tap_code(KC_MPRV);
}
break;
case _DBG:
// debug layer - brightness up (CW) and brightness down (CCW)
if (clockwise) {
tap_code(KC_BRIU);
} else {
tap_code(KC_BRID);
}
break;
default:
// any other layer (shouldn't exist..) - volume up (CW) and down (CCW)
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
break;
}
}
}

30
keyboards/dumbpad/readme.md
View File

@ -1,19 +1,23 @@
# dumbpad
![dumbpad](https://i.imgur.com/sS3fq1Z.jpg)
![dumbpad](https://i.imgur.com/1T7ciLZl.jpg)
A 4x4 macro/numpad with rotary encoder.
dumbpad is a num/macro pad available in two major form factors - single- and dual-rotary encoder.
Keyboard Maintainer: [imchipwood](https://github.com/imchipwood)
* Single-encoder PCBs are reversible - components can be soldered to either side to allow
the encoder to be on either the left or right side.
* Dual-encoder PCBs come in two versions - one with the encoders in the bottom corners, the otherin the top corners
PCB repository: https://github.com/imchipwood/dumbpad
Support for dumbpad all PCB revisions can be found in this directory.
Make example for this keyboard (after setting up your build environment):
make dumbpad:default
Program with:
make dumbpad:default:avrdude
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).
* Maintainer: [imchipwood](https://github.com/imchipwood)
* PCB repository: [dumbpad on github](https://github.com/imchipwood/dumbpad)
* PCB revisions:
* v0.x - these revisions have two LEDs for layer indication
* ['v0x'](v0x/): Default setup for single rotary encoder v0.x PCBs
* ['v0x_right'](v0x_right/): Same as v0x but with rotary encoder on right side (components on bottom of PCB)
* ['v0x_dualencoder'](v0x_dualencoder/): Dual-encoder PCBs
* v1.x - these revisions have three LEDs - two for layer indication, one for numlock indication
* ['v1x'](v1x/): Default setup for v1.x PCBs with a single rotary encoder on the left side
* ['v1x_right'](v1x_right/): Same as v1x but with rotary encoder on right side (components on bottom of PCB)
* ['v1x_dualencoder'](v1x_dualencoder/): v1x PCB with two rotary encoders

36
keyboards/dumbpad/rules.mk
View File

@ -1,35 +1 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
# Teensy halfkay
# Pro Micro caterina
# Atmel DFU atmel-dfu
# LUFA DFU lufa-dfu
# QMK DFU qmk-dfu
# ATmega32A bootloadHID
# ATmega328P USBasp
BOOTLOADER = caterina
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality on B7 by default
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
MIDI_ENABLE = no # MIDI support
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
AUDIO_ENABLE = no # Audio output on port C6
ENCODER_ENABLE = yes
MOUSEKEY_ENABLE = yes
KEY_LOCK_ENABLE = yes
DEFAULT_FOLDER = dumbpad/v0x

41
keyboards/dumbpad/v0x/config.h 100644
View File

@ -0,0 +1,41 @@
/*
Copyright 2020 imchipwood
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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define DEVICE_VER 0x0007
/* Column/Row IO definitions */
#define MATRIX_ROWS 4
#define MATRIX_COLS 5
#define MATRIX_ROW_PINS { F4, F5, F6, F7 }
#define MATRIX_COL_PINS { C6, D7, E6, B4, B5 }
#define UNUSED_PINS
/* Single rotary encoder */
#define ENCODERS_PAD_A { D0 }
#define ENCODERS_PAD_B { D4 }
/* Onboard LEDs */
#define LED_00 B3
#define LED_01 B1
/* Bootmagic - hold down rotary encoder pushbutton while plugging in to enter bootloader */
#define BOOTMAGIC_LITE_ROW 3
#define BOOTMAGIC_LITE_COLUMN 0

18
keyboards/dumbpad/v0x/info.json 100644
View File

@ -0,0 +1,18 @@
{
"keyboard_name": "dumbpad/v0x",
"keyboard_folder": "dumbpad/v0x",
"url": "https://www.github.com/imchipwood/dumbpad",
"maintainer": "imchipwood",
"width": 5,
"height": 4,
"layouts": {
"LAYOUT": {
"layout": [
{"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0},
{"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1},
{"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2}, {"x":4, "y":2},
{"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}
]
}
}
}

106
keyboards/dumbpad/v0x/keymaps/default/keymap.c 100644
View File

@ -0,0 +1,106 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/-----------------------------------------------------`
| | 7 | 8 | 9 | Bkspc |
| |---------|---------|---------|---------|
| | 4 | 5 | 6 | Esc |
| |---------|---------|---------|---------|
| | 1 | 2 | 3 | Tab |
|-------------|---------|---------|---------|---------|
| Left mouse | TT(1) | 0 | . | Enter |
\-----------------------------------------------------'
*/
[0] = LAYOUT(
KC_7, KC_8, KC_9, KC_BSPC,
KC_4, KC_5, KC_6, KC_ESC,
KC_1, KC_2, KC_3, KC_TAB,
KC_BTN1, TT(1), KC_0, LSFT_T(KC_DOT), KC_ENTER
),
/*
SUB LAYER
/-----------------------------------------------------`
| | | | | Reset |
| |---------|---------|---------|---------|
| | | | | + |
| |---------|---------|---------|---------|
| | | | | - |
|-------------|---------|---------|---------|---------|
| LOCK | | | | = |
\-----------------------------------------------------'
*/
[1] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, KC_KP_PLUS,
_______, _______, _______, KC_KP_MINUS,
KC_LOCK, _______, _______, _______, KC_EQL
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
//debug_enable = true;
//debug_matrix = true;
//debug_keyboard = true;
//debug_mouse = true;
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Default behavior:
* main layer:
* CW: move mouse right
* CCW: move mouse left
* other layers:
* CW: = (equals/plus - increase slider in Adobe products)
* CCW: - (minus/underscore - decrease slider in adobe products)
*/
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - move mouse right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
// other layers - =/+ (quals/plus) (CW) and -/_ (minus/underscore) (CCW)
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

15
keyboards/dumbpad/v0x/readme.md 100644
View File

@ -0,0 +1,15 @@
# dumbpad v0.x
![dumbpad](https://i.imgur.com/c3YBNp0l.jpg)
A 4x4 numpad/macropad with a rotary encoder to the left of the bottom row of keys.
* Keyboard Maintainer: [imchipwood](https://github.com/imchipwood)
* Hardware repository: [dumbpad on github](https://github.com/imchipwood/dumbpad)
* PCB Revisions Supported: v0.2, v0.6, v0.7
Make example for this keyboard (after setting up your build environment):
make dumbpad/v0x:default
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).

25
keyboards/dumbpad/v0x/rules.mk 100644
View File

@ -0,0 +1,25 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
BOOTLOADER = caterina
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
BLUETOOTH_ENABLE = no # Enable Bluetooth
AUDIO_ENABLE = no # Audio output
ENCODER_ENABLE = yes
KEY_LOCK_ENABLE = yes

25
keyboards/dumbpad/v0x/templates/keymap.c 100644
View File

@ -0,0 +1,25 @@
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {__KEYMAP_GOES_HERE__};
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

59
keyboards/dumbpad/v0x/v0x.c 100644
View File

@ -0,0 +1,59 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "v0x.h"
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
setPinOutput(LED_00);
setPinOutput(LED_01);
keyboard_pre_init_user();
}
void shutdown_user() {
// Shutdown LEDs
writePinLow(LED_00);
writePinLow(LED_01);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
writePin(LED_00, layer & 0b1);
writePin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
writePinHigh(LED_00);
writePinHigh(LED_01);
wait_ms(led_delay_ms);
writePinLow(LED_00);
writePinLow(LED_01);
if (i < 1) {
wait_ms(led_delay_ms);
}
}
matrix_init_user();
}

19
keyboards/dumbpad/dumbpad.h → keyboards/dumbpad/v0x/v0x.h
View File

@ -1,4 +1,4 @@
/* Copyright 2019 Chip
/* Copyright 2020 imchipwood
*
* 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
@ -14,22 +14,13 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
/* This a shortcut to help you visually see your layout.
*
* The first section contains all of the arguments representing the physical
* layout of the board and position of the keys.
*
* The second converts the arguments into a two-dimensional array which
* represents the switch matrix.
*/
#define LAYOUT( \
k01, k02, k03, k04, \
k11, k12, k13, k14, \
k21, k22, k23, k24, \
k30, k31, k32, k33, k34 \
k01, k02, k03, k04, \
k11, k12, k13, k14, \
k21, k22, k23, k24, \
k30, k31, k32, k33, k34 \
) \
{ \
{ KC_NO, k01, k02, k03, k04 }, \

40
keyboards/dumbpad/v0x_dualencoder/config.h 100644
View File

@ -0,0 +1,40 @@
/*
Copyright 2020 imchipwood
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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define DEVICE_VER 0x0006
/* Column/Row IO definitions - dualencoder version is true 4x4 */
#define MATRIX_ROWS 4
#define MATRIX_COLS 4
#define MATRIX_ROW_PINS { F4, F5, F6, F7 }
#define MATRIX_COL_PINS { D7, E6, B4, B5 }
/* Dual rotary encoders */
#define ENCODERS_PAD_A { C6, D0 }
#define ENCODERS_PAD_B { D4, D1 }
/* Onboard LEDs */
#define LED_00 B3
#define LED_01 B1
/* Bootmagic - hold down rotary encoder pushbutton while plugging in to enter bootloader */
#define BOOTMAGIC_LITE_ROW 3
#define BOOTMAGIC_LITE_COLUMN 0

18
keyboards/dumbpad/v0x_dualencoder/info.json 100644
View File

@ -0,0 +1,18 @@
{
"keyboard_name": "dumbpad/v0x_dualencoder",
"keyboard_folder": "dumbpad/v0x_dualencoder",
"url": "https://www.github.com/imchipwood/dumbpad",
"maintainer": "imchipwood",
"width": 4,
"height": 4,
"layouts": {
"LAYOUT": {
"layout": [
{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0},
{"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1},
{"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2},
{"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}
]
}
}
}

134
keyboards/dumbpad/v0x_dualencoder/keymaps/default/keymap.c 100644
View File

@ -0,0 +1,134 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/---------------------------------------`
| 7 | 8 | 9 | Bkspc |
|---------|---------|---------|---------|
| 4 | 5 | 6 | Esc |
|---------|---------|---------|---------|
| 1 | 2 | 3 | Tab |
|---------|---------|---------|---------|
| TT(1) | 0 | . | Enter |
\---------------------------------------'
*/
[0] = LAYOUT(
KC_7, KC_8, KC_9, KC_BSPC,
KC_4, KC_5, KC_6, KC_ESC,
KC_1, KC_2, KC_3, KC_TAB,
TT(1), KC_0, KC_DOT, KC_ENTER
),
/*
SUB LAYER
/---------------------------------------`
| | | | Reset |
|---------|---------|---------|---------|
| | | | + |
|---------|---------|---------|---------|
| | | | - |
|---------|---------|---------|---------|
| | | | = |
\---------------------------------------'
*/
[1] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, KC_KP_PLUS,
_______, _______, _______, KC_KP_MINUS,
_______, _______, _______, KC_EQL
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
// debug_enable = true;
// debug_matrix = true;
// debug_keyboard = true;
// debug_mouse = true;
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Default behavior:
* left encoder:
* main layer:
* CW: move mouse right
* CCW: move mouse left
* other layers:
* CW: = (equals/plus - increase slider in Adobe products)
* CCW: - (minus/underscore - decrease slider in adobe products)
* right encoder:
* main layer:
* CW: colume up
* CCW: volume down
* other layers:
* CW: right arrow
* CCW: left arrow
*/
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - move mouse right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
// other layers - =/+ (quals/plus) (CW) and -/_ (minus/underscore) (CCW)
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
} else if (index == 1) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - volume up (CW) and down (CCW)
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
break;
default:
// other layers - right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_RIGHT);
} else {
tap_code(KC_LEFT);
}
break;
}
}
}

15
keyboards/dumbpad/v0x_dualencoder/readme.md 100644
View File

@ -0,0 +1,15 @@
# dumbpad v0.x dual-encoder
![dumbpad](https://i.imgur.com/OkSRXWTl.jpg)
A 4x4 numpad/macropad with two rotary encoders
* Keyboard Maintainer: [imchipwood](https://github.com/imchipwood)
* Hardware repository: [dumbpad on github](https://github.com/imchipwood/dumbpad)
* PCB Revisions Supported: v0.6_dualencoder, v0.6_dualencoder_top
Make example for this keyboard (after setting up your build environment):
make dumbpad/v0x_dualencoder:default
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).

25
keyboards/dumbpad/v0x_dualencoder/rules.mk 100644
View File

@ -0,0 +1,25 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
BOOTLOADER = caterina
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
BLUETOOTH_ENABLE = no # Enable Bluetooth
AUDIO_ENABLE = no # Audio output
ENCODER_ENABLE = yes
KEY_LOCK_ENABLE = yes

43
keyboards/dumbpad/v0x_dualencoder/templates/keymap.c 100644
View File

@ -0,0 +1,43 @@
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {__KEYMAP_GOES_HERE__};
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
} else if (index == 1) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
break;
default:
if (clockwise) {
tap_code(KC_RIGHT);
} else {
tap_code(KC_LEFT);
}
break;
}
}
}

59
keyboards/dumbpad/v0x_dualencoder/v0x_dualencoder.c 100644
View File

@ -0,0 +1,59 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "v0x_dualencoder.h"
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
setPinOutput(LED_00);
setPinOutput(LED_01);
keyboard_pre_init_user();
}
void shutdown_user() {
// Shutdown LEDs
writePinLow(LED_00);
writePinLow(LED_01);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
writePin(LED_00, layer & 0b1);
writePin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
writePinHigh(LED_00);
writePinHigh(LED_01);
wait_ms(led_delay_ms);
writePinLow(LED_00);
writePinLow(LED_01);
if (i < 1) {
wait_ms(led_delay_ms);
}
}
matrix_init_user();
}

30
keyboards/dumbpad/v0x_dualencoder/v0x_dualencoder.h 100644
View File

@ -0,0 +1,30 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
#define LAYOUT( \
k00, k01, k02, k03, \
k10, k11, k12, k13, \
k20, k21, k22, k23, \
k30, k31, k32, k33 \
) \
{ \
{ k00, k01, k02, k03 }, \
{ k10, k11, k12, k13 }, \
{ k20, k21, k22, k23 }, \
{ k30, k31, k32, k33 }, \
}

39
keyboards/dumbpad/v0x_right/config.h 100644
View File

@ -0,0 +1,39 @@
/*
Copyright 2020 imchipwood
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 <http://www.gnu.org/licenses/>.
*/
#pragma once
/* USB Device descriptor parameter */
#define DEVICE_VER 0x0007
/* Column/Row IO definitions */
#define MATRIX_ROWS 4
#define MATRIX_COLS 5
#define MATRIX_ROW_PINS { F4, F5, F6, F7 }
#define MATRIX_COL_PINS { B5, B4, E6, D7, C6 }
#define UNUSED_PINS
/* Single rotary encoder */
#define ENCODERS_PAD_A { D4 }
#define ENCODERS_PAD_B { D0 }
/* Onboard LEDs */
#define LED_00 B1
#define LED_01 B3
/* Bootmagic - hold down rotary encoder pushbutton while plugging in to enter bootloader */
#define BOOTMAGIC_LITE_ROW 3
#define BOOTMAGIC_LITE_COLUMN 4

18
keyboards/dumbpad/v0x_right/info.json 100644
View File

@ -0,0 +1,18 @@
{
"keyboard_name": "dumbpad/v0x_right",
"keyboard_folder": "dumbpad/v0x_right",
"url": "https://www.github.com/imchipwood/dumbpad",
"maintainer": "imchipwood",
"width": 5,
"height": 4,
"layouts": {
"LAYOUT": {
"layout": [
{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0},
{"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1},
{"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2},
{"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}
]
}
}
}

106
keyboards/dumbpad/v0x_right/keymaps/default/keymap.c 100644
View File

@ -0,0 +1,106 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/-----------------------------------------------------`
| 7 | 8 | 9 | Bkspc | |
|---------|---------|---------|---------| |
| 4 | 5 | 6 | Esc | |
|---------|---------|---------|---------| |
| 1 | 2 | 3 | Tab | |
|---------|---------|---------|---------|-------------|
| TT(1) | 0 | . | Enter | Left mouse |
\-----------------------------------------------------'
*/
[0] = LAYOUT(
KC_7, KC_8, KC_9, KC_BSPC,
KC_4, KC_5, KC_6, KC_ESC,
KC_1, KC_2, KC_3, KC_TAB,
TT(1), KC_0, LSFT_T(KC_DOT), KC_ENTER, KC_BTN1
),
/*
SUB LAYER
/-----------------------------------------------------`
| | | | Reset | |
|---------|---------|---------|---------| |
| | | | + | |
|---------|---------|---------|---------| |
| | | | - | |
|---------|---------|---------|---------|-------------|
| | | | = | LOCK |
\-----------------------------------------------------'
*/
[1] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, KC_KP_PLUS,
_______, _______, _______, KC_KP_MINUS,
_______, _______, _______, KC_EQL, KC_LOCK
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
// debug_enable = true;
// debug_matrix = true;
// debug_keyboard = true;
// debug_mouse = true;
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Default behavior:
* main layer:
* CW: move mouse right
* CCW: move mouse left
* other layers:
* CW: = (equals/plus - increase slider in Adobe products)
* CCW: - (minus/underscore - decrease slider in adobe products)
*/
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - move mouse right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
// other layers - =/+ (quals/plus) (CW) and -/_ (minus/underscore) (CCW)
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

15
keyboards/dumbpad/v0x_right/readme.md 100644
View File

@ -0,0 +1,15 @@
# dumbpad v0.x with encoder on right side
![dumbpad](https://i.imgur.com/c3YBNp0l.jpg)
A 4x4 numpad/macropad with a rotary encoder to the right of the bottom row of keys.
* Keyboard Maintainer: [imchipwood](https://github.com/imchipwood)
* Hardware repository: [dumbpad on github](https://github.com/imchipwood/dumbpad)
* PCB Revisions Supported: v0.6, v0.7
Make example for this keyboard (after setting up your build environment):
make dumbpad/v0x_right:default
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).

25
keyboards/dumbpad/v0x_right/rules.mk 100644
View File

@ -0,0 +1,25 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
BOOTLOADER = caterina
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
BLUETOOTH_ENABLE = no # Enable Bluetooth
AUDIO_ENABLE = no # Audio output
ENCODER_ENABLE = yes
KEY_LOCK_ENABLE = yes

25
keyboards/dumbpad/v0x_right/templates/keymap.c 100644
View File

@ -0,0 +1,25 @@
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {__KEYMAP_GOES_HERE__};
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

59
keyboards/dumbpad/v0x_right/v0x_right.c 100644
View File

@ -0,0 +1,59 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "v0x_right.h"
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
setPinOutput(LED_00);
setPinOutput(LED_01);
keyboard_pre_init_user();
}
void shutdown_user() {
// Shutdown LEDs
writePinLow(LED_00);
writePinLow(LED_01);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
writePin(LED_00, layer & 0b1);
writePin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
writePinHigh(LED_00);
writePinHigh(LED_01);
wait_ms(led_delay_ms);
writePinLow(LED_00);
writePinLow(LED_01);
if (i < 1) {
wait_ms(led_delay_ms);
}
}
matrix_init_user();
}

30
keyboards/dumbpad/v0x_right/v0x_right.h 100644
View File

@ -0,0 +1,30 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
#define LAYOUT( \
k00, k01, k02, k03, \
k10, k11, k12, k13, \
k20, k21, k22, k23, \
k30, k31, k32, k33, k34 \
) \
{ \
{ k00, k01, k02, k03, KC_NO }, \
{ k10, k11, k12, k13, KC_NO }, \
{ k20, k21, k22, k23, KC_NO }, \
{ k30, k31, k32, k33, k34 }, \
}

42
keyboards/dumbpad/v1x/config.h 100644
View File

@ -0,0 +1,42 @@
/*
Copyright 2020 imchipwood
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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define DEVICE_VER 0x0010
/* Column/Row IO definitions */
#define MATRIX_ROWS 4
#define MATRIX_COLS 5
#define MATRIX_ROW_PINS { F4, F5, F6, F7 }
#define MATRIX_COL_PINS { C6, D7, E6, B4, B5 }
#define UNUSED_PINS
/* Single rotary encoder */
#define ENCODERS_PAD_A { B2 }
#define ENCODERS_PAD_B { D4 }
/* Onboard LEDs */
#define LED_00 B6
#define LED_01 B1
#define LED_02 B3
/* Bootmagic - hold down rotary encoder pushbutton while plugging in to enter bootloader */
#define BOOTMAGIC_LITE_ROW 3
#define BOOTMAGIC_LITE_COLUMN 0

18
keyboards/dumbpad/v1x/info.json 100644
View File

@ -0,0 +1,18 @@
{
"keyboard_name": "dumbpad/v1x",
"keyboard_folder": "dumbpad/v1x",
"url": "https://www.github.com/imchipwood/dumbpad",
"maintainer": "imchipwood",
"width": 5,
"height": 4,
"layouts": {
"LAYOUT": {
"layout": [
{"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0},
{"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1},
{"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2}, {"x":4, "y":2},
{"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}
]
}
}
}

106
keyboards/dumbpad/v1x/keymaps/default/keymap.c 100644
View File

@ -0,0 +1,106 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/-----------------------------------------------------`
| | 7 | 8 | 9 | Bkspc |
| |---------|---------|---------|---------|
| | 4 | 5 | 6 | Esc |
| |---------|---------|---------|---------|
| | 1 | 2 | 3 | Tab |
|-------------|---------|---------|---------|---------|
| Left mouse | TT(1) | 0 | . | Enter |
\-----------------------------------------------------'
*/
[0] = LAYOUT(
KC_7, KC_8, KC_9, KC_BSPC,
KC_4, KC_5, KC_6, KC_ESC,
KC_1, KC_2, KC_3, KC_TAB,
KC_BTN1, TT(1), KC_0, LSFT_T(KC_DOT), KC_ENTER
),
/*
SUB LAYER
/-----------------------------------------------------`
| | | | | Reset |
| |---------|---------|---------|---------|
| | | | | + |
| |---------|---------|---------|---------|
| | | | | - |
|-------------|---------|---------|---------|---------|
| LOCK | | | | = |
\-----------------------------------------------------'
*/
[1] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, KC_KP_PLUS,
_______, _______, _______, KC_KP_MINUS,
KC_LOCK, _______, _______, _______, KC_EQL
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
//debug_enable = true;
//debug_matrix = true;
//debug_keyboard = true;
//debug_mouse = true;
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Default behavior:
* main layer:
* CW: move mouse right
* CCW: move mouse left
* other layers:
* CW: = (equals/plus - increase slider in Adobe products)
* CCW: - (minus/underscore - decrease slider in adobe products)
*/
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - move mouse right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
// other layers - =/+ (quals/plus) (CW) and -/_ (minus/underscore) (CCW)
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

15
keyboards/dumbpad/v1x/readme.md 100644
View File

@ -0,0 +1,15 @@
# dumbpad v1.x
![dumbpad](https://i.imgur.com/ND03FiFl.png)
A 4x4 numpad/macropad with a rotary encoder to the left of the bottom row of keys.
* Keyboard Maintainer: [imchipwood](https://github.com/imchipwood)
* Hardware repository: [dumbpad on github](https://github.com/imchipwood/dumbpad)
* PCB Revisions Supported: v1.0
Make example for this keyboard (after setting up your build environment):
make dumbpad/v1x:default
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).

25
keyboards/dumbpad/v1x/rules.mk 100644
View File

@ -0,0 +1,25 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
BOOTLOADER = caterina
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
BLUETOOTH_ENABLE = no # Enable Bluetooth
AUDIO_ENABLE = no # Audio output
ENCODER_ENABLE = yes
KEY_LOCK_ENABLE = yes

25
keyboards/dumbpad/v1x/templates/keymap.c 100644
View File

@ -0,0 +1,25 @@
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {__KEYMAP_GOES_HERE__};
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

69
keyboards/dumbpad/v1x/v1x.c 100644
View File

@ -0,0 +1,69 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "v1x.h"
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
setPinOutput(LED_00);
setPinOutput(LED_01);
setPinOutput(LED_02);
keyboard_pre_init_user();
}
void shutdown_user() {
// Shutdown LEDs
writePinLow(LED_00);
writePinLow(LED_01);
writePinLow(LED_02);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
writePin(LED_00, layer & 0b1);
writePin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
writePinHigh(LED_00);
writePinHigh(LED_01);
writePinHigh(LED_02);
wait_ms(led_delay_ms);
writePinLow(LED_00);
writePinLow(LED_01);
writePinLow(LED_02);
if (i < 1) {
wait_ms(led_delay_ms);
}
}
matrix_init_user();
}
void led_set_kb(uint8_t usb_led) {
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
writePin(LED_02, !IS_LED_ON(usb_led, USB_LED_NUM_LOCK));
led_set_user(usb_led);
}

30
keyboards/dumbpad/v1x/v1x.h 100644
View File

@ -0,0 +1,30 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
#define LAYOUT( \
k01, k02, k03, k04, \
k11, k12, k13, k14, \
k21, k22, k23, k24, \
k30, k31, k32, k33, k34 \
) \
{ \
{ KC_NO, k01, k02, k03, k04 }, \
{ KC_NO, k11, k12, k13, k14 }, \
{ KC_NO, k21, k22, k23, k24 }, \
{ k30, k31, k32, k33, k34 }, \
}

42
keyboards/dumbpad/v1x_dualencoder/config.h 100644
View File

@ -0,0 +1,42 @@
/*
Copyright 2020 imchipwood
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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define DEVICE_VER 0x0010
/* Column/Row IO definitions */
#define MATRIX_ROWS 4
#define MATRIX_COLS 5
#define MATRIX_ROW_PINS { F4, F5, F6, F7 }
#define MATRIX_COL_PINS { C6, D7, E6, B4, B5 }
#define UNUSED_PINS
/* Dual rotary encoders */
#define ENCODERS_PAD_A { B2, D0 }
#define ENCODERS_PAD_B { D4, D1 }
/* Onboard LEDs */
#define LED_00 B6
#define LED_01 B1
#define LED_02 B3
/* Bootmagic - hold down rotary encoder pushbutton while plugging in to enter bootloader */
#define BOOTMAGIC_LITE_ROW 3
#define BOOTMAGIC_LITE_COLUMN 0

18
keyboards/dumbpad/v1x_dualencoder/info.json 100644
View File

@ -0,0 +1,18 @@
{
"keyboard_name": "dumbpad/v1x_dualencoder",
"keyboard_folder": "dumbpad/v1x_dualencoder",
"url": "https://www.github.com/imchipwood/dumbpad",
"maintainer": "imchipwood",
"width": 5,
"height": 4,
"layouts": {
"LAYOUT": {
"layout": [
{"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0},
{"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1},
{"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2}, {"x":4, "y":2},
{"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}
]
}
}
}

134
keyboards/dumbpad/v1x_dualencoder/keymaps/default/keymap.c 100644
View File

@ -0,0 +1,134 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/-----------------------------------------------------`
| | 7 | 8 | 9 | Bkspc |
| |---------|---------|---------|---------|
| | 4 | 5 | 6 | Esc |
| |---------|---------|---------|---------|
| | 1 | 2 | 3 | Tab |
|-------------|---------|---------|---------|---------|
| Left mouse | TT(1) | 0 | . | Enter |
\-----------------------------------------------------'
*/
[0] = LAYOUT(
KC_7, KC_8, KC_9, KC_BSPC,
KC_4, KC_5, KC_6, KC_ESC,
KC_1, KC_2, KC_3, KC_TAB,
KC_BTN1, TT(1), KC_0, LSFT_T(KC_DOT), KC_ENTER
),
/*
SUB LAYER
/-----------------------------------------------------`
| | | | | Reset |
| |---------|---------|---------|---------|
| | | | | + |
| |---------|---------|---------|---------|
| | | | | - |
|-------------|---------|---------|---------|---------|
| LOCK | | | | = |
\-----------------------------------------------------'
*/
[1] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, KC_KP_PLUS,
_______, _______, _______, KC_KP_MINUS,
KC_LOCK, _______, _______, _______, KC_EQL
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
// debug_enable = true;
// debug_matrix = true;
// debug_keyboard = true;
// debug_mouse = true;
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Default behavior:
* left encoder:
* main layer:
* CW: move mouse right
* CCW: move mouse left
* other layers:
* CW: = (equals/plus - increase slider in Adobe products)
* CCW: - (minus/underscore - decrease slider in adobe products)
* right encoder:
* main layer:
* CW: colume up
* CCW: volume down
* other layers:
* CW: right arrow
* CCW: left arrow
*/
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - move mouse right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
// other layers - =/+ (quals/plus) (CW) and -/_ (minus/underscore) (CCW)
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
} else if (index == 1) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - volume up (CW) and down (CCW)
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
break;
default:
// other layers - right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_RIGHT);
} else {
tap_code(KC_LEFT);
}
break;
}
}
}

87
keyboards/dumbpad/v1x_dualencoder/readme.md 100644
View File

@ -0,0 +1,87 @@
# dumbpad v1.x dual-encoder
![dumbpad](https://i.imgur.com/s69rdfA.png)
## Single- vs Dual-Encoder Support
The combined Cherry MX/encoder sockets allow single- and dual-encoder configurations.
The only rule when using two encoders is that there cannot be two encoders on the left side at once, or two on the right side.
This table shows where the encoders are in the switch grid ("X" for encoder, "s" for switch):
| C0 | C1 | C2 | C3 | C4 |
|:---:|:---:|:---:|:---:|:---:|
| |__X__| s | s |__X__|
| | s | s | s | s |
| | s | s | s | s |
|__X__|__X__| s | s |__X__|
- The three encoders in columns C0 and C1 are connected to each other
- The two encoders in column C4 are connected to each other
So, if doing dual encoders, one must be in column C4 and the other in either C0 or C1. Three or more encoders will not work.
The following sections describe the configurations that the default keymaps in QMK are designed for.
### Single-Encoder (Default Configuration)
In the default configuration, the encoder is in column 0, the bottom left corner below the Pro Micro. All other sockets are filled with switches.
| C0 | C1 | C2 | C3 | C4 |
|:---:|:---:|:---:|:---:|:---:|
| | s | s | s | s |
| | s | s | s | s |
| | s | s | s | s |
|__X__| s | s | s | s |
![single encoder](https://i.imgur.com/8ZPz1gFl.jpg)
### Dual-Encoder Bottom
One dual-encoder configuration has encoders in the bottom two corners of the 4x4 grid, and switches in the rest of the grid. The socket in column 0 is left empty.
| C0 | C1 | C2 | C3 | C4 |
|:---:|:---:|:---:|:---:|:---:|
| | s | s | s | s |
| | s | s | s | s |
| | s | s | s | s |
| |__X__| s | s |__X__|
![dual-encoder bottom](https://i.imgur.com/QCqKDMSl.jpg)
### Dual-Encoder Top
Another dual-encoder configuration has encoders in the top two corners of the 4x4 grid, and switches in the rest of the grid. The socket in column 0 is left empty.
| C0 | C1 | C2 | C3 | C4 |
|:---:|:---:|:---:|:---:|:---:|
| |__X__| s | s |__X__|
| | s | s | s | s |
| | s | s | s | s |
| | s | s | s | s |
![dual-encoder top](https://i.imgur.com/Rq6ox2Ol.jpg)
### No-Encoder
You may also choose not to use any rotary encoders if you like!
### Bill Of Materials
- Cherry-style mechanical switches
- EC11 rotary encoder with pushbutton (7-pin) - one or two depending on your desired configuration
- 1n4148 diodes (thru hole) - one per switch and rotary encoder (if using clickable encoder(s))
- 1x Arduino Pro Micro or pin-compatible ATmega32u4-based MCU
- (optional) 3x 3mm LEDs
- (optional) 3x 330 ohm resistors (for limiting current in LEDs)
- (optional) 6mm SPST switch for resetting MCU
* Keyboard Maintainer: [imchipwood](https://github.com/imchipwood)
* Hardware repository: [dumbpad on github](https://github.com/imchipwood/dumbpad)
* PCB Revisions Supported: v1.0_dual
Make example for this keyboard (after setting up your build environment):
make dumbpad/v1x_dualencoder:default
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).

25
keyboards/dumbpad/v1x_dualencoder/rules.mk 100644
View File

@ -0,0 +1,25 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
BOOTLOADER = caterina
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
BLUETOOTH_ENABLE = no # Enable Bluetooth
AUDIO_ENABLE = no # Audio output
ENCODER_ENABLE = yes
KEY_LOCK_ENABLE = yes

43
keyboards/dumbpad/v1x_dualencoder/templates/keymap.c 100644
View File

@ -0,0 +1,43 @@
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {__KEYMAP_GOES_HERE__};
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
} else if (index == 1) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
break;
default:
if (clockwise) {
tap_code(KC_RIGHT);
} else {
tap_code(KC_LEFT);
}
break;
}
}
}

69
keyboards/dumbpad/v1x_dualencoder/v1x_dualencoder.c 100644
View File

@ -0,0 +1,69 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "v1x_dualencoder.h"
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
setPinOutput(LED_00);
setPinOutput(LED_01);
setPinOutput(LED_02);
keyboard_pre_init_user();
}
void shutdown_user() {
// Shutdown LEDs
writePinLow(LED_00);
writePinLow(LED_01);
writePinLow(LED_02);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
writePin(LED_00, layer & 0b1);
writePin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
writePinHigh(LED_00);
writePinHigh(LED_01);
writePinHigh(LED_02);
wait_ms(led_delay_ms);
writePinLow(LED_00);
writePinLow(LED_01);
writePinLow(LED_02);
if (i < 1) {
wait_ms(led_delay_ms);
}
}
matrix_init_user();
}
void led_set_kb(uint8_t usb_led) {
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
writePin(LED_02, !IS_LED_ON(usb_led, USB_LED_NUM_LOCK));
led_set_user(usb_led);
}

30
keyboards/dumbpad/v1x_dualencoder/v1x_dualencoder.h 100644
View File

@ -0,0 +1,30 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
#define LAYOUT( \
k01, k02, k03, k04, \
k11, k12, k13, k14, \
k21, k22, k23, k24, \
k30, k31, k32, k33, k34 \
) \
{ \
{ KC_NO, k01, k02, k03, k04 }, \
{ KC_NO, k11, k12, k13, k14 }, \
{ KC_NO, k21, k22, k23, k24 }, \
{ k30, k31, k32, k33, k34 }, \
}

42
keyboards/dumbpad/v1x_right/config.h 100644
View File

@ -0,0 +1,42 @@
/*
Copyright 2020 imchipwood
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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define DEVICE_VER 0x0010
/* Column/Row IO definitions */
#define MATRIX_ROWS 4
#define MATRIX_COLS 5
#define MATRIX_ROW_PINS { F4, F5, F6, F7 }
#define MATRIX_COL_PINS { B5, B4, E6, D7, C6 }
#define UNUSED_PINS
/* Single rotary encoder */
#define ENCODERS_PAD_A { D4 }
#define ENCODERS_PAD_B { B2 }
/* Onboard LEDs - reversed */
#define LED_00 B3
#define LED_01 B1
#define LED_02 B6
/* Bootmagic - hold down rotary encoder pushbutton while plugging in to enter bootloader */
#define BOOTMAGIC_LITE_ROW 3
#define BOOTMAGIC_LITE_COLUMN 4

18
keyboards/dumbpad/v1x_right/info.json 100644
View File

@ -0,0 +1,18 @@
{
"keyboard_name": "dumbpad/v1x_right",
"keyboard_folder": "dumbpad/v1x_right",
"url": "https://www.github.com/imchipwood/dumbpad",
"maintainer": "imchipwood",
"width": 5,
"height": 4,
"layouts": {
"LAYOUT": {
"layout": [
{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0},
{"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1},
{"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2},
{"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}
]
}
}
}

106
keyboards/dumbpad/v1x_right/keymaps/default/keymap.c 100644
View File

@ -0,0 +1,106 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
BASE LAYER
/-----------------------------------------------------`
| 7 | 8 | 9 | Bkspc | |
|---------|---------|---------|---------| |
| 4 | 5 | 6 | Esc | |
|---------|---------|---------|---------| |
| 1 | 2 | 3 | Tab | |
|---------|---------|---------|---------|-------------|
| TT(1) | 0 | . | Enter | Left mouse |
\-----------------------------------------------------'
*/
[0] = LAYOUT(
KC_7, KC_8, KC_9, KC_BSPC,
KC_4, KC_5, KC_6, KC_ESC,
KC_1, KC_2, KC_3, KC_TAB,
TT(1), KC_0, LSFT_T(KC_DOT), KC_ENTER, KC_BTN1
),
/*
SUB LAYER
/-----------------------------------------------------`
| | | | Reset | |
|---------|---------|---------|---------| |
| | | | + | |
|---------|---------|---------|---------| |
| | | | - | |
|---------|---------|---------|---------|-------------|
| | | | = | LOCK |
\-----------------------------------------------------'
*/
[1] = LAYOUT(
_______, _______, _______, RESET,
_______, _______, _______, KC_KP_PLUS,
_______, _______, _______, KC_KP_MINUS,
_______, _______, _______, KC_EQL, KC_LOCK
),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed
/*
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
*/
return true;
}
void keyboard_post_init_user(void) {
// Customise these values to desired behaviour
// debug_enable = true;
// debug_matrix = true;
// debug_keyboard = true;
// debug_mouse = true;
}
void encoder_update_user(uint8_t index, bool clockwise) {
/* Custom encoder control - handles CW/CCW turning of encoder
* Default behavior:
* main layer:
* CW: move mouse right
* CCW: move mouse left
* other layers:
* CW: = (equals/plus - increase slider in Adobe products)
* CCW: - (minus/underscore - decrease slider in adobe products)
*/
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
// main layer - move mouse right (CW) and left (CCW)
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
// other layers - =/+ (quals/plus) (CW) and -/_ (minus/underscore) (CCW)
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

15
keyboards/dumbpad/v1x_right/readme.md 100644
View File

@ -0,0 +1,15 @@
# dumbpad v1.x with encoder on right side
![dumbpad](https://i.imgur.com/ND03FiFl.png)
A 4x4 numpad/macropad with a rotary encoder to the right of the bottom row of keys.
* Keyboard Maintainer: [imchipwood](https://github.com/imchipwood)
* Hardware repository: [dumbpad on github](https://github.com/imchipwood/dumbpad)
* PCB Revisions Supported: v1.0
Make example for this keyboard (after setting up your build environment):
make dumbpad/v1x_right:default
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).

25
keyboards/dumbpad/v1x_right/rules.mk 100644
View File

@ -0,0 +1,25 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
BOOTLOADER = caterina
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
BLUETOOTH_ENABLE = no # Enable Bluetooth
AUDIO_ENABLE = no # Audio output
ENCODER_ENABLE = yes
KEY_LOCK_ENABLE = yes

25
keyboards/dumbpad/v1x_right/templates/keymap.c 100644
View File

@ -0,0 +1,25 @@
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {__KEYMAP_GOES_HERE__};
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case 0:
if (clockwise) {
tap_code(KC_MS_R);
} else {
tap_code(KC_MS_L);
}
break;
default:
if (clockwise) {
tap_code(KC_EQL);
} else {
tap_code(KC_MINS);
}
break;
}
}
}

69
keyboards/dumbpad/v1x_right/v1x_right.c 100644
View File

@ -0,0 +1,69 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "v1x_right.h"
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
setPinOutput(LED_00);
setPinOutput(LED_01);
setPinOutput(LED_02);
keyboard_pre_init_user();
}
void shutdown_user() {
// Shutdown LEDs
writePinLow(LED_00);
writePinLow(LED_01);
writePinLow(LED_02);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
writePin(LED_00, layer & 0b1);
writePin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
writePinHigh(LED_00);
writePinHigh(LED_01);
writePinHigh(LED_02);
wait_ms(led_delay_ms);
writePinLow(LED_00);
writePinLow(LED_01);
writePinLow(LED_02);
if (i < 1) {
wait_ms(led_delay_ms);
}
}
matrix_init_user();
}
void led_set_kb(uint8_t usb_led) {
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
writePin(LED_02, !IS_LED_ON(usb_led, USB_LED_NUM_LOCK));
led_set_user(usb_led);
}

30
keyboards/dumbpad/v1x_right/v1x_right.h 100644
View File

@ -0,0 +1,30 @@
/* Copyright 2020 imchipwood
*
* 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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
#define LAYOUT( \
k00, k01, k02, k03, \
k10, k11, k12, k13, \
k20, k21, k22, k23, \
k30, k31, k32, k33, k34 \
) \
{ \
{ k00, k01, k02, k03, KC_NO }, \
{ k10, k11, k12, k13, KC_NO }, \
{ k20, k21, k22, k23, KC_NO }, \
{ k30, k31, k32, k33, k34 }, \
}