mirrors/keychron_qmk_firmware
mirrors/keychron_qmk_firmware
0
0
Fork 0
mirror of https://github.com/Keychron/qmk_firmware.git synced 2024-12-25 10:44:59 +06:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
QMK Bot 2022-10-13 03:06:56 +00:00
commit 563a59d3c7
17 changed files with 1369 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
keyboards/splitkb/aurora/sweep/config.h Normal file
View File

@ -0,0 +1,22 @@
/* Copyright 2022 splitkb.com <support@splitkb.com>
*
* 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
// Not yet available in `info.json`
#ifdef OLED_ENABLE
# define OLED_FONT_H "keyboards/splitkb/aurora/sweep/glcdfont.c"
#endif

234
keyboards/splitkb/aurora/sweep/glcdfont.c Normal file
View File

@ -0,0 +1,234 @@
#include "progmem.h"
// NOTE: This file is a copy of `crkbd/soundmonster/glcdfont.c`
// Corne 8x6 font with QMK Firmware Logo
// Online editor: https://helixfonteditor.netlify.com/
// See also: https://github.com/soundmonster/glcdfont_converter
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, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8,
0xF8, 0x18, 0x00, 0xC0, 0xF0, 0xFC,
0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x7E, 0x00, 0x00, 0x00,
0x00, 0xF8, 0x04, 0x22, 0x52, 0xE2,
0x42, 0x42, 0x42, 0xE2, 0x52, 0x22,
0x22, 0x22, 0x42, 0x82, 0x02, 0x02,
0x22, 0x22, 0x02, 0x04, 0xF8, 0x00,
0x00, 0xF8, 0x04, 0x02, 0x02, 0x82,
0x42, 0x22, 0x42, 0x82, 0x02, 0x02,
0x02, 0x82, 0x42, 0x22, 0x12, 0x22,
0x42, 0x82, 0x02, 0x04, 0xF8, 0x00,
0x00, 0xF8, 0xFC, 0xDE, 0xAE, 0x1E,
0xBE, 0xBE, 0xBE, 0x1E, 0xAE, 0xDE,
0xDE, 0xDE, 0xBE, 0x7E, 0xFE, 0xFE,
0xDE, 0xDE, 0xFE, 0xFC, 0xF8, 0x00,
0x00, 0xF8, 0xFC, 0xFE, 0xFE, 0x7E,
0xBE, 0xDE, 0xBE, 0x7E, 0xFE, 0xFE,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x80, 0x40, 0x40, 0x20, 0x20,
0x10, 0x10, 0x08, 0x08, 0x10, 0x10,
0x20, 0x20, 0x40, 0x40, 0x80, 0x80,
0x80, 0x80, 0xC0, 0xC0, 0xE0, 0xE0,
0xF0, 0xF0, 0xF8, 0xF8, 0xF0, 0xF0,
0xE0, 0xE0, 0xC0, 0xC0, 0x80, 0x80,
0x80, 0x80, 0x40, 0x40, 0x20, 0x20,
0x10, 0x10, 0x08, 0x08, 0x10, 0x10,
0x20, 0x20, 0x40, 0x40, 0x80, 0x80,
0x80, 0x80, 0x40, 0xC0, 0x60, 0xA0,
0x50, 0xB0, 0x58, 0xA8, 0x50, 0xB0,
0x60, 0xA0, 0x40, 0xC0, 0x80, 0x80,
0x00, 0xF8, 0xFC, 0xFE, 0xFF, 0xE0,
0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x80, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F,
0x07, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x1F, 0x20, 0x44, 0x4A, 0x47,
0x42, 0x42, 0x42, 0x47, 0x4A, 0x44,
0x40, 0x40, 0x40, 0x40, 0x41, 0x42,
0x44, 0x44, 0x40, 0x20, 0x1F, 0x00,
0x00, 0x1F, 0x20, 0x40, 0x41, 0x40,
0x40, 0x40, 0x40, 0x40, 0x41, 0x40,
0x41, 0x41, 0x4F, 0x48, 0x48, 0x48,
0x4F, 0x41, 0x41, 0x20, 0x1F, 0x00,
0x00, 0x1F, 0x3F, 0x7B, 0x75, 0x78,
0x7D, 0x7D, 0x7D, 0x78, 0x75, 0x7B,
0x7F, 0x7F, 0x7F, 0x7F, 0x7E, 0x7D,
0x7B, 0x7B, 0x7F, 0x3F, 0x1F, 0x00,
0x00, 0x1F, 0x3F, 0x7F, 0x7E, 0x7F,
0x7F, 0x7F, 0x7F, 0x7F, 0x7E, 0x7F,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x88, 0x88, 0x5D, 0x5D, 0x3E, 0x3E,
0x7C, 0x7C, 0xF8, 0xF8, 0x7C, 0x7C,
0x3E, 0x3E, 0x5D, 0x5D, 0x88, 0x88,
0x88, 0x88, 0x55, 0x55, 0x23, 0x23,
0x47, 0x47, 0x8F, 0x8F, 0x47, 0x47,
0x23, 0x23, 0x55, 0x55, 0x88, 0x88,
0x88, 0x88, 0xD5, 0xD5, 0xE2, 0xE2,
0xC4, 0xC4, 0x88, 0x88, 0xC4, 0xC4,
0xE2, 0xE2, 0xD5, 0xD5, 0x88, 0x88,
0x88, 0x88, 0x5D, 0xD5, 0x6B, 0xB6,
0x6D, 0xD6, 0xAD, 0xDA, 0x6D, 0xD6,
0x6B, 0xB6, 0x5D, 0xD5, 0x88, 0x88,
0x00, 0x03, 0x0F, 0x1F, 0x3F, 0x3F,
0x3F, 0x3F, 0x1F, 0x1F, 0x3F, 0x3F,
0x7F, 0x7F, 0x7F, 0x3F, 0x3F, 0x1F,
0x3F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7C,
0x78, 0x78, 0x38, 0x1C, 0x0F, 0x00,
0x04, 0xF8, 0x00, 0x00, 0xF8, 0x04,
0x20, 0x1F, 0x00, 0x00, 0x1F, 0x20,
0xFC, 0xF8, 0x00, 0x00, 0xF8, 0x04,
0x3F, 0x1F, 0x00, 0x00, 0x1F, 0x20,
0x04, 0xF8, 0x00, 0x00, 0xF8, 0xFC,
0x20, 0x1F, 0x00, 0x00, 0x1F, 0x3F,
0xFC, 0xF8, 0x00, 0x00, 0xF8, 0xFC,
0x3F, 0x1F, 0x00, 0x00, 0x1F, 0x3F,
0xFE, 0x7E, 0xBE, 0xDE, 0xEE, 0xDE,
0xBE, 0x7E, 0xFE, 0xFC, 0xF8, 0x00,
0x7E, 0x7E, 0x70, 0x77, 0x77, 0x77,
0x70, 0x7E, 0x7E, 0x3F, 0x1F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x01, 0x02, 0x02,
0x04, 0x04, 0x08, 0x08, 0x04, 0x04,
0x02, 0x02, 0x01, 0x01, 0x00, 0x00,
0x00, 0x00, 0x01, 0x01, 0x02, 0x02,
0x04, 0x04, 0x08, 0x08, 0x04, 0x04,
0x02, 0x02, 0x01, 0x01, 0x00, 0x00,
0x00, 0x00, 0x01, 0x01, 0x03, 0x03,
0x07, 0x07, 0x0F, 0x0F, 0x07, 0x07,
0x03, 0x03, 0x01, 0x01, 0x00, 0x00,
0x00, 0x00, 0x01, 0x01, 0x03, 0x02,
0x05, 0x06, 0x0D, 0x0A, 0x05, 0x06,
0x03, 0x02, 0x01, 0x01, 0x00, 0x00
};

67
keyboards/splitkb/aurora/sweep/info.json Normal file
View File

@ -0,0 +1,67 @@
{
"manufacturer": "splitkb.com",
"url": "https://splitkb.com/products/aurora-sweep-pcb-kit",
"maintainer": "splitkb",
"usb": {
// pid is not defined here as that is
// revision-specific due to VIA limitations
"vid": "0x8D1D",
"device_version": "1.0.0"
},
// Technically it only uses Pro Micro pins,
// but most people buy the Elite-C controller
// so we want to use the atmel-dfu bootloader.
"development_board": "elite_c",
"split": {
"enabled": true
},
"build": {
"lto": true
},
"layout_aliases": {
"LAYOUT": "LAYOUT_split_3x5_2"
},
"layouts": {
"LAYOUT_split_3x5_2": {
"layout": [
{"label": "L01", "x": 0, "y": 0.93},
{"label": "L02", "x": 1, "y": 0.31},
{"label": "L03", "x": 2, "y": 0},
{"label": "L04", "x": 3, "y": 0.28},
{"label": "L05", "x": 4, "y": 0.42},
{"label": "R05", "x": 7, "y": 0.42},
{"label": "R04", "x": 8, "y": 0.28},
{"label": "R03", "x": 9, "y": 0},
{"label": "R02", "x": 10, "y": 0.31},
{"label": "R01", "x": 11, "y": 0.93},
{"label": "L06", "x": 0, "y": 1.93},
{"label": "L07", "x": 1, "y": 1.31},
{"label": "L08", "x": 2, "y": 1},
{"label": "L09", "x": 3, "y": 1.28},
{"label": "L10", "x": 4, "y": 1.42},
{"label": "R10", "x": 7, "y": 1.42},
{"label": "R09", "x": 8, "y": 1.28},
{"label": "R08", "x": 9, "y": 1},
{"label": "R07", "x": 10, "y": 1.31},
{"label": "R06", "x": 11, "y": 1.93},
{"label": "L11", "x": 0, "y": 2.93},
{"label": "L12", "x": 1, "y": 2.31},
{"label": "L13", "x": 2, "y": 2},
{"label": "L14", "x": 3, "y": 2.28},
{"label": "L15", "x": 4, "y": 2.42},
{"label": "R15", "x": 7, "y": 2.42},
{"label": "R14", "x": 8, "y": 2.28},
{"label": "R13", "x": 9, "y": 2},
{"label": "R12", "x": 10, "y": 2.31},
{"label": "R11", "x": 11, "y": 2.93},
{"label": "L16", "x": 3.5, "y": 3.75},
{"label": "L17", "x": 4.5, "y": 4},
{"label": "R17", "x": 6.5, "y": 4},
{"label": "R16", "x": 7.5, "y": 3.75}
]
}
}
}

21
keyboards/splitkb/aurora/sweep/keymaps/debug/config.h Normal file
View File

@ -0,0 +1,21 @@
/* Copyright 2022 splitkb.com <support@splitkb.com>
*
* 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
#ifdef RGBLIGHT_ENABLE
# define RGBLIGHT_EFFECT_BREATHING
#endif

77
keyboards/splitkb/aurora/sweep/keymaps/debug/keymap.c Normal file
View File

@ -0,0 +1,77 @@
/* Copyright 2022 splitkb.com <support@splitkb.com>
*
* 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
enum layers {
_DEFAULT = 0,
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_DEFAULT] = LAYOUT(
KC_A, KC_B, KC_C, KC_D, KC_E, S(KC_E), S(KC_D), S(KC_C), S(KC_B), S(KC_A),
KC_F, KC_G, KC_H, KC_I, KC_J, S(KC_J), S(KC_I), S(KC_H), S(KC_G), S(KC_F),
KC_K, KC_L, KC_M, KC_N, KC_O, S(KC_O), S(KC_N), S(KC_M), S(KC_L), S(KC_K),
KC_P, KC_Q, S(KC_Q), S(KC_P)
)
};
#ifdef RGBLIGHT_ENABLE
void keyboard_post_init_user(void) {
rgblight_enable_noeeprom(); // enables RGB, without saving settings
rgblight_sethsv_noeeprom(HSV_RED); // sets the color to red without saving
rgblight_mode_noeeprom(RGBLIGHT_MODE_BREATHING + 3); // sets mode to Fast breathing without saving
}
#endif
#ifdef ENCODER_ENABLE
bool encoder_update_user(uint8_t index, bool clockwise) {
// 0 and 1 are left-half encoders
// 2 and 3 are right-half encoders
if (index == 0) {
tap_code(KC_0);
} else if (index == 1) {
tap_code(KC_1);
} else if (index == 2) {
tap_code(KC_2);
} else if (index == 3) {
tap_code(KC_3);
}
if (clockwise) {
tap_code16(KC_PLUS);
} else {
tap_code(KC_MINUS);
}
return false;
}
#endif
#ifdef OLED_ENABLE
bool oled_task_user(void) {
// A 128x32 OLED rotated 90 degrees is 5 characters wide and 16 characters tall
// This example string should fill that neatly
const char *text = PSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789!@#$%^&*()[]{}-=_+?");
if (is_keyboard_master()) {
oled_write_P(text, false);
} else {
oled_write_P(text, false);
}
return false;
}
#endif

25
keyboards/splitkb/aurora/sweep/keymaps/debug/readme.md Normal file
View File

@ -0,0 +1,25 @@
# Aurora Sweep's Debug Keymap
Due to the complex layer setup, the default keymap for the Aurora Sweep is relatively hard to debug.
This debug keymap should make that a lot easier.
## Keys
![Keys](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/debug/keys.png)
The left side uses lowercase letters, the right side uses uppercase ones.
## Encoders
Encoders output a number of 0 to 3, depending on the installed position.
These correspond to the index used for custom encoder code.
The number is followed by either a `+` or a `-`, depending on the direction turned.
## LEDs
Both underglow and per-key RGB should be fading between red and off.
## OLEDs
Both the primary and secondary side should be filled with characters.

18
keyboards/splitkb/aurora/sweep/keymaps/debug/rules.mk Normal file
View File

@ -0,0 +1,18 @@
# Copyright 2022 splitkb.com <support@splitkb.com>
#
# 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/>.
ENCODER_ENABLE = yes
OLED_ENABLE = yes
RGBLIGHT_ENABLE = yes

34
keyboards/splitkb/aurora/sweep/keymaps/default/config.h Normal file
View File

@ -0,0 +1,34 @@
/* Copyright 2022 splitkb.com <support@splitkb.com>
*
* 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
// Not yet available in `keymap.json` format
#ifdef RGB_MATRIX_ENABLE
# define RGB_DISABLE_WHEN_USB_SUSPENDED
# define RGB_MATRIX_KEYPRESSES
# define ENABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
# define ENABLE_RGB_MATRIX_SOLID_SPLASH
# define ENABLE_RGB_MATRIX_RAINBOW_BEACON
#endif
// Not yet available in `keymap.json` format
#ifdef MOUSEKEY_ENABLE
// The default is 100
# define MOUSEKEY_WHEEL_INTERVAL 50
// The default is 40
# define MOUSEKEY_WHEEL_TIME_TO_MAX 100
#endif

93
keyboards/splitkb/aurora/sweep/keymaps/default/keymap.json Normal file
View File

@ -0,0 +1,93 @@
{
"keyboard": "splitkb/aurora/sweep",
"keymap": "default",
"version": 1,
"layout": "LAYOUT",
"layers": [
[
"KC_Q" , "KC_W" , "KC_E" , "KC_R" , "KC_T" , "KC_Y" , "KC_U" , "KC_I" , "KC_O" , "KC_P",
"LSFT_T(KC_A)", "LT(5,KC_S)" , "LT(1,KC_D)" , "LT(3,KC_F)" , "KC_G" , "KC_H" , "LT(4,KC_J)" , "LT(2,KC_K)" , "LT(6,KC_L)" , "LSFT_T(KC_SCLN)",
"KC_Z" , "LCTL_T(KC_X)", "LALT_T(KC_C)" , "KC_V" , "KC_B" , "KC_N" , "KC_M" , "LALT_T(KC_COMM)", "LCTL_T(KC_DOT)", "KC_SLSH",
"KC_P0" , "KC_BSPC" , "LT(7,KC_SPC)" , "KC_P1"
],
[
"RGB_TOG" , "RGB_MOD" , "RGB_HUI" , "RGB_SAI" , "RGB_VAI" , "RGB_SPI" , "KC_BTN1" , "KC_WH_U" , "KC_BTN2" , "KC_TRNS",
"KC_TRNS" , "KC_BTN2" , "KC_NO" , "KC_BTN1" , "KC_TRNS" , "KC_TRNS" , "KC_MS_L" , "KC_MS_D" , "KC_MS_U" , "KC_MS_R",
"KC_TRNS" , "RGB_RMOD" , "RGB_HUD" , "RGB_SAD" , "RGB_VAD" , "RGB_SPD" , "KC_WH_L" , "KC_WH_D" , "KC_WH_R" , "KC_TRNS",
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS"
],
[
"KC_TRNS" , "KC_TRNS" , "KC_PGUP" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS",
"KC_LEFT" , "KC_UP" , "KC_DOWN" , "KC_RGHT" , "KC_TRNS" , "KC_TRNS" , "KC_LGUI" , "KC_NO" , "LCTL(KC_LALT)" , "LCA(KC_LSFT)",
"KC_TRNS" , "KC_HOME" , "KC_PGDN" , "KC_END" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS",
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS"
],
[
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_UNDS" , "KC_PIPE" , "KC_QUOT" , "KC_TRNS",
"KC_CIRC" , "KC_ASTR" , "KC_AMPR" , "KC_NO" , "KC_TRNS" , "KC_HASH" , "KC_TILD" , "KC_SLSH" , "KC_DQUO" , "KC_DLR",
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_MINS" , "KC_BSLS" , "KC_GRV" , "KC_TRNS",
"RGB_RMOD" , "KC_TRNS" , "KC_TRNS" , "RGB_MOD"
],
[
"KC_TRNS" , "KC_COLN" , "KC_LT" , "KC_GT" , "KC_SCLN" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS",
"KC_LCBR" , "KC_RCBR" , "KC_LPRN" , "KC_RPRN" , "KC_AT" , "KC_TRNS" , "KC_NO" , "KC_EQL" , "KC_PLUS" , "KC_PERC",
"KC_TRNS" , "KC_EXLM" , "KC_LBRC" , "KC_RBRC" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS",
"KC_VOLD" , "KC_TRNS" , "KC_TRNS" , "KC_VOLU"
],
[
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_F7" , "KC_F8" , "KC_F9" , "KC_F10",
"KC_TRNS" , "KC_NO" , "LCTL(KC_LALT)" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_F4" , "KC_F5" , "KC_F6" , "KC_F11",
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_F1" , "KC_F2" , "KC_F3" , "KC_F12",
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS"
],
[
"KC_PSLS" , "KC_7" , "KC_8" , "KC_9" , "KC_PPLS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS",
"KC_0" , "KC_1" , "KC_2" , "KC_3" , "KC_PMNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_NO" , "KC_TRNS",
"KC_PAST" , "KC_4" , "KC_5" , "KC_6" , "KC_PEQL" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS",
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS"
],
[
"KC_TRNS" , "KC_TRNS" , "KC_COLN" , "KC_ESC" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_DEL",
"KC_TRNS" , "KC_PERC" , "KC_SLSH" , "KC_ENT" , "KC_TRNS" , "DF(1)" , "KC_LGUI" , "KC_TRNS" , "KC_TRNS" , "KC_TRNS",
"KC_TRNS" , "KC_TRNS" , "KC_TRNS" , "KC_EXLM" , "KC_TRNS" , "DF(0)" , "KC_TRNS" , "RALT_T(KC_COMM)", "RCTL_T(KC_DOT)", "QK_BOOT",
"KC_TRNS" , "KC_TAB" , "KC_NO" , "KC_TRNS"
]
],
"config": {
"features": {
"oled": true,
"rgb_matrix": true,
"rgblight": false
},
"encoder": {
"enabled": true
},
"rgblight": {
"hue_steps": 8,
"saturation_steps": 8,
"brightness_steps": 8,
"sleep": true
}
},
"mouse_key": {
"enabled": true,
// Set the mouse settings to a comfortable speed/accuracy trade-off,
// assuming a screen refresh rate of 60 Htz or higher
// The default is 50. This makes the mouse ~3 times faster and more accurate
"interval": 16,
// The default is 20. Since we made the mouse about 3 times faster with the previous setting,
// give it more time to accelerate to max speed to retain precise control over short distances.
"time_to_max": 40,
// The default is 300. Let's try and make this as low as possible while keeping the cursor responsive
"delay": 100,
// It makes sense to use the same delay for the mouseweel
"wheel_delay": 100
},
// Pick good defaults for enabling homerow modifiers
"tapping": {
"term": 200,
"permissive_hold": true,
"ignore_mod_tap_interrupt": true,
"force_hold": true
}
}

142
keyboards/splitkb/aurora/sweep/keymaps/default/readme.md Normal file
View File

@ -0,0 +1,142 @@
# Aurora Sweep's Default Keymap
_This keymap is a copy of the [Ferris default keymap](https://github.com/qmk/qmk_firmware/tree/master/keyboards/ferris/keymaps/default), with the addition of RGB modifier keys._
A usable default keymap for the Ferris keyboard
===============================================
Keymaps in general are quite personal, so it is difficult to come up with a default that will suit every user.
This keymap makes heavy use of keys behaving differently when tapped and held, so that all the keys one may need remain accessible despite the low number of thumb keys.
It comes with a number of layers to give access to most of the keys one may need on a keyboard. It is not meant to be the best possible keymap, but rather a good base on which to build a keymap that works for you.
This is not the only way to make 34 keys a comfortable typing experience, but it is one way to do so. If you don't already know of a better way, this may be as good a starting point as any :)
Note that this keymap was built from the perspective that it is OK to take a steep learning curve if it results in a keymap that is easier to use in the long run. This means that it may take more effort to learn this keymap than some alternatives. "Easy to use" was assessed against the workflow of the author, so your mileage may vary on some of the details.
What do all these layers do?
----------------------------
### Layer 0: Base layer
![Layer 0](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer0.png)
On tapping the keys, our base layer is qwerty with space on the right homing thumb and backspace on the left homing thumb.
In this layer, the non-homing-thumb positions have 0 and 1. I recommend modifying this to some frequently accessed shortcut such as copy/paste, previous/next tab or anything that makes most sense in your own workflow. O and 1 are place-holders and make it easy to troubleshoot that all keys are working properly before soldering in the switches.
The reason I recommend convenience shortcuts instead of more commonly used keys like tab or meta is that unhoming of the thumbs was a frequent source of typos for me when I used more than one thumb key frequently in the context of typing.
Despite being missing on this layer, "meta", "tab", "esc" and such are accessible from any other layer: see Layer 7.
The behaviour of some keys differ when held:
* Both homing pinkies behave as shift.
* Both bottom-row ring fingers behave as ctrl.
* Both bottom-row middle fingers behave as alt.
* The homing left ring finger gives access to the Function keys layer
* The homing right ring finger gives access to the Numbers layer
* The homing left middle finger gives access to the Mouse layer
* The homing right middle finger gives access to the Navigation layer
* The homing left index finger gives access to the Right symbols layer
* The homing right index finger gives access to the Left symbols layer
* The homing right thumb gives access to the Always accessible layer
### Layer 1: Mouse
![Layer 1](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer1.png)
Layer 1 is a mouse layer: it can be used one-handed or two-handed. The most common way to use it is two handed, with left and right click on the homerow of the left hand and directions on the homerow of the right hand.
Scrolling is available on the right hand with mid finger up and down for vertical scroll and index and ring finger down for horizontal scroll.
On the right hand, left click and right click are also available with index and ring finger up to allow one handed operation. This can be particularly handy when enabling the mouse layer permanently (no need to hold the left middle finger), which can be done from Layer 7.
**Addition**: The Aurora Sweep allows the RGB settings to be modified on this layer. This is an extra feature over the default Ferris / Sweep keymap.
### Layer 2: Navigation
![Layer 2](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer2.png)
The navigation layer somewhat mirrors the mouse layer. It is accessed by holding the right middle finger and gives access to arrow keys on the left homerow. Page up and down, Home and End mirror the vertical scrolling and horizontal scrolling on the mouse layer.
On the right hand, in addition to ctrl and alt which are available through transparency, ctrl + alt, ctrl + alt + shift and meta are accessible on the homerow to enable common shortcuts in some window managers. This part is quite workflow dependent, so make sure to adapt it to your own workflow as appropriate.
### Layer 3: Right symbols
![Layer 3](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer3.png)
When holding down the left index, one may access about half of the symbols. The pinkies store `^` and `$` symbols that represent begin and end in vim. The left homerow hosts `*` and `&`, symbols which are related in the way that they represent some form of indirection in programming languages such as rust. On the right hand, most symbols used when navigating the command line are stored together, organized by columns of related symbols.
### Layer 4: Left symbols
![Layer 4](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer4.png)
When holding down the right index, one may access the other symbols. On the left hand, most of the different brackets are laid out. The most frequent ones (round brackets and curly brackets) get a spot on the homerow. The rest of the layer hosts the remaining symbols that are easier to access here than on any other layers.
### Layer 5: Function keys
![Layer 5](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer5.png)
By holding down the left ring finger, one may access the function keys, roughly in a numpad layout.
This means that alt+F4 is easy to type, with F4 being on the homerow.
There is a shortcut for ctrl+alt on the left hand to enable convenient switching between virtual terminals on Linux.
### Layer 6: Numbers
![Layer 6](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer6.png)
The number layer is accessed by holding the right ring finger. It hosts the numbers and some duplicated symbols that are commonly accessed next to numbers, such as mathematical operators.
The number are layed out similarly to a numpad, but with the middle row and the homerow swapped so that the most used numbers: 0, 1, 2 and 3 are all available in homing positions.
### Layer 7: Always accessible
![Layer 7](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/keymaps/default/layer7.png)
Layer 7 is accessed by holding the right homing thumb down. Because this position is left transparent from every other layer, this layer is always accessible.
It gives access to some essential keys that would typically be accessed on a thumb cluster or pinkies, such as meta, enter, tab, esc and delete.
As the layer hosting esc, we duplicated some symbols here to allow for fast navigation in vim. For instance, esc, :, w, q can be done in a single roll.
Where is the keymap.c?
----------------------
The keymap.c file is not published to the repository. It is generated from `keymap.json` by the build system.
This avoids duplicating information and allow users to edit their keymap from the qmk configurator web interface.
How do I edit and update the keymap?
------------------------------------
The `keymap.json` file is generated from the qmk configurator interface and formatted for better readability in the context of the Ferris keyboard.
To edit it, you may:
* Edit it directly from a text editor.
* Edit it from the qmk configurator.
If you decide to use the latter workflow, here are the steps to follow:
* From the qmk configurator, hit the "import QMK keymap json file" button (it has a drawing with an up arrow on it).
* Browse to the location of your keymap (for example, `<your qmk repo>/keyboards/splitkb/aurora/sweep/keymaps/default/keymap.json`)
* Perform any modification to the keymap in the web UI
* Export the keymap to your downloads folder, by hitting the "Export QMK keymap json file" button (it has a drawing with a down arrow on it)
* Replace your original keymap with the one you just downloaded
I want to do more than the configurator supports!
-------------------------------------------------
While the `json` format is easy to use, it does lack certain functionality - most notably custom OLED or encoder behaviour.
To add this, you need to convert it to the `c` format. Do keep in mind that this is generally a one-way operation.
First, from the root of your qmk repo, move to your keymap folder
```bash
cd ./keymaps/splitkb/aurora/corne/my_personal_keymap
```
Next, convert your `keymap.json` to a `keymap.c`
```bash
qmk json2c -o keymap.c keymap.json
```
You can add custom C code to the newly generated `keymap.c` file. Do note that you have to use **either** a C file **or** a JSON file - you cannot do both!
**If a JSON file is present, the C file is ignored.**

48
keyboards/splitkb/aurora/sweep/readme.md Normal file
View File

@ -0,0 +1,48 @@
![Aurora Sweep](https://raw.githubusercontent.com/splitkb/qmk_firmware/assets/aurora/sweep/sweep.jpg)
# Aurora Sweep
The Aurora Sweep is a redesign by splitkb.com of the popular Sweep (Sweep Bling MX) by David Barr and contributors.
Keyboard Maintainer: [splitkb.com](https://github.com/splitkb)
Hardware Supported: Pro Micro 5V/16MHz and compatible.
Hardware Availability: [splitkb.com](https://splitkb.com).
Make example for this keyboard (after setting up your build environment):
make splitkb/aurora/sweep/rev1:default
Example of flashing this keyboard:
make splitkb/aurora/sweep/rev1:default:flash
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
## Bootloader
You can enter the bootloader in 3 ways:
* **Physical reset button**: Briefly press the button on the side of the PCB, next to the TRRS socket.
* **Bootmagic reset**: Hold down the bootmagic key and plug in the keyboard. For the left half, this is the top-left button. For the right half, this is the top-right button.
* **Keycode in layout**: Press the key mapped to `QK_BOOT` if it is available.
# Assembly
A build guide for the entire Aurora series will become available soon at [docs.splitkb.com](https://docs.splitkb.com).
# Features
The Aurora Sweep supports the following features:
- Support for MX or Kailh Choc (v1 sold at splitkb.com, not v2) switches;
- Top mounted controllers for a lower profile;
- Up to two 128×32 pixel OLED displays;
- Up to two EC11 rotary encoders per half in two of four possible positions;
- Per-key RGB backlight by individual RGB LEDs;
- Underglow by individual RGB LEDs;
- Support for a power switch for wireless controllers;
- Support for the splitkb.com tenting puck.
# What is the Aurora Series?
The Aurora series were designed as a homage to open source keyboard kits that have carved their space into the community. Kits that provided something new and unique, kits that resonated with the community and that have both received and have given a lot of love in return.
With the Aurora series, we aim to make these kits available to the community in a way that both honors the original, while also offering the best possible feature set and a consistent, well-documented build experience.
For each kit sold, we give back to the community by donating €1 across [the firmware projects we support](https://opencollective.com/splitkb). This way we support open source projects and benefit everyone using keyboards, whether they use our kits or their own.

45
keyboards/splitkb/aurora/sweep/rev1/config.h Normal file
View File

@ -0,0 +1,45 @@
/* Copyright 2022 splitkb.com <support@splitkb.com>
*
* 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
// `SPLIT_HAND_PIN` can currently be defined in `info.json`,
// but can't yet be given a value
#define SPLIT_HAND_PIN F4
// Not yet available in `info.json`
#ifdef OLED_ENABLE
# define OLED_DISPLAY_128X32
# define SPLIT_OLED_ENABLE
#endif
// Not yet available in `info.json`
#ifdef RGB_MATRIX_ENABLE
# define RGB_MATRIX_MAXIMUM_BRIGHTNESS RGBLIGHT_LIMIT_VAL
# define DRIVER_LED_TOTAL RGBLED_NUM
# define RGB_MATRIX_SPLIT RGBLED_SPLIT
# define SPLIT_TRANSPORT_MIRROR
#endif
// Not yet available in `info.json`
#ifdef BOOTMAGIC_ENABLE
// Top left key on left half
# define BOOTMAGIC_LITE_ROW 0
# define BOOTMAGIC_LITE_COLUMN 4
// Top right key on right half
# define BOOTMAGIC_LITE_ROW_RIGHT 4
# define BOOTMAGIC_LITE_COLUMN_RIGHT 4
#endif

155
keyboards/splitkb/aurora/sweep/rev1/info.json Normal file
View File

@ -0,0 +1,155 @@
{
"keyboard_name": "Aurora Sweep rev1",
"usb": {
"pid": "0xEC17"
},
"features": {
"mousekey": true,
"bootmagic": true,
"extrakey": true
},
"layouts": {
"LAYOUT_split_3x5_2": {
"layout": [
// Note: `label` is here only for readability,
// order must match the parent's definition!
{"label": "L01", "matrix": [0, 4]},
{"label": "L02", "matrix": [0, 3]},
{"label": "L03", "matrix": [0, 2]},
{"label": "L04", "matrix": [0, 1]},
{"label": "L05", "matrix": [0, 0]},
{"label": "R05", "matrix": [4, 0]},
{"label": "R04", "matrix": [4, 1]},
{"label": "R03", "matrix": [4, 2]},
{"label": "R02", "matrix": [4, 3]},
{"label": "R01", "matrix": [4, 4]},
{"label": "L06", "matrix": [1, 4]},
{"label": "L07", "matrix": [1, 3]},
{"label": "L08", "matrix": [1, 2]},
{"label": "L09", "matrix": [1, 1]},
{"label": "L10", "matrix": [1, 0]},
{"label": "R10", "matrix": [5, 0]},
{"label": "R09", "matrix": [5, 1]},
{"label": "R08", "matrix": [5, 2]},
{"label": "R07", "matrix": [5, 3]},
{"label": "R06", "matrix": [5, 4]},
{"label": "L11", "matrix": [2, 4]},
{"label": "L12", "matrix": [2, 3]},
{"label": "L13", "matrix": [2, 2]},
{"label": "L14", "matrix": [2, 1]},
{"label": "L15", "matrix": [2, 0]},
{"label": "R15", "matrix": [6, 0]},
{"label": "R14", "matrix": [6, 1]},
{"label": "R13", "matrix": [6, 2]},
{"label": "R12", "matrix": [6, 3]},
{"label": "R11", "matrix": [6, 4]},
{"label": "L16", "matrix": [3, 1]},
{"label": "L17", "matrix": [3, 0]},
{"label": "R17", "matrix": [7, 0]},
{"label": "R16", "matrix": [7, 1]}
]
}
},
"diode_direction": "ROW2COL",
"matrix_pins": {
"rows": ["F6", "F5", "F7", "B1"],
"cols": ["B6", "D4", "C6", "D7", "E6"]
},
"encoder": {
"rotary": [
{
"pin_a": "B5",
"pin_b": "B4"
},
{
"pin_a": "B3",
"pin_b": "B2"
}
]
},
"split": {
"soft_serial_pin": "D2",
"main": "pin",
"matrix_pins": {
"right": {
"rows": ["B1", "F7", "F6", "B3"],
"cols": ["B5", "B4", "E6", "D7", "C6"]
}
},
"encoder": {
"right": {
"rotary": [
{
"pin_a": "B2",
"pin_b": "B6"
},
{
"pin_a": "F5",
"pin_b": "D4"
}
]
}
}
},
"rgblight": {
"pin": "D3",
"led_count": 46,
"split": true,
"split_count": [23, 23],
"max_brightness": 128
},
"rgb_matrix": {
"driver": "WS2812",
"layout": [
{"flags": 2, "x": 71, "y": 15}, // L RGB1
{"flags": 2, "x": 51, "y": 8}, // L RGB2
{"flags": 2, "x": 10, "y": 13}, // L RGB3
{"flags": 2, "x": 10, "y": 42}, // L RGB4
{"flags": 2, "x": 41, "y": 45}, // L RGB5
{"flags": 2, "x": 76, "y": 50}, // L RGB6
{"flags": 4, "matrix": [0, 4], "x": 0, "y": 15}, // L SW01
{"flags": 4, "matrix": [0, 3], "x": 20, "y": 5}, // L SW02
{"flags": 4, "matrix": [0, 2], "x": 41, "y": 0}, // L SW03
{"flags": 4, "matrix": [0, 1], "x": 61, "y": 4}, // L SW04
{"flags": 4, "matrix": [0, 0], "x": 81, "y": 7}, // L SW05
{"flags": 4, "matrix": [1, 4], "x": 0, "y": 31}, // L SW06
{"flags": 4, "matrix": [1, 3], "x": 20, "y": 21}, // L SW07
{"flags": 4, "matrix": [1, 2], "x": 41, "y": 16}, // L SW08
{"flags": 4, "matrix": [1, 1], "x": 61, "y": 20}, // L SW09
{"flags": 4, "matrix": [1, 0], "x": 81, "y": 23}, // L SW10
{"flags": 4, "matrix": [2, 4], "x": 0, "y": 47}, // L SW11
{"flags": 4, "matrix": [2, 3], "x": 20, "y": 37}, // L SW12
{"flags": 4, "matrix": [2, 2], "x": 41, "y": 32}, // L SW13
{"flags": 4, "matrix": [2, 1], "x": 61, "y": 36}, // L SW14
{"flags": 4, "matrix": [2, 0], "x": 81, "y": 39}, // L SW15
{"flags": 4, "matrix": [3, 1], "x": 71, "y": 60}, // L SW16
{"flags": 4, "matrix": [3, 0], "x": 92, "y": 64}, // L SW17
{"flags": 2, "x": 150, "y": 15}, // R RGB1
{"flags": 2, "x": 190, "y": 8}, // R RGB2
{"flags": 2, "x": 210, "y": 13}, // R RGB3
{"flags": 2, "x": 220, "y": 42}, // R RGB4
{"flags": 2, "x": 183, "y": 45}, // R RGB5
{"flags": 2, "x": 155, "y": 50}, // R RGB6
{"flags": 4, "matrix": [4, 0], "x": 143, "y": 7}, // R SW05
{"flags": 4, "matrix": [4, 1], "x": 163, "y": 4}, // R SW04
{"flags": 4, "matrix": [4, 2], "x": 183, "y": 0}, // R SW03
{"flags": 4, "matrix": [4, 3], "x": 204, "y": 5}, // R SW02
{"flags": 4, "matrix": [4, 4], "x": 224, "y": 15}, // R SW01
{"flags": 4, "matrix": [5, 0], "x": 143, "y": 23}, // R SW10
{"flags": 4, "matrix": [5, 1], "x": 163, "y": 20}, // R SW09
{"flags": 4, "matrix": [5, 2], "x": 183, "y": 16}, // R SW08
{"flags": 4, "matrix": [5, 3], "x": 204, "y": 21}, // R SW07
{"flags": 4, "matrix": [5, 4], "x": 224, "y": 31}, // R SW06
{"flags": 4, "matrix": [6, 0], "x": 143, "y": 39}, // R SW15
{"flags": 4, "matrix": [6, 1], "x": 163, "y": 36}, // R SW14
{"flags": 4, "matrix": [6, 2], "x": 183, "y": 32}, // R SW13
{"flags": 4, "matrix": [6, 3], "x": 204, "y": 37}, // R SW12
{"flags": 4, "matrix": [6, 4], "x": 224, "y": 47}, // R SW11
{"flags": 4, "matrix": [7, 0], "x": 132, "y": 64}, // R SW17
{"flags": 4, "matrix": [7, 1], "x": 153, "y": 60} // R SW16
]
}
}

33
keyboards/splitkb/aurora/sweep/rev1/rev1.c Normal file
View File

@ -0,0 +1,33 @@
/* Copyright 2022 splitkb.com <support@splitkb.com>
*
* 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/>.
*/
#ifdef SWAP_HANDS_ENABLE
// clang-format off
__attribute__ ((weak)) const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
{{0, 4}, {1, 4}, {2, 4}, {3, 4}, {4, 4}},
{{0, 5}, {1, 5}, {2, 5}, {3, 5}, {4, 5}},
{{0, 6}, {1, 6}, {2, 6}, {3, 6}, {4, 6}},
{{0, 7}, {1, 7}, {2, 7}, {3, 7}, {4, 7}},
{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}},
{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}},
{{0, 2}, {1, 2}, {2, 2}, {3, 2}, {4, 2}},
{{0, 3}, {1, 3}, {2, 3}, {3, 3}, {4, 3}}
};
// clang-format on
# ifdef ENCODER_MAP_ENABLE
const uint8_t PROGMEM encoder_hand_swap_config[NUM_ENCODERS] = {3,2,1,0};
# endif
#endif

