rekahsoft
/
qmk-firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[Keyboard] Keyboard Naked48 Update (#7085) 

* Keyboard Naked48 Update

Support for SPLIT_KEYBOARD
Readme updates
Keymap updates
Support for RGB matrix (salicylic keymap)

* Keymap Update

Change KC_NO to KC_TRANSPARENT.
Update the old part.
This commit is contained in:
Salicylic-acid3 2019-10-21 04:03:46 +09:00 committed by Drashna Jaelre
parent a41066beed
commit 233a1e9bcd
40 changed files with 391 additions and 2169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
keyboards/naked48/config.h
View File

@ -19,25 +19,3 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "config_common.h"
// GCC include 'config.h" sequence in qmk_firmware/keyboards/naked48/
// -include keyboards/naked48/config.h
// -include keyboards/naked48/rev?/config.h
// -include keyboards/naked48/rev?/keymaps/MAPNAME/config.h
// XXXX.c
#include <serial_config.h>
// GCC include search path in qmk_firmare/keyboards/naked48/
// #include "..." search starts here:
// #include <...> search starts here:
// keyboards/naked48/rev?/keymaps/MAPNAME
// keyboards/naked48
// keyboards/naked48/rev?
// .
// ./tmk_core
// ......
// MACRO and FUNCTION are features that are depreciated.
#define NO_ACTION_MACRO
#define NO_ACTION_FUNCTION

17
keyboards/naked48/keymaps/default/config.h
View File

@ -18,24 +18,13 @@
/* Select hand configuration */
#define MASTER_LEFT
//#define MASTER_LEFT
// #define MASTER_RIGHT
// #define EE_HANDS
#define USE_SERIAL_PD2
//#define USE_SERIAL
#define TAPPING_FORCE_HOLD
#define TAPPING_TERM 180
// Selection of RGBLIGHT MODE to use.
#if defined(LED_ANIMATIONS)
//#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
//#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
//#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
//#define RGBLIGHT_EFFECT_RGB_TEST
//#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#define RGBLED_NUM 48 // Number of LEDs

49
keyboards/naked48/keymaps/default/keymap.c
View File

@ -21,16 +21,10 @@ enum layer_number {
};
enum custom_keycodes {
LOWER = SAFE_RANGE,
RAISE,
ADJUST,
RGBRST
RGB_RST = SAFE_RANGE
};
// Layer Mode aliases
#define _____ KC_TRNS
#define XXXXX KC_NO
#define KC_SNUBS S(KC_NUBS)
#define KC_SNUHS S(KC_NUHS)
@ -43,7 +37,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
ADJUST,KC_LCTRL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
MO(_ADJUST),KC_LCTRL, KC_LALT, KC_LGUI,MO(_LOWER),KC_SPC,KC_SPC,MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
//`------------------------------------------------------------------------------------------------------------'
),
@ -52,11 +46,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//,-----------------------------------------------------| |-----------------------------------------------------.
KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR,KC_LPRN, KC_RPRN, KC_DEL,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE,
_______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_____, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,KC_SNUHS,KC_SNUBS, _____, _____, _____,
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,KC_SNUHS,KC_SNUBS, _______, _______, _______,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
_____, _____, _____, _____, _____, _____, _____, _____, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
//`------------------------------------------------------------------------------------------------------------'
),
@ -65,45 +59,33 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//,-----------------------------------------------------| |-----------------------------------------------------.
KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS,
_______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_____, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _____, _____, _____,
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _______, _______, _______,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
),
[_ADJUST] = LAYOUT( /* Base */
//,-----------------------------------------------------| |-----------------------------------------------------.
_____, RESET, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, _____,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_RST, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_____, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, RGB_TOG, RGB_MOD, XXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_MOD, XXXXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_____, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, RESET, RESET, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
)
};
static inline void update_change_layer(bool pressed, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
pressed ? layer_on(layer1) : layer_off(layer1);
IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2) ? layer_on(layer3) : layer_off(layer3);
}
int RGB_current_mode;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
bool result = false;
switch (keycode) {
case LOWER:
update_change_layer(record->event.pressed, _LOWER, _RAISE, _ADJUST);
break;
case RAISE:
update_change_layer(record->event.pressed, _RAISE, _LOWER, _ADJUST);
break;
#ifdef RGBLIGHT_ENABLE
case RGB_MOD:
if (record->event.pressed) {
@ -112,7 +94,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
RGB_current_mode = rgblight_config.mode;
}
break;
case RGBRST:
case RGB_RST:
if (record->event.pressed) {
eeconfig_update_rgblight_default();
rgblight_enable();
@ -129,7 +111,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode;
#endif
}

72
keyboards/naked48/keymaps/default/readme.md
View File

@ -1,45 +1,37 @@
# The default keymap for naked48
Default
//,-----------------------------------------| |-----------------------------------------.
TAB, Q, W, E, R, T, Y, U, I, O, P, BSPC,
//|------+------+------+------+------+------| |------+------+------+------+------+------|
ESC, A, S, D, F, G, H, J, K, L, ;, :,
//|------+------+------+------+------+------| |------+------+------+------+------+------|
LSFT, Z, X, C, V, B, N, M, ,, ., /, ENT,
//|------+------+------+------+------+------|------+------+------+------+------+------+------|
ADJUST, LCTRL, LALT, LGUI, LOWER, SPC, SPC, RAISE, LEFT, DOWN, UP, RIGHT
//`----------------------------------------------------------------------------------'
## Default
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|
| TAB | Q| W| E| R| T| | | Y| U| I| O| P| BSPC|
| ESC | A| S| D| F| G| | | H| J| K| L| ;| '|
| LSFT | Z| X| C| V| B| | | N| M| ,| .| /| ENT|
| |ADJUST| LCTRL| LALT| LGUI| LOWER| SPC| SPC| RAISE| LEFT| DOWN| UP| RIGHT| |
Lower
//,-----------------------------------------| |-----------------------------------------.
~, !, @, #, $, %, ^, &, *, (, ), DEL,
//|------+------+------+------+------+------| |------+------+------+------+------+------|
DEL, F1, F2, F3, F4, F5, F6, _, +, {, }, |,
//|------+------+------+------+------+------| |------+------+------+------+------+------|
LSFT, F7, F8, F9, F10, F11, F12, ~, |, ,, ., ENT,
//|------+------+------+------+------+------|------+------+------+------+------+------+------|
ADJUST, LCTRL, LALT, LGUI, LOWER, SPC, SPC, RAISE, MNXT, VOLD, VOLU, MPLY
//`----------------------------------------------------------------------------------'
Raise
//,-----------------------------------------| |-----------------------------------------.
~, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, DEL,
//|------+------+------+------+------+------| |------+------+------+------+------+------|
DEL, F1, F2, F3, F4, F5, F6, -, =, [, ], BSLS,
//|------+------+------+------+------+------| |------+------+------+------+------+------|
LSFT, F7, F8, F9, F10, F11, F12, #, \, ,, ., ENT,
//|------+------+------+------+------+------|------+------+------+------+------+------+------|
ADJUST, LCTRL, LALT, LGUI, LOWER, SPC, SPC, RAISE, MNXT, VOLD, VOLU, MPLY
//`----------------------------------------------------------------------------------'
## Lower
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|
| ~| !| @| #| $| %| | | ^| &| *| (| )| DEL|
| ESC| F1| F2| F3| F4| F5| | | F6| _| +| {| }| PIPE|
| LSFT| F7| F8| F9| F10| F11| | | F12| SNUHS| SNUBS| ,| .| ENT|
| |ADJUST| LCTRL| LALT| LGUI| LOWER| SPC| SPC| RAISE| MNXT| VOLD| VOLU| MPLY| |
## Raise
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|
| ~| 1| 2| 3| 4| 5| | | 6| 7| 8| 9| 0| DEL|
| DEL| F1| F2| F3| F4| F5| | | F6| -| =| [| ]| BSLS|
| LSFT| F7| F8| F9| F10| F11| | | F12| NUHS| NUBS| ,| .| ENT|
| |ADJUST| LCTRL| LALT| LGUI| LOWER| SPC| SPC| RAISE| MNXT| VOLD| VOLU| MPLY| |
## Adjust
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:------:|:------:|:------:|:------:|:-------:|:------:|
| ~| XXXXX| XXXXX| XXXXX| XXXXX| XXXXX| | | RGB_RST| XXXXX| XXXXX| XXXXX| XXXXX| DEL|
| ESC| XXXXX| XXXXX| XXXXX| XXXXX| XXXXX| | | RGB_TOG| RGB_MOD| XXXXX| C+A+D| Alt+PSCR| PSCR|
| LSFT| XXXXX| XXXXX| XXXXX| XXXXX| XXXXX| | | RGB_VAD| RGB_VAI| RGB_HUD| RGB_HUI| RGB_SAD| RGB_SAI|
| |ADJUST| LCTRL| LALT| LGUI| LOWER| RESET| RESET| RAISE| MNXT| VOLD| VOLU| MPLY| |
Adjust
//,-----------------------------------------| |----------------------------------------------.
~, RST, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, DEL,
//|------+------+------+------+------+------| |------+-------+-------+-------+-------+-------|
DEL, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, LED ON/Off,LED MOD, XXXXX, C+A+D,Alt+PSCR, PSCR,
//|------+------+------+------+------+------| |------+-------+-------+-------+-------+-------|
LSFT, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, LED VAD,LED VAI,LED HUD,LED HUI,LED SAD,LED SAI,
//|------+------+------+------+------+------|------+------+------+-------+-------+-------+-------+-------|
ADJUST, LCTRL, LALT, LGUI, LOWER, SPC, SPC, RAISE, MNXT, VOLD, VOLU, MPLY
//`--------------------------------------------------------------------------------------'

29
keyboards/naked48/keymaps/default/rules.mk
View File

@ -1,29 +0,0 @@
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # 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 = no # 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.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
# If your custom naked48 pcb, you can rewrite to yes.
LED_ANIMATIONS = yes # LED animations
ifeq ($(strip $(LED_ANIMATIONS)), yes)
# OPT_DEFS += -DRGBLIGHT_ANIMATIONS
OPT_DEFS += -DLED_ANIMATIONS
endif
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend

38
keyboards/naked48/keymaps/default_with_nafuda/config.h
View File

@ -21,44 +21,12 @@
#define MASTER_LEFT
// #define MASTER_RIGHT
// #define EE_HANDS
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD
#define TAPPING_TERM 180
// Selection of RGBLIGHT MODE to use.
#if defined(LED_ANIMATIONS)
//#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
//#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
//#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
//#define RGBLIGHT_EFFECT_RGB_TEST
//#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#define RGBLED_NUM 55 // Number of LEDs
#define RGBLIGHT_SPLIT
#define RGBLED_SPLIT { 48, 7 }
#define MK_3_SPEED
#undef MOUSEKEY_INTERVAL
#define MOUSEKEY_INTERVAL 0
#undef MOUSEKEY_TIME_TO_MAX
#define MOUSEKEY_TIME_TO_MAX 150
#undef MOUSEKEY_MAX_SPEED
#define MOUSEKEY_MAX_SPEED 3
#undef MOUSEKEY_MOVE_DELTA
#define MOUSEKEY_MOVE_DELTA 5
#undef MOUSEKEY_DELAY
#define MOUSEKEY_DELAY 0
#undef MOUSEKEY_WHEEL_MAX_SPEED
#define MOUSEKEY_WHEEL_MAX_SPEED 1
#undef MOUSEKEY_WHEEL_TIME_TO_MAX
#define MOUSEKEY_WHEEL_TIME_TO_MAX 0

82
keyboards/naked48/keymaps/default_with_nafuda/keymap.c
View File

@ -23,125 +23,94 @@ enum layer_number {
};
enum custom_keycodes {
MOUSE = SAFE_RANGE,
BROWSER,
LOWER,
RAISE,
ADJUST,
RGBRST
RGB_RST = SAFE_RANGE
};
// Fillers to make layering more clear
#define _____ KC_TRNS
#define XXXXX KC_NO
#define KC_CAD LCA(KC_DEL)
#define KC_APSCR LALT(KC_PSCR)
#define KC_SNUBS S(KC_NUBS)
#define KC_SNUHS S(KC_NUHS)
#define KC_RTAB LCTL(KC_TAB)
#define KC_LTAB LCTL(LSFT(KC_TAB))
#define KC_CTAB LCTL(KC_W)
#define KC_RETAB LCTL(LSFT(KC_T))
#define KC_TGMO TG(_MOUSE)
#define KC_TGBR TG(_BROWSER)
#define KC_BSAD LT(_ADJUST, KC_BSPC)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, KC_TGMO,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_BSAD, KC_UP, KC_TGBR,
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_BSAD, KC_UP,TG(_BROWSER),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, KC_LEFT, KC_DOWN,KC_RIGHT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
ADJUST,KC_LCTRL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
MO(_ADJUST),KC_LCTRL, KC_LALT, KC_LGUI,MO(_LOWER),KC_SPC,KC_SPC,MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
//`------------------------------------------------------------------------------------------------------------'
),
[_MOUSE] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, KC_TGMO,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_BTN1, KC_MS_U, KC_BTN2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, KC_MS_L, KC_MS_D, KC_MS_R,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
ADJUST,KC_LCTRL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
MO(_ADJUST),KC_LCTRL, KC_LALT, KC_LGUI,MO(_LOWER),KC_SPC,KC_SPC,MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
//`------------------------------------------------------------------------------------------------------------'
),
[_BROWSER] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, KC_CTAB,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, LCTL(KC_W),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_RETAB, KC_WH_U, KC_TGBR,
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,LCTL(LSFT(KC_T)),KC_WH_U,TG(_BROWSER),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, KC_LTAB, KC_WH_D, KC_RTAB,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT,LCTL(LSFT(KC_TAB)), KC_WH_D,LCTL(KC_TAB),
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
ADJUST,KC_LCTRL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
MO(_ADJUST),KC_LCTRL, KC_LALT, KC_LGUI,MO(_LOWER),KC_SPC,KC_SPC,MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT
//`------------------------------------------------------------------------------------------------------------'
),
[_LOWER] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR,KC_LPRN, KC_RPRN, KC_DEL, KC_TGMO,
KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR,KC_LPRN, KC_RPRN, KC_DEL, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, KC_BSAD, KC_UP, KC_TGBR,
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, KC_BSAD, KC_UP,TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
_____, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,KC_SNUHS,KC_SNUBS, _____, _____, _____, KC_LEFT, KC_DOWN,KC_RIGHT,
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,KC_SNUHS,KC_SNUBS, _______, _______, _______, KC_LEFT, KC_DOWN,KC_RIGHT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
_____, _____, _____, _____, _____, _____, _____, _____, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
//`------------------------------------------------------------------------------------------------------------'
),
[_RAISE] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, KC_TGMO,
KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, KC_BSAD, KC_UP, KC_TGBR,
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, KC_BSAD, KC_UP,TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
_____, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _____, _____, _____, KC_LEFT, KC_DOWN,KC_RIGHT,
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _______, _______, _______, KC_LEFT, KC_DOWN,KC_RIGHT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
),
[_ADJUST] = LAYOUT_with_nafuda( /* Base */
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
_____, RESET, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, _____, RGB_VAD,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, RGB_VAD,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
_____, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, RGB_TOG, RGB_MOD, XXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, ADJUST, RGB_SAD, RGB_VAI,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_MOD, XXXXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, _ADJUST, RGB_SAD, RGB_VAI,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
_____, _____, _____, _____, _____, _____, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RGB_MOD, RGB_TOG, RGB_SAI,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RGB_MOD, RGB_TOG, RGB_SAI,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, RESET, RESET, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
)
};
static inline void update_change_layer(bool pressed, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
pressed ? layer_on(layer1) : layer_off(layer1);
IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2) ? layer_on(layer3) : layer_off(layer3);
}
int RGB_current_mode;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
bool result = false;
switch (keycode) {
case LOWER:
update_change_layer(record->event.pressed, _LOWER, _RAISE, _ADJUST);
break;
case RAISE:
update_change_layer(record->event.pressed, _RAISE, _LOWER, _ADJUST);
break;
#ifdef RGBLIGHT_ENABLE
case RGB_MOD:
if (record->event.pressed) {
@ -150,7 +119,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
RGB_current_mode = rgblight_config.mode;
}
break;
case RGBRST:
case RGB_RST:
if (record->event.pressed) {
eeconfig_update_rgblight_default();
rgblight_enable();
@ -167,7 +136,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode;
#endif
}

56
keyboards/naked48/keymaps/default_with_nafuda/readme.md
View File

@ -2,38 +2,30 @@
Add Nafuda maps to the default layout.
Default
//|--------------------|
Mouse,
//|------+------+------|
BS + Ad, UP,Browser,
//|------+------+------|
LEFT, DOWN, RIGHT
//|--------------------|
## Default
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| | MOUSE| |
| BS+Ad| UP|Browser|
| LEFT| DOWN| RIGHT|
Mouse
//|--------------------|
Default,
//|------+------+------|
BTN1, MS_U, BTN2,
//|------+------+------|
MS_L, MS_D, MS_R
//|--------------------|
## Mouse
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| |Default| |
| BTN1| MS_U| BTN2|
| MS_L| MS_D| MS_R|
Browser
//|--------------------|
CloseTAB,
//|------+------+------|
ReOpenTAB, WH_U,Default,
//|------+------+------|
LTAB, WH_D, RTAB
//|--------------------|
## Browser
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| |CloseTAB| |
|ReOpenTAB|WH_U|Default|
| LTAB| WH_D| RTAB|
Adjust
//|------------------------|
LED VAD,
//|------+----------+------|
Default, LED HUD,LED VAI,
//|------+----------+------|
LED MOD,LED ON/Off,LED HUI
//|------------------------|
## Adjust
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| |LED_VAD| |
|Default|LED_HUD|LED_VAI|
|LED_MOD|LED_ON/Off|LED_HUI|

28
keyboards/naked48/keymaps/default_with_nafuda/rules.mk
View File

@ -1,29 +1 @@
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # 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 = no # 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.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
# If your custom naked48 pcb, you can rewrite to yes.
LED_ANIMATIONS = yes # LED animations
ifeq ($(strip $(LED_ANIMATIONS)), yes)
# OPT_DEFS += -DRGBLIGHT_ANIMATIONS
OPT_DEFS += -DLED_ANIMATIONS
endif
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend

16
keyboards/naked48/keymaps/default_with_setta21/config.h
View File

@ -21,21 +21,11 @@
#define MASTER_LEFT
// #define MASTER_RIGHT
// #define EE_HANDS
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD
#define TAPPING_TERM 180
// Selection of RGBLIGHT MODE to use.
#if defined(LED_ANIMATIONS)
//#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
//#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
//#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
//#define RGBLIGHT_EFFECT_RGB_TEST
//#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#define RGBLED_NUM 69 // Number of LEDs
#define RGBLIGHT_SPLIT
#define RGBLED_SPLIT { 48, 21 }

91
keyboards/naked48/keymaps/default_with_setta21/keymap.c
View File

@ -21,114 +21,87 @@ enum layer_number {
};
enum custom_keycodes {
LOWER = SAFE_RANGE,
RAISE,
ADJUST,
KANJI,
RGBRST,
RGB_RST = SAFE_RANGE,
SEND_SUM,
SEND_AVERAGE,
SEND_COUNTIF,
SEND_AVE,
SEND_CIF,
SEND_MAX,
SEND_MIN
};
// Fillers to make layering more clear
#define _____ KC_TRNS
#define XXXXX KC_NO
#define KC_SNUBS S(KC_NUBS)
#define KC_SNUHS S(KC_NUHS)
#define KC_SSUM SEND_SUM
#define KC_SAVE SEND_AVERAGE
#define KC_SCOU SEND_COUNTIF
#define KC_SMAX SEND_MAX
#define KC_SMIN SEND_MIN
#define KC_RADO LT(_RAISE, KC_PDOT)
#define KC_LOP0 LT(_LOWER, KC_P0)
#define KC_ADNL LT(_ADJUST, KC_NLCK)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_with_setta21(
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, KC_LOP0, KC_P1, KC_P4, KC_P7,KC_ADNL, KC_ESC,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, KC_LOP0, KC_P1, KC_P4, KC_P7,KC_NLCK, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_P2, KC_P5, KC_P8,KC_PSLS, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, KC_RADO, KC_P3, KC_P6, KC_P9,KC_PAST, KC_EQL,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+-------+-------|
ADJUST,KC_LCTRL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT, KC_PENT, KC_PPLS,KC_PMNS, KC_DEL
MO(_ADJUST),KC_LCTRL, KC_LALT, KC_LGUI,MO(_LOWER), KC_SPC, KC_SPC,MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP,KC_RIGHT, KC_PENT, KC_PPLS,KC_PMNS, KC_DEL
//`------------------------------------------------------------------------------------------------------------' |-----------------------------------------------|
),
[_LOWER] = LAYOUT_with_setta21(
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR,KC_LPRN, KC_RPRN, KC_DEL, LOWER, XXXXX,KC_LEFT, XXXXX, XXXXX, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, KC_DOWN,KC_DOWN, KC_UP,KC_PSLS, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
_____, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,KC_SNUHS,KC_SNUBS, _____, _____, _____, RAISE, XXXXX,KC_RIGHT, XXXXX,KC_PAST, KC_EQL,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+-------+-------|
_____, _____, _____, _____, _____, _____, _____, _____, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY, KC_PENT, KC_PPLS,KC_PMNS, KC_DEL
//`------------------------------------------------------------------------------------------------------------' |-----------------------------------------------|
//,-----------------------------------------------------| |-----------------------------------------------------. |------------------------------------------------|
KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR,KC_LPRN, KC_RPRN, KC_DEL, MO(_LOWER),XXXXXXX,KC_LEFT, XXXXXXX,XXXXXXX, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+--------+-------+-------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, KC_DOWN,KC_DOWN, KC_UP,KC_PSLS, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+--------+-------+-------|
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,KC_SNUHS,KC_SNUBS, _______, _______, _______, MO(_RAISE),XXXXXXX,KC_RIGHT,XXXXXXX,KC_PAST, KC_EQL,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+----------------+-------+-------|
_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY, KC_PENT, KC_PPLS,KC_PMNS, KC_DEL
//`------------------------------------------------------------------------------------------------------------' |------------------------------------------------|
),
[_RAISE] = LAYOUT_with_setta21(
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, LOWER, KC_F11, KC_F4, KC_F7,KC_SMIN, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, KC_F12, KC_F5, KC_F8,KC_SMAX, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
_____, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _____, _____, _____, RAISE, KC_F3, KC_F6, KC_F9,KC_SCOU, KC_EQL,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+-------+-------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, KC_RPRN, KC_SSUM,KC_SAVE, KC_DEL
//`------------------------------------------------------------------------------------------------------------' |-----------------------------------------------|
//,-----------------------------------------------------| |-----------------------------------------------------. |------------------------------------------------|
KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, _______, KC_F11, KC_F4, KC_F7,SEND_MIN, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+--------+-------|
KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, KC_F12, KC_F5, KC_F8,SEND_MAX, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+--------+-------|
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _______, _______, _______, _______, KC_F3, KC_F6, KC_F9,SEND_CIF, KC_EQL,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+--------+-------|
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_RPRN, SEND_SUM,SEND_AVE, KC_DEL
//`------------------------------------------------------------------------------------------------------------' |------------------------------------------------|
),
[_ADJUST] = LAYOUT_with_setta21( /* Base */
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
_____, RESET, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, _____, LOWER,RGB_VAD,RGB_HUD,RGB_SAD, ADJUST,RGB_TOG,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_RST, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, _______,RGB_VAD,RGB_HUD,RGB_SAD,XXXXXXX,_______,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
_____, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, RGB_TOG, RGB_MOD, XXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, RGB_VAI,RGB_HUI,RGB_SAI, XXXXX, _____,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_MOD, XXXXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, RGB_VAI,RGB_HUI,RGB_SAI,XXXXXXX,_______,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
_____, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RAISE, XXXXX, XXXXX, XXXXX, XXXXX, _____,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, _______,XXXXXXX,XXXXXXX,XXXXXXX,XXXXXXX,_______,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+-------+-------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, RGB_MOD, _____, _____, _____
_______, _______, _______, _______, _______, RESET, RESET, _______, _______, _______, _______, _______, RGB_MOD, RGB_TOG,_______,_______
//`------------------------------------------------------------------------------------------------------------' |-----------------------------------------------|
)
};
static inline void update_change_layer(bool pressed, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
pressed ? layer_on(layer1) : layer_off(layer1);
IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2) ? layer_on(layer3) : layer_off(layer3);
}
int RGB_current_mode;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
bool result = false;
switch (keycode) {
case LOWER:
update_change_layer(record->event.pressed, _LOWER, _RAISE, _ADJUST);
break;
case RAISE:
update_change_layer(record->event.pressed, _RAISE, _LOWER, _ADJUST);
break;
case SEND_SUM:
if (record->event.pressed) {
SEND_STRING("=SUM(");
}
break;
case SEND_AVERAGE:
case SEND_AVE:
if (record->event.pressed) {
SEND_STRING("=AVERAGE(");
}
break;
case SEND_COUNTIF:
case SEND_CIF:
if (record->event.pressed) {
SEND_STRING("=COUNTIF(");
}
@ -151,7 +124,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
RGB_current_mode = rgblight_config.mode;
}
break;
case RGBRST:
case RGB_RST:
if (record->event.pressed) {
eeconfig_update_rgblight_default();
rgblight_enable();
@ -168,7 +141,5 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode;
#endif
}

