g1smo
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into develop

master
QMK Bot 2021-10-02 14:51:25 +00:00
parent 5b644af415 79ad30a9d5
commit 79c6757081
6 changed files with 849 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
keyboards/splitkb/kyria/keymaps/john-ezra/config.h
View File

@ -16,19 +16,15 @@
#pragma once #pragma once
#ifdef OLED_DRIVER_ENABLE #define OLED_FONT_H "keyboards/splitkb/kyria/keymaps/john-ezra/glcdfont.c"
#define OLED_DISPLAY_128X64 #define OLED_FONT_END 255
#endif #define OLED_TIMEOUT 30000
#define OLED_DISPLAY_128X64
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
#define RGBLIGHT_EFFECT_RAINBOW_MOOD #define RGBLIGHT_HUE_STEP 5
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL #define RGBLIGHT_SAT_STEP 5
#define RGBLIGHT_EFFECT_STATIC_GRADIENT #define RGBLIGHT_VAL_STEP 5
#define RGBLIGHT_EFFECT_TWINKLE
#define RGBLIGHT_HUE_STEP 8
#define RGBLIGHT_SAT_STEP 8
#define RGBLIGHT_VAL_STEP 8
#define RGBLIGHT_LIMIT_VAL 150 #define RGBLIGHT_LIMIT_VAL 150
#endif #endif
@ -38,3 +34,7 @@
#define TAPPING_TERM 125 #define TAPPING_TERM 125
#define SPLIT_WPM_ENABLE #define SPLIT_WPM_ENABLE
#define USB_POLLING_INTERVAL_MS 1
#define DEBUG_MATRIX_SCAN_RATE

276
keyboards/splitkb/kyria/keymaps/john-ezra/glcdfont.c 100644
View File

