[Keyboard] Zen keyboard update for Rev2 (#5522) * Updated Zen keyboard for rev2 support * Fixing r1 compile errors * PR feedback and changes for Proton-C compile errors
34 files changed, 659 insertions(+), 984 deletions(-) A keyboards/zen/common/glcdfont.c M keyboards/zen/config.h D keyboards/zen/matrix.c M keyboards/zen/readme.md M keyboards/zen/rev1/config.h R keyboards/zen/{ => rev1}/keymaps/333fred/config.h R keyboards/zen/{ => rev1}/keymaps/333fred/keymap.c R keyboards/zen/{ => rev1}/keymaps/333fred/rules.mk R keyboards/zen/{keymaps/jwlawrence => rev1/keymaps/default}/config.h R keyboards/zen/{ => rev1}/keymaps/default/keymap.c R keyboards/zen/{ => rev1}/keymaps/default/rules.mk R keyboards/zen/{keymaps/default => rev1/keymaps/jwlawrence}/config.h R keyboards/zen/{ => rev1}/keymaps/jwlawrence/keymap.c R keyboards/zen/{ => rev1}/keymaps/jwlawrence/rules.mk R keyboards/zen/{ => rev1}/keymaps/kageurufu/keymap.c R keyboards/zen/{ => rev1}/keymaps/xyverz/config.h R keyboards/zen/{ => rev1}/keymaps/xyverz/keymap.c R keyboards/zen/{ => rev1}/keymaps/xyverz/rules.mk M keyboards/zen/rev1/rev1.h M keyboards/zen/rev1/rules.mk A keyboards/zen/rev2/config.h A keyboards/zen/rev2/keymaps/debug/keymap.c A keyboards/zen/rev2/keymaps/default/keymap.c A keyboards/zen/rev2/rev2.c A keyboards/zen/rev2/rev2.h A keyboards/zen/rev2/rules.mk M keyboards/zen/rules.mk D keyboards/zen/serial.c D keyboards/zen/serial.h D keyboards/zen/split_rgb.c D keyboards/zen/split_rgb.h D keyboards/zen/split_util.c D keyboards/zen/split_util.h M keyboards/zen/zen.h
A keyboards/zen/common/glcdfont.c => keyboards/zen/common/glcdfont.c +239 -0
@@ 0,0 1,239 @@ // This is the SOL 6x8 font #pragma once #ifdef __AVR__ #include <avr/io.h> #include <avr/pgmspace.h> #elif defined(ESP8266) #include <pgmspace.h> #else #define PROGMEM #endif 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, 0xA4, 0xA4, 0x9C, 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, 0xFC, 0x18, 0x24, 0x24, 0x18, 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC, 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, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0C, 0x90, 0xB0, 0xE0, 0x72, 0x31, 0x9B, 0xDE, 0xCE, 0xEC, 0xEE, 0xE9, 0xE9, 0xEC, 0xCF, 0xDA, 0x99, 0x3E, 0x62, 0xE4, 0xC4, 0x70, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xC0, 0xC0, 0x80, 0x80, 0x02, 0x85, 0x85, 0x87, 0x85, 0x89, 0x89, 0x92, 0xEA, 0xC6, 0xC4, 0x48, 0x50, 0x60, 0x40, 0x40, 0x40, 0x40, 0xC0, 0xE0, 0x50, 0x28, 0x10, 0x10, 0x60, 0xC0, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80, 0x80, 0xE0, 0xF8, 0xFC, 0xF8, 0xF0, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xF0, 0xF0, 0xF0, 0xE0, 0xEC, 0xEE, 0xF7, 0xF3, 0x70, 0x20, 0x00, 0x7C, 0x7C, 0x7C, 0x7E, 0x00, 0x7E, 0x7E, 0x7E, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B, 0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00, 0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE, 0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xEC, 0xDF, 0xFC, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x80, 0x80, 0x80, 0x70, 0x0F, 0x00, 0x00, 0x80, 0x7F, 0x00, 0x00, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x21, 0x33, 0x3B, 0x7B, 0xFF, 0x00, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7C, 0x01, 0xFF, 0xDE, 0x8C, 0x04, 0x0C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x7F, 0x80, 0x80, 0xBE, 0xBE, 0x80, 0x80, 0x80, 0xC1, 0xFF, 0x80, 0x04, 0x32, 0x5E, 0x1C, 0x3D, 0x26, 0x10, 0xC1, 0xFF, 0x3E, 0x00, 0x00, 0x08, 0x36, 0xC1, 0x08, 0x08, 0x14, 0x77, 0x94, 0x94, 0x94, 0xF7, 0x94, 0xF7, 0x9C, 0x9C, 0xFF, 0xFF, 0x1E, 0x00, 0x00, 0x00, 0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x3F, 0x1E, 0x0C, 0x00, 0x1F, 0x1F, 0x1F, 0x3F, 0x00, 0x3F, 0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x00, 0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20, 0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00, 0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F, 0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00, 0x40, 0x7C, 0x3F, 0x3F, 0x23, 0x01, 0x23, 0x3F, 0x37, 0x6C, 0x40, 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, 0x06, 0x02, 0x06, 0x4D, 0x4F, 0x8C, 0xF9, 0x73, 0x37, 0x27, 0x2F, 0x2F, 0xAF, 0xEF, 0x6F, 0x77, 0x17, 0x33, 0x79, 0xCC, 0x1F, 0x31, 0x20, 0x21, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xE0, 0xA0, 0xA0, 0xD0, 0x90, 0x48, 0x48, 0x25, 0x2B, 0x11, 0x09, 0x05, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0F, 0x1F, 0x0F, 0x03, 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, };
M keyboards/zen/config.h => keyboards/zen/config.h +1 -12
@@ 15,17 15,6 @@ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef CONFIG_H #define CONFIG_H #pragma once #include "config_common.h" #endif // CONFIG_H #undef RGBLED_NUM #define RGBLIGHT_ANIMATIONS #define RGBLED_NUM 16 #ifndef TAPPING_TERM #define TAPPING_TERM 100 #endif
D keyboards/zen/matrix.c => keyboards/zen/matrix.c +0 -466
@@ 1,466 0,0 @@ /* Copyright 2017 Danny Nguyen <danny@keeb.io> 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/>. */ /* * scan matrix */ #include <stdint.h> #include <stdbool.h> #include <avr/io.h> #include "wait.h" #include "print.h" #include "debug.h" #include "util.h" #include "matrix.h" #include "split_util.h" #include "pro_micro.h" #include "config.h" #include "timer.h" #include "backlight.h" #ifdef USE_I2C # include "i2c.h" #else // USE_SERIAL # include "serial.h" #endif #ifndef DEBOUNCING_DELAY # define DEBOUNCING_DELAY 5 #endif #if (DEBOUNCING_DELAY > 0) static uint16_t debouncing_time; static bool debouncing = false; #endif #if (MATRIX_COLS <= 8) # define print_matrix_header() print("\nr/c 01234567\n") # define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define matrix_bitpop(i) bitpop(matrix[i]) # define ROW_SHIFTER ((uint8_t)1) #else # error "Currently only supports 8 COLS" #endif static matrix_row_t matrix_debouncing[MATRIX_ROWS]; #define ERROR_DISCONNECT_COUNT 5 #define SERIAL_LED_ADDR 0x00 #define ROWS_PER_HAND (MATRIX_ROWS/2) static uint8_t error_count = 0; static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; /* matrix state(1:on, 0:off) */ static matrix_row_t matrix[MATRIX_ROWS]; static matrix_row_t matrix_debouncing[MATRIX_ROWS]; #if (DIODE_DIRECTION == COL2ROW) static void init_cols(void); static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row); static void unselect_rows(void); static void select_row(uint8_t row); static void unselect_row(uint8_t row); #elif (DIODE_DIRECTION == ROW2COL) static void init_rows(void); static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col); static void unselect_cols(void); static void unselect_col(uint8_t col); static void select_col(uint8_t col); #endif __attribute__ ((weak)) void matrix_init_kb(void) { matrix_init_user(); } __attribute__ ((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } __attribute__ ((weak)) void matrix_init_user(void) { } __attribute__ ((weak)) void matrix_scan_user(void) { } inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } inline uint8_t matrix_cols(void) { return MATRIX_COLS; } void matrix_init(void) { debug_enable = true; debug_matrix = true; debug_mouse = true; // initialize row and col unselect_rows(); init_cols(); TX_RX_LED_INIT; // initialize matrix state: all keys off for (uint8_t i=0; i < MATRIX_ROWS; i++) { matrix[i] = 0; matrix_debouncing[i] = 0; } matrix_init_quantum(); } uint8_t _matrix_scan(void) { int offset = isLeftHand ? 0 : (ROWS_PER_HAND); #if (DIODE_DIRECTION == COL2ROW) // Set row, read cols for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) { # if (DEBOUNCING_DELAY > 0) bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row); if (matrix_changed) { debouncing = true; debouncing_time = timer_read(); } # else read_cols_on_row(matrix+offset, current_row); # endif } #elif (DIODE_DIRECTION == ROW2COL) // Set col, read rows for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) { # if (DEBOUNCING_DELAY > 0) bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col); if (matrix_changed) { debouncing = true; debouncing_time = timer_read(); } # else read_rows_on_col(matrix+offset, current_col); # endif } #endif # if (DEBOUNCING_DELAY > 0) if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) { for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { matrix[i+offset] = matrix_debouncing[i+offset]; } debouncing = false; } # endif return 1; } #ifdef USE_I2C // Get rows from other half over i2c int i2c_transaction(void) { int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); if (err) goto i2c_error; // start of matrix stored at 0x00 err = i2c_master_write(0x00); if (err) goto i2c_error; // Start read err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ); if (err) goto i2c_error; if (!err) { int i; for (i = 0; i < ROWS_PER_HAND-1; ++i) { matrix[slaveOffset+i] = i2c_master_read(I2C_ACK); } matrix[slaveOffset+i] = i2c_master_read(I2C_NACK); i2c_master_stop(); } else { i2c_error: // the cable is disconnceted, or something else went wrong i2c_reset_state(); return err; } return 0; } #else // USE_SERIAL int serial_transaction(void) { int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; if (serial_update_buffers()) { return 1; } for (int i = 0; i < ROWS_PER_HAND; ++i) { matrix[slaveOffset+i] = serial_slave_buffer[i]; } #ifdef BACKLIGHT_ENABLE // Write backlight level for slave to read serial_master_buffer[SERIAL_LED_ADDR] = get_backlight_level(); #endif return 0; } #endif uint8_t matrix_scan(void) { uint8_t ret = _matrix_scan(); #ifdef USE_I2C if( i2c_transaction() ) { #else // USE_SERIAL if( serial_transaction() ) { #endif // turn on the indicator led when halves are disconnected TXLED1; error_count++; if (error_count > ERROR_DISCONNECT_COUNT) { // reset other half if disconnected int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; for (int i = 0; i < ROWS_PER_HAND; ++i) { matrix[slaveOffset+i] = 0; } } } else { // turn off the indicator led on no error TXLED0; error_count = 0; } matrix_scan_quantum(); return ret; } void matrix_slave_scan(void) { _matrix_scan(); int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; #ifdef USE_I2C for (int i = 0; i < ROWS_PER_HAND; ++i) { i2c_slave_buffer[i] = matrix[offset+i]; } #else // USE_SERIAL for (int i = 0; i < ROWS_PER_HAND; ++i) { serial_slave_buffer[i] = matrix[offset+i]; } #ifdef BACKLIGHT_ENABLE // Read backlight level sent from master and update level on slave backlight_set(serial_master_buffer[SERIAL_LED_ADDR]); #endif #endif } bool matrix_is_modified(void) { if (debouncing) return false; return true; } inline bool matrix_is_on(uint8_t row, uint8_t col) { return (matrix[row] & ((matrix_row_t)1<<col)); } inline matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } void matrix_print(void) { print("\nr/c 0123456789ABCDEF\n"); for (uint8_t row = 0; row < MATRIX_ROWS; row++) { phex(row); print(": "); pbin_reverse16(matrix_get_row(row)); print("\n"); } } uint8_t matrix_key_count(void) { uint8_t count = 0; for (uint8_t i = 0; i < MATRIX_ROWS; i++) { count += bitpop16(matrix[i]); } return count; } #if (DIODE_DIRECTION == COL2ROW) static void init_cols(void) { for(uint8_t x = 0; x < MATRIX_COLS; x++) { uint8_t pin = col_pins[x]; _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } } static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { // Store last value of row prior to reading matrix_row_t last_row_value = current_matrix[current_row]; // Clear data in matrix row current_matrix[current_row] = 0; // Select row and wait for row selecton to stabilize select_row(current_row); wait_us(30); // For each col... for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { // Select the col pin to read (active low) uint8_t pin = col_pins[col_index]; uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)); // Populate the matrix row with the state of the col pin current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index); } // Unselect row unselect_row(current_row); return (last_row_value != current_matrix[current_row]); } static void select_row(uint8_t row) { uint8_t pin = row_pins[row]; _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW } static void unselect_row(uint8_t row) { uint8_t pin = row_pins[row]; _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } static void unselect_rows(void) { for(uint8_t x = 0; x < ROWS_PER_HAND; x++) { uint8_t pin = row_pins[x]; _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } } #elif (DIODE_DIRECTION == ROW2COL) static void init_rows(void) { for(uint8_t x = 0; x < ROWS_PER_HAND; x++) { uint8_t pin = row_pins[x]; _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } } static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) { bool matrix_changed = false; // Select col and wait for col selecton to stabilize select_col(current_col); wait_us(30); // For each row... for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) { // Store last value of row prior to reading matrix_row_t last_row_value = current_matrix[row_index]; // Check row pin state if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0) { // Pin LO, set col bit current_matrix[row_index] |= (ROW_SHIFTER << current_col); } else { // Pin HI, clear col bit current_matrix[row_index] &= ~(ROW_SHIFTER << current_col); } // Determine if the matrix changed state if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) { matrix_changed = true; } } // Unselect col unselect_col(current_col); return matrix_changed; } static void select_col(uint8_t col) { uint8_t pin = col_pins[col]; _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW } static void unselect_col(uint8_t col) { uint8_t pin = col_pins[col]; _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } static void unselect_cols(void) { for(uint8_t x = 0; x < MATRIX_COLS; x++) { uint8_t pin = col_pins[x]; _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } } #endif
M keyboards/zen/readme.md => keyboards/zen/readme.md +13 -6
@@ 2,19 2,26 @@ A split ergo keyboard with a few goals in mind: - Be as thin as possible. Other split KBs (Let's Split, Nyquist, Iris) are 15.2mm thick. The Zen is only 8.0mm thick. - Be as thin as possible. Other split KBs (Let's Split, Nyquist, Iris) are 15.2mm thick. The Zen rev2 is only 13.2mm thick *including switches and caps* when using Kailh Choc low-profile switches, and 22.1mm using standard MX switches and DSA keycaps. - Layout designed for gaming. 1.5u pinky keys, ortho alphas, and angled thumb keys. After trying Ortholinear, Atreus62, and Ergodox, this is the best layout for gaming and typing. - RGB backlighting. 16 WS2812b LEDs shine through the perimeter switches. The SK6812 variant are cheap and easy to solder. - Per-key RGB lighting. 34 WS2812b LEDs per side make it exceptionally bright - Price. Using Arduino Pro Micro, SK6812 LEDs, and PCB FR4 for the case, the cost of each half without switches or caps can be reduced to under $20 when purchased at volume. - Options. The Zen rev2 comes with rotary encoder support, SSD1306 OLED pinout, USB-C or TRRS interconnect, and jumpers to enable compatibility with the [QMK Proton-C](https://olkb.com/parts/qmk-proton-c) and the [Keeb.io Elite-C](https://keeb.io/products/elite-c-usb-c-pro-micro-replacement-arduino-compatible-atmega32u4) Keyboard Maintainer: [Legonut](https://github.com/Legonut) Hardware Supported: Zen rev1 Keyboard Maintainer: [Legonut](https://github.com/Legonut) Hardware Supported: Zen rev1, Zen rev2 Hardware Availability: [RGBKB.net](https://www.rgbkb.net/) A build guide and more info for this keyboard can be found here: [Zen Build Guide](https://legonut.gitbooks.io/zen-keyboard/content/). A build guide and more info for this keyboard can be found here: [Zen Build Guide](https://rgbkb.gitbook.io/sol-build-guide/zygomorph-build-guide/untitled). Make example for this keyboard (after setting up your build environment): make zen/rev1:default make zen/rev2:default To build for a Proton-C: make zen/rev2:default CTPC=yes **Note:** The Proton-C does not have split keyboard, or encoder support. Also OLED driver support is untested. Will update as status changes. See [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) then the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information.
M keyboards/zen/rev1/config.h => keyboards/zen/rev1/config.h +6 -15
@@ 15,15 15,12 @@ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef REV1_CONFIG_H #define REV1_CONFIG_H #include QMK_KEYBOARD_CONFIG_H #pragma once /* USB Device descriptor parameter */ #define VENDOR_ID 0xCEEB #define PRODUCT_ID 0x1256 #define DEVICE_VER 0x0200 #define VENDOR_ID 0xFEED #define PRODUCT_ID 0x3060 #define DEVICE_VER 0x0001 #define MANUFACTURER Legonut #define PRODUCT Project Zen #define DESCRIPTION Split gaming keyboard @@ 40,12 37,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* COL2ROW or ROW2COL */ #define DIODE_DIRECTION COL2ROW #define SOFT_SERIAL_PIN D0 /* define if matrix has ghost */ //#define MATRIX_HAS_GHOST /* number of backlight levels */ // #define BACKLIGHT_LEVELS 3 /* Set 0 if debouncing isn't needed */ #define DEBOUNCING_DELAY 5 @@ 54,9 50,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Locking resynchronize hack */ #define LOCKING_RESYNC_ENABLE #define BACKLIGHT_PIN F4 #define BACKLIGHT_LEVELS 5 /* ws2812 RGB LED */ #define RGB_DI_PIN D1 @@ 79,5 72,3 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. //#define NO_ACTION_ONESHOT //#define NO_ACTION_MACRO //#define NO_ACTION_FUNCTION #endif
R keyboards/zen/keymaps/333fred/config.h => keyboards/zen/rev1/keymaps/333fred/config.h +0 -0
R keyboards/zen/keymaps/333fred/keymap.c => keyboards/zen/rev1/keymaps/333fred/keymap.c +0 -0
R keyboards/zen/keymaps/333fred/rules.mk => keyboards/zen/rev1/keymaps/333fred/rules.mk +0 -1
@@ 1,5 1,4 @@ RGBLIGHT_ENABLE = yes BACKLIGHT_ENABLE = no NKRO_ENABLE = yes KEY_LOCK_ENABLE = yes TAP_DANCE_ENABLE = yes
R keyboards/zen/keymaps/jwlawrence/config.h => keyboards/zen/rev1/keymaps/default/config.h +1 -4
@@ 15,8 15,7 @@ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef CONFIG_USER_H #define CONFIG_USER_H #pragma once #include "config_common.h" @@ 37,5 36,3 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define RGBLIGHT_HUE_STEP 8 #define RGBLIGHT_SAT_STEP 8 #define RGBLIGHT_VAL_STEP 8 #endif
R keyboards/zen/keymaps/default/keymap.c => keyboards/zen/rev1/keymaps/default/keymap.c +0 -0
R keyboards/zen/keymaps/default/rules.mk => keyboards/zen/rev1/keymaps/default/rules.mk +0 -2
R keyboards/zen/keymaps/default/config.h => keyboards/zen/rev1/keymaps/jwlawrence/config.h +0 -0
R keyboards/zen/keymaps/jwlawrence/keymap.c => keyboards/zen/rev1/keymaps/jwlawrence/keymap.c +0 -0
R keyboards/zen/keymaps/jwlawrence/rules.mk => keyboards/zen/rev1/keymaps/jwlawrence/rules.mk +0 -2
R keyboards/zen/keymaps/kageurufu/keymap.c => keyboards/zen/rev1/keymaps/kageurufu/keymap.c +2 -2
@@ 1,8 1,8 @@ #include QMK_KEYBOARD_H #include "kageurufu.h" #ifdef PROTOCOL_LUFA #include "lufa.h" #include "split_util.h" #include "lufa.h" #include "split_util.h" #endif extern keymap_config_t keymap_config;
R keyboards/zen/keymaps/xyverz/config.h => keyboards/zen/rev1/keymaps/xyverz/config.h +1 -4
@@ 15,8 15,7 @@ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef CONFIG_USER_H #define CONFIG_USER_H #pragma once #include "config_common.h" @@ 31,5 30,3 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define RGBLIGHT_HUE_STEP 8 #define RGBLIGHT_SAT_STEP 8 #define RGBLIGHT_VAL_STEP 8 #endif
R keyboards/zen/keymaps/xyverz/keymap.c => keyboards/zen/rev1/keymaps/xyverz/keymap.c +0 -0
R keyboards/zen/keymaps/xyverz/rules.mk => keyboards/zen/rev1/keymaps/xyverz/rules.mk +0 -2
M keyboards/zen/rev1/rev1.h => keyboards/zen/rev1/rev1.h +1 -4
@@ 1,5 1,4 @@ #ifndef REV1_H #define REV1_H #pragma once #include "zen.h" @@ 36,5 35,3 @@ { k80, k81, k82, k83, k84, k85, KC_NO }, \ { k90, k91, k92, k93, k94, k95, k96 } \ } #endif
M keyboards/zen/rev1/rules.mk => keyboards/zen/rev1/rules.mk +0 -2
A keyboards/zen/rev2/config.h => keyboards/zen/rev2/config.h +98 -0
@@ 0,0 1,98 @@ /* Copyright 2017 Danny Nguyen <danny@hexwire.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 /* USB Device descriptor parameter */ #define VENDOR_ID 0xFEED #define PRODUCT_ID 0x3061 #define DEVICE_VER 0x0002 #define MANUFACTURER Legonut #define PRODUCT "Project Zen" #define DESCRIPTION "Split gaming keyboard" /* key matrix size */ // Rows are doubled-up // wiring of each half #ifdef CONVERT_TO_PROTON_C #define MATRIX_ROWS 5 #define MATRIX_COLS 7 #else #define MATRIX_ROWS 10 #define MATRIX_COLS 7 #endif // Proton-C does pin conversion #define MATRIX_ROW_PINS { C6, E6, B5, D7, B4 } #define MATRIX_COL_PINS { F4, F5, F6, F7, B3, B1, B2 } #define NUMBER_OF_ENCODERS 1 #define ENCODERS_PAD_A { D4 } #define ENCODERS_PAD_B { D2 } #define RGB_DI_PIN B6 #define SOFT_SERIAL_PIN D3 /* COL2ROW or ROW2COL */ #define DIODE_DIRECTION COL2ROW /* define if matrix has ghost */ //#define MATRIX_HAS_GHOST /* Set 0 if debouncing isn't needed */ #define DEBOUNCING_DELAY 5 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ #define LOCKING_SUPPORT_ENABLE /* Locking resynchronize hack */ #define LOCKING_RESYNC_ENABLE /* ws2812 RGB LED */ #define RGBLED_NUM 34 // Number of LEDs // If using 90 Degree rotation, increase block cout #ifdef OLED_ROTATE90 #define OLED_DISPLAY_CUSTOM #define OLED_DISPLAY_WIDTH 128 #define OLED_DISPLAY_HEIGHT 32 #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 512 (compile time mathed) #define OLED_BLOCK_TYPE uint16_t // Type to use for segmenting the oled display for smart rendering, use unsigned types only #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 8 (compile time mathed) #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 32 (compile time mathed) #define OLED_SOURCE_MAP { 0, 8, 16, 24 } #define OLED_TARGET_MAP { 24, 16, 8, 0 } #endif /* * Feature disable options * These options are also useful to firmware size reduction. */ /* disable debug print */ // #define NO_DEBUG /* disable print */ // #define NO_PRINT /* disable action features */ //#define NO_ACTION_LAYER //#define NO_ACTION_TAPPING //#define NO_ACTION_ONESHOT //#define NO_ACTION_MACRO //#define NO_ACTION_FUNCTION
A keyboards/zen/rev2/keymaps/debug/keymap.c => keyboards/zen/rev2/keymaps/debug/keymap.c +19 -0
@@ 0,0 1,19 @@ #include QMK_KEYBOARD_H #include <stdio.h> // extern keymap_config_t keymap_config; const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { { { KC_TRNS } } }; bool process_record_user(uint16_t keycode, keyrecord_t *record) { static char buf[10] = " "; if (record->event.pressed) { snprintf(buf, 10, "C%dR%d ", record->event.key.col, record->event.key.row); send_string(buf); } return false; return true; }
A keyboards/zen/rev2/keymaps/default/keymap.c => keyboards/zen/rev2/keymaps/default/keymap.c +117 -0
@@ 0,0 1,117 @@ #include QMK_KEYBOARD_H extern keymap_config_t keymap_config; // Each layer gets a name for readability, which is then used in the keymap matrix below. // The underscores don't mean anything - you can have a layer called STUFF or any other name. // Layer names don't all need to be of the same length, obviously, and you can also skip them // entirely and just use numbers. #define _QWERTY 0 #define _NAV 2 enum custom_keycodes { QWERTY = SAFE_RANGE, NAV, }; const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { /* Qwerty * ,-----------------------------------------. .-----------------------------------------. * | GESC | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | Bksp | * |------+------+------+------+------+------| |------+------+------+------+------+------| * | Tab | Q | W | E | R | T | | Y | U | I | O | P | \ | * |------+------+------+------+------+------| |------+------+------+------+------+------| * |CAPS(NAV)|A | S | D | F | G | | H | J | K | L | ; | " | * |------+------+------+------+------+------+------..------+------+------+------+------+------+------| * | Shift| Z | X | C | V | B |RGBPrv||RGBNxt| N | M | , | . | / |Enter | * |------+------+------+------+------+------+------||------+------+------+------+------+------+------| * | Ctrl | GUI | Alt |RGBTOG| NAV |Space |Delete||Enter |Space | NAV | - | = | PGUP | PGDN | * `----------------------------------+-------------''------------------------------------------------' * |Space |Delete||Enter |Space | * '-------------''-------------' */ [_QWERTY] = LAYOUT( \ KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, \ KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSLS, \ LT(_NAV, KC_CAPS),KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, \ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, RGB_RMOD,RGB_MOD, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, \ KC_LCTL, KC_LGUI, KC_LALT, RGB_TOG, MO(_NAV), KC_SPC, KC_DEL, KC_ENT, KC_SPACE, MO(_NAV), KC_MINS, KC_EQL, KC_PGUP, KC_PGDN, \ KC_SPC, KC_DEL, KC_ENT, KC_SPACE \ ), /* NAV * ,-----------------------------------------. .-----------------------------------------. * | GESC | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | Bksp | * |------+------+------+------+------+------| |------+------+------+------+------+------| * | Tab | Q | W | E | R | T | | Y | U | I | O | P | \ | * |------+------+------+------+------+------| |------+------+------+------+------+------| * |CAPS(NAV)|A | S | D | F | G | | H | J | K | L | ; | " | * |------+------+------+------+------+------+------..------+------+------+------+------+------+------| * | Shift| Z | X | C | V | B | || | N | M | , | . | / |Enter | * |------+------+------+------+------+------+------||------+------+------+------+------+------+------| * | Ctrl | GUI | Alt |RGBTOG| NAV |Space |Delete||Enter |Space | NAV | - | = | PGUP | PGDN | * `----------------------------------+-------------''------------------------------------------------' * |Space |Delete||Enter |Space | * '-------------''-------------' */ [_NAV] = LAYOUT( \ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, \ _______, RGB_SAI, RGB_VAI, RGB_SAD, RESET, KC_LBRC, KC_RBRC, KC_PGUP, KC_UP, KC_PGDN, KC_INS, KC_HOME, \ _______, RGB_HUD, RGB_VAD, RGB_HUI, _______, _______, _______, KC_LEFT, KC_DOWN, KC_RGHT, KC_DEL, KC_END, \ KC_LSFT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MPLY, KC_MPRV, KC_MNXT, \ KC_LCTL, KC_LGUI, KC_LALT, RGB_MOD, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLU, KC_VOLD, \ _______, _______, _______, _______ ), }; void encoder_update_user(uint8_t index, bool clockwise) { if (index == 0) { /* First encoder */ if (clockwise) { tap_code(KC_PGDN); } else { tap_code(KC_PGUP); } } else if (index == 1) { /* Second encoder from slave */ if (clockwise) { tap_code(KC_UP); } else { tap_code(KC_DOWN); } } } bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case QWERTY: if (record->event.pressed) { set_single_persistent_default_layer(1UL<<_QWERTY); } return false; break; //case COLEMAK: //if (record->event.pressed) { //set_single_persistent_default_layer(1UL<<_COLEMAK); //} //return false; //break; } return true; } #if OLED_DRIVER_ENABLE const char* layer_name_user(uint32_t layer) { switch (layer) { case _QWERTY: return PSTR("QWRTY"); case _NAV: return PSTR("NAV\n"); default: return PSTR("UNDEF"); } } #endif
A keyboards/zen/rev2/rev2.c => keyboards/zen/rev2/rev2.c +66 -0
@@ 0,0 1,66 @@ #include "rev2.h" #ifdef OLED_DRIVER_ENABLE #include "split_util.h" #include "oled_driver.h" __attribute__((weak)) void render_logo(void) { static const char PROGMEM sol_logo[] = { 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94, 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4, 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0}; oled_write_P(sol_logo, false); } __attribute__((weak)) const char* layer_name_user(uint32_t layer) { switch (layer) { default: return PSTR("UNDEF\n"); } } __attribute__((weak)) void render_status(void) { // Setup for 90 degree rendering because it's awesome! // It can house 16 lines of text, with 5 letters each line // Render to mode icon static const char PROGMEM mode_logo[2][4] = { {0x97,0x98,0x0a,0}, {0xb7,0xb8,0x0a,0} }; oled_write_P(mode_logo[0], false); // Line 1 oled_write_P(mode_logo[1], false); // Line 2 // Define layers here, Have not worked out how to have text displayed for each layer. Copy down the number you see and add a case for it below oled_set_cursor(0, 3); // Line 3 oled_write_P(PSTR("Layer"), false); // Line 4 oled_write_P(layer_name_user(biton32(layer_state)), false); // Host Keyboard LED Status uint8_t led_usb_state = host_keyboard_leds(); oled_set_cursor(0, OLED_MAX_LINES - 4); // Line 13 oled_write_P(led_usb_state & (1<<USB_LED_NUM_LOCK) ? PSTR("NUMLK") : PSTR(" "), false); // Line 14 oled_write_P(led_usb_state & (1<<USB_LED_CAPS_LOCK) ? PSTR("CAPLK") : PSTR(" "), false); // Line 15 oled_write_P(led_usb_state & (1<<USB_LED_SCROLL_LOCK) ? PSTR("SCRLK") : PSTR(" "), false); // Line 16 } #ifdef OLED_ROTATE90 bool oled_init_user(bool flip180) { return true; } #endif __attribute__((weak)) void oled_task_user(void) { if (is_keyboard_master()) { render_status(); } else { render_logo(); oled_scroll_left(); } } #endif
A keyboards/zen/rev2/rev2.h => keyboards/zen/rev2/rev2.h +56 -0
@@ 0,0 1,56 @@ #pragma once #include "zen.h" //void promicro_bootloader_jmp(bool program); #include "quantum.h" #ifdef USE_I2C #include <stddef.h> #ifdef __AVR__ #include <avr/io.h> #include <avr/interrupt.h> #endif #endif //void promicro_bootloader_jmp(bool program); #ifdef CONVERT_TO_PROTON_C #define LAYOUT( \ k00, k01, k02, k03, k04, k05, k55, k54, k53, k52, k51, k50, \ k10, k11, k12, k13, k14, k15, k65, k64, k63, k62, k61, k60, \ k20, k21, k22, k23, k24, k25, k75, k74, k73, k72, k71, k70, \ k30, k31, k32, k33, k34, k35, k16, k66, k85, k84, k83, k82, k81, k80, \ k40, k41, k42, k43, k44, k36, k26, k76, k86, k94, k93, k92, k91, k90, \ k45, k46, k96, k95 \ ) \ { \ { k00, k01, k02, k03, k04, k05, KC_NO }, \ { k10, k11, k12, k13, k14, k15, k16 }, \ { k20, k21, k22, k23, k24, k25, k26 }, \ { k30, k31, k32, k33, k34, k35, k36 }, \ { k40, k41, k42, k43, k44, k45, k46 } \ } #else #define LAYOUT( \ k00, k01, k02, k03, k04, k05, k55, k54, k53, k52, k51, k50, \ k10, k11, k12, k13, k14, k15, k65, k64, k63, k62, k61, k60, \ k20, k21, k22, k23, k24, k25, k75, k74, k73, k72, k71, k70, \ k30, k31, k32, k33, k34, k35, k16, k66, k85, k84, k83, k82, k81, k80, \ k40, k41, k42, k43, k44, k36, k26, k76, k86, k94, k93, k92, k91, k90, \ k45, k46, k96, k95 \ ) \ { \ { k00, k01, k02, k03, k04, k05, KC_NO }, \ { k10, k11, k12, k13, k14, k15, k16 }, \ { k20, k21, k22, k23, k24, k25, k26 }, \ { k30, k31, k32, k33, k34, k35, k36 }, \ { k40, k41, k42, k43, k44, k45, k46 }, \ { k50, k51, k52, k53, k54, k55, KC_NO }, \ { k60, k61, k62, k63, k64, k65, k66 }, \ { k70, k71, k72, k73, k74, k75, k76 }, \ { k80, k81, k82, k83, k84, k85, k86 }, \ { k90, k91, k92, k93, k94, k95, k96 } \ } #endif
A keyboards/zen/rev2/rules.mk => keyboards/zen/rev2/rules.mk +14 -0
@@ 0,0 1,14 @@ ENCODER_ENABLE = yes OLED_DRIVER_ENABLE = no OLED_ROTATE90 = yes # Setup so that OLED and 90 degree rotation can be turned on/off easily # with "OLED_DRIVER_ENABLE = yes" or "OLED_ROTATE90 = no" in user's rules.mk file ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes) # Custom local font file OPT_DEFS += -DOLED_FONT_H=\"common/glcdfont.c\" ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes) OPT_DEFS += -DOLED_ROTATE90 endif endif
M keyboards/zen/rules.mk => keyboards/zen/rules.mk +19 -50
@@ 1,51 1,26 @@ SRC += matrix.c \ split_util.c \ serial.c # MCU name #MCU = at90usb1287 # Pro Micro or Elite-C # Automagically converted to Proton-C MCU = atmega32u4 # Processor frequency. # This will define a symbol, F_CPU, in all source code files equal to the # processor frequency in Hz. You can then use this symbol in your source code to # calculate timings. Do NOT tack on a 'UL' at the end, this will be done # automatically to create a 32-bit value in your source code. # # This will be an integer division of F_USB below, as it is sourced by # F_USB after it has run through any CPU prescalers. Note that this value # does not *change* the processor frequency - it should merely be updated to # reflect the processor speed set externally so that the code can use accurate # software delays. F_CPU = 16000000 # # LUFA specific # # Target architecture (see library "Board Types" documentation). ARCH = AVR8 # Input clock frequency. # This will define a symbol, F_USB, in all source code files equal to the # input clock frequency (before any prescaling is performed) in Hz. This value may # differ from F_CPU if prescaling is used on the latter, and is required as the # raw input clock is fed directly to the PLL sections of the AVR for high speed # clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL' # at the end, this will be done automatically to create a 32-bit value in your # source code. # # If no clock division is performed on the input clock inside the AVR (via the # CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU. F_USB = $(F_CPU) BOOTLOADER = dfu OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT # Bootloader # This definition is optional, and if your keyboard supports multiple bootloaders of # different sizes, comment this out, and the correct address will be loaded # automatically (+60). See bootloader.mk for all options. BOOTLOADER = caterina ifeq ($(strip $(CTPC)), yes) CONVERT_TO_PROTON_C=yes endif # Interrupt driven control endpoint task(+60) OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT ifeq ($(strip $(CONVERT_TO_PROTON_C)), yes) SPLIT_KEYBOARD = no # currently unsupported on ARM RGBLIGHT_ENABLE = no # currently unsupported on ARM EXTRAFLAGS += -DUSE_PROTON_C else # Currently moved to Pro Micro only section because of lack of Proton-C support SPLIT_KEYBOARD = yes RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight. endif # Build Options # change to "no" to disable the options, or define them in the Makefile in @@ 57,17 32,11 @@ EXTRAKEY_ENABLE = yes # Audio control and System control(+450) CONSOLE_ENABLE = no # Console for debug(+400) COMMAND_ENABLE = yes # Commands for debug and configuration NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality MIDI_ENABLE = no # MIDI controls AUDIO_ENABLE = no # Audio output on port C6 UNICODE_ENABLE = no # Unicode BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight. SUBPROJECT_rev1 = yes USE_I2C = no # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend CUSTOM_MATRIX = yes SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend DEFAULT_FOLDER = zen/rev1 DEFAULT_FOLDER = zen/rev2
D keyboards/zen/serial.c => keyboards/zen/serial.c +0 -228
@@ 1,228 0,0 @@ /* * WARNING: be careful changing this code, it is very timing dependent */ #ifndef F_CPU #define F_CPU 16000000 #endif #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <stdbool.h> #include "serial.h" #ifndef USE_I2C // Serial pulse period in microseconds. Its probably a bad idea to lower this // value. #define SERIAL_DELAY 24 uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0}; uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0}; #define SLAVE_DATA_CORRUPT (1<<0) volatile uint8_t status = 0; inline static void serial_delay(void) { _delay_us(SERIAL_DELAY); } inline static void serial_output(void) { SERIAL_PIN_DDR |= SERIAL_PIN_MASK; } // make the serial pin an input with pull-up resistor inline static void serial_input(void) { SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK; SERIAL_PIN_PORT |= SERIAL_PIN_MASK; } inline static uint8_t serial_read_pin(void) { return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK); } inline static void serial_low(void) { SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK; } inline static void serial_high(void) { SERIAL_PIN_PORT |= SERIAL_PIN_MASK; } void serial_master_init(void) { serial_output(); serial_high(); } void serial_slave_init(void) { serial_input(); // Enable INT0 EIMSK |= _BV(INT0); // Trigger on falling edge of INT0 EICRA &= ~(_BV(ISC00) | _BV(ISC01)); } // Used by the master to synchronize timing with the slave. static void sync_recv(void) { serial_input(); // This shouldn't hang if the slave disconnects because the // serial line will float to high if the slave does disconnect. while (!serial_read_pin()); serial_delay(); } // Used by the slave to send a synchronization signal to the master. static void sync_send(void) { serial_output(); serial_low(); serial_delay(); serial_high(); } // Reads a byte from the serial line static uint8_t serial_read_byte(void) { uint8_t byte = 0; serial_input(); for ( uint8_t i = 0; i < 8; ++i) { byte = (byte << 1) | serial_read_pin(); serial_delay(); _delay_us(1); } return byte; } // Sends a byte with MSB ordering static void serial_write_byte(uint8_t data) { uint8_t b = 8; serial_output(); while( b-- ) { if(data & (1 << b)) { serial_high(); } else { serial_low(); } serial_delay(); } } // interrupt handle to be used by the slave device ISR(SERIAL_PIN_INTERRUPT) { sync_send(); uint8_t checksum = 0; for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) { serial_write_byte(serial_slave_buffer[i]); sync_send(); checksum += serial_slave_buffer[i]; } serial_write_byte(checksum); sync_send(); // wait for the sync to finish sending serial_delay(); // read the middle of pulses _delay_us(SERIAL_DELAY/2); uint8_t checksum_computed = 0; for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) { serial_master_buffer[i] = serial_read_byte(); sync_send(); checksum_computed += serial_master_buffer[i]; } uint8_t checksum_received = serial_read_byte(); sync_send(); serial_input(); // end transaction if ( checksum_computed != checksum_received ) { status |= SLAVE_DATA_CORRUPT; } else { status &= ~SLAVE_DATA_CORRUPT; } } inline bool serial_slave_DATA_CORRUPT(void) { return status & SLAVE_DATA_CORRUPT; } // Copies the serial_slave_buffer to the master and sends the // serial_master_buffer to the slave. // // Returns: // 0 => no error // 1 => slave did not respond int serial_update_buffers(void) { // this code is very time dependent, so we need to disable interrupts cli(); // signal to the slave that we want to start a transaction serial_output(); serial_low(); _delay_us(1); // wait for the slaves response serial_input(); serial_high(); _delay_us(SERIAL_DELAY); // check if the slave is present if (serial_read_pin()) { // slave failed to pull the line low, assume not present sei(); return 1; } // if the slave is present syncronize with it sync_recv(); uint8_t checksum_computed = 0; // receive data from the slave for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) { serial_slave_buffer[i] = serial_read_byte(); sync_recv(); checksum_computed += serial_slave_buffer[i]; } uint8_t checksum_received = serial_read_byte(); sync_recv(); if (checksum_computed != checksum_received) { sei(); return 1; } uint8_t checksum = 0; // send data to the slave for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) { serial_write_byte(serial_master_buffer[i]); sync_recv(); checksum += serial_master_buffer[i]; } serial_write_byte(checksum); sync_recv(); // always, release the line when not in use serial_output(); serial_high(); sei(); return 0; } #endif
D keyboards/zen/serial.h => keyboards/zen/serial.h +0 -26
@@ 1,26 0,0 @@ #ifndef MY_SERIAL_H #define MY_SERIAL_H #include "config.h" #include <stdbool.h> /* TODO: some defines for interrupt setup */ #define SERIAL_PIN_DDR DDRD #define SERIAL_PIN_PORT PORTD #define SERIAL_PIN_INPUT PIND #define SERIAL_PIN_MASK _BV(PD0) #define SERIAL_PIN_INTERRUPT INT0_vect #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2 #define SERIAL_MASTER_BUFFER_LENGTH 1 // Buffers for master - slave communication extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH]; extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH]; void serial_master_init(void); void serial_slave_init(void); int serial_update_buffers(void); bool serial_slave_data_corrupt(void); #endif
D keyboards/zen/split_rgb.c => keyboards/zen/split_rgb.c +0 -41
@@ 1,41 0,0 @@ #include <stdint.h> #include <stdbool.h> #include "split_util.h" #include "progmem.h" #include "print.h" #include "rgblight.h" #ifdef USE_I2C # include "i2c.h" #else // USE_SERIAL # include "serial.h" #endif rgblight_config_t rgblight_config; void rgblight_slave_update(void) { //rgblight_effect_christmas(); } void rgblight_set(void) { if (rgblight_config.enable) { #ifdef RGBW ws2812_setleds_rgbw(led, RGBLED_NUM); #else ws2812_setleds(led, RGBLED_NUM); #endif } else { for (uint8_t i = 0; i < RGBLED_NUM; i++) { led[i].r = 0; led[i].g = 0; led[i].b = 0; } #ifdef RGBW ws2812_setleds_rgbw(led, RGBLED_NUM); #else ws2812_setleds(led, RGBLED_NUM); #endif } }
D keyboards/zen/split_rgb.h => keyboards/zen/split_rgb.h +0 -6
D keyboards/zen/split_util.c => keyboards/zen/split_util.c +0 -86
@@ 1,86 0,0 @@ #include <avr/io.h> #include <avr/wdt.h> #include <avr/power.h> #include <avr/interrupt.h> #include <util/delay.h> #include <avr/eeprom.h> #include "split_util.h" #include "matrix.h" #include "keyboard.h" #include "config.h" #include "timer.h" #ifdef USE_I2C # include "i2c.h" #else # include "serial.h" #endif volatile bool isLeftHand = true; static void setup_handedness(void) { #ifdef EE_HANDS isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS); #else // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT) isLeftHand = !has_usb(); #else isLeftHand = has_usb(); #endif #endif } static void keyboard_master_setup(void) { #ifdef USE_I2C i2c_master_init(); #ifdef SSD1306OLED matrix_master_OLED_init (); #endif #else serial_master_init(); #endif } static void keyboard_slave_setup(void) { timer_init(); #ifdef USE_I2C i2c_slave_init(SLAVE_I2C_ADDRESS); #else serial_slave_init(); #endif } bool has_usb(void) { USBCON |= (1 << OTGPADE); //enables VBUS pad _delay_us(5); return (USBSTA & (1<<VBUS)); //checks state of VBUS } void split_keyboard_setup(void) { setup_handedness(); if (has_usb()) { keyboard_master_setup(); } else { keyboard_slave_setup(); } sei(); } void keyboard_slave_loop(void) { matrix_init(); while (1) { matrix_slave_scan(); } } // this code runs before the usb and keyboard is initialized void matrix_setup(void) { split_keyboard_setup(); if (!has_usb()) { keyboard_slave_loop(); } }
D keyboards/zen/split_util.h => keyboards/zen/split_util.h +0 -20
@@ 1,20 0,0 @@ #ifndef SPLIT_KEYBOARD_UTIL_H #define SPLIT_KEYBOARD_UTIL_H #include <stdbool.h> #include "eeconfig.h" #define SLAVE_I2C_ADDRESS 0x32 extern volatile bool isLeftHand; // slave version of matix scan, defined in matrix.c void matrix_slave_scan(void); void split_keyboard_setup(void); bool has_usb(void); void keyboard_slave_loop(void); void matrix_master_OLED_init (void); #endif
M keyboards/zen/zen.h => keyboards/zen/zen.h +6 -5