77
keyboards/naked48/keymaps/default_with_setta21/readme.md
View File

@ -2,46 +2,43 @@
Add Setta21 maps to the default layout.
Default
//|-----------------------------------------|
Rai+0, 1, 4, 7,Ad+Num, ESC,
//|------+------+------+------+------+------|
2, 5, 8, /, F2,
//|------+------+------+------+------+------|
Low+., 3, 6, 9, *, =,
//|-------------+-------------+------+------|
ENT, +, -, DEL
//|-----------------------------------------|
## Default
| 1 | 2 | 3 | 4 |
|:----:|:----:|:----:|:----:|
| ESC| F2| =| DEL|
|Ad+Num| /| *| -|
| 7| 8| 9| |
| 4| 5| 6| +|
| 1| 2| 3| |
| Rai+0| | LOW + .| ENT|
Lower
//|-----------------------------------------|
RAISE, F11, F4, F7, "=MIN(", ESC,
//|------+------+------+------+-----------+------|
F12, F5, F8, "=MAX(", F2,
//|------+------+------+------+-----------+------|
LOWER, F3, F6, F9,"=COUNTIF(", =,
//|-------------+-------------+-----------+------|
), "=SUM(","=AVERAGE(", DEL
//|-----------------------------------------|
## Lower
| 1 | 2 | 3 | 4 |
|:----:|:----:|:----:|:----:|
| ESC| F2| =| DEL|
| =MIN(| =MAX(|=COUNTIF(|=AVERAGE(|
| F7| F8| F9| |
| F4| F5| F6| =SUM(|
| F11| F12| F3| |
| RAISE| | LOWER| )|
Raise
//|-----------------------------------------|
RAISE, XXXXX, LEFT, XXXXX, XXXXX, ESC,
//|------+------+------+------+------+------|
DOWN, DOWN, UP, /, F2,
//|------+------+------+------+------+------|
LOWER, XXXXX, RIGHT, XXXXX, *, =,
//|-------------+-------------+------+------|
ENT, +, -, DEL
//|-----------------------------------------|
## Raise
| 1 | 2 | 3 | 4 |
|:----:|:----:|:----:|:----:|
| ESC| F2| =| DEL|
| XXXXX| /| *| -|
| XXXXX| UP| XXXXX| |
| LEFT| DOWN| RIGHT| +|
| XXXXX| DOWN| XXXXX| |
| RAISE| | LOWER| ENT|
## Adjust
| 1 | 2 | 3 | 4 |
|:----:|:----:|:----:|:----:|
| ESC| F2| =| DEL|
|ADJUST| XXXXX| XXXXX| -|
|LED_SAD|LED_SAI| XXXXX| |
|LED_HUD|LED_HUI| XXXXX| +|
|LED_VAD|LED_VAI| XXXXX| |
|LED_ON/Off| | XXXXX|LED_MOD|
Adjust
//|------------------------------------------------|
LED ON/Off,LED VAD,LED HUD,LED SAD, ADJUST, ESC,
//|--------+-------+-------+-------+-------+-------|
LED VAI,LED HUI,LED SAI, XXXXX, F2,
//|--------+-------+-------+-------+-------+-------|
XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, =,
//|----------------+---------------+-------+-------|
LED MOD, +, -, DEL
//|------------------------------------------------|

29
keyboards/naked48/keymaps/default_with_setta21/rules.mk
View File

@ -1,29 +0,0 @@
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # 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 = no # 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.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
# If your custom naked48 pcb, you can rewrite to yes.
LED_ANIMATIONS = yes # LED animations
ifeq ($(strip $(LED_ANIMATIONS)), yes)
# OPT_DEFS += -DRGBLIGHT_ANIMATIONS
OPT_DEFS += -DLED_ANIMATIONS
endif
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend

35
keyboards/naked48/keymaps/salicylic/config.h
View File

@ -18,24 +18,23 @@
/* Select hand configuration */
#define MASTER_LEFT
// #define MASTER_RIGHT
// #define EE_HANDS
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD
#define TAPPING_TERM 180
// Selection of RGBLIGHT MODE to use.
#if defined(LED_ANIMATIONS)
//#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
//#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
//#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
//#define RGBLIGHT_EFFECT_RGB_TEST
//#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#define DRIVER_LED_TOTAL 48
#ifdef RGB_MATRIX_ENABLE
# define RGB_MATRIX_KEYPRESSES // reacts to keypresses
// # define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
// # define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
# define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
// # define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
// # define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
// # define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
# define RGB_MATRIX_HUE_STEP 8
# define RGB_MATRIX_SAT_STEP 8
# define RGB_MATRIX_LIMIT_VAL 50
# define RGB_MATRIX_VAL_STEP 5
# define RGB_MATRIX_SPD_STEP 10
#endif

64
keyboards/naked48/keymaps/salicylic/keymap.c
View File

@ -3,10 +3,11 @@
extern keymap_config_t keymap_config;
#ifdef RGBLIGHT_ENABLE
//#ifdef RGB_MATRIX_ENABLE
//Following line allows macro to read current RGB settings
extern rgblight_config_t rgblight_config;
#endif
//extern rgblight_config_t rgblight_config;
//#endif
extern uint8_t is_master;
@ -22,17 +23,10 @@ enum layer_number {
};
enum custom_keycodes {
LOWER = SAFE_RANGE,
RAISE,
ADJUST,
KANJI,
RGBRST
RGB_RST = SAFE_RANGE
};
// Fillers to make layering more clear
#define _____ KC_TRNS
#define XXXXX KC_NO
#define KC_CT11 LCTL_T(KC_F11)
#define KC_SF12 SFT_T(KC_F12)
#define KC_LOEN LT(_LOWER, KC_ENT)
@ -56,44 +50,42 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//,-----------------------------------------------------| |-----------------------------------------------------.
KC_ESC, JP_EXLM, JP_QUES, JP_LBRC, JP_RBRC, JP_TILD, KC_6, KC_7, KC_8, KC_9, JP_ASTR, JP_SLSH,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
JP_QUOT, JP_HASH, JP_DQT, JP_LPRN, JP_RPRN, JP_AT, XXXXX, KC_4, KC_5, KC_6, JP_MINS, JP_EQL,
JP_QUOT, JP_HASH, JP_DQT, JP_LPRN, JP_RPRN, JP_AT, XXXXXXX, KC_4, KC_5, KC_6, JP_MINS, JP_EQL,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
JP_CIRC, JP_PERC, JP_AMPR, JP_SCLN, JP_COLN, JP_PIPE, KC_0, KC_1, KC_2, KC_3, JP_PLUS, KC_ENT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
_____, _____, _____, KC_ZKHK, LOWER, _____, _____, RAISE, KC_0, JP_DOT, _____, _____
_______, _______, _______, KC_ZKHK,MO(_LOWER),_______,_______,MO(_RAISE),JP_DOT, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
),
[_RAISE] = LAYOUT(
//,-----------------------------------------------------| |-----------------------------------------------------.
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, XXXXX, KC_UP, XXXXX, KC_PGUP, KC_DEL,
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, XXXXXXX, KC_UP, XXXXXXX, KC_PGUP, KC_DEL,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
KC_CT11, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, XXXXX, KC_LEFT, KC_DOWN,KC_RIGHT, KC_LSFT, KC_ENT,
KC_CT11, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, XXXXXXX, KC_LEFT, KC_DOWN,KC_RIGHT, KC_LSFT, KC_ENT,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
KC_SF12, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, XXXXX, XXXXX, XXXXX, XXXXX, KC_PGDN, XXXXX,
KC_SF12, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PGDN, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
),
[_ADJUST] = LAYOUT( /* Base */
//,-----------------------------------------------------| |-----------------------------------------------------.
_____, _____, _____, _____, _____, _____, _____, KC_7, KC_8, KC_9, KC_0, _____,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_RST, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_____, _____, _____, _____, _____, _____, RGB_TOG, RGB_MOD, XXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR,
KC_LCTRL, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_MOD, XXXXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_____, _____, _____, _____, _____, _____, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI,
KC_LSFT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, RESET, RESET, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
)
};
static inline void update_change_layer(bool pressed, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
pressed ? layer_on(layer1) : layer_off(layer1);
IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2) ? layer_on(layer3) : layer_off(layer3);
uint32_t layer_state_set_user(uint32_t state) {
return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
}
int RGB_current_mode;
@ -101,23 +93,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
bool result = false;
switch (keycode) {
case LOWER:
update_change_layer(record->event.pressed, _LOWER, _RAISE, _ADJUST);
break;
case RAISE:
update_change_layer(record->event.pressed, _RAISE, _LOWER, _ADJUST);
break;
case KANJI:
if (record->event.pressed) {
if (keymap_config.swap_lalt_lgui == false) {
register_code(KC_LANG2);
} else {
SEND_STRING(SS_LALT("`"));
}
} else {
unregister_code(KC_LANG2);
}
break;
#ifdef RGBLIGHT_ENABLE
case RGB_MOD:
if (record->event.pressed) {
@ -143,7 +118,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode;
#endif
}

30
keyboards/naked48/keymaps/salicylic/rules.mk
View File

@ -1,29 +1,3 @@
RGBLIGHT_ENABLE = no
RGB_MATRIX_ENABLE = WS2812
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # 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 = no # 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.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
# If your custom naked48 pcb, you can rewrite to yes.
LED_ANIMATIONS = yes # LED animations
ifeq ($(strip $(LED_ANIMATIONS)), yes)
# OPT_DEFS += -DRGBLIGHT_ANIMATIONS
OPT_DEFS += -DLED_ANIMATIONS
endif
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend

37
keyboards/naked48/keymaps/salicylic_with_nafuda/config.h
View File

@ -27,38 +27,7 @@
#define TAPPING_FORCE_HOLD
#define TAPPING_TERM 180
// Selection of RGBLIGHT MODE to use.
#if defined(LED_ANIMATIONS)
//#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
//#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
//#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
//#define RGBLIGHT_EFFECT_RGB_TEST
//#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#define RGBLED_NUM 55 // Number of LEDs
#define RGBLIGHT_SPLIT
#define RGBLED_SPLIT { 48, 7 }
#define MK_3_SPEED
#undef MOUSEKEY_INTERVAL
#define MOUSEKEY_INTERVAL 0
#undef MOUSEKEY_TIME_TO_MAX
#define MOUSEKEY_TIME_TO_MAX 150
#undef MOUSEKEY_MAX_SPEED
#define MOUSEKEY_MAX_SPEED 3
#undef MOUSEKEY_MOVE_DELTA
#define MOUSEKEY_MOVE_DELTA 5
#undef MOUSEKEY_DELAY
#define MOUSEKEY_DELAY 0
#undef MOUSEKEY_WHEEL_MAX_SPEED
#define MOUSEKEY_WHEEL_MAX_SPEED 1
#undef MOUSEKEY_WHEEL_TIME_TO_MAX
#define MOUSEKEY_WHEEL_TIME_TO_MAX 0

84
keyboards/naked48/keymaps/salicylic_with_nafuda/keymap.c
View File

@ -24,43 +24,24 @@ enum layer_number {
};
enum custom_keycodes {
MOUSE = SAFE_RANGE,
BROWSER,
LOWER,
RAISE,
ADJUST,
KANJI,
RGBRST
RGB_RST = SAFE_RANGE
};
// Fillers to make layering more clear
#define _____ KC_TRNS
#define XXXXX KC_NO
#define KC_CT11 LCTL_T(KC_F11)
#define KC_SF12 SFT_T(KC_F12)
#define KC_LOEN LT(_LOWER, KC_ENT)
#define KC_RASP LT(_RAISE, KC_SPC)
#define KC_CAD LCA(KC_DEL)
#define KC_APSCR LALT(KC_PSCR)
#define KC_RTAB LCTL(KC_TAB)
#define KC_LTAB LCTL(LSFT(KC_TAB))
#define KC_CTAB LCTL(KC_W)
#define KC_RETAB LCTL(LSFT(KC_T))
#define KC_TGMO TG(_MOUSE)
#define KC_TGBR TG(_BROWSER)
#define KC_BSAD LT(_ADJUST, KC_BSPC)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, KC_TGMO,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LCTRL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, JP_MINS, JP_RBRC, KC_BSAD, KC_UP, KC_TGBR,
KC_LCTRL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, JP_MINS, JP_RBRC, KC_BSAD, KC_UP,TG(_BROWSER),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, JP_COMM, JP_DOT, JP_SLSH, JP_BSLS, KC_LEFT, KC_DOWN,KC_RIGHT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
@ -70,7 +51,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_MOUSE] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, KC_TGMO,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LCTRL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, JP_MINS, JP_RBRC, KC_BTN1, KC_MS_U, KC_BTN2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
@ -82,11 +63,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_BROWSER] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, KC_CTAB,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, LCTL(KC_W),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LCTRL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, JP_MINS, JP_RBRC, KC_RETAB, KC_WH_U, KC_TGBR,
KC_LCTRL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, JP_MINS, JP_RBRC,LCTL(LSFT(KC_T)),KC_WH_U,TG(_BROWSER),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, JP_COMM, JP_DOT, JP_SLSH, JP_BSLS, KC_LTAB, KC_WH_D, KC_RTAB,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, JP_COMM, JP_DOT, JP_SLSH, JP_BSLS,LCTL(LSFT(KC_TAB)), KC_WH_D,LCTL(KC_TAB),
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
KC_LEFT,KC_RIGHT, KC_LGUI, KC_MHEN, KC_LOEN, KC_BSPC, KC_DEL, KC_RASP, KC_HENK, KC_LALT, KC_DOWN, KC_UP
//`------------------------------------------------------------------------------------------------------------'
@ -94,45 +75,43 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_LOWER] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_ESC, JP_EXLM, JP_QUES, JP_LBRC, JP_RBRC, JP_TILD, KC_6, KC_7, KC_8, KC_9, JP_ASTR, JP_SLSH, KC_TGMO,
KC_ESC, JP_EXLM, JP_QUES, JP_LBRC, JP_RBRC, JP_TILD, KC_6, KC_7, KC_8, KC_9, JP_ASTR, JP_SLSH, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
JP_QUOT, JP_HASH, JP_DQT, JP_LPRN, JP_RPRN, JP_AT, XXXXX, KC_4, KC_5, KC_6, JP_MINS, JP_EQL, KC_BSAD, KC_UP, KC_TGBR,
JP_QUOT, JP_HASH, JP_DQT, JP_LPRN, JP_RPRN, JP_AT, XXXXXXX, KC_4, KC_5, KC_6, JP_MINS, JP_EQL, KC_BSAD, KC_UP,TG(_BROWSER),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
JP_CIRC, JP_PERC, JP_AMPR, JP_SCLN, JP_COLN, JP_PIPE, KC_0, KC_1, KC_2, KC_3, JP_PLUS, KC_ENT, KC_LEFT, KC_DOWN,KC_RIGHT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
_____, _____, _____, KC_ZKHK, LOWER, _____, _____, RAISE, KC_0, JP_DOT, _____, _____
_______, _______, _______, KC_ZKHK,MO(_LOWER),_______,_______,MO(_RAISE),JP_DOT, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
),
[_RAISE] = LAYOUT_with_nafuda(
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
KC_ESC, JP_EXLM, JP_QUES, JP_LBRC, JP_RBRC, JP_TILD, KC_6, KC_7, KC_8, KC_9, JP_ASTR, JP_SLSH, KC_TGMO,
KC_ESC, JP_EXLM, JP_QUES, JP_LBRC, JP_RBRC, JP_TILD, KC_6, KC_7, KC_8, KC_9, JP_ASTR, JP_SLSH, TG(_MOUSE),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_CT11, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, XXXXX, KC_LEFT, KC_DOWN,KC_RIGHT, KC_LSFT, KC_ENT, KC_BSAD, KC_UP, KC_TGBR,
KC_CT11, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, XXXXXXX, KC_LEFT, KC_DOWN,KC_RIGHT, KC_LSFT, KC_ENT, KC_BSAD, KC_UP,TG(_BROWSER),
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
KC_SF12, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, XXXXX, XXXXX, XXXXX, XXXXX, KC_PGDN, XXXXX, KC_LEFT, KC_DOWN,KC_RIGHT,
KC_SF12, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PGDN, XXXXXXX, KC_LEFT, KC_DOWN,KC_RIGHT,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
),
[_ADJUST] = LAYOUT_with_nafuda( /* Base */
//,-----------------------------------------------------| |-----------------------------------------------------. |--------------------------|
_____, _____, _____, _____, _____, _____, _____, KC_7, KC_8, KC_9, KC_0, _____, RGB_VAD,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_RST, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, RGB_VAD,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
_____, _____, _____, _____, _____, _____, RGB_TOG, RGB_MOD, XXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, ADJUST, RGB_SAD, RGB_VAI,
KC_LCTRL, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_MOD, XXXXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, _ADJUST, RGB_SAD, RGB_VAI,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |--------+--------+--------|
_____, _____, _____, _____, _____, _____, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RGB_MOD, RGB_TOG, RGB_SAI,
KC_LSFT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RGB_MOD, RGB_TOG, RGB_SAI,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |--------------------------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____
_______, _______, _______, _______, _______, RESET, RESET, _______, _______, _______, _______, _______
//`------------------------------------------------------------------------------------------------------------'
)
};
static inline void update_change_layer(bool pressed, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
pressed ? layer_on(layer1) : layer_off(layer1);
IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2) ? layer_on(layer3) : layer_off(layer3);
uint32_t layer_state_set_user(uint32_t state) {
return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
}
int RGB_current_mode;
@ -140,23 +119,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
bool result = false;
switch (keycode) {
case LOWER:
update_change_layer(record->event.pressed, _LOWER, _RAISE, _ADJUST);
break;
case RAISE:
update_change_layer(record->event.pressed, _RAISE, _LOWER, _ADJUST);
break;
case KANJI:
if (record->event.pressed) {
if (keymap_config.swap_lalt_lgui == false) {
register_code(KC_LANG2);
} else {
SEND_STRING(SS_LALT("`"));
}
} else {
unregister_code(KC_LANG2);
}
break;
#ifdef RGBLIGHT_ENABLE
case RGB_MOD:
if (record->event.pressed) {
@ -165,7 +127,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
RGB_current_mode = rgblight_config.mode;
}
break;
case RGBRST:
case RGB_RST:
if (record->event.pressed) {
eeconfig_update_rgblight_default();
rgblight_enable();
@ -182,7 +144,5 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode;
#endif
}

57
keyboards/naked48/keymaps/salicylic_with_nafuda/readme.md
View File

@ -2,38 +2,31 @@
Add Nafuda maps to the salicylic layout.
Default
//|--------------------|
Mouse,
//|------+------+------|
BS + Ad, UP,Browser,
//|------+------+------|
LEFT, DOWN, RIGHT
//|--------------------|
## Default
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| | MOUSE| |
| BS+Ad| UP|Browser|
| LEFT| DOWN| RIGHT|
Mouse
//|--------------------|
Default,
//|------+------+------|
BTN1, MS_U, BTN2,
//|------+------+------|
MS_L, MS_D, MS_R
//|--------------------|
## Mouse
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| |Default| |
| BTN1| MS_U| BTN2|
| MS_L| MS_D| MS_R|
Browser
//|--------------------|
CloseTAB,
//|------+------+------|
ReOpenTAB, WH_U,Default,
//|------+------+------|
LTAB, WH_D, RTAB
//|--------------------|
## Browser
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| |CloseTAB| |
|ReOpenTAB|WH_U|Default|
| LTAB| WH_D| RTAB|
## Adjust
| 1 | 2 | 3 |
|:----:|:----:|:----:|
| |LED_VAD| |
|Default|LED_HUD|LED_VAI|
|LED_MOD|LED_ON/Off|LED_HUI|
Adjust
//|------------------------|
LED VAD,
//|------+----------+------|
Default, LED HUD,LED VAI,
//|------+----------+------|
LED MOD,LED ON/Off,LED HUI
//|------------------------|

28
keyboards/naked48/keymaps/salicylic_with_nafuda/rules.mk
View File

@ -1,29 +1 @@
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # 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 = no # 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.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
# If your custom naked48 pcb, you can rewrite to yes.
LED_ANIMATIONS = yes # LED animations
ifeq ($(strip $(LED_ANIMATIONS)), yes)
# OPT_DEFS += -DRGBLIGHT_ANIMATIONS
OPT_DEFS += -DLED_ANIMATIONS
endif
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend

16
keyboards/naked48/keymaps/salicylic_with_setta21/config.h
View File

@ -21,21 +21,11 @@
#define MASTER_LEFT
// #define MASTER_RIGHT
// #define EE_HANDS
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD
#define TAPPING_TERM 180
// Selection of RGBLIGHT MODE to use.
#if defined(LED_ANIMATIONS)
//#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
//#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
//#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
//#define RGBLIGHT_EFFECT_RGB_TEST
//#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#define RGBLED_NUM 69 // Number of LEDs
#define RGBLIGHT_SPLIT
#define RGBLED_SPLIT { 48, 21 }

81
keyboards/naked48/keymaps/salicylic_with_setta21/keymap.c
View File

@ -22,41 +22,27 @@ enum layer_number {
};
enum custom_keycodes {
LOWER = SAFE_RANGE,
RAISE,
ADJUST,
KANJI,
RGBRST,
RGB_RST = SAFE_RANGE,
SEND_SUM,
SEND_AVERAGE,
SEND_COUNTIF,
SEND_AVE,
SEND_CIF,
SEND_MAX,
SEND_MIN
};
// Fillers to make layering more clear
#define _____ KC_TRNS
#define XXXXX KC_NO
#define KC_CT11 LCTL_T(KC_F11)
#define KC_SF12 SFT_T(KC_F12)
#define KC_LOEN LT(_LOWER, KC_ENT)
#define KC_RASP LT(_RAISE, KC_SPC)
#define KC_SSUM SEND_SUM
#define KC_SAVE SEND_AVERAGE
#define KC_SCOU SEND_COUNTIF
#define KC_SMAX SEND_MAX
#define KC_SMIN SEND_MIN
#define KC_RADO LT(_RAISE, KC_PDOT)
#define KC_LOP0 LT(_LOWER, KC_P0)
#define KC_ADNL LT(_ADJUST, KC_NLCK)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_with_setta21(
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, KC_LOP0, KC_P1, KC_P4, KC_P7,KC_ADNL, KC_ESC,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, JP_LBRC, KC_LOP0, KC_P1, KC_P4, KC_P7,KC_NLCK, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
KC_LCTRL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, JP_MINS, JP_RBRC, KC_P2, KC_P5, KC_P8,KC_PSLS, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
@ -68,80 +54,60 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_LOWER] = LAYOUT_with_setta21(
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
KC_ESC, JP_EXLM, JP_QUES, JP_LBRC, JP_RBRC, JP_TILD, KC_6, KC_7, KC_8, KC_9, JP_ASTR, JP_SLSH, LOWER, XXXXX,KC_LEFT, XXXXX, XXXXX, KC_ESC,
KC_ESC, JP_EXLM, JP_QUES, JP_LBRC, JP_RBRC, JP_TILD, KC_6, KC_7, KC_8, KC_9, JP_ASTR, JP_SLSH, MO(_LOWER),XXXXXXX,KC_LEFT,XXXXXXX,XXXXXXX, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
JP_QUOT, JP_HASH, JP_DQT, JP_LPRN, JP_RPRN, JP_AT, XXXXX, KC_4, KC_5, KC_6, JP_MINS, JP_EQL, KC_DOWN,KC_DOWN, KC_UP,KC_PSLS, KC_F2,
JP_QUOT, JP_HASH, JP_DQT, JP_LPRN, JP_RPRN, JP_AT, XXXXXXX, KC_4, KC_5, KC_6, JP_MINS, JP_EQL, KC_DOWN,KC_DOWN, KC_UP,KC_PSLS, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
JP_CIRC, JP_PERC, JP_AMPR, JP_SCLN, JP_COLN, JP_PIPE, KC_0, KC_1, KC_2, KC_3, JP_PLUS, KC_ENT, RAISE, XXXXX,KC_RIGHT, XXXXX,KC_PAST, JP_EQL,
JP_CIRC, JP_PERC, JP_AMPR, JP_SCLN, JP_COLN, JP_PIPE, KC_0, KC_1, KC_2, KC_3, JP_PLUS, KC_ENT, MO(_RAISE),XXXXXXX,KC_RIGHT,XXXXXXX,KC_PAST, JP_EQL,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+-------+-------|
_____, _____, _____, KC_ZKHK, LOWER, _____, _____, RAISE, KC_0, JP_DOT, _____, _____, KC_PENT, KC_PPLS,KC_PMNS, KC_DEL
_______, _______, _______, KC_ZKHK,MO(_LOWER),_______,_______,MO(_RAISE),JP_DOT, _______, _______, _______, KC_PENT, KC_PPLS,KC_PMNS, KC_DEL
//`------------------------------------------------------------------------------------------------------------' |-----------------------------------------------|
),
[_RAISE] = LAYOUT_with_setta21(
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, XXXXX, KC_UP, XXXXX, KC_PGUP, KC_DEL, LOWER, KC_F11, KC_F4, KC_F7,KC_SMIN, KC_ESC,
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, XXXXXXX, KC_UP, XXXXXXX, KC_PGUP, KC_DEL, _______, KC_F11, KC_F4, KC_F7,SEND_MIN, KC_ESC,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
KC_CT11, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, XXXXX, KC_LEFT, KC_DOWN,KC_RIGHT, KC_LSFT, KC_ENT, KC_F12, KC_F5, KC_F8,KC_SMAX, KC_F2,
KC_CT11, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, XXXXXXX, KC_LEFT, KC_DOWN,KC_RIGHT, KC_LSFT, KC_ENT, KC_F12, KC_F5, KC_F8,SEND_MAX, KC_F2,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
KC_SF12, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, XXXXX, XXXXX, XXXXX, XXXXX, KC_PGDN, XXXXX, RAISE, KC_F3, KC_F6, KC_F9,KC_SCOU, JP_EQL,
KC_SF12, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PGDN, XXXXXXX, _______, KC_F3, KC_F6, KC_F9,SEND_CIF, JP_EQL,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+-------+-------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, JP_RPRN, KC_SSUM,KC_SAVE, KC_DEL
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, JP_RPRN, SEND_SUM,SEND_AVE, KC_DEL
//`------------------------------------------------------------------------------------------------------------' |-----------------------------------------------|
),
[_ADJUST] = LAYOUT_with_setta21( /* Base */
//,-----------------------------------------------------| |-----------------------------------------------------. |-----------------------------------------------|
_____, _____, _____, _____, _____, _____, _____, KC_7, KC_8, KC_9, KC_0, _____, LOWER,RGB_VAD,RGB_HUD,RGB_SAD, ADJUST,RGB_TOG,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_RST, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______,RGB_VAD,RGB_HUD,RGB_SAD,XXXXXXX,_______,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
_____, _____, _____, _____, _____, _____, RGB_TOG, RGB_MOD, XXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, RGB_VAI,RGB_HUI,RGB_SAI, XXXXX, _____,
KC_LCTRL, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_MOD, XXXXXXX,LCA(KC_DEL),LALT(KC_PSCR),KC_PSCR, RGB_VAI,RGB_HUI,RGB_SAI,XXXXXXX,_______,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| |-------+-------+-------+-------+-------+-------|
_____, _____, _____, _____, _____, _____, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RAISE, XXXXX, XXXXX, XXXXX, XXXXX, _____,
KC_LSFT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, _______,XXXXXXX,XXXXXXX,XXXXXXX,XXXXXXX,_______,
//|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| |---------------+---------------+-------+-------|
_____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, RGB_MOD, _____, _____, _____
_______, _______, _______, _______, _______, RESET, RESET, _______, _______, _______, _______, _______, RGB_MOD, RGB_TOG,_______,_______
//`------------------------------------------------------------------------------------------------------------' |-----------------------------------------------|
)
};
static inline void update_change_layer(bool pressed, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
pressed ? layer_on(layer1) : layer_off(layer1);
IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2) ? layer_on(layer3) : layer_off(layer3);
uint32_t layer_state_set_user(uint32_t state) {
return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
}
int RGB_current_mode;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
bool result = false;
switch (keycode) {
case LOWER:
update_change_layer(record->event.pressed, _LOWER, _RAISE, _ADJUST);
break;
case RAISE:
update_change_layer(record->event.pressed, _RAISE, _LOWER, _ADJUST);
break;
case KANJI:
if (record->event.pressed) {
if (keymap_config.swap_lalt_lgui == false) {
register_code(KC_LANG2);
} else {
SEND_STRING(SS_LALT("`"));
}
} else {
unregister_code(KC_LANG2);
}
break;
case SEND_SUM:
if (record->event.pressed) {
SEND_STRING("_SUM*");
}
break;
case SEND_AVERAGE:
case SEND_AVE:
if (record->event.pressed) {
SEND_STRING("_AVERAGE*");
}
break;
case SEND_COUNTIF:
case SEND_CIF:
if (record->event.pressed) {
SEND_STRING("_COUNTIF*");
}
@ -164,7 +130,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
RGB_current_mode = rgblight_config.mode;
}
break;
case RGBRST:
case RGB_RST:
if (record->event.pressed) {
eeconfig_update_rgblight_default();
rgblight_enable();
@ -181,7 +147,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode;
#endif
}