@ -0,0 +1,276 @@
/* Copyright 2021 John Ezra
*
* 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 "progmem.h"
static const unsigned char font[] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
0x18, 0x24, 0x24, 0x1C, 0x78, 0x00,
0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
0x7C, 0x18, 0x24, 0x24, 0x18, 0x00,
0x18, 0x24, 0x24, 0x18, 0x7C, 0x00,
0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00,
0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00,
0x00, 0xF0, 0x08, 0x24, 0x52, 0xE2,
0x42, 0x42, 0x42, 0xE2, 0x52, 0x22,
0x24, 0x22, 0x42, 0x82, 0x02, 0x02,
0x22, 0x22, 0x02, 0x02, 0xFE, 0x00,
0x00, 0xF0, 0x08, 0x04, 0x02, 0x82,
0x42, 0x22, 0x42, 0x82, 0x02, 0x02,
0x04, 0x82, 0x42, 0x22, 0x12, 0x22,
0x42, 0x82, 0x02, 0x02, 0xFE, 0x00,
0x00, 0xF0, 0x08, 0x84, 0x42, 0x42,
0x82, 0x82, 0x42, 0x42, 0x42, 0x82,
0x04, 0x82, 0xC2, 0xE2, 0xF2, 0xE2,
0xC2, 0x82, 0x02, 0x02, 0xFE, 0x00,
0x00, 0xF0, 0x08, 0x44, 0x42, 0xF2,
0x42, 0x42, 0x42, 0xF2, 0x42, 0x42,
0x04, 0x82, 0xE2, 0x92, 0x92, 0x92,
0xE2, 0x82, 0x02, 0x02, 0xFE, 0x00,
0x00, 0xF0, 0x08, 0x84, 0x82, 0x02,
0x82, 0x02, 0x02, 0x82, 0x82, 0x02,
0x02, 0x02, 0x82, 0x82, 0x02, 0x02,
0xE2, 0x12, 0x12, 0xE2, 0x02, 0x62,
0x92, 0x92, 0x22, 0x02, 0xFE, 0x00,
0x00, 0xF0, 0x08, 0x04, 0xF2, 0x02,
0x02, 0x02, 0xF2, 0x02, 0x82, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x22,
0xF2, 0x02, 0x02, 0xE2, 0x12, 0x12,
0x12, 0xE2, 0x02, 0x02, 0xFE, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0xFE, 0x00, 0x00, 0xF0, 0x08,
0x02, 0xFE, 0x00, 0x00, 0xF0, 0xF8,
0x00, 0x7F, 0x40, 0x44, 0x4A, 0x47,
0x42, 0x42, 0x42, 0x47, 0x4A, 0x44,
0x40, 0x40, 0x40, 0x40, 0x41, 0x42,
0x44, 0x44, 0x40, 0x40, 0x7F, 0x00,
0x00, 0x7F, 0x40, 0x40, 0x41, 0x40,
0x40, 0x40, 0x40, 0x40, 0x41, 0x40,
0x41, 0x41, 0x4F, 0x48, 0x48, 0x48,
0x4F, 0x41, 0x41, 0x40, 0x7F, 0x00,
0x00, 0x7F, 0x40, 0x41, 0x42, 0x42,
0x42, 0x41, 0x41, 0x42, 0x42, 0x41,
0x40, 0x40, 0x40, 0x4B, 0x4B, 0x4B,
0x40, 0x40, 0x40, 0x40, 0x7F, 0x00,
0x00, 0x7F, 0x40, 0x42, 0x42, 0x4F,
0x42, 0x42, 0x42, 0x4F, 0x42, 0x42,
0x40, 0x4F, 0x4F, 0x4F, 0x48, 0x4F,
0x4F, 0x4F, 0x40, 0x40, 0x7F, 0x00,
0x00, 0x7F, 0x40, 0x4F, 0x40, 0x4F,
0x40, 0x4F, 0x44, 0x4A, 0x4A, 0x4F,
0x48, 0x47, 0x48, 0x48, 0x45, 0x40,
0x47, 0x48, 0x48, 0x47, 0x40, 0x44,
0x48, 0x48, 0x47, 0x40, 0x7F, 0x00,
0x00, 0x7F, 0x40, 0x40, 0x47, 0x48,
0x47, 0x48, 0x47, 0x40, 0x4E, 0x40,
0x4F, 0x41, 0x41, 0x4E, 0x40, 0x48,
0x4F, 0x48, 0x40, 0x47, 0x48, 0x48,
0x48, 0x47, 0x40, 0x40, 0x7F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x40, 0x7F, 0x00, 0x00, 0x7F, 0x40,
0x40, 0x7F, 0x00, 0x00, 0x7F, 0x7F,
0x00, 0xF0, 0xF8, 0xDC, 0xAE, 0x1E,
0xBE, 0xBE, 0xBE, 0x1E, 0xAE, 0xDE,
0xDC, 0xDE, 0xBE, 0x7E, 0xFE, 0xFE,
0xDE, 0xDE, 0xFE, 0xFE, 0xFE, 0x00,
0x00, 0xF0, 0xF8, 0xFC, 0xFE, 0x7E,
0xBE, 0xDE, 0xBE, 0x7E, 0xFE, 0xFE,
0xFC, 0x7E, 0x3E, 0x1E, 0x0E, 0x1E,
0x3E, 0x7E, 0xFE, 0xFE, 0xFE, 0x00,
0x00, 0xF0, 0xF8, 0x7C, 0xBE, 0xBE,
0x7E, 0x7E, 0xBE, 0xBE, 0xBE, 0x7E,
0xFC, 0x7E, 0x3E, 0x1E, 0x0E, 0x1E,
0x3E, 0x7E, 0xFE, 0xFE, 0xFE, 0x00,
0x00, 0xF0, 0xF8, 0xBC, 0xBE, 0x0E,
0xBE, 0xBE, 0xBE, 0x0E, 0xBE, 0xBE,
0xFC, 0x7E, 0x1E, 0x6E, 0x6E, 0x6E,
0x1E, 0x7E, 0xFE, 0xFE, 0xFE, 0x00,
0x00, 0xF0, 0xF8, 0x7C, 0x7E, 0xFE,
0x7E, 0xFE, 0xFE, 0x7E, 0x7E, 0xFE,
0xFE, 0xFE, 0x7E, 0x7E, 0xFE, 0xFE,
0x1E, 0xEE, 0xEE, 0x1E, 0xFE, 0x9E,
0x6E, 0x6E, 0xDE, 0xFE, 0xFE, 0x00,
0x00, 0xF0, 0xF8, 0xFC, 0x0E, 0xFE,
0xFE, 0xFE, 0x0E, 0xFE, 0x7E, 0xFE,
0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xDE,
0x0E, 0xFE, 0xFE, 0x1E, 0xEE, 0xEE,
0xEE, 0x1E, 0xFE, 0xFE, 0xFE, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFE, 0xFE, 0x00, 0x00, 0xF0, 0x08,
0xFE, 0xFE, 0x00, 0x00, 0xF0, 0xF8,
0x00, 0x7F, 0x7F, 0x7B, 0x75, 0x78,
0x7D, 0x7D, 0x7D, 0x78, 0x75, 0x7B,
0x7F, 0x7F, 0x7F, 0x7F, 0x7E, 0x7D,
0x7B, 0x7B, 0x7F, 0x7F, 0x7F, 0x00,
0x00, 0x7F, 0x7F, 0x7F, 0x7E, 0x7F,
0x7F, 0x7F, 0x7F, 0x7F, 0x7E, 0x7F,
0x7E, 0x7E, 0x70, 0x70, 0x70, 0x70,
0x70, 0x7E, 0x7E, 0x7F, 0x7F, 0x00,
0x00, 0x7F, 0x7F, 0x7E, 0x7D, 0x7D,
0x7D, 0x7E, 0x7E, 0x7D, 0x7D, 0x7E,
0x7F, 0x7F, 0x7F, 0x74, 0x74, 0x74,
0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x00,
0x00, 0x7F, 0x7F, 0x7D, 0x7D, 0x70,
0x7D, 0x7D, 0x7D, 0x70, 0x7D, 0x7D,
0x7F, 0x70, 0x70, 0x70, 0x77, 0x70,
0x70, 0x70, 0x7F, 0x7F, 0x7F, 0x00,
0x00, 0x7F, 0x7F, 0x70, 0x7F, 0x70,
0x7F, 0x70, 0x7B, 0x75, 0x75, 0x70,
0x77, 0x78, 0x77, 0x77, 0x7A, 0x7F,
0x78, 0x77, 0x77, 0x78, 0x7F, 0x7B,
0x77, 0x77, 0x78, 0x7F, 0x7F, 0x00,
0x00, 0x7F, 0x7F, 0x7F, 0x78, 0x77,
0x78, 0x77, 0x78, 0x7F, 0x71, 0x7F,
0x70, 0x7E, 0x7E, 0x71, 0x7F, 0x77,
0x70, 0x77, 0x7F, 0x78, 0x77, 0x77,
0x77, 0x78, 0x7F, 0x7F, 0x7F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7F, 0x7F, 0x00, 0x00, 0x7F, 0x40,
0x7F, 0x7F, 0x00, 0x00, 0x7F, 0x7F,
};

130
keyboards/splitkb/kyria/keymaps/john-ezra/keymap.c
View File

@ -1,23 +1,25 @@
/* Copyright 2021 John Ezra /* Copyright 2021 John Ezra
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or * the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
enum kyria_layers { enum kyria_layers {
_HNTS, _HNTS,
_GAME,
_NUMPAD,
_LOWER, _LOWER,
_RAISE, _RAISE,
_ADJUST _ADJUST
@ -25,20 +27,27 @@ enum kyria_layers {
enum kyria_keycodes { enum kyria_keycodes {
HNTS = SAFE_RANGE, HNTS = SAFE_RANGE,
ESC_NUM,
LOWER, LOWER,
RAISE, RAISE,
MSS_CTL,
CPY_PST, CPY_PST,
UNDO, UNDO,
FIND FIND
}; };
#define HNTS DF(_HNTS) #define HNTS DF(_HNTS)
#define QWERTY DF(_QWERTY) #define GAME TG(_GAME)
#define NUMPAD TG(_NUMPAD)
#define MSS_CTL MT(MOD_LCTL, C(KC_UP))
#define BSP_CMD MT(MOD_LGUI, KC_BSPC) #define BSP_CMD MT(MOD_LGUI, KC_BSPC)
#define TAB_CMD MT(MOD_LGUI, KC_TAB)
#define SFT_ENT MT(MOD_LSFT, KC_ENT) #define SFT_ENT MT(MOD_LSFT, KC_ENT)
#define ALT_ESC MT(MOD_LALT, KC_ESC)
#define ALT_TAB A(KC_TAB)
#define UNDO G(KC_Z) #define UNDO G(KC_Z)
#define FIND G(KC_F) #define FIND G(KC_F)
#define MSS_CTL C(KC_UP)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
@ -52,15 +61,57 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |-------+-------+-------+-------+-------+-------+---------------. ,---------------+-------+-------+-------+-------+-------+-------| * |-------+-------+-------+-------+-------+-------+---------------. ,---------------+-------+-------+-------+-------+-------+-------|
* | Undo | K | V | M | F | G | Esc |MssnCtl| |MssnCtl| Esc | J | ; : | , < | . > | / ? | ' " | * | Undo | K | V | M | F | G | Esc |MssnCtl| |MssnCtl| Esc | J | ; : | , < | . > | / ? | ' " |
* `-------+-------+-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-----------------------' * `-------+-------+-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-----------------------'
* | Ctrl | Alt | Lower | Space | BSPC | | Tab | Shift | Raise | Del | Caps | * | Numpad| Enter | Lower | Space | BSPC | | Tab | Shift | Raise | Del | Caps |
* `---------------------------------------' `---------------------------------------' * `---------------------------------------' `---------------------------------------'
*/ */
[_HNTS] = LAYOUT( [_HNTS] = LAYOUT(
FIND, KC_Z, KC_R, KC_L, KC_D, KC_W, KC_Y, KC_P, KC_U, KC_X, KC_Q, KC_BSLS, FIND, KC_Z, KC_R, KC_L, KC_D, KC_W, KC_Y, KC_P, KC_U, KC_X, KC_Q, KC_BSLS,
CPY_PST, KC_H, KC_N, KC_T, KC_S, KC_C, KC_B, KC_I, KC_E, KC_O, KC_A, KC_GRV, CPY_PST, KC_H, KC_N, KC_T, KC_S, KC_C, KC_B, KC_I, KC_E, KC_O, KC_A, KC_GRV,
UNDO, KC_K, KC_V, KC_M, KC_F, KC_G, KC_ESC, MSS_CTL, MSS_CTL, KC_ESC, KC_J, KC_SCLN, KC_COMM, KC_DOT, KC_SLSH, KC_QUOT, UNDO, KC_K, KC_V, KC_M, KC_F, KC_G, ALT_ESC, MSS_CTL, MSS_CTL, ALT_ESC, KC_J, KC_SCLN, KC_COMM, KC_DOT, KC_SLSH, KC_QUOT,
KC_LCTL, KC_LALT, LOWER, KC_SPC, BSP_CMD, KC_TAB, SFT_ENT, RAISE, KC_DEL, KC_CAPS NUMPAD, SFT_ENT, LOWER, KC_SPC, BSP_CMD, TAB_CMD, SFT_ENT, RAISE, KC_DEL, KC_CAPS
),
/*
* Game: Gaming Layer
*
* ,-----------------------------------------------. ,-----------------------------------------------.
* | 0 | Z | R | L | D | W | | Y | P | U | X | Q | Esc |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | 1 | H | N | T | S | C | | B | I | E | O | A | Enter |
* |-------+-------+-------+-------+-------+-------+---------------. ,---------------+-------+-------+-------+-------+-------+-------|
* | 2 | K | V | M | F | G | 8 | 9 | |Default| Esc | J | ; : | , < | . > | / ? |Alt+Tab|
* `-------+-------+-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-----------------------'
* | 3 | 4 | 5 | 6 | 7 | | Tab | Shift | Raise | Del | Caps |
* `---------------------------------------' `---------------------------------------'
*/
[_GAME] = LAYOUT(
KC_0, KC_Z, KC_R, KC_L, KC_D, KC_W, KC_Y, KC_P, KC_U, KC_X, KC_Q, KC_ESC,
KC_1, KC_H, KC_N, KC_T, KC_S, KC_C, KC_B, KC_I, KC_E, KC_O, KC_A, KC_ENT,
KC_2, KC_K, KC_V, KC_M, KC_F, KC_G, KC_8, KC_9, GAME, ALT_ESC, KC_J, KC_SCLN, KC_COMM, KC_DOT, KC_SLSH, ALT_TAB,
KC_3, KC_4, KC_5, KC_6, KC_7, TAB_CMD, SFT_ENT, RAISE, KC_DEL, KC_CAPS
),
/*
* Numpad
*
* ,-----------------------------------------------. ,-----------------------------------------------.
* | * | + | 7 | 8 | 9 | 0 | | | | | | | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | / | - | 4 | 5 | 6 | ( | | | Left | Up | Down | Right | |
* |-------+-------+-------+-------+-------+-------+---------------. ,---------------+-------+-------+-------+-------+-------+-------|
* | = | . | 1 | 2 | 3 | ) | | | | | | | | | | | |
* `-------+-------+-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-----------------------'
* | | | | | | | | | | | |
* `---------------------------------------' `---------------------------------------'
*/
[_NUMPAD] = LAYOUT(
KC_ASTR, KC_PLUS, KC_7, KC_8, KC_9, KC_0, _______, _______, _______, _______, _______, _______,
KC_SLSH, KC_MINS, KC_4, KC_5, KC_6, KC_LPRN, _______, KC_LEFT, KC_UP, KC_DOWN, KC_RGHT, _______,
KC_EQL, KC_DOT, KC_1, KC_2, KC_3, KC_RPRN, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______
), ),
/* /*
@ -105,26 +156,27 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
), ),
/* /*
* Adjust: Function Keys & RGB * Adjust: Function Keys & RGB
* *
* ,-----------------------------------------------. ,-----------------------------------------------. * ,-----------------------------------------------. ,-----------------------------------------------.
* | Reset | | | | | | | | NKRO |CG SWAP| | | HNTS | * | Reset | | | | | | | | NKRO |CG SWAP| | | HNTS |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------| * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | TOG | SAI | HUI | VAI | MOD | | | | | | | | * | | TOG | SAI | HUI | VAI | MOD | | |Bright+|Bright-| | | |
* |-------+-------+-------+-------+-------+-------+---------------. ,---------------+-------+-------+-------+-------+-------+-------| * |-------+-------+-------+-------+-------+-------+---------------. ,---------------+-------+-------+-------+-------+-------+-------|
* | | | SAD | HUD | VAD | RMOD | | | | | | | |Bright+|Bright-| | | * | | | SAD | HUD | VAD | RMOD | | | | | | | | | | | |
* `-------+-------+-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-----------------------' * `-------+-------+-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-----------------------'
* | | | | | | | | | | | | * | | | | | | | | | | | |
* `---------------------------------------' `---------------------------------------' * `---------------------------------------' `---------------------------------------'
*/ */
[_ADJUST] = LAYOUT( [_ADJUST] = LAYOUT(
RESET, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, HNTS, RESET, _______, _______, _______, _______, _______, _______, NK_TOGG, CG_TOGG, _______, GAME, HNTS,
_______, RGB_TOG, RGB_SAI, RGB_HUI, RGB_VAI, RGB_MOD, CG_TOGG, NK_TOGG, KC_BRID, KC_BRIU, _______, _______, _______, RGB_TOG, RGB_SAI, RGB_HUI, RGB_VAI, RGB_MOD, _______, KC_BRIU, KC_BRID, _______, _______, _______,
_______, _______, RGB_SAD, RGB_HUD, RGB_VAD,RGB_RMOD,_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, RGB_SAD, RGB_HUD, RGB_VAD,RGB_RMOD,_______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
), ),
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user(uint16_t keycode, keyrecord_t *record) {
@ -167,6 +219,12 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
} }
break; break;
case MSS_CTL:
if (record->event.pressed && record->tap.count) {
tap_code16(C(KC_UP));
return false;
}
break;
case UNDO: // Tap to Undo, Tap with GUI to Redo case UNDO: // Tap to Undo, Tap with GUI to Redo
if (get_mods() & MOD_MASK_GUI) { if (get_mods() & MOD_MASK_GUI) {
if (record->event.pressed) { if (record->event.pressed) {

536
keyboards/splitkb/kyria/keymaps/john-ezra/oled.c
View File

@ -1,18 +1,18 @@
/* Copyright 2021 John Ezra /* Copyright 2021 John Ezra
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or * the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
//Sets up what the OLED screens display. //Sets up what the OLED screens display.
@ -26,7 +26,7 @@ int vert_count = 0;
//============= USER CONFIG PARAMS =============== //============= USER CONFIG PARAMS ===============
float max_wpm = 150.0f; //WPM value at the top of the graph window float max_wpm = 150.0f; //WPM value at the top of the graph window
int graph_refresh_interval = 80; //in milliseconds int graph_refresh_interval = 100; //in milliseconds
int graph_area_fill_interval = 3; //determines how dense the horizontal lines under the graph line are; lower = more dense int graph_area_fill_interval = 3; //determines how dense the horizontal lines under the graph line are; lower = more dense
int vert_interval = 3; //determines frequency of vertical lines under the graph line int vert_interval = 3; //determines frequency of vertical lines under the graph line
bool vert_line = false; //determines whether to draw vertical lines bool vert_line = false; //determines whether to draw vertical lines
@ -34,110 +34,456 @@ int graph_line_thickness = 2; //determines thickness of graph line in pixels
//============= END USER PARAMS =============== //============= END USER PARAMS ===============
#ifdef OLED_ENABLE #ifdef OLED_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) { oled_rotation_t oled_init_user(oled_rotation_t rotation) {
return OLED_ROTATION_180; return OLED_ROTATION_180;
} }
static void render_qmk_logo(void) { static void render_qmk_logo(void) {
static const char PROGMEM qmk_logo[] = { static const char PROGMEM qmk_logo[] = {
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0x70, 0x70, 0x7e, 0xf0, 0xf0, 0xfe, 0xf0, 0x70, 0x7e,
0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4, 0x70, 0xf0, 0xfe, 0xf0, 0xf0, 0x7e, 0x70, 0x70, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x92, 0x92, 0x92, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x92, 0x92, 0x92, 0x00, 0x00,
0xf8, 0xfc, 0x0e, 0x06, 0x06, 0x06, 0x0e, 0xfc, 0xf8, 0x00, 0xfe, 0xfe, 0x1c, 0x38, 0x70, 0xe0,
0x70, 0x38, 0x1c, 0xfe, 0xfe, 0x00, 0xfe, 0xfe, 0xe0, 0xf0, 0xb8, 0x1c, 0x0e, 0x06, 0x00, 0x00,
0x00, 0xfe, 0xfe, 0xc6, 0xc6, 0xc6, 0x06, 0x00, 0xe6, 0xe6, 0x00, 0xf0, 0xf0, 0x60, 0x30, 0x30,
0x60, 0x00, 0xf0, 0xf0, 0x30, 0x30, 0xe0, 0xc0, 0x30, 0x30, 0x30, 0xe0, 0xc0, 0x00, 0xf0, 0xf0,
0x00, 0xc0, 0xe0, 0x70, 0xe0, 0xc0, 0x00, 0xf0, 0xf0, 0x00, 0x20, 0xb0, 0x90, 0xb0, 0xf0, 0xe0,
0x00, 0xf0, 0xf0, 0x60, 0x30, 0x30, 0x60, 0x00, 0xc0, 0xe0, 0x30, 0x30, 0x30, 0xe0, 0xc0, 0x00,
0x00, 0x24, 0x24, 0x24, 0xff, 0xff, 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xf1, 0xe3, 0xe3, 0x00, 0x00,
0x00, 0xe3, 0xe3, 0xf1, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xff, 0xff, 0x24, 0x24, 0x24, 0x00, 0x00,
0x03, 0x07, 0x0e, 0x0c, 0x0c, 0x1c, 0x1e, 0x17, 0x13, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x0f, 0x0f, 0x00, 0x01, 0x03, 0x07, 0x0e, 0x0c, 0x00, 0x00,
0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x01, 0x0f,
0x0f, 0x07, 0x01, 0x00, 0x01, 0x07, 0x0f, 0x0f, 0x01, 0x00, 0x07, 0x0f, 0x0c, 0x04, 0x0f, 0x0f,
0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0d, 0x09, 0x09, 0x0d, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x07, 0x07, 0x3f, 0x07, 0x07, 0x3f, 0x07, 0x07, 0x3f,
0x07, 0x07, 0x3f, 0x07, 0x07, 0x3f, 0x07, 0x07, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
oled_write_raw_P(qmk_logo, sizeof(qmk_logo));
}
oled_write_P(qmk_logo, false); // Loop to create line by line rendering for Horizontal display
// Input is oled_render_image(how many rows tall, how many pixels wide, what to render, X pos, Y pos, Frame offset)
void oled_render_image(int lines, int px, const char render_line[][px], int X_pos, int Y_pos, int frame) {
for (uint8_t i = 0; i < lines; i++){
oled_set_cursor(X_pos, Y_pos + i);
oled_write_raw_P(render_line[i + frame], px);
}
}
static void render_layers(void) {
static const char PROGMEM layer_background_r1[1][38] = {
{0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x82, 0x82, 0x42,
0x42, 0x42, 0x22, 0x22, 0x22, 0x42, 0x42, 0x42, 0x82, 0x82, 0x82, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0xfe}
};
static const char PROGMEM layer_background_r2[1][38] = {
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xaa, 0xaa, 0xaa, 0x11, 0x11, 0x11, 0x20, 0x20, 0x20, 0x40,
0x40, 0x40, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x20, 0x20, 0x20, 0x11, 0x11, 0x11, 0xaa, 0xaa,
0xaa, 0x44, 0x44, 0x44, 0x00, 0xff}
};
static const char PROGMEM layer_background_r3[1][38] = {
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xaa, 0xaa, 0xaa, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x44,
0x44, 0x44, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0xaa, 0xaa,
0xaa, 0x44, 0x44, 0x44, 0x00, 0xff}
};
static const char PROGMEM layer_background_r4[1][38] = {
{0x00, 0x7f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41, 0x41, 0x41, 0x42, 0x42, 0x42, 0x44,
0x44, 0x44, 0x48, 0x48, 0x48, 0x44, 0x44, 0x44, 0x42, 0x42, 0x42, 0x41, 0x41, 0x41, 0x40, 0x40,
0x40, 0x40, 0x40, 0x40, 0x40, 0x7f}
};
static const char PROGMEM base[1][38] = {
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xae, 0xae, 0xae, 0x1f, 0x1f, 0x1f, 0x3e, 0x3e, 0x3e, 0x7c,
0x7c, 0x7c, 0xf8, 0xf8, 0xf8, 0x7c, 0x7c, 0x7c, 0x3e, 0x3e, 0x3e, 0x1f, 0x1f, 0x1f, 0xae, 0xae,
0xae, 0x44, 0x44, 0x44, 0x00, 0xff}
};
static const char PROGMEM lower[2][38] = {
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xea, 0xea, 0xea, 0xf1, 0xf1, 0xf1, 0xe2, 0xe2, 0xe2, 0xc4,
0xc4, 0xc4, 0x88, 0x88, 0x88, 0xc4, 0xc4, 0xc4, 0xe2, 0xe2, 0xe2, 0xf1, 0xf1, 0xf1, 0xea, 0xea,
0xea, 0x44, 0x44, 0x44, 0x00, 0xff},
{0x00, 0x7f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41, 0x41, 0x41, 0x43, 0x43, 0x43, 0x47,
0x47, 0x47, 0x4f, 0x4f, 0x4f, 0x47, 0x47, 0x47, 0x43, 0x43, 0x43, 0x41, 0x41, 0x41, 0x40, 0x40,
0x40, 0x40, 0x40, 0x40, 0x40, 0x7f}
};
static const char PROGMEM raise[][38] = {
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xea, 0xea, 0xea, 0xf1, 0xf1, 0xf1, 0xe0, 0xe0, 0xe0, 0xc0,
0xc0, 0xc0, 0x80, 0x80, 0x80, 0xc0, 0xc0, 0xc0, 0xe0, 0xe0, 0xe0, 0xf1, 0xf1, 0xf1, 0xea, 0xea,
0xea, 0x44, 0x44, 0x44, 0x00, 0xff},
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xaa, 0xaa, 0xaa, 0x11, 0x11, 0x11, 0x23, 0x23, 0x23, 0x47,
0x47, 0x47, 0x8f, 0x8f, 0x8f, 0x47, 0x47, 0x47, 0x23, 0x23, 0x23, 0x11, 0x11, 0x11, 0xaa, 0xaa,
0xaa, 0x44, 0x44, 0x44, 0x00, 0xff}
};
static const char PROGMEM adjust[][38] = {
{0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x82, 0x82, 0xc2,
0xc2, 0xc2, 0xe2, 0xe2, 0xe2, 0xc2, 0xc2, 0xc2, 0x82, 0x82, 0x82, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0xfe},
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xae, 0xae, 0xae, 0x1f, 0x1f, 0x1f, 0x3f, 0x3f, 0x3f, 0x7f,
0x7f, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x3f, 0x3f, 0x3f, 0x1f, 0x1f, 0x1f, 0xae, 0xae,
0xae, 0x44, 0x44, 0x44, 0x00, 0xff}
};
static const char PROGMEM custom[][38] = {
{0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x82, 0x82, 0x42,
0xc2, 0x42, 0xa2, 0x62, 0xa2, 0x42, 0xc2, 0x42, 0x82, 0x82, 0x82, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0xfe},
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xaa, 0xee, 0xaa, 0x55, 0xbb, 0x55, 0xaa, 0x75, 0xaa, 0x55,
0xea, 0x55, 0xaa, 0xd5, 0xaa, 0x55, 0xea, 0x55, 0xaa, 0x75, 0xaa, 0x55, 0xbb, 0x55, 0xaa, 0xee,
0xaa, 0x44, 0x44, 0x44, 0x00, 0xff},
{0x00, 0xff, 0x00, 0x44, 0x44, 0x44, 0xaa, 0xee, 0xaa, 0x55, 0xbb, 0x55, 0xaa, 0x77, 0xaa, 0x55,
0xee, 0x55, 0xaa, 0xdd, 0xaa, 0x55, 0xee, 0x55, 0xaa, 0x77, 0xaa, 0x55, 0xbb, 0x55, 0xaa, 0xee,
0xaa, 0x44, 0x44, 0x44, 0x00, 0xff},
{0x00, 0x7f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41, 0x41, 0x41, 0x42, 0x43, 0x42, 0x45,
0x46, 0x45, 0x4a, 0x4d, 0x4a, 0x45, 0x46, 0x45, 0x42, 0x43, 0x42, 0x41, 0x41, 0x41, 0x40, 0x40,
0x40, 0x40, 0x40, 0x40, 0x40, 0x7f}
};
switch (get_highest_layer(layer_state)) {
case 0:
oled_render_image(1, 38, layer_background_r1, 15, 4, 0);
oled_render_image(1, 38, layer_background_r2, 15, 5, 0);
oled_render_image(1, 38, base, 15, 6, 0);
oled_render_image(1, 38, layer_background_r4, 15, 7, 0);
break;
case 3:
oled_render_image(2, 38, lower, 15, 6, 0);
break;
case 4:
oled_render_image(1, 38, layer_background_r1, 15, 4, 0);
oled_render_image(2, 38, raise, 15, 5, 0);
oled_render_image(1, 38, layer_background_r4, 15, 7, 0);
break;
case 5:
oled_render_image(2, 38, adjust, 15, 4, 0);
oled_render_image(1, 38, layer_background_r3, 15, 6, 0);
oled_render_image(1, 38, layer_background_r4, 15, 7, 0);
break;
default:
oled_render_image(4, 38, custom, 15, 4, 0);
break;
}
}
void render_mod_state(uint8_t modifiers) {
static const char PROGMEM gui_off [][3]= {{0x80, 0x81, 0}, {0xa0, 0xa1, 0}};
static const char PROGMEM gui_on [][3]= {{0xc0, 0xc1, 0}, {0xe0, 0xe1, 0}};
static const char PROGMEM alt_off [][3]= {{0x82, 0x83, 0}, {0xa2, 0xa3, 0}};
static const char PROGMEM alt_on [][3]= {{0xc2, 0xc3, 0}, {0xe2, 0xe3, 0}};
static const char PROGMEM ctrl_off [][3]= {{0x84, 0x85, 0}, {0xa4, 0xa5, 0}};
static const char PROGMEM ctrl_on [][3]= {{0xc4, 0xc5, 0}, {0xe4, 0xe5, 0}};
static const char PROGMEM shift_off [][3]= {{0x86, 0x87, 0}, {0xa6, 0xa7, 0}};
static const char PROGMEM shift_on [][3]= {{0xc6, 0xc7, 0}, {0xe6, 0xe7, 0}};
// fillers between the modifier icons bleed into the icon frames
static const char PROGMEM off_off [][2]= {{0x9e, 0}, {0xbe, 0}};
static const char PROGMEM on_on [][2]= {{0xdf, 0}, {0xff, 0}};
static const char PROGMEM on_off [][2]= {{0xde, 0}, {0xfe, 0}};
static const char PROGMEM off_on [][2]= {{0x9f, 0}, {0xbf, 0}};
// render icons
if(modifiers & MOD_MASK_GUI) {
oled_set_cursor(0, 4);
oled_write_P(gui_on[0], false);
oled_set_cursor(0, 5);
oled_write_P(gui_on[1], false);
} else {
oled_set_cursor(0, 4);
oled_write_P(gui_off[0], false);
oled_set_cursor(0, 5);
oled_write_P(gui_off[1], false);
}
if(modifiers & MOD_MASK_ALT) {
oled_set_cursor(3, 4);
oled_write_P(alt_on[0], false);
oled_set_cursor(3, 5);
oled_write_P(alt_on[1], false);
} else {
oled_set_cursor(3, 4);
oled_write_P(alt_off[0], false);
oled_set_cursor(3, 5);
oled_write_P(alt_off[1], false);
}
if(modifiers & MOD_MASK_CTRL) {
oled_set_cursor(0, 6);
oled_write_P(ctrl_on[0], false);
oled_set_cursor(0, 7);
oled_write_P(ctrl_on[1], false);
} else {
oled_set_cursor(0, 6);
oled_write_P(ctrl_off[0], false);
oled_set_cursor(0, 7);
oled_write_P(ctrl_off[1], false);
}
if(modifiers & MOD_MASK_SHIFT) {
oled_set_cursor(3, 6);
oled_write_P(shift_on[0], false);
oled_set_cursor(3, 7);
oled_write_P(shift_on[1], false);
} else {
oled_set_cursor(3, 6);
oled_write_P(shift_off[0], false);
oled_set_cursor(3, 7);
oled_write_P(shift_off[1], false);
}
// render fillers
if ((modifiers & MOD_MASK_GUI) && (modifiers & MOD_MASK_ALT)) {
oled_set_cursor(2, 4);
oled_write_P(on_on[0], false);
oled_set_cursor(2, 5);
oled_write_P(on_on[1], false);
} else if(modifiers & MOD_MASK_GUI) {
oled_set_cursor(2, 4);
oled_write_P(on_off[0], false);
oled_set_cursor(2, 5);
oled_write_P(on_off[1], false);
} else if(modifiers & MOD_MASK_ALT) {
oled_set_cursor(2, 4);
oled_write_P(off_on[0], false);
oled_set_cursor(2, 5);
oled_write_P(off_on[1], false);
} else {
oled_set_cursor(2, 4);
oled_write_P(off_off[0], false);
oled_set_cursor(2, 5);
oled_write_P(off_off[1], false);
}
if ((modifiers & MOD_MASK_CTRL) && (modifiers & MOD_MASK_SHIFT)) {
oled_set_cursor(2, 6);
oled_write_P(on_on[0], false);
oled_set_cursor(2, 7);
oled_write_P(on_on[1], false);
} else if(modifiers & MOD_MASK_CTRL) {
oled_set_cursor(2, 6);
oled_write_P(on_off[0], false);
oled_set_cursor(2, 7);
oled_write_P(on_off[1], false);
} else if(modifiers & MOD_MASK_SHIFT) {
oled_set_cursor(2, 6);
oled_write_P(off_on[0], false);
oled_set_cursor(2, 7);
oled_write_P(off_on[1], false);
} else {
oled_set_cursor(2, 6);
oled_write_P(off_off[0], false);
oled_set_cursor(2, 7);
oled_write_P(off_off[1], false);
}
} }
void render_bootmagic_status(void) { void render_bootmagic_status(void) {
oled_write_P((keymap_config.swap_lctl_lgui) ? PSTR("OS: Windows\n\n") : PSTR("OS: MacOS\n\n"), false); static const char PROGMEM nkro_off [][3]= {{0x88, 0x89, 0}, {0xa8, 0xa9, 0}};
oled_write_P((keymap_config.nkro) ? PSTR("NKRO ") : PSTR(" "), false); static const char PROGMEM nkro_on [][3]= {{0xc8, 0xc9, 0}, {0xe8, 0xe9, 0}};
static const char PROGMEM mac_os_off [][6]= {{0x90, 0x91, 0x92, 0x93, 0x94, 0}, {0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0}};
static const char PROGMEM mac_os_on [][6]= {{0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0}, {0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0}};
static const char PROGMEM windows_off [][6]= {{0x95, 0x96, 0x97, 0x98, 0x99, 0}, {0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0}};
static const char PROGMEM windows_on [][6]= {{0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0}, {0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0}};
if (keymap_config.nkro) {
oled_set_cursor(5, 4);
oled_write_P(nkro_on[0], false);
oled_set_cursor(5, 5);
oled_write_P(nkro_on[1], false);
} else {
oled_set_cursor(5, 4);
oled_write_P(nkro_off[0], false);
oled_set_cursor(5, 5);
oled_write_P(nkro_off[1], false);
}
if (keymap_config.swap_lctl_lgui) {
oled_set_cursor(10, 6);
oled_write_P(windows_on[0], false);
oled_set_cursor(10, 7);
oled_write_P(windows_on[1], false);
oled_set_cursor(10, 4);
oled_write_P(mac_os_off[0], false);
oled_set_cursor(10, 5);
oled_write_P(mac_os_off[1], false);
} else {
oled_set_cursor(10, 4);
oled_write_P(mac_os_on[0], false);
oled_set_cursor(10, 5);
oled_write_P(mac_os_on[1], false);
oled_set_cursor(10, 6);
oled_write_P(windows_off[0], false);
oled_set_cursor(10, 7);
oled_write_P(windows_off[1], false);
}
} }
void render_wpm(void) { void render_lock_status(void) {
//get current WPM value static const char PROGMEM caps_off [][3]= {{0x8a, 0x8b, 0}, {0xaa, 0xab, 0}};
currwpm = get_current_wpm(); static const char PROGMEM caps_on [][3]= {{0xca, 0xcb, 0}, {0xea, 0xeb, 0}};
//check if it's been long enough before refreshing graph static const char PROGMEM num_off [][3]= {{0x8c, 0x8d, 0}, {0xac, 0xad, 0}};
if(timer_elapsed(timer) > graph_refresh_interval){ static const char PROGMEM num_on [][3]= {{0xcc, 0xcd, 0}, {0xec, 0xed, 0}};
// main calculation to plot graph line static const char PROGMEM scrl_off [][3]= {{0x8e, 0x8f, 0}, {0xae, 0xaf, 0}};
x = 64 - ((currwpm / max_wpm) * 64); static const char PROGMEM scrl_on [][3]= {{0xce, 0xcf, 0}, {0xee, 0xef, 0}};
//first draw actual value line
for(int i = 0; i <= graph_line_thickness - 1; i++){ static const char PROGMEM off_off [][2]= {{0x9e, 0}, {0xbe, 0}};
oled_write_pixel(1, x + i, true); static const char PROGMEM on_on [][2]= {{0xdf, 0}, {0xff, 0}};
static const char PROGMEM on_off [][2]= {{0xde, 0}, {0xfe, 0}};
static const char PROGMEM off_on [][2]= {{0x9f, 0}, {0xbf, 0}};
led_t led_usb_state = host_keyboard_led_state();
if (led_usb_state.caps_lock) {
oled_set_cursor(8, 4);
oled_write_P(caps_on[0], false);
oled_set_cursor(8, 5);
oled_write_P(caps_on[1], false);
} else {
oled_set_cursor(8, 4);
oled_write_P(caps_off[0], false);
oled_set_cursor(8, 5);
oled_write_P(caps_off[1], false);
}
if (led_usb_state.num_lock) {
oled_set_cursor(5, 6);
oled_write_P(num_on[0], false);
oled_set_cursor(5, 7);
oled_write_P(num_on[1], false);
} else {
oled_set_cursor(5, 6);
oled_write_P(num_off[0], false);
oled_set_cursor(5, 7);
oled_write_P(num_off[1], false);
}
if (led_usb_state.scroll_lock) {
oled_set_cursor(8, 6);
oled_write_P(scrl_on[0], false);
oled_set_cursor(8, 7);
oled_write_P(scrl_on[1], false);
} else {
oled_set_cursor(8, 6);
oled_write_P(scrl_off[0], false);
oled_set_cursor(8, 7);
oled_write_P(scrl_off[1], false);
}
// render fillers
if ((led_usb_state.caps_lock) && (keymap_config.nkro)) {
oled_set_cursor(7, 4);
oled_write_P(on_on[0], false);
oled_set_cursor(7, 5);
oled_write_P(on_on[1], false);
} else if(keymap_config.nkro) {
oled_set_cursor(7, 4);
oled_write_P(on_off[0], false);
oled_set_cursor(7, 5);
oled_write_P(on_off[1], false);
} else if(led_usb_state.caps_lock) {
oled_set_cursor(7, 4);
oled_write_P(off_on[0], false);
oled_set_cursor(7, 5);
oled_write_P(off_on[1], false);
} else {
oled_set_cursor(7, 4);
oled_write_P(off_off[0], false);
oled_set_cursor(7, 5);
oled_write_P(off_off[1], false);
}
if ((led_usb_state.num_lock) && (led_usb_state.scroll_lock)) {
oled_set_cursor(7, 6);
oled_write_P(on_on[0], false);
oled_set_cursor(7, 7);
oled_write_P(on_on[1], false);
} else if(led_usb_state.num_lock) {
oled_set_cursor(7, 6);
oled_write_P(on_off[0], false);
oled_set_cursor(7, 7);
oled_write_P(on_off[1], false);
} else if(led_usb_state.scroll_lock) {
oled_set_cursor(7, 6);
oled_write_P(off_on[0], false);
oled_set_cursor(7, 7);
oled_write_P(off_on[1], false);
} else {
oled_set_cursor(7, 6);
oled_write_P(off_off[0], false);
oled_set_cursor(7, 7);
oled_write_P(off_off[1], false);
}
}
void render_wpm_graph(void) {
currwpm = get_current_wpm(); //get current WPM value
if(timer_elapsed(timer) > graph_refresh_interval){ //check if it's been long enough before refreshing graph
x = 63 - ((currwpm / max_wpm) * 63); // main calculation to plot graph line
for(int i = 0; i <= graph_line_thickness - 1; i++){ //first draw actual value line
oled_write_pixel(1, x + i, true);
} }
//then fill in area below the value line if(vert_line){ //then fill in area below the value line
if(vert_line){ if(vert_count == vert_interval){
if(vert_count == vert_interval){ vert_count = 0;
vert_count = 0; while(x <= 63){
while(x <= 64){ oled_write_pixel(1, x, true);
oled_write_pixel(1, x, true); x++;
x++;
} }
} else {
for(int i = 64; i > x; i--){
if(i % graph_area_fill_interval == 0){
oled_write_pixel(1, i, true);
}
}
vert_count++;
}
} else { } else {
for(int i = 64; i > x; i--){ for(int i = 63; i > x; i--){
if(i % graph_area_fill_interval == 0){ if(i % graph_area_fill_interval == 0){
oled_write_pixel(1, i, true); oled_write_pixel(1, i, true);
} }
} }
vert_count++;
}
} else {
for(int i = 63; i > x; i--){
if(i % graph_area_fill_interval == 0){
oled_write_pixel(1, i, true);
}
} }
//then move the entire graph one pixel to the right
oled_pan(false);
//refresh the timer for the next iteration
timer = timer_read();
} }
//format current WPM value into a printable string oled_pan(false); //then move the entire graph one pixel to the right
char buf[4]; timer = timer_read(); //refresh the timer for the next iteration
oled_set_cursor(14, 0); }
oled_write("WPM:", false); char buf[4]; //format current WPM value into a printable string
buf[0] = currwpm >= 100 ? ((currwpm/100) + '0') : ' '; oled_set_cursor(14, 0);
buf[1] = currwpm >= 10 ? (((currwpm/10) % 10) + '0') : ' '; oled_write("WPM:", false);
buf[2] = (currwpm % 10) + '0'; buf[0] = currwpm >= 100 ? ((currwpm/100) + '0') : ' ';
buf[3] = 0; buf[1] = currwpm >= 10 ? (((currwpm/10) % 10) + '0') : ' ';
oled_write(buf, false); buf[2] = (currwpm % 10) + '0';
buf[3] = 0;
oled_write(buf, false);
} }
static void render_status(void) { void render_status_main(void) {
// QMK Logo and version information render_qmk_logo();
render_qmk_logo(); render_layers();
oled_write_P(PSTR("Kyria: Rev1.0\n"), false); render_mod_state(get_mods());
render_bootmagic_status();
render_lock_status();
// Host Keyboard Layer Status }
oled_write_P(PSTR("Layer: "), false);
switch (get_highest_layer(layer_state)) {
case 0:
oled_write_P(PSTR("Default\n"), false);
break;
case 1:
oled_write_P(PSTR("Lower\n"), false);
break;
case 2:
oled_write_P(PSTR("Raise\n"), false);
break;
case 3:
oled_write_P(PSTR("Adjust\n"), false);
break;
default:
oled_write_P(PSTR("Undefined\n"), false);
}
render_bootmagic_status(); void render_status_secondary(void) {
render_wpm_graph();
// Host Keyboard LED Status
led_t led_state = host_keyboard_led_state();
oled_write_P(led_state.caps_lock ? PSTR("CAPLCK ") : PSTR(" "), false);
} }
void oled_task_user(void) { void oled_task_user(void) {
if (is_keyboard_master()) { if (is_keyboard_master()) {
render_status(); render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
} else { } else {
render_wpm(); render_status_secondary();
} }
} }
#endif #endif

20
keyboards/splitkb/kyria/keymaps/john-ezra/readme.md 100644
View File

@ -0,0 +1,20 @@
### This Keymap uses the nanoBoot bootloader to maximize available firmware space.
As is, the firmware will be too large if using the standard bootloader. Removing `DEBOUNCE_TYPE = sym_eager_pk` from the `rules.mk` should get the size under the limit.
If nanoBoot is not going to be used, delete or comment out the following from your `rules.mk`:
```make
BOOTLOADER = hid
BOOTLOADER_SIZE = 512
PROGRAM_CMD = $(HID_BOOTLOADER_CLI) -mmcu=$(MCU) -w -v $(BUILD_DIR)/$(TARGET).hex
```
nanoBoot can be found here: [nanoBoot](https://github.com/sigprof/nanoBoot) I used the string-descriptors branch as it was the latest update.
To ISP Flash nanoBoot: `avrdude -p atmega32u4 -c avrisp -U flash:w:/Users/DempseyTech/nanoBoot/nanoBoot.hex:i -P /dev/cu.usbmodem123451 -U lfuse:w:0x7F:m -U hfuse:w:0xD6:m -U efuse:w:0xC7:m`
You will need to change the path in the CLI command to match your file structure.
QMK Toolbox will not recognize controllers using nanoBoot, instead use the CLI to flash.
To Flash: `qmk flash -kb splitkb/kyria/rev1 -km john-ezra -bl hid_bootloader`

7
keyboards/splitkb/kyria/keymaps/john-ezra/rules.mk
View File

@ -8,5 +8,12 @@ GRAVE_ESC_ENABLE = no # Disable Grave Escape
MOUSEKEY_ENABLE = no # Disable Mousekeys MOUSEKEY_ENABLE = no # Disable Mousekeys
WPM_ENABLE = yes # Enable WPM Counter (Works with default wpm files, but works better with vectorstorm updated wpm.c and wpm.h -> https://github.com/vectorstorm/qmk_firmware/tree/wpm_exact) WPM_ENABLE = yes # Enable WPM Counter (Works with default wpm files, but works better with vectorstorm updated wpm.c and wpm.h -> https://github.com/vectorstorm/qmk_firmware/tree/wpm_exact)
KEY_OVERRIDE_ENABLE = yes # Enable Key Overrides KEY_OVERRIDE_ENABLE = yes # Enable Key Overrides
CONSOLE_ENABLE = no
DEBOUNCE_TYPE = sym_eager_pk
BOOTLOADER = hid # This Keymap Uses nanoBoot, more info in readme
BOOTLOADER_SIZE = 512
PROGRAM_CMD = $(HID_BOOTLOADER_CLI) -mmcu=$(MCU) -w -v $(BUILD_DIR)/$(TARGET).hex
SRC += oled.c SRC += oled.c