17
keyboards/splitkb/aurora/sweep/rev1/rules.mk Normal file
View File

@ -0,0 +1,17 @@
# Copyright 2022 splitkb.com <support@splitkb.com>
#
# 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/>.
# Although no rules are defined,
# presence of this file is required for QMK to compile it.

16
keyboards/splitkb/aurora/sweep/rules.mk Normal file
View File

@ -0,0 +1,16 @@
# Copyright 2022 splitkb.com <support@splitkb.com>
#
# 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/>.
DEFAULT_FOLDER = splitkb/aurora/sweep/rev1

322
keyboards/splitkb/aurora/sweep/sweep.c Normal file
View File

@ -0,0 +1,322 @@
/* Copyright 2022 splitkb.com <support@splitkb.com>
*
* 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 "quantum.h"
// The first four layers gets a name for readability, which is then used in the OLED below.
enum layers {
_DEFAULT,
_LOWER,
_RAISE,
_ADJUST
};
#ifdef OLED_ENABLE
// NOTE: Most of the OLED code was originally written by Soundmonster for the Corne,
// and has been copied directly from `crkbd/soundmonster/keymap.c`
oled_rotation_t oled_init_kb(oled_rotation_t rotation) {
return OLED_ROTATION_270;
}
void render_space(void) {
oled_write_P(PSTR(" "), false);
}
void render_mod_status_gui_alt(uint8_t modifiers) {
static const char PROGMEM gui_off_1[] = {0x85, 0x86, 0};
static const char PROGMEM gui_off_2[] = {0xa5, 0xa6, 0};
static const char PROGMEM gui_on_1[] = {0x8d, 0x8e, 0};
static const char PROGMEM gui_on_2[] = {0xad, 0xae, 0};
static const char PROGMEM alt_off_1[] = {0x87, 0x88, 0};
static const char PROGMEM alt_off_2[] = {0xa7, 0xa8, 0};
static const char PROGMEM alt_on_1[] = {0x8f, 0x90, 0};
static const char PROGMEM alt_on_2[] = {0xaf, 0xb0, 0};
// fillers between the modifier icons bleed into the icon frames
static const char PROGMEM off_off_1[] = {0xc5, 0};
static const char PROGMEM off_off_2[] = {0xc6, 0};
static const char PROGMEM on_off_1[] = {0xc7, 0};
static const char PROGMEM on_off_2[] = {0xc8, 0};
static const char PROGMEM off_on_1[] = {0xc9, 0};
static const char PROGMEM off_on_2[] = {0xca, 0};
static const char PROGMEM on_on_1[] = {0xcb, 0};
static const char PROGMEM on_on_2[] = {0xcc, 0};
if(modifiers & MOD_MASK_GUI) {
oled_write_P(gui_on_1, false);
} else {
oled_write_P(gui_off_1, false);
}
if ((modifiers & MOD_MASK_GUI) && (modifiers & MOD_MASK_ALT)) {
oled_write_P(on_on_1, false);
} else if(modifiers & MOD_MASK_GUI) {
oled_write_P(on_off_1, false);
} else if(modifiers & MOD_MASK_ALT) {
oled_write_P(off_on_1, false);
} else {
oled_write_P(off_off_1, false);
}
if(modifiers & MOD_MASK_ALT) {
oled_write_P(alt_on_1, false);
} else {
oled_write_P(alt_off_1, false);
}
if(modifiers & MOD_MASK_GUI) {
oled_write_P(gui_on_2, false);
} else {
oled_write_P(gui_off_2, false);
}
if (modifiers & MOD_MASK_GUI & MOD_MASK_ALT) {
oled_write_P(on_on_2, false);
} else if(modifiers & MOD_MASK_GUI) {
oled_write_P(on_off_2, false);
} else if(modifiers & MOD_MASK_ALT) {
oled_write_P(off_on_2, false);
} else {
oled_write_P(off_off_2, false);
}
if(modifiers & MOD_MASK_ALT) {
oled_write_P(alt_on_2, false);
} else {
oled_write_P(alt_off_2, false);
}
}
void render_mod_status_ctrl_shift(uint8_t modifiers) {
static const char PROGMEM ctrl_off_1[] = {0x89, 0x8a, 0};
static const char PROGMEM ctrl_off_2[] = {0xa9, 0xaa, 0};
static const char PROGMEM ctrl_on_1[] = {0x91, 0x92, 0};
static const char PROGMEM ctrl_on_2[] = {0xb1, 0xb2, 0};
static const char PROGMEM shift_off_1[] = {0x8b, 0x8c, 0};
static const char PROGMEM shift_off_2[] = {0xab, 0xac, 0};
static const char PROGMEM shift_on_1[] = {0xcd, 0xce, 0};
static const char PROGMEM shift_on_2[] = {0xcf, 0xd0, 0};
// fillers between the modifier icons bleed into the icon frames
static const char PROGMEM off_off_1[] = {0xc5, 0};
static const char PROGMEM off_off_2[] = {0xc6, 0};
static const char PROGMEM on_off_1[] = {0xc7, 0};
static const char PROGMEM on_off_2[] = {0xc8, 0};
static const char PROGMEM off_on_1[] = {0xc9, 0};
static const char PROGMEM off_on_2[] = {0xca, 0};
static const char PROGMEM on_on_1[] = {0xcb, 0};
static const char PROGMEM on_on_2[] = {0xcc, 0};
if(modifiers & MOD_MASK_CTRL) {
oled_write_P(ctrl_on_1, false);
} else {
oled_write_P(ctrl_off_1, false);
}
if ((modifiers & MOD_MASK_CTRL) && (modifiers & MOD_MASK_SHIFT)) {
oled_write_P(on_on_1, false);
} else if(modifiers & MOD_MASK_CTRL) {
oled_write_P(on_off_1, false);
} else if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(off_on_1, false);
} else {
oled_write_P(off_off_1, false);
}
if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(shift_on_1, false);
} else {
oled_write_P(shift_off_1, false);
}
if(modifiers & MOD_MASK_CTRL) {
oled_write_P(ctrl_on_2, false);
} else {
oled_write_P(ctrl_off_2, false);
}
if (modifiers & MOD_MASK_CTRL & MOD_MASK_SHIFT) {
oled_write_P(on_on_2, false);
} else if(modifiers & MOD_MASK_CTRL) {
oled_write_P(on_off_2, false);
} else if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(off_on_2, false);
} else {
oled_write_P(off_off_2, false);
}
if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(shift_on_2, false);
} else {
oled_write_P(shift_off_2, false);
}
}
void render_logo(void) {
static const char PROGMEM aurora_logo[] = {
0x00, 0x00, 0x00, 0xe0, 0x00, 0xf8, 0xc0, 0xf8, 0xe0, 0xc0, 0xfc, 0x00, 0x7e, 0x18, 0x00, 0x80,
0x00, 0x02, 0x80, 0xf0, 0x00, 0xc0, 0x80, 0xf8, 0xc0, 0xe0, 0x70, 0x60, 0x3c, 0x38, 0x3c, 0x1c,
0x00, 0x3f, 0x0c, 0x0f, 0x1f, 0x03, 0x07, 0x01, 0xc3, 0x00, 0xe0, 0x80, 0x00, 0xe0, 0x80, 0xf8,
0x80, 0xc0, 0xf7, 0xc7, 0x6f, 0x7b, 0x39, 0x30, 0x00, 0x80, 0x00, 0xc0, 0x00, 0xc0, 0xc2, 0xe0,
0x00, 0x40, 0x38, 0x30, 0x38, 0x1e, 0x18, 0x1e, 0x0f, 0x0c, 0x07, 0x07, 0x07, 0x03, 0x03, 0x21,
0x21, 0x31, 0x30, 0x18, 0x18, 0x1c, 0x08, 0x0c, 0x0e, 0x07, 0x06, 0x07, 0x03, 0xc3, 0x03, 0x01,
0x4c, 0xcc, 0xc2, 0xc2, 0x41, 0x49, 0x09, 0x2b, 0x2a, 0x6a, 0x6e, 0x24, 0x24, 0x04, 0x92, 0x92,
0xb1, 0xf1, 0xf1, 0xf2, 0xe6, 0xa4, 0xa4, 0x04, 0x04, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28
};
oled_write_raw_P(aurora_logo, sizeof(aurora_logo));
oled_set_cursor(0, 4);
}
void render_logo_text(void) {
oled_write_P(PSTR("sweep"), false);
}
void render_kb_LED_state(void) {
// Host Keyboard LED Status
led_t led_usb_state = host_keyboard_led_state();
oled_write_P(led_usb_state.num_lock ? PSTR("N ") : PSTR(" "), false);
oled_write_P(led_usb_state.caps_lock ? PSTR("C ") : PSTR(" "), false);
oled_write_P(led_usb_state.scroll_lock ? PSTR("S ") : PSTR(" "), false);
}
void render_layer_state(void) {
static const char PROGMEM default_layer[] = {
0x20, 0x94, 0x95, 0x96, 0x20,
0x20, 0xb4, 0xb5, 0xb6, 0x20,
0x20, 0xd4, 0xd5, 0xd6, 0x20, 0};
static const char PROGMEM raise_layer[] = {
0x20, 0x97, 0x98, 0x99, 0x20,
0x20, 0xb7, 0xb8, 0xb9, 0x20,
0x20, 0xd7, 0xd8, 0xd9, 0x20, 0};
static const char PROGMEM lower_layer[] = {
0x20, 0x9a, 0x9b, 0x9c, 0x20,
0x20, 0xba, 0xbb, 0xbc, 0x20,
0x20, 0xda, 0xdb, 0xdc, 0x20, 0};
static const char PROGMEM adjust_layer[] = {
0x20, 0x9d, 0x9e, 0x9f, 0x20,
0x20, 0xbd, 0xbe, 0xbf, 0x20,
0x20, 0xdd, 0xde, 0xdf, 0x20, 0};
if(layer_state_is(_LOWER)) {
oled_write_P(lower_layer, false);
} else if(layer_state_is(_RAISE)) {
oled_write_P(raise_layer, false);
} else if(layer_state_is(_DEFAULT)) {
oled_write_P(default_layer, false);
} else {
oled_write_P(adjust_layer, false);
}
}
bool oled_task_kb(void) {
if (!oled_task_user()) {
return false;
}
if (is_keyboard_master()) {
// Renders the current keyboard state (layers and mods)
render_logo();
render_logo_text();
render_space();
render_layer_state();
render_space();
render_mod_status_gui_alt(get_mods()|get_oneshot_mods());
render_mod_status_ctrl_shift(get_mods()|get_oneshot_mods());
render_kb_LED_state();
} else {
// clang-format off
static const char PROGMEM aurora_art[] = {
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x1c, 0x08, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x40,
0xe0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0x80,
0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x80, 0x00, 0xf0, 0x00, 0x00, 0xc0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
0x81, 0x00, 0xc0, 0x00, 0xfe, 0x00, 0xfc, 0x00, 0xff, 0x20, 0xff, 0xf0, 0x0f, 0xf0, 0x00, 0xff,
0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xf8, 0x00, 0x00, 0xf8,
0xff, 0x10, 0xff, 0x84, 0xff, 0x60, 0xff, 0x36, 0xff, 0x0f, 0xff, 0x3f, 0x00, 0x5f, 0x00, 0x05,
0x80, 0x00, 0x80, 0x00, 0xc0, 0x38, 0x00, 0xec, 0xf0, 0x00, 0xfb, 0x80, 0xff, 0xf0, 0xff, 0xef,
0xff, 0xe8, 0xff, 0x03, 0xff, 0x0c, 0xff, 0x00, 0xff, 0x00, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x80,
0xff, 0x20, 0xff, 0xd0, 0xff, 0xe0, 0xfe, 0xf8, 0xff, 0xfc, 0xff, 0xff, 0x0f, 0xff, 0x01, 0x3f,
0xff, 0x00, 0x0f, 0x00, 0x01, 0x00, 0x03, 0x00, 0xfe, 0x80, 0xfe, 0x00, 0xc0, 0xff, 0xc4, 0xfb,
0xff, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0x07, 0xff, 0x03, 0x3f, 0x00, 0x0f, 0xc0, 0x00,
0x00, 0x00, 0xb8, 0x00, 0xff, 0x40, 0xbe, 0xf0, 0xff, 0xf1, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff,
0x1f, 0xff, 0x67, 0x00, 0xef, 0x00, 0x1f, 0x00, 0x00, 0x07, 0x00, 0x00, 0xe0, 0x00, 0xff, 0xf0,
0xff, 0x88, 0xff, 0xc4, 0xff, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0x7f, 0x0f, 0xff,
0x00, 0x07, 0xfe, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x00, 0xc0, 0x3f, 0xf8, 0xe7, 0xff,
0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0x1f, 0x3f, 0x01, 0xff, 0x0b, 0x00, 0xff, 0x00, 0x00, 0x05,
0x00, 0x00, 0x00, 0xe0, 0x00, 0xf8, 0x60, 0x80, 0xfe, 0xe3, 0xfc, 0xff, 0x1e, 0xff, 0xff, 0x23,
0xff, 0x09, 0xff, 0x20, 0x00, 0x3f, 0x02, 0x00, 0x00, 0x0f, 0x00, 0x40, 0x00, 0xc0, 0x00, 0xfc,
0xe0, 0xfc, 0xf0, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0x0f, 0xff, 0x07, 0x1f, 0x00, 0x01, 0x0f, 0x00,
0x0f, 0x00, 0x81, 0x70, 0x0c, 0xf0, 0x80, 0x00, 0x00, 0xe4, 0xf8, 0xe6, 0x70, 0x3f, 0xcf, 0xff,
0x1f, 0xff, 0x48, 0xff, 0x0f, 0x00, 0x07, 0x00, 0x00, 0x43, 0x60, 0xf8, 0xf0, 0xfe, 0x38, 0xfe,
0x00, 0xfc, 0x03, 0x00, 0xc8, 0x72, 0xcf, 0xfc, 0x00, 0x03, 0x0f, 0x01, 0xe0, 0x1c, 0xe0, 0x03,
0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x06, 0xf9, 0x00, 0x03, 0x00, 0x07,
0xff, 0x00, 0x10, 0x12, 0xc9, 0xf0, 0xcf, 0xb4, 0x7f, 0x80, 0xe0, 0x1e, 0x01, 0x40, 0x65, 0x5e,
0xe0, 0x00, 0x00, 0xf0, 0x0c, 0xf0, 0x00, 0x80, 0x7e, 0x01, 0x80, 0x93, 0xfc, 0xc0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x89, 0x18, 0x2c, 0x46, 0x00, 0x07, 0x21, 0x10, 0x10, 0x80, 0x09, 0x13,
0x31, 0xbf, 0xff, 0x00, 0x08, 0x1a, 0xf7, 0x0f, 0x00, 0x00, 0x44, 0x45, 0x34, 0xbf, 0xb8, 0x00,
0x10, 0xf0, 0x08, 0xf4, 0x18, 0x11, 0xfc, 0x18, 0xfb, 0x0e, 0x10, 0xf8, 0x04, 0xf8, 0x10, 0x20,
0x18, 0x09, 0xff, 0x0c, 0xea, 0x1f, 0x28, 0x60, 0x30, 0xf8, 0x20, 0xc0, 0x42, 0x33, 0x21, 0x00
};
// clang-format on
oled_write_raw_P(aurora_art, sizeof(aurora_art));
}
return false;
}
#endif
#ifdef ENCODER_ENABLE
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!encoder_update_user(index, clockwise)) {
return false;
}
// 0 and 1 are left-half encoders,
// 2 and 3 are right-half encoders
if (index == 0) {
// Volume control
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
} else if (index == 1) {
// Volume control
if (clockwise) {
tap_code(KC_VOLU);
} else {
tap_code(KC_VOLD);
}
} else if (index == 2) {
// Page up/Page down
if (clockwise) {
tap_code(KC_PGDN);
} else {
tap_code(KC_PGUP);
}
} else if (index == 3) {
// Page up/Page down
if (clockwise) {
tap_code(KC_PGDN);
} else {
tap_code(KC_PGUP);
}
}
return true;
}
#endif