29
keyboards/naked48/keymaps/salicylic_with_setta21/rules.mk
View File

@ -1,29 +0,0 @@
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # 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 = no # 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.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
# If your custom naked48 pcb, you can rewrite to yes.
LED_ANIMATIONS = yes # LED animations
ifeq ($(strip $(LED_ANIMATIONS)), yes)
# OPT_DEFS += -DRGBLIGHT_ANIMATIONS
OPT_DEFS += -DLED_ANIMATIONS
endif
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend

5
keyboards/naked48/naked48.c
View File

@ -1 +1,6 @@
#include "naked48.h"
// Optional override functions below.
// You can leave any or all of these undefined.
// These are only required if you want to perform custom actions.

9
keyboards/naked48/naked48.h
View File

@ -1,12 +1,7 @@
#pragma once
#include "quantum.h"
#ifdef KEYBOARD_naked48_rev1
#include "rev1.h"
#endif
#include "quantum.h"
#ifdef PROTOCOL_LUFA
#include "lufa.h"
#include "split_util.h"
#endif

4
keyboards/naked48/readme.md
View File

@ -5,8 +5,8 @@
This is 48 keys modification Ortholinear keyboard.
Keyboard Maintainer: [Salicylic_acid3](https://github.com/Salicylic-acid3)
Hardware Supported: The PCBs, controllers supported
Hardware Availability: links to where you can find this hardware
Hardware Supported: Naked60BMP PCB, Pro Micro
Hardware Availability: [PCB & Case Data](https://github.com/Salicylic-acid3/PCB_Data), [Booth Shop](https://salicylic-acid3.booth.pm/items/1271568)
Make example for this keyboard (after setting up your build environment):

81
keyboards/naked48/rev1/config.h
View File

@ -18,6 +18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include QMK_KEYBOARD_CONFIG_H
/* USB Device descriptor parameter */
#define VENDOR_ID 0xFEED
#define PRODUCT_ID 0x3060
@ -26,57 +28,31 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define PRODUCT naked48
#define DESCRIPTION Ortholinear 48 Keys Keyboard
/* Use I2C or Serial */
//#define USE_I2C
#define USE_SERIAL
//#define USE_MATRIX_I2C
/* Select hand configuration */
#define MASTER_LEFT
// #define MASTER_RIGHT
// #define EE_HANDS
// OLED support
// see ./rules.mk: OLED_ENABLE=yes or no
#ifdef OLED_ENABLE
#define SSD1306OLED
#endif
/* key matrix size */
#define MATRIX_ROWS 8
#define MATRIX_COLS 14
// Rows are doubled-up
#define MATRIX_ROW_PINS { D1, D0, D4, C6 }
#define MATRIX_COLS 12
// wiring of each half
#define MATRIX_ROW_PINS { D1, D0, D4, C6 }
#define MATRIX_COL_PINS { F4, F5, F6, F7, B1, B3, B2, B6, D7, E6, B4, B5 }
// #define MATRIX_COL_PINS { B5, B4, E6, D7, D6, B2, B3, B1, F7, F6, F5, F4 } //uncomment this line and comment line above if you need to reverse left-to-right key order
/* define if matrix has ghost */
//#define MATRIX_HAS_GHOST
/* number of backlight levels */
// #define BACKLIGHT_LEVELS 3
// When using Nafuda, comment out MATRIX_ROW_PINS_RIGHT and MATRIX_COL_PINS_RIGHT.
#define MATRIX_ROW_PINS_RIGHT { D4, C6, D7, E6 }
#define MATRIX_COL_PINS_RIGHT { F4, F5, F6, F7, B1, B3, B2, B6, B4, B5, B2, B2 }
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
/* serial.c configuration for split keyboard */
#define SOFT_SERIAL_PIN D2
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
//#define LOCKING_SUPPORT_ENABLE
#define LOCKING_SUPPORT_ENABLE
/* Locking resynchronize hack */
//#define LOCKING_RESYNC_ENABLE
#define LOCKING_RESYNC_ENABLE
/* ws2812 RGB LED */
#define RGB_DI_PIN D3
#define RGBLIGHT_TIMER
#define ws2812_PORTREG PORTD
#define ws2812_DDRREG DDRD
// naked48 keyboard RGB LED support
//#define RGBLIGHT_ANIMATIONS : see ./rules.mk: LED_ANIMATIONS = yes or no
// see ./rules.mk: LED_BACK_ENABLE or LED_UNDERGLOW_ENABLE set yes
#define RGBLED_NUM 48
#define RGBLIGHT_ANIMATIONS
#ifndef IOS_DEVICE_ENABLE
#define RGBLIGHT_LIMIT_VAL 180
@ -88,6 +64,19 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17
// Selection of RGBLIGHT MODE to use.
#if defined(LED_ANIMATIONS)
//#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
//#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
//#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
//#define RGBLIGHT_EFFECT_RGB_TEST
//#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#if defined(RGBLIGHT_ENABLE) && !defined(IOS_DEVICE_ENABLE)
// USB_MAX_POWER_CONSUMPTION value for naked48 keyboard
// 120 RGBoff, OLEDoff
@ -101,21 +90,3 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// iOS device need lessthan 100
#define USB_MAX_POWER_CONSUMPTION 100
#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

357
keyboards/naked48/rev1/matrix.c
View File

@ -1,357 +0,0 @@
/*
Copyright 2012 Jun Wako <wakojun@gmail.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/>.
*/
/*
* scan matrix
*/
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h"
#include "split_util.h"
#include "pro_micro.h"
#ifdef USE_MATRIX_I2C
# include "i2c.h"
#else // USE_SERIAL
# include "split_scomm.h"
#endif
#ifndef DEBOUNCE
# define DEBOUNCE 5
#endif
#define ERROR_DISCONNECT_COUNT 5
static uint8_t debouncing = DEBOUNCE;
static const int ROWS_PER_HAND = MATRIX_ROWS/2;
static uint8_t error_count = 0;
uint8_t is_master = 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];
static matrix_row_t read_cols(void);
static void init_cols(void);
static void unselect_rows(void);
static void select_row(uint8_t row);
static uint8_t matrix_master_scan(void);
__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;
TXLED0;
RXLED0;
// initialize matrix state: all keys off
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
matrix_debouncing[i] = 0;
}
is_master = has_usb();
matrix_init_quantum();
}
uint8_t _matrix_scan(void)
{
// Right hand is stored after the left in the matirx so, we need to offset it
int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if (matrix_debouncing[i+offset] != cols) {
matrix_debouncing[i+offset] = cols;
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
matrix[i+offset] = matrix_debouncing[i+offset];
}
}
}
return 1;
}
#ifdef USE_MATRIX_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(int master_changed) {
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
#ifdef SERIAL_USE_MULTI_TRANSACTION
int ret=serial_update_buffers(master_changed);
#else
int ret=serial_update_buffers();
#endif
if (ret ) {
if(ret==2) RXLED1;
return 1;
}
RXLED0;
memcpy(&matrix[slaveOffset],
(void *)serial_slave_buffer, sizeof(serial_slave_buffer));
return 0;
}
#endif
uint8_t matrix_scan(void)
{
if (is_master) {
matrix_master_scan();
}else{
matrix_slave_scan();
int offset = (isLeftHand) ? ROWS_PER_HAND : 0;
memcpy(&matrix[offset],
(void *)serial_master_buffer, sizeof(serial_master_buffer));
matrix_scan_quantum();
}
return 1;
}
uint8_t matrix_master_scan(void) {
int ret = _matrix_scan();
int mchanged = 1;
int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
#ifdef USE_MATRIX_I2C
// for (int i = 0; i < ROWS_PER_HAND; ++i) {
/* i2c_slave_buffer[i] = matrix[offset+i]; */
// i2c_slave_buffer[i] = matrix[offset+i];
// }
#else // USE_SERIAL
#ifdef SERIAL_USE_MULTI_TRANSACTION
mchanged = memcmp((void *)serial_master_buffer,
&matrix[offset], sizeof(serial_master_buffer));
#endif
memcpy((void *)serial_master_buffer,
&matrix[offset], sizeof(serial_master_buffer));
#endif
#ifdef USE_MATRIX_I2C
if( i2c_transaction() ) {
#else // USE_SERIAL
if( serial_transaction(mchanged) ) {
#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_MATRIX_I2C
for (int i = 0; i < ROWS_PER_HAND; ++i) {
/* i2c_slave_buffer[i] = matrix[offset+i]; */
i2c_slave_buffer[i] = matrix[offset+i];
}
#else // USE_SERIAL
#ifdef SERIAL_USE_MULTI_TRANSACTION
int change = 0;
#endif
for (int i = 0; i < ROWS_PER_HAND; ++i) {
#ifdef SERIAL_USE_MULTI_TRANSACTION
if( serial_slave_buffer[i] != matrix[offset+i] )
change = 1;
#endif
serial_slave_buffer[i] = matrix[offset+i];
}
#ifdef SERIAL_USE_MULTI_TRANSACTION
slave_buffer_change_count += change;
#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;
}
static void init_cols(void)
{
for(int x = 0; x < MATRIX_COLS; x++) {
_SFR_IO8((col_pins[x] >> 4) + 1) &= ~_BV(col_pins[x] & 0xF);
_SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);
}
}
static matrix_row_t read_cols(void)
{
matrix_row_t result = 0;
for(int x = 0; x < MATRIX_COLS; x++) {
result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);
}
return result;
}
static void unselect_rows(void)
{
for(int x = 0; x < ROWS_PER_HAND; x++) {
_SFR_IO8((row_pins[x] >> 4) + 1) &= ~_BV(row_pins[x] & 0xF);
_SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);
}
}
static void select_row(uint8_t row)
{
_SFR_IO8((row_pins[row] >> 4) + 1) |= _BV(row_pins[row] & 0xF);
_SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);
}

35
keyboards/naked48/rev1/rev1.c
View File

@ -1,15 +1,36 @@
#include "naked48.h"
#ifdef SSD1306OLED
/*#ifdef SSD1306OLED
void led_set_kb(uint8_t usb_led) {
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
//led_set_user(usb_led);
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
//led_set_user(usb_led);
}
#endif*/
#ifdef RGB_MATRIX_ENABLE
led_config_t g_led_config = { {
// Key Matrix to LED Index
{ 0,47,42,41,36,35,30,29,24,23,18,17 },
{ 1,46,43,40,37,34,31,28,25,22,19,16 },
{ 2,45,44,39,38,33,32,27,26,21,20,15 },
{ 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14 }
}, {
// LED Index to Physical Position
{ 0, 0 }, { 0, 21 }, { 0, 43 }, { 17, 64 }, { 34, 64 },{ 52, 64 }, { 69, 64 }, { 86, 64 }, { 103, 64 }, { 121, 64 },
{ 138, 64 }, { 155, 64 }, { 172, 64 }, { 190, 64 }, { 207, 64 },{ 224, 43 }, { 224, 21 }, { 224, 0 }, { 207, 0 }, { 207, 21 },
{ 207, 43 }, { 190, 43 }, { 190, 21 }, { 190, 0 }, { 172, 0 },{ 172, 21 }, { 172, 43 }, { 155, 43 }, { 155, 21 }, { 155, 0 },
{ 138, 0 }, { 138, 21 }, { 138, 43 }, { 86, 43 }, { 86, 21 },{ 86, 0 }, { 69, 0 }, { 69, 21 }, { 69, 43 }, { 52, 43 },
{ 52, 21 }, { 52, 0 }, { 34, 0 }, { 34, 21 }, { 34, 43 },{ 17, 43 }, { 17, 21 }, { 17, 0 }
}, {
// LED Index to Flag
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4
} };
#endif
void matrix_init_kb(void) {
matrix_init_user();
};
};

41
keyboards/naked48/rev1/rev1.h
View File

@ -3,12 +3,19 @@
#include "naked48.h"
#include "quantum.h"
#ifdef RGBLIGHT_ENABLE
//rgb led driver
#include "ws2812.h"
#endif
#ifdef USE_I2C
#include <stddef.h>
#ifdef __AVR__
#include <avr/io.h>
#include <avr/interrupt.h>
#endif
#endif
//////////////////////////////////////////////////////////////////////////////
// When only use Naked48.
//////////////////////////////////////////////////////////////////////////////
@ -52,14 +59,14 @@
L30, L31, L32, L33, L34, L35, L36, L37, L38, L39, L3A, L3B, R30, R32, R34, R35 \
) \
{ \
{ L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A, L0B,KC_NO,KC_NO }, \
{ L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L1A, L1B,KC_NO,KC_NO }, \
{ L20, L21, L22, L23, L24, L25, L26, L27, L28, L29, L2A, L2B,KC_NO,KC_NO }, \
{ L30, L31, L32, L33, L34, L35, L36, L37, L38, L39, L3A, L3B,KC_NO,KC_NO }, \
{ R00, R01, R02, R03, R04, R05,KC_NO,KC_NO,KC_NO, R11, R12, R13, R14, R15 }, \
{ R20, R21, R22, R23, R24, R25,KC_NO,KC_NO, R30,KC_NO, R32,KC_NO, R34, R35 }, \
{KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO } \
{ L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A, L0B }, \
{ L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L1A, L1B }, \
{ L20, L21, L22, L23, L24, L25, L26, L27, L28, L29, L2A, L2B }, \
{ L30, L31, L32, L33, L34, L35, L36, L37, L38, L39, L3A, L3B }, \
{ R00, R01, R02, R03, R04, R05,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{KC_NO, R11, R12, R13, R14, R15,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{ R20, R21, R22, R23, R24, R25,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{ R30,KC_NO, R32,KC_NO, R34, R35,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO } \
}
//////////////////////////////////////////////////////////////////////////////
@ -73,13 +80,13 @@
L30, L31, L32, L33, L34, L35, L36, L37, L38, L39, L3A, L3B \
) \
{ \
{ L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A, L0B,KC_NO,KC_NO }, \
{ L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L1A, L1B,KC_NO,KC_NO }, \
{ L20, L21, L22, L23, L24, L25, L26, L27, L28, L29, L2A, L2B,KC_NO,KC_NO }, \
{ L30, L31, L32, L33, L34, L35, L36, L37, L38, L39, L3A, L3B,KC_NO,KC_NO }, \
{KC_NO, R01,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO, R10, R11, R12,KC_NO,KC_NO,KC_NO }, \
{ R20, R21, R22,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO } \
{ L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A, L0B }, \
{ L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L1A, L1B }, \
{ L20, L21, L22, L23, L24, L25, L26, L27, L28, L29, L2A, L2B }, \
{ L30, L31, L32, L33, L34, L35, L36, L37, L38, L39, L3A, L3B }, \
{KC_NO, R01,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{ R10, R11, R12,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{ R20, R21, R22,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO }, \
{KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO,KC_NO } \
}

3
keyboards/naked48/rev1/rules.mk
View File

@ -1,3 +0,0 @@
SRC += matrix.c \
split_util.c \
split_scomm.c

8
keyboards/naked48/rev1/serial_config.h
View File

@ -1,8 +0,0 @@
//// #error rev2 serial config
#ifndef SOFT_SERIAL_PIN
/* Soft Serial defines */
#define SOFT_SERIAL_PIN D2
#define SERIAL_USE_MULTI_TRANSACTION
#endif

8
keyboards/naked48/rev1/serial_config_simpleapi.h
View File

@ -1,8 +0,0 @@
#ifndef SERIAL_CONFIG_SIMPLEAPI_H
#define SERIAL_CONFIG_SIMPLEAPI_H
#undef SERIAL_USE_MULTI_TRANSACTION
#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2
#endif // SERIAL_CONFIG_SIMPLEAPI_H

92
keyboards/naked48/rev1/split_scomm.c
View File

@ -1,92 +0,0 @@
#ifdef USE_SERIAL
#ifdef SERIAL_USE_MULTI_TRANSACTION
/* --- USE flexible API (using multi-type transaction function) --- */
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <split_scomm.h>
#include "serial.h"
#ifdef CONSOLE_ENABLE
#include <print.h>
#endif
uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
uint8_t volatile status_com = 0;
uint8_t volatile status1 = 0;
uint8_t slave_buffer_change_count = 0;
uint8_t s_change_old = 0xff;
uint8_t s_change_new = 0xff;
SSTD_t transactions[] = {
#define GET_SLAVE_STATUS 0
/* master buffer not changed, only recive slave_buffer_change_count */
{ (uint8_t *)&status_com,
0, NULL,
sizeof(slave_buffer_change_count), &slave_buffer_change_count,
},
#define PUT_MASTER_GET_SLAVE_STATUS 1
/* master buffer changed need send, and recive slave_buffer_change_count */
{ (uint8_t *)&status_com,
sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer,
sizeof(slave_buffer_change_count), &slave_buffer_change_count,
},
#define GET_SLAVE_BUFFER 2
/* recive serial_slave_buffer */
{ (uint8_t *)&status1,
0, NULL,
sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer
}
};
void serial_master_init(void)
{
soft_serial_initiator_init(transactions, TID_LIMIT(transactions));
}
void serial_slave_init(void)
{
soft_serial_target_init(transactions, TID_LIMIT(transactions));
}
// 0 => no error
// 1 => slave did not respond
// 2 => checksum error
int serial_update_buffers(int master_update)
{
int status, smatstatus;
static int need_retry = 0;
if( s_change_old != s_change_new ) {
smatstatus = soft_serial_transaction(GET_SLAVE_BUFFER);
if( smatstatus == TRANSACTION_END ) {
s_change_old = s_change_new;
#ifdef CONSOLE_ENABLE
uprintf("slave matrix = %b %b %b %b %b\n",
serial_slave_buffer[0], serial_slave_buffer[1],
serial_slave_buffer[2], serial_slave_buffer[3],
serial_slave_buffer[4] );
#endif
}
} else {
// serial_slave_buffer dosen't change
smatstatus = TRANSACTION_END; // dummy status
}
if( !master_update && !need_retry) {
status = soft_serial_transaction(GET_SLAVE_STATUS);
} else {
status = soft_serial_transaction(PUT_MASTER_GET_SLAVE_STATUS);
}
if( status == TRANSACTION_END ) {
s_change_new = slave_buffer_change_count;
need_retry = 0;
} else {
need_retry = 1;
}
return smatstatus;
}
#endif // SERIAL_USE_MULTI_TRANSACTION
#endif /* USE_SERIAL */

22
keyboards/naked48/rev1/split_scomm.h
View File

@ -1,22 +0,0 @@
#pragma once
#ifndef SERIAL_USE_MULTI_TRANSACTION
/* --- USE Simple API (OLD API, compatible with let's split serial.c) --- */
#include "serial.h"
#else
/* --- USE flexible API (using multi-type transaction function) --- */
// Buffers for master - slave communication
#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2
extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
extern uint8_t slave_buffer_change_count;
void serial_master_init(void);
void serial_slave_init(void);
int serial_update_buffers(int master_changed);
#endif

70
keyboards/naked48/rev1/split_util.c
View File

@ -1,70 +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"
#ifdef USE_MATRIX_I2C
# include "i2c.h"
#else
# include "split_scomm.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_MATRIX_I2C
i2c_master_init();
#else
serial_master_init();
#endif
}
static void keyboard_slave_setup(void) {
#ifdef USE_MATRIX_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();
}
// this code runs before the usb and keyboard is initialized
void matrix_setup(void) {
split_keyboard_setup();
}

16
keyboards/naked48/rev1/split_util.h
View File

@ -1,16 +0,0 @@
#pragma once
#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 matrix_master_OLED_init (void);

66
keyboards/naked48/rules.mk
View File

@ -1,46 +1,14 @@
# SRC += i2c.c
QUANTUM_LIB_SRC += serial.c
# SRC += ssd1306.c
# MCU name
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
# 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 selection
# Teensy halfkay
# Pro Micro caterina
# Atmel DFU atmel-dfu
# LUFA DFU lufa-dfu
# QMK DFU qmk-dfu
# ATmega32A bootloadHID
# ATmega328P USBasp
BOOTLOADER = caterina
# Interrupt driven control endpoint task(+60)
@ -51,22 +19,22 @@ OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # Commands for debug and configuration
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 = no # Enable keyboard backlight functionality
BACKLIGHT_ENABLE = no # 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 = no # Enable WS2812 RGB underlight.
SUBPROJECT_rev1 = no
USE_I2C = no
RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight.
OLED_DRIVER_ENABLE = no
# USE_I2C = yes
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
CUSTOM_MATRIX = yes
SPLIT_KEYBOARD = yes
DEFAULT_FOLDER = naked48/rev1

590
keyboards/naked48/serial.c
View File

@ -1,590 +0,0 @@
/*
* WARNING: be careful changing this code, it is very timing dependent
*
* 2018-10-28 checked
* avr-gcc 4.9.2
* avr-gcc 5.4.0
* avr-gcc 7.3.0
*/
#ifndef F_CPU
#define F_CPU 16000000
#endif
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stddef.h>
#include <stdbool.h>
#include "serial.h"
//#include <pro_micro.h>
#ifdef SOFT_SERIAL_PIN
#ifdef __AVR_ATmega32U4__
// if using ATmega32U4 I2C, can not use PD0 and PD1 in soft serial.
#ifdef USE_I2C
#if SOFT_SERIAL_PIN == D0 || SOFT_SERIAL_PIN == D1
#error Using ATmega32U4 I2C, so can not use PD0, PD1
#endif
#endif
#if SOFT_SERIAL_PIN >= D0 && SOFT_SERIAL_PIN <= D3
#define SERIAL_PIN_DDR DDRD
#define SERIAL_PIN_PORT PORTD
#define SERIAL_PIN_INPUT PIND
#if SOFT_SERIAL_PIN == D0
#define SERIAL_PIN_MASK _BV(PD0)
#define EIMSK_BIT _BV(INT0)
#define EICRx_BIT (~(_BV(ISC00) | _BV(ISC01)))
#define SERIAL_PIN_INTERRUPT INT0_vect
#elif SOFT_SERIAL_PIN == D1
#define SERIAL_PIN_MASK _BV(PD1)
#define EIMSK_BIT _BV(INT1)
#define EICRx_BIT (~(_BV(ISC10) | _BV(ISC11)))
#define SERIAL_PIN_INTERRUPT INT1_vect
#elif SOFT_SERIAL_PIN == D2
#define SERIAL_PIN_MASK _BV(PD2)
#define EIMSK_BIT _BV(INT2)
#define EICRx_BIT (~(_BV(ISC20) | _BV(ISC21)))
#define SERIAL_PIN_INTERRUPT INT2_vect
#elif SOFT_SERIAL_PIN == D3
#define SERIAL_PIN_MASK _BV(PD3)
#define EIMSK_BIT _BV(INT3)
#define EICRx_BIT (~(_BV(ISC30) | _BV(ISC31)))
#define SERIAL_PIN_INTERRUPT INT3_vect
#endif
#elif SOFT_SERIAL_PIN == E6
#define SERIAL_PIN_DDR DDRE
#define SERIAL_PIN_PORT PORTE
#define SERIAL_PIN_INPUT PINE
#define SERIAL_PIN_MASK _BV(PE6)
#define EIMSK_BIT _BV(INT6)
#define EICRx_BIT (~(_BV(ISC60) | _BV(ISC61)))
#define SERIAL_PIN_INTERRUPT INT6_vect
#else
#error invalid SOFT_SERIAL_PIN value
#endif
#else
#error serial.c now support ATmega32U4 only
#endif
//////////////// for backward compatibility ////////////////////////////////
#if !defined(SERIAL_USE_SINGLE_TRANSACTION) && !defined(SERIAL_USE_MULTI_TRANSACTION)
/* --- USE OLD API (compatible with let's split serial.c) */
#if SERIAL_SLAVE_BUFFER_LENGTH > 0
uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
#endif
#if SERIAL_MASTER_BUFFER_LENGTH > 0
uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
#endif
uint8_t volatile status0 = 0;
SSTD_t transactions[] = {
{ (uint8_t *)&status0,
#if SERIAL_MASTER_BUFFER_LENGTH > 0
sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer,
#else
0, (uint8_t *)NULL,
#endif
#if SERIAL_SLAVE_BUFFER_LENGTH > 0
sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer
#else
0, (uint8_t *)NULL,
#endif
}
};
void serial_master_init(void)
{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
void serial_slave_init(void)
{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
// 0 => no error
// 1 => slave did not respond
// 2 => checksum error
int serial_update_buffers()
{
int result;
result = soft_serial_transaction();
return result;
}
#endif // end of OLD API (compatible with let's split serial.c)
////////////////////////////////////////////////////////////////////////////
#define ALWAYS_INLINE __attribute__((always_inline))
#define NO_INLINE __attribute__((noinline))
#define _delay_sub_us(x) __builtin_avr_delay_cycles(x)
// parity check
#define ODD_PARITY 1
#define EVEN_PARITY 0
#define PARITY EVEN_PARITY
#ifdef SERIAL_DELAY
// custom setup in config.h
// #define TID_SEND_ADJUST 2
// #define SERIAL_DELAY 6 // micro sec
// #define READ_WRITE_START_ADJUST 30 // cycles
// #define READ_WRITE_WIDTH_ADJUST 8 // cycles
#else
// ============ Standard setups ============
#ifndef SELECT_SOFT_SERIAL_SPEED
#define SELECT_SOFT_SERIAL_SPEED 1
// 0: about 189kbps
// 1: about 137kbps (default)
// 2: about 75kbps
// 3: about 39kbps
// 4: about 26kbps
// 5: about 20kbps
#endif
#if __GNUC__ < 6
#define TID_SEND_ADJUST 14
#else
#define TID_SEND_ADJUST 2
#endif
#if SELECT_SOFT_SERIAL_SPEED == 0
// Very High speed
#define SERIAL_DELAY 4 // micro sec
#if __GNUC__ < 6
#define READ_WRITE_START_ADJUST 33 // cycles
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_START_ADJUST 34 // cycles
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 1
// High speed
#define SERIAL_DELAY 6 // micro sec
#if __GNUC__ < 6
#define READ_WRITE_START_ADJUST 30 // cycles
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_START_ADJUST 33 // cycles
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 2
// Middle speed
#define SERIAL_DELAY 12 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 3
// Low speed
#define SERIAL_DELAY 24 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 4
// Very Low speed
#define SERIAL_DELAY 36 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 5
// Ultra Low speed
#define SERIAL_DELAY 48 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#else
#error invalid SELECT_SOFT_SERIAL_SPEED value
#endif /* SELECT_SOFT_SERIAL_SPEED */
#endif /* SERIAL_DELAY */
#define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2)
#define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2)
#define SLAVE_INT_WIDTH_US 1
#ifndef SERIAL_USE_MULTI_TRANSACTION
#define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY
#else
#define SLAVE_INT_ACK_WIDTH_UNIT 2
#define SLAVE_INT_ACK_WIDTH 4
#endif
static SSTD_t *Transaction_table = NULL;
static uint8_t Transaction_table_size = 0;
inline static void serial_delay(void) ALWAYS_INLINE;
inline static
void serial_delay(void) {
_delay_us(SERIAL_DELAY);
}
inline static void serial_delay_half1(void) ALWAYS_INLINE;
inline static
void serial_delay_half1(void) {
_delay_us(SERIAL_DELAY_HALF1);
}
inline static void serial_delay_half2(void) ALWAYS_INLINE;
inline static
void serial_delay_half2(void) {
_delay_us(SERIAL_DELAY_HALF2);
}
inline static void serial_output(void) ALWAYS_INLINE;
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_with_pullup(void) ALWAYS_INLINE;
inline static
void serial_input_with_pullup(void) {
SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK;
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
inline static uint8_t serial_read_pin(void) ALWAYS_INLINE;
inline static
uint8_t serial_read_pin(void) {
return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
}
inline static void serial_low(void) ALWAYS_INLINE;
inline static
void serial_low(void) {
SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
}
inline static void serial_high(void) ALWAYS_INLINE;
inline static
void serial_high(void) {
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size)
{
Transaction_table = sstd_table;
Transaction_table_size = (uint8_t)sstd_table_size;
serial_output();
serial_high();
}
void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size)
{
Transaction_table = sstd_table;
Transaction_table_size = (uint8_t)sstd_table_size;
serial_input_with_pullup();
// Enable INT0-INT3,INT6
EIMSK |= EIMSK_BIT;
#if SERIAL_PIN_MASK == _BV(PE6)
// Trigger on falling edge of INT6
EICRB &= EICRx_BIT;
#else
// Trigger on falling edge of INT0-INT3
EICRA &= EICRx_BIT;
#endif
}
// Used by the sender to synchronize timing with the reciver.
static void sync_recv(void) NO_INLINE;
static
void sync_recv(void) {
for (uint8_t i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) {
}
// This shouldn't hang if the target disconnects because the
// serial line will float to high if the target does disconnect.
while (!serial_read_pin());
}
// Used by the reciver to send a synchronization signal to the sender.
static void sync_send(void) NO_INLINE;
static
void sync_send(void) {
serial_low();
serial_delay();
serial_high();
}
// Reads a byte from the serial line
static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) NO_INLINE;
static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) {
uint8_t byte, i, p, pb;
_delay_sub_us(READ_WRITE_START_ADJUST);
for( i = 0, byte = 0, p = PARITY; i < bit; i++ ) {
serial_delay_half1(); // read the middle of pulses
if( serial_read_pin() ) {
byte = (byte << 1) | 1; p ^= 1;
} else {
byte = (byte << 1) | 0; p ^= 0;
}
_delay_sub_us(READ_WRITE_WIDTH_ADJUST);
serial_delay_half2();
}
/* recive parity bit */
serial_delay_half1(); // read the middle of pulses
pb = serial_read_pin();
_delay_sub_us(READ_WRITE_WIDTH_ADJUST);
serial_delay_half2();
*pterrcount += (p != pb)? 1 : 0;
return byte;
}
// Sends a byte with MSB ordering
void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE;
void serial_write_chunk(uint8_t data, uint8_t bit) {
uint8_t b, p;
for( p = PARITY, b = 1<<(bit-1); b ; b >>= 1) {
if(data & b) {
serial_high(); p ^= 1;
} else {
serial_low(); p ^= 0;
}
serial_delay();
}
/* send parity bit */
if(p & 1) { serial_high(); }
else { serial_low(); }
serial_delay();
serial_low(); // sync_send() / senc_recv() need raise edge
}
static void serial_send_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
static
void serial_send_packet(uint8_t *buffer, uint8_t size) {
for (uint8_t i = 0; i < size; ++i) {
uint8_t data;
data = buffer[i];
sync_send();
serial_write_chunk(data,8);
}
}
static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
static
uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) {
uint8_t pecount = 0;
for (uint8_t i = 0; i < size; ++i) {
uint8_t data;
sync_recv();
data = serial_read_chunk(&pecount, 8);
buffer[i] = data;
}
return pecount == 0;
}
inline static
void change_sender2reciver(void) {
sync_send(); //0
serial_delay_half1(); //1
serial_low(); //2
serial_input_with_pullup(); //2
serial_delay_half1(); //3
}
inline static
void change_reciver2sender(void) {
sync_recv(); //0
serial_delay(); //1
serial_low(); //3
serial_output(); //3
serial_delay_half1(); //4
}
static inline uint8_t nibble_bits_count(uint8_t bits)
{
bits = (bits & 0x5) + (bits >> 1 & 0x5);
bits = (bits & 0x3) + (bits >> 2 & 0x3);
return bits;
}
// interrupt handle to be used by the target device
ISR(SERIAL_PIN_INTERRUPT) {
#ifndef SERIAL_USE_MULTI_TRANSACTION
serial_low();
serial_output();
SSTD_t *trans = Transaction_table;
#else
// recive transaction table index
uint8_t tid, bits;
uint8_t pecount = 0;
sync_recv();
bits = serial_read_chunk(&pecount,7);
tid = bits>>3;
bits = (bits&7) != nibble_bits_count(tid);
if( bits || pecount> 0 || tid > Transaction_table_size ) {
return;
}
serial_delay_half1();
serial_high(); // response step1 low->high
serial_output();
_delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT*SLAVE_INT_ACK_WIDTH);
SSTD_t *trans = &Transaction_table[tid];
serial_low(); // response step2 ack high->low
#endif
// target send phase
if( trans->target2initiator_buffer_size > 0 )
serial_send_packet((uint8_t *)trans->target2initiator_buffer,
trans->target2initiator_buffer_size);
// target switch to input
change_sender2reciver();
// target recive phase
if( trans->initiator2target_buffer_size > 0 ) {
if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer,
trans->initiator2target_buffer_size) ) {
*trans->status = TRANSACTION_ACCEPTED;
} else {
*trans->status = TRANSACTION_DATA_ERROR;
}
} else {
*trans->status = TRANSACTION_ACCEPTED;
}
sync_recv(); //weit initiator output to high
}
/////////
// start transaction by initiator
//
// int soft_serial_transaction(int sstd_index)
//
// Returns:
// TRANSACTION_END
// TRANSACTION_NO_RESPONSE
// TRANSACTION_DATA_ERROR
// this code is very time dependent, so we need to disable interrupts
#ifndef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_transaction(void) {
SSTD_t *trans = Transaction_table;
#else
int soft_serial_transaction(int sstd_index) {
if( sstd_index > Transaction_table_size )
return TRANSACTION_TYPE_ERROR;
SSTD_t *trans = &Transaction_table[sstd_index];
#endif
cli();
// signal to the target that we want to start a transaction
serial_output();
serial_low();
_delay_us(SLAVE_INT_WIDTH_US);
#ifndef SERIAL_USE_MULTI_TRANSACTION
// wait for the target response
serial_input_with_pullup();
_delay_us(SLAVE_INT_RESPONSE_TIME);
// check if the target is present
if (serial_read_pin()) {
// target failed to pull the line low, assume not present
serial_output();
serial_high();
*trans->status = TRANSACTION_NO_RESPONSE;
sei();
return TRANSACTION_NO_RESPONSE;
}
#else
// send transaction table index
int tid = (sstd_index<<3) | (7 & nibble_bits_count(sstd_index));
sync_send();
_delay_sub_us(TID_SEND_ADJUST);
serial_write_chunk(tid, 7);
serial_delay_half1();
// wait for the target response (step1 low->high)
serial_input_with_pullup();
while( !serial_read_pin() ) {
_delay_sub_us(2);
}
// check if the target is present (step2 high->low)
for( int i = 0; serial_read_pin(); i++ ) {
if (i > SLAVE_INT_ACK_WIDTH + 1) {
// slave failed to pull the line low, assume not present
serial_output();
serial_high();
*trans->status = TRANSACTION_NO_RESPONSE;
sei();
return TRANSACTION_NO_RESPONSE;
}
_delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT);
}
#endif
// initiator recive phase
// if the target is present syncronize with it
if( trans->target2initiator_buffer_size > 0 ) {
if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer,
trans->target2initiator_buffer_size) ) {
serial_output();
serial_high();
*trans->status = TRANSACTION_DATA_ERROR;
sei();
return TRANSACTION_DATA_ERROR;
}
}
// initiator switch to output
change_reciver2sender();
// initiator send phase
if( trans->initiator2target_buffer_size > 0 ) {
serial_send_packet((uint8_t *)trans->initiator2target_buffer,
trans->initiator2target_buffer_size);
}
// always, release the line when not in use
sync_send();
*trans->status = TRANSACTION_END;
sei();
return TRANSACTION_END;
}
#ifdef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_get_and_clean_status(int sstd_index) {
SSTD_t *trans = &Transaction_table[sstd_index];
cli();
int retval = *trans->status;
*trans->status = 0;;
sei();
return retval;
}
#endif
#endif
// Helix serial.c history
// 2018-1-29 fork from let's split and add PD2, modify sync_recv() (#2308, bceffdefc)
// 2018-6-28 bug fix master to slave comm and speed up (#3255, 1038bbef4)
// (adjusted with avr-gcc 4.9.2)
// 2018-7-13 remove USE_SERIAL_PD2 macro (#3374, f30d6dd78)
// (adjusted with avr-gcc 4.9.2)
// 2018-8-11 add support multi-type transaction (#3608, feb5e4aae)
// (adjusted with avr-gcc 4.9.2)
// 2018-10-21 fix serial and RGB animation conflict (#4191, 4665e4fff)
// (adjusted with avr-gcc 7.3.0)
// 2018-10-28 re-adjust compiler depend value of delay (#4269, 8517f8a66)
// (adjusted with avr-gcc 5.4.0, 7.3.0)

86
keyboards/naked48/serial.h
View File

@ -1,86 +0,0 @@
#pragma once
#include <stdbool.h>
// /////////////////////////////////////////////////////////////////
// Need Soft Serial defines in config.h
// /////////////////////////////////////////////////////////////////
// ex.
// #define SOFT_SERIAL_PIN ?? // ?? = D0,D1,D2,D3,E6
// OPTIONAL: #define SELECT_SOFT_SERIAL_SPEED ? // ? = 1,2,3,4,5
// // 1: about 137kbps (default)
// // 2: about 75kbps
// // 3: about 39kbps
// // 4: about 26kbps
// // 5: about 20kbps
//
// //// USE OLD API (compatible with let's split serial.c)
// ex.
// #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
// #define SERIAL_MASTER_BUFFER_LENGTH 1
//
// //// USE NEW API
// //// USE simple API (using signle-type transaction function)
// #define SERIAL_USE_SINGLE_TRANSACTION
// //// USE flexible API (using multi-type transaction function)
// #define SERIAL_USE_MULTI_TRANSACTION
//
// /////////////////////////////////////////////////////////////////
//////////////// for backward compatibility ////////////////////////////////
#if !defined(SERIAL_USE_SINGLE_TRANSACTION) && !defined(SERIAL_USE_MULTI_TRANSACTION)
/* --- USE OLD API (compatible with let's split serial.c) */
#if SERIAL_SLAVE_BUFFER_LENGTH > 0
extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
#endif
#if SERIAL_MASTER_BUFFER_LENGTH > 0
extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
#endif
void serial_master_init(void);
void serial_slave_init(void);
int serial_update_buffers(void);
#endif // end of USE OLD API
////////////////////////////////////////////////////////////////////////////
// Soft Serial Transaction Descriptor
typedef struct _SSTD_t {
uint8_t *status;
uint8_t initiator2target_buffer_size;
uint8_t *initiator2target_buffer;
uint8_t target2initiator_buffer_size;
uint8_t *target2initiator_buffer;
} SSTD_t;
#define TID_LIMIT( table ) (sizeof(table) / sizeof(SSTD_t))
// initiator is transaction start side
void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size);
// target is interrupt accept side
void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size);
// initiator resullt
#define TRANSACTION_END 0
#define TRANSACTION_NO_RESPONSE 0x1
#define TRANSACTION_DATA_ERROR 0x2
#define TRANSACTION_TYPE_ERROR 0x4
#ifndef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_transaction(void);
#else
int soft_serial_transaction(int sstd_index);
#endif
// target status
// *SSTD_t.status has
// initiator:
// TRANSACTION_END
// or TRANSACTION_NO_RESPONSE
// or TRANSACTION_DATA_ERROR
// target:
// TRANSACTION_DATA_ERROR
// or TRANSACTION_ACCEPTED
#define TRANSACTION_ACCEPTED 0x8
#ifdef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_get_and_clean_status(int sstd_index);
#endif