New v.0.3を新規追加

This commit is contained in:
Takeshi Nishio 2020-09-18 05:34:44 +09:00
parent 31d043fef2
commit b65b4afa31
9 changed files with 1272 additions and 3 deletions

3
.gitmodules vendored
View File

@ -16,9 +16,6 @@
[submodule "lib/lufa"] [submodule "lib/lufa"]
path = lib/lufa path = lib/lufa
url = https://github.com/qmk/lufa url = https://github.com/qmk/lufa
[submodule "lib/vusb"]
path = lib/vusb
url = https://github.com/qmk/v-usb
[submodule "lib/printf"] [submodule "lib/printf"]
path = lib/printf path = lib/printf
url = https://github.com/qmk/printf url = https://github.com/qmk/printf

View File

@ -0,0 +1,261 @@
/*
Copyright 2020 Takeshi Nishio
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define VENDOR_ID 0xFEED
#define PRODUCT_ID 0x175A
#define DEVICE_VER 0x0003
#define MANUFACTURER jpskenn
#define PRODUCT Jones
#define DESCRIPTION Jones is a Row-staggered 60% keyboard with gapless R2-R3 row. GH60 case compatible PCB and keyplate.
/* key matrix size */
#define MATRIX_ROWS 11
#define MATRIX_COLS 11
/*
* Keyboard Matrix Assignments
*
* Change this to how you wired your keyboard
* COLS: AVR pins used for columns, left to right
* ROWS: AVR pins used for rows, top to bottom
* DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
*
*/
#define MATRIX_ROW_PINS { D4, D7, C7, F1, F4, F5, D6, D5, E6, B0, B1 }
#define MATRIX_COL_PINS { D4, D7, C7, F1, F4, F5, D6, D5, E6, B0, B1 }
#define UNUSED_PINS
/* COL2ROW, ROW2COL*/
// We're using custom matrix file. So, no need to define DIODE_DIRECTION.
//#define DIODE_DIRECTION COL2ROW
/* Rotary Encoder */
#define ENCODERS_PAD_A { F6, B2 }
#define ENCODERS_PAD_B { F7, B3 }
#define ENCODER_RESOLUTION 4 //the default & suggested is 4
/*
* Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN.
*/
//#define SOFT_SERIAL_PIN D0 // or D1, D2, D3, E6
// #define BACKLIGHT_PIN B7
// #define BACKLIGHT_BREATHING
// #define BACKLIGHT_LEVELS 3
#define RGB_DI_PIN B7
#ifdef RGB_DI_PIN
#define RGBLED_NUM 2
#define RGBLIGHT_HUE_STEP 8
#define RGBLIGHT_SAT_STEP 8
#define RGBLIGHT_VAL_STEP 8
#define RGBLIGHT_LIMIT_VAL 40 /* The maximum brightness level */
// #define RGBLIGHT_SLEEP /* If defined, the RGB lighting will be switched off when the host goes to sleep */
/*== Lighting Layers ==*/
#define RGBLIGHT_LAYERS
// #define RGBLIGHT_MAX_LAYERS 2
#define RGBLIGHT_LAYERS_OVERRIDE_RGB_OFF // Overriding RGB Lighting on/off status
/*== all animations enable ==*/
// #define RGBLIGHT_ANIMATIONS
/*== or choose animations ==*/
// #define RGBLIGHT_EFFECT_BREATHING
// #define RGBLIGHT_EFFECT_RAINBOW_MOOD
// #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
// #define RGBLIGHT_EFFECT_SNAKE
// #define RGBLIGHT_EFFECT_KNIGHT
// #define RGBLIGHT_EFFECT_CHRISTMAS
// #define RGBLIGHT_EFFECT_STATIC_GRADIENT
// #define RGBLIGHT_EFFECT_RGB_TEST
// #define RGBLIGHT_EFFECT_ALTERNATING
// /*== customize breathing effect ==*/
// /*==== (DEFAULT) use fixed table instead of exp() and sin() ====*/
// #define RGBLIGHT_BREATHE_TABLE_SIZE 256 // 256(default) or 128 or 64
// /*==== use exp() and sin() ====*/
// #define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85 // 1 to 2.7
// #define RGBLIGHT_EFFECT_BREATHE_MAX 255 // 0 to 255
#endif
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5
/* define if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE
/* Locking resynchronize hack */
#define LOCKING_RESYNC_ENABLE
/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
* This is userful for the Windows task manager shortcut (ctrl+shift+esc).
*/
// #define GRAVE_ESC_CTRL_OVERRIDE
/*
* Force NKRO
*
* Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
* state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
* makefile for this to work.)
*
* If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
* until the next keyboard reset.
*
* NKRO may prevent your keystrokes from being detected in the BIOS, but it is
* fully operational during normal computer usage.
*
* For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
* or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
* bootmagic, NKRO mode will always be enabled until it is toggled again during a
* power-up.
*
*/
//#define FORCE_NKRO
/*
* Magic Key Options
*
* Magic keys are hotkey commands that allow control over firmware functions of
* the keyboard. They are best used in combination with the HID Listen program,
* found here: https://www.pjrc.com/teensy/hid_listen.html
*
* The options below allow the magic key functionality to be changed. This is
* useful if your keyboard/keypad is missing keys and you want magic key support.
*
*/
/* key combination for magic key command */
/* defined by default; to change, uncomment and set to the combination you want */
// #define IS_COMMAND() (get_mods() == MOD_MASK_SHIFT)
/* control how magic key switches layers */
//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS true
//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS true
//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
/* override magic key keymap */
//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
//#define MAGIC_KEY_HELP H
//#define MAGIC_KEY_HELP_ALT SLASH
//#define MAGIC_KEY_DEBUG D
//#define MAGIC_KEY_DEBUG_MATRIX X
//#define MAGIC_KEY_DEBUG_KBD K
//#define MAGIC_KEY_DEBUG_MOUSE M
//#define MAGIC_KEY_VERSION V
//#define MAGIC_KEY_STATUS S
//#define MAGIC_KEY_CONSOLE C
//#define MAGIC_KEY_LAYER0 0
//#define MAGIC_KEY_LAYER0_ALT GRAVE
//#define MAGIC_KEY_LAYER1 1
//#define MAGIC_KEY_LAYER2 2
//#define MAGIC_KEY_LAYER3 3
//#define MAGIC_KEY_LAYER4 4
//#define MAGIC_KEY_LAYER5 5
//#define MAGIC_KEY_LAYER6 6
//#define MAGIC_KEY_LAYER7 7
//#define MAGIC_KEY_LAYER8 8
//#define MAGIC_KEY_LAYER9 9
//#define MAGIC_KEY_BOOTLOADER B
//#define MAGIC_KEY_BOOTLOADER_ALT ESC
//#define MAGIC_KEY_LOCK CAPS
//#define MAGIC_KEY_EEPROM E
//#define MAGIC_KEY_EEPROM_CLEAR BSPACE
//#define MAGIC_KEY_NKRO N
//#define MAGIC_KEY_SLEEP_LED Z
/*
* Feature disable options
* These options are also useful to firmware size reduction.
*/
/* disable debug print */
//#define NO_DEBUG
/* disable print */
//#define NO_PRINT
/* disable action features */
//#define NO_ACTION_LAYER
//#define NO_ACTION_TAPPING
//#define NO_ACTION_ONESHOT
/* disable these deprecated features by default */
#define NO_ACTION_MACRO
#define NO_ACTION_FUNCTION
/*
* MIDI options
*/
/* Prevent use of disabled MIDI features in the keymap */
//#define MIDI_ENABLE_STRICT 1
/* enable basic MIDI features:
- MIDI notes can be sent when in Music mode is on
*/
//#define MIDI_BASIC
/* enable advanced MIDI features:
- MIDI notes can be added to the keymap
- Octave shift and transpose
- Virtual sustain, portamento, and modulation wheel
- etc.
*/
//#define MIDI_ADVANCED
/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
//#define MIDI_TONE_KEYCODE_OCTAVES 1
/*
* HD44780 LCD Display Configuration
*/
/*
#define LCD_LINES 2 //< number of visible lines of the display
#define LCD_DISP_LENGTH 16 //< visibles characters per line of the display
#define LCD_IO_MODE 1 //< 0: memory mapped mode, 1: IO port mode
#if LCD_IO_MODE
#define LCD_PORT PORTB //< port for the LCD lines
#define LCD_DATA0_PORT LCD_PORT //< port for 4bit data bit 0
#define LCD_DATA1_PORT LCD_PORT //< port for 4bit data bit 1
#define LCD_DATA2_PORT LCD_PORT //< port for 4bit data bit 2
#define LCD_DATA3_PORT LCD_PORT //< port for 4bit data bit 3
#define LCD_DATA0_PIN 4 //< pin for 4bit data bit 0
#define LCD_DATA1_PIN 5 //< pin for 4bit data bit 1
#define LCD_DATA2_PIN 6 //< pin for 4bit data bit 2
#define LCD_DATA3_PIN 7 //< pin for 4bit data bit 3
#define LCD_RS_PORT LCD_PORT //< port for RS line
#define LCD_RS_PIN 3 //< pin for RS line
#define LCD_RW_PORT LCD_PORT //< port for RW line
#define LCD_RW_PIN 2 //< pin for RW line
#define LCD_E_PORT LCD_PORT //< port for Enable line
#define LCD_E_PIN 1 //< pin for Enable line
#endif
*/
/* Bootmagic Lite key configuration */
// #define BOOTMAGIC_LITE_ROW 0
// #define BOOTMAGIC_LITE_COLUMN 0

View File

@ -0,0 +1,23 @@
/* Copyright 2020 Takeshi Nishio
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
// place overrides here
#define TAPPING_TOGGLE 2
// time for long press
#define TAPPING_TERM 200

View File

@ -0,0 +1,600 @@
/* Copyright 2020 Takeshi Nishio
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
#ifdef RGBLIGHT_ENABLE
#include "rgblight.h"
extern rgblight_config_t rgblight_config;
#endif
// Defines names for use in layer keycodes and the keymap
enum layer_number {
_MAC = 0,
_WIN,
_NUM,
_LOWER,
_RAISE,
_NUM_RAISE,
_ADJUST
};
// Defines the keycodes used by our macros in process_record_user
enum custom_keycodes {
MAC = SAFE_RANGE,
WIN,
NUM,
LOWER,
RAISE,
NUM_RAISE,
ADJUST,
ALT_US,
ALT_JP,
MAC_IME,
WIN_IME,
A_IME_M,
A_IME_W,
DBG_LAY,
};
// Tap Dance
enum tap_dances{
TD_GRV_ESC = 0 ,
TD_Y_LBRC,
TD_LSFT_CAPS,
TD_LBRC_RBRC,
TD_ESC_NUM,
TD_MINS_MAC_IME,
TD_MINS_WIN_IME,
TD_SCLN_MINS,
};
// Tap Dance state
// for toggle layer by ESC
enum {
SINGLE_TAP = 1,
DOUBLE_TAP,
TRIPLE_TAP,
TAP_HOLD,
};
// Declare the functions to be used with your tap dance key(s)
// Function associated with all tap dances
uint8_t cur_dance(qk_tap_dance_state_t *state);
// Functions associated with individual tap dances
void ql_finished(qk_tap_dance_state_t *state, void *user_data);
void ql_reset(qk_tap_dance_state_t *state, void *user_data);
void ql_each(qk_tap_dance_state_t *state, void *user_data);
// Tap Dance definitions
qk_tap_dance_action_t tap_dance_actions[] = {
[TD_Y_LBRC] = ACTION_TAP_DANCE_DOUBLE(KC_Y, KC_LBRC),
[TD_LSFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS),
[TD_LBRC_RBRC] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_RBRC),
[TD_ESC_NUM] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 275),
[TD_MINS_MAC_IME] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 275),
[TD_MINS_WIN_IME] = ACTION_TAP_DANCE_DOUBLE(KC_MINS, WIN_IME),
[TD_SCLN_MINS] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 500),
};
#define ESC_NUM TD(TD_ESC_NUM)
#define Y_LBRC TD(TD_Y_LBRC)
#define S_CAP TD(TD_LSFT_CAPS)
#define L_R_BRC TD(TD_LBRC_RBRC)
#define M_M_IME TD(TD_MINS_MAC_IME)
#define M_W_IME TD(TD_MINS_WIN_IME)
#define SCLN_M TD(TD_SCLN_MINS)
#define SP_LOW LT(_LOWER, KC_SPC)
#define SP_RAI LT(_RAISE, KC_SPC)
#define SP_NRAI LT(_NUM_RAISE, KC_SPC)
#define SP_ADJ LT(_ADJUST, KC_SPC)
#define SP_GUI MT(MOD_LGUI, KC_SPC)
#define SP_SFT MT(MOD_LSFT, KC_SPC)
#define S_SLS RSFT_T(KC_SLSH)
#define C_SCLN RCTL_T(KC_SCLN)
#define C_QUOT RCTL_T(KC_QUOT)
#define C_MINS RCTL_T(KC_MINS)
#define C_SLSH RCTL_T(KC_SLSH)
#define CT_E LCTL(KC_E)
#define CT_A LCTL(KC_A)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_MAC] = LAYOUT(
ESC_NUM,KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSLS,KC_GRV, \
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_LBRC,KC_RBRC, \
KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, SCLN_M, KC_ENT, XXXXXXX,KC_QUOT, \
S_CAP, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, C_SLSH, KC_RSFT,KC_UP, LOWER, \
KC_MUTE,XXXXXXX,KC_LALT,KC_LGUI, SP_SFT, SP_RAI, KC_RGUI,A_IME_M,XXXXXXX,KC_LEFT,KC_DOWN,KC_RGHT \
),
[_WIN] = LAYOUT(
_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______, \
_______, _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______, _______,_______, \
_______, _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______, _______,_______, \
_______, _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______, \
_______,_______,KC_LGUI,KC_LALT, _______, _______, A_IME_W,KC_APP, _______,_______,_______,_______ \
),
[_NUM] = LAYOUT(
_______,_______,_______,_______,_______,_______,_______,XXXXXXX,KC_PSLS,KC_PSLS,KC_PAST,_______,_______,_______,_______, \
_______, _______,_______,_______,_______,_______,_______,KC_P7, KC_P8, KC_P9, KC_PPLS,_______, _______,_______, \
_______, _______,_______,_______,_______,_______,_______,KC_P4, KC_P5, KC_P6, XXXXXXX, _______, _______,_______, \
_______, _______,_______,_______,_______,_______,_______,KC_P1, KC_P2, KC_P3, KC_PENT,_______,_______,_______, \
_______,_______,_______,_______, _______, SP_NRAI, KC_P0, KC_PDOT,_______,_______,_______,_______ \
),
[_LOWER] = LAYOUT(
KC_PAUS,KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_INS, KC_DEL, \
KC_PSCR, _______,_______,_______,_______,_______,_______,_______,_______,_______,KC_HOME,KC_UP, KC_END, KC_VOLU, \
_______, _______,_______,_______,_______,_______,_______,_______,_______,KC_PGUP,KC_LEFT,KC_RGHT, _______,KC_VOLD, \
_______, _______,_______,_______,_______,_______,_______,_______,_______,KC_PGDN,KC_DOWN,_______,KC_PGUP,_______, \
ADJUST, _______,_______,_______, _______, ADJUST, _______,_______,_______,KC_HOME,KC_PGDN,KC_END \
),
[_RAISE] = LAYOUT(
KC_PAUS,KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_INS, KC_DEL, \
KC_PSCR, _______,_______,CT_E, _______,_______,_______,_______,_______,_______,KC_PGUP,KC_DEL, _______,_______,\
_______, CT_A, _______,KC_DEL, KC_RGHT,KC_ESC, KC_LEFT,KC_DOWN,KC_UP, KC_RGHT,KC_MINS,KC_INS, _______,_______, \
_______, _______,_______,_______,_______,KC_LEFT,KC_PGDN,KC_ENT, _______,KC_MRWD,KC_MFFD,_______,KC_PGUP,ADJUST, \
_______,_______,_______,_______, _______, _______, _______,_______,_______,KC_HOME,KC_PGDN,KC_END \
),
[_NUM_RAISE] = LAYOUT(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSLS,KC_GRV, \
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_LBRC,KC_RBRC, \
KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_ENT, KC_SCLN,KC_QUOT, \
S_CAP, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, S_SLS, KC_RSFT,XXXXXXX,ADJUST, \
_______,_______,_______,_______, _______, ADJUST, _______,_______,_______,_______,_______,_______ \
),
[_ADJUST] = LAYOUT(
_______,RGB_HUI,RGB_SAI,RGB_VAI,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______, \
_______, _______,WIN, _______,RESET, _______,_______,_______,_______,_______,_______,_______, _______,_______, \
_______, _______,_______,_______,_______,_______,_______,_______,RGB_M_P,RGB_TOG,RGB_MOD,_______, _______,_______, \
_______, _______,_______,_______,_______,_______,TG(_NUM),MAC, _______,_______,_______,_______,_______,_______, \
_______,_______,_______,_______, _______, _______, _______,_______,_______,_______,_______,_______ \
)
};
// レイヤーキーを変換・無変換キーと共用する際に動作を改善する。
static bool lower_pressed = false;
static uint16_t lower_pressed_time = 0;
static bool raise_pressed = false;
static uint16_t raise_pressed_time = 0;
static bool alt_ime_pressed = false;
static uint16_t alt_ime_pressed_time = 0;
// デフォルトレイヤー格納用
static uint16_t current_default_layer = 0;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case DBG_LAY:
if (current_default_layer == _MAC) {
SEND_STRING("L-MAC");
} else if (current_default_layer == _WIN) {
SEND_STRING("L-WIN");
} else {
SEND_STRING("L-NO");
}
return false;
break;
case MAC: // Write default layer to EEPROM
if (record->event.pressed) {
set_single_persistent_default_layer(_MAC);
}
return false;
break;
case WIN: // Write default layer to EEPROM
if (record->event.pressed) {
set_single_persistent_default_layer(_WIN);
}
return false;
break;
case LOWER:
if (record->event.pressed) {
lower_pressed = true;
lower_pressed_time = record->event.time;
layer_on(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
// /*
// 長押し時に入力キャンセルする場合
// if (lower_pressed && (TIMER_DIFF_16(record->event.time, lower_pressed_time) < TAPPING_TERM)) {
//
// 長押しキャンセルなしの場合
// if (lower_pressed) {
// */
// if (lower_pressed && (TIMER_DIFF_16(record->event.time, lower_pressed_time) < TAPPING_TERM)) {
// register_code(KC_LANG1); // for macOS
// register_code(KC_HENK);
// unregister_code(KC_HENK);
// unregister_code(KC_LANG1);
// }
lower_pressed = false;
}
return false;
break;
case RAISE:
if (record->event.pressed) {
raise_pressed = true;
raise_pressed_time = record->event.time;
layer_on(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
// /*
// 長押し時に入力キャンセルする場合はこれ
// if (raise_pressed && (TIMER_DIFF_16(record->event.time, raise_pressed_time) < TAPPING_TERM)) {
// */
// if (raise_pressed) {
// register_code(KC_LANG2); // for macOS
// register_code(KC_MHEN);
// unregister_code(KC_MHEN);
// unregister_code(KC_LANG2);
// }
raise_pressed = false;
}
return false;
break;
case ADJUST:
if (record->event.pressed) {
layer_on(_ADJUST);
} else {
layer_off(_ADJUST);
}
return false;
break;
case A_IME_M:
if (record->event.pressed) {
alt_ime_pressed = true;
alt_ime_pressed_time = record->event.time;
register_code(KC_RALT);
} else {
unregister_code(KC_RALT);
/*
if (raise_pressed && (TIMER_DIFF_16(record->event.time, raise_pressed_time) < TAPPING_TERM)) {
*/
// if (alt_ime_pressed) {
if (alt_ime_pressed && (TIMER_DIFF_16(record->event.time, alt_ime_pressed_time) < TAPPING_TERM)) {
register_code(KC_LCTL); // for macOS
register_code(KC_SPC);
unregister_code(KC_SPC);
unregister_code(KC_LCTL);
}
alt_ime_pressed = false;
}
return false;
break;
case A_IME_W:
if (record->event.pressed) {
alt_ime_pressed = true;
alt_ime_pressed_time = record->event.time;
register_code(KC_RALT);
} else {
unregister_code(KC_RALT);
/*
if (raise_pressed && (TIMER_DIFF_16(record->event.time, raise_pressed_time) < TAPPING_TERM)) {
*/
// if (alt_ime_pressed) {
if (alt_ime_pressed && (TIMER_DIFF_16(record->event.time, alt_ime_pressed_time) < TAPPING_TERM)) {
// register_code(KC_LALT);
// register_code(KC_GRV);
// unregister_code(KC_GRV);
// unregister_code(KC_LALT);
SEND_STRING(SS_LALT("`"));
}
alt_ime_pressed = false;
}
return false;
break;
case MAC_IME:
if (record->event.pressed) {
// when pressed
register_code(KC_LCTL);
register_code(KC_SPC);
} else {
// when released
unregister_code(KC_SPC);
unregister_code(KC_LCTL);
}
break;
case WIN_IME:
if (record->event.pressed) {
// when pressed
register_code(KC_LALT);
register_code(KC_GRV);
} else {
// when released
unregister_code(KC_GRV);
unregister_code(KC_LALT);
}
break;
default:
if (record->event.pressed) {
// reset the flags
lower_pressed = false;
raise_pressed = false;
alt_ime_pressed = false;
alt_ime_pressed = false;
}
break;
}
return true;
}
//------------------------------------------------------------------------------
// RGB Light settings
#ifdef RGBLIGHT_LAYERS
// 1st LED
const rgblight_segment_t PROGMEM my_mac_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{0, 1, HSV_WHITE}
);
const rgblight_segment_t PROGMEM my_win_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{0, 1, HSV_BLUE}
);
const rgblight_segment_t PROGMEM my_num_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{0, 1, HSV_YELLOW}
);
// 2nd LED
const rgblight_segment_t PROGMEM my_caps_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{1, 1, HSV_MAGENTA}
);
const rgblight_segment_t PROGMEM my_lower_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{1, 1, HSV_GREEN}
);
const rgblight_segment_t PROGMEM my_raise_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{1, 1, HSV_CYAN}
);
const rgblight_segment_t PROGMEM my_num_raise_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{1, 1, HSV_GOLD}
);
const rgblight_segment_t PROGMEM my_adjust_layer[] = RGBLIGHT_LAYER_SEGMENTS(
{1, 1, HSV_RED}
);
// Define the array of layers. Later layers take precedence
const rgblight_segment_t* const PROGMEM my_rgb_layers[] = RGBLIGHT_LAYERS_LIST(
my_mac_layer,
my_win_layer,
my_num_layer,
my_caps_layer,
my_lower_layer,
my_raise_layer,
my_num_raise_layer,
my_adjust_layer
);
void keyboard_post_init_user(void) {
// Enable the LED layers
rgblight_layers = my_rgb_layers;
}
// Enabling and disabling lighting layers
layer_state_t layer_state_set_user(layer_state_t state) {
rgblight_set_layer_state(2, layer_state_cmp(state, _NUM));
rgblight_set_layer_state(4, layer_state_cmp(state, _LOWER));
rgblight_set_layer_state(5, layer_state_cmp(state, _RAISE));
rgblight_set_layer_state(6, layer_state_cmp(state, _NUM_RAISE));
rgblight_set_layer_state(7, layer_state_cmp(state, _ADJUST));
return state;
}
// Enabling and disabling lighting layers for default layer
layer_state_t default_layer_state_set_user(layer_state_t state) {
rgblight_set_layer_state(0, layer_state_cmp(state, _MAC));
rgblight_set_layer_state(1, layer_state_cmp(state, _WIN));
rgblight_set_layer_state(2, layer_state_cmp(state, _NUM));
if (layer_state_cmp(state, _MAC)) {
current_default_layer = _MAC;
} else if (layer_state_cmp(state, _WIN)) {
current_default_layer = _WIN;
}
return state;
}
bool led_update_user(led_t led_state) {
rgblight_set_layer_state(3, led_state.caps_lock);
return true;
}
#endif
//------------------------------------------------------------------------------
// TEST LEDs
// void keyboard_post_init_user(void) {
// rgblight_enable_noeeprom();
// rgblight_mode_noeeprom(RGBLIGHT_MODE_RGB_TEST);
// }
//------------------------------------------------------------------------------
// Rotary Encoder
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) { /* First encoder, Right side */
if (clockwise) {
tap_code(KC_VOLD);
} else {
tap_code(KC_VOLU);
}
}
if (index == 1) { /* Second encoder, Left side */
if (clockwise) {
tap_code(KC_VOLD);
} else {
tap_code(KC_VOLU);
}
}
}
//------------------------------------------------------------------------------
// Tap Dance function
// ESCキーの動作を、次のようにする設定
// シングルタップESC
// シングルタップしてホールドNUMレイヤー
// トリプルタップNumレイヤーをトグル
// NOTE:ESCを連打タブルタップして、Numレイヤーになるのを防止するためトリプルに。
typedef struct {
bool is_press_action;
uint8_t state;
} tap;
// Determine the current tap dance state
uint8_t cur_dance(qk_tap_dance_state_t *state) {
if (state->count == 1) {
if (!state->pressed) return SINGLE_TAP;
else return TAP_HOLD;
} else if (state->count == 2) {
if (!state->pressed) return DOUBLE_TAP;
else return TAP_HOLD;
} else if (state->count == 3) return TRIPLE_TAP;
else return 8; // Magic number. At some point this method will expand to work for more presses
}
// Initialize tap structure associated with example tap dance key
static tap ql_tap_state = {
.is_press_action = true,
.state = 0
};
// Functions that control what our tap dance key does
void ql_each(qk_tap_dance_state_t *state, void *user_data) {
}
void ql_finished(qk_tap_dance_state_t *state, void *user_data) {
ql_tap_state.state = cur_dance(state);
switch(state->keycode) {
case TD(TD_ESC_NUM):
switch (ql_tap_state.state) {
case SINGLE_TAP:
case DOUBLE_TAP:
tap_code(KC_ESC);
break;
case TAP_HOLD:
layer_on(_NUM);
break;
case TRIPLE_TAP:
// Check to see if the layer is already set
if (layer_state_is(_NUM)) {
// If already set, then switch it off
layer_off(_NUM);
} else {
// If not already set, then switch the layer on
layer_on(_NUM);
}
break;
}
break;
case TD(TD_MINS_MAC_IME):
switch (ql_tap_state.state) {
case SINGLE_TAP:
case TAP_HOLD:
register_code(KC_MINS);
break;
case DOUBLE_TAP:
//TODO デフォルトレイヤーが何かを読み取り、MAC or WINで処理を変える
register_code(KC_LCTL);
register_code(KC_SPC);
break;
}
break;
case TD(TD_SCLN_MINS):
switch (ql_tap_state.state) {
case SINGLE_TAP:
case TAP_HOLD:
register_code(KC_SCLN);
break;
case DOUBLE_TAP:
register_code(KC_MINS);
break;
}
break;
}
}
void ql_reset(qk_tap_dance_state_t *state, void *user_data) {
switch(state->keycode) {
case TD(TD_ESC_NUM):
// If the key was held down and now is released then switch off the layer
if (ql_tap_state.state == TAP_HOLD) {
layer_off(_NUM);
}
ql_tap_state.state = 0;
break;
case TD(TD_MINS_MAC_IME):
switch (ql_tap_state.state) {
case SINGLE_TAP:
case TAP_HOLD:
unregister_code(KC_MINS);
break;
case DOUBLE_TAP:
//TODO デフォルトレイヤーが何かを読み取り、MAC or WINで処理を変える
unregister_code(KC_LCTL);
unregister_code(KC_SPC);
break;
}
break;
case TD(TD_SCLN_MINS):
switch (ql_tap_state.state) {
case SINGLE_TAP:
case TAP_HOLD:
unregister_code(KC_SCLN);
break;
case DOUBLE_TAP:
unregister_code(KC_MINS);
break;
}
break;
}
}
//------------------------------------------------------------------------------
/*
void matrix_init_user(void) {
}
void matrix_scan_user(void) {
}
bool led_update_user(led_t led_state) {
return true;
}
*/

View File

@ -0,0 +1 @@
# The narrow keymap for jones

View File

@ -0,0 +1,236 @@
/*
Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include "util.h"
#include "matrix.h"
#include "debounce.h"
#include "quantum.h"
#include "wait.h"
#include "print.h"
#include "debug.h"
#if (MATRIX_COLS <= 8)
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
#ifdef MATRIX_MASKED
extern const matrix_row_t matrix_mask[];
#endif
static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
/* matrix state(1:on, 0:off) */
static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values
static matrix_row_t matrix[MATRIX_ROWS]; // debounced values
// user functions?
__attribute__ ((weak))
void matrix_init_quantum(void) {
matrix_init_kb();
}
__attribute__ ((weak))
void matrix_scan_quantum(void) {
matrix_scan_kb();
}
__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;
}
//Deprecated.
bool matrix_is_modified(void)
{
if (debounce_active()) 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)
{
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
return matrix[row] & matrix_mask[row];
#else
return matrix[row];
#endif
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
phex(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
}
// user-defined overridable functions
__attribute__((weak)) void matrix_slave_scan_user(void) {}
// matrix code
static void select_row(uint8_t row) {
setPinOutput(row_pins[row]);
writePinLow(row_pins[row]);
}
static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
setPinInputHigh(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
setPinInputHigh(col_pins[x]);
}
}
//TODO
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
// Clear data in matrix row
current_matrix[current_row] = 0;
// Select row and wait for row selecton to stabilize
select_row(current_row);
// matrix_io_delay();
wait_us(30);
uint8_t col_in_matrix_index = 0;
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// // Select the col pin to read (active low)
// uint8_t pin_state = readPin(col_pins[col_index]);
//
// // Populate the matrix row with the state of the col pin
// current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
// rowと同じインデックスのcol同じピンは読まない
if (col_index != current_row) {
// Check col pin pin_state
if (readPin(col_pins[col_index]) == 0) {
// Pin LO, set col bit
current_matrix[current_row] |= (ROW_SHIFTER << col_in_matrix_index);
} else {
// Pin HI, clear col bit
current_matrix[current_row] &= ~(ROW_SHIFTER << col_in_matrix_index);
}
}
col_in_matrix_index++;
}
// Unselect row
unselect_row(current_row);
return (last_row_value != current_matrix[current_row]);
}
void matrix_init(void) {
// initialize key pins
init_pins();
// initialize matrix state: all keys off
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
raw_matrix[i] = 0;
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
matrix_init_quantum();
}
uint8_t matrix_scan(void) {
bool changed = false;
// Set row, read cols
for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
changed |= read_cols_on_row(raw_matrix, current_row);
}
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
matrix_scan_quantum();
return (uint8_t)changed;
}

View File

@ -0,0 +1,38 @@
# MCU name
MCU = atmega32u4
# Bootloader selection
# Teensy halfkay
# Pro Micro caterina
# Atmel DFU atmel-dfu
# LUFA DFU lufa-dfu
# QMK DFU qmk-dfu
# ATmega32A bootloadHID
# ATmega328P USBasp
BOOTLOADER = atmel-dfu
# Build Options
# change yes to no to disable
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = no # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
NKRO_ENABLE = no # USB Nkey Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = yes # Enable keyboard RGB underglow
MIDI_ENABLE = no # MIDI support
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
AUDIO_ENABLE = no # Audio output
FAUXCLICKY_ENABLE = no # Use buzzer to emulate clicky switches
HD44780_ENABLE = no # Enable support for HD44780 based LCDs
ENCODER_ENABLE = yes # Rotary Encoder
TAP_DANCE_ENABLE = yes # Tap Dance
CUSTOM_MATRIX = yes
SRC += matrix.c

View File

@ -0,0 +1,50 @@
/* Copyright 2020 Takeshi Nishio
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "v.0.3.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.
/*
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
matrix_init_user();
}
void matrix_scan_kb(void) {
// put your looping keyboard code here
// runs every cycle (a lot)
matrix_scan_user();
}
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here
// runs for every action, just before processing by the firmware
return process_record_user(keycode, record);
}
bool led_update_kb(led_t led_state) {
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
return led_update_user(led_state);
}
*/

View File

@ -0,0 +1,63 @@
/* Copyright 2020 Takeshi Nishio
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
/* This is a shortcut to help you visually see your layout.
*
* The first section contains all of the arguments representing the physical
* layout of the board and position of the keys.
*
* The second converts the arguments into a two-dimensional array which
* represents the switch matrix.
*/
#define LAYOUT( \
k17, k27, k37, k47, k57, k67, k76, k86, k96, ka6, kb6, k81, k91, ka1, kb1, \
k18, k38, k48, k58, k68, k78, k87, k97, ka7, kb7, k82, k92, ka2, kb2, \
k19, k39, k49, k59, k69, k79, k89, k98, ka8, kb8, k83, k93, ka3, kb3, \
k1a, k3a, k4a, k5a, k6a, k7a, k8a, k9a, ka9, kb9, k84, k94, ka4, kb4, \
k1b, k2b, k3b, k4b, k6b, k8b, k9b, kab, k85, k95, ka5, kb5 \
) \
{ \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, k81, k91, ka1, kb1 }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, k82, k92, ka2, kb2 }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, k83, k93, ka3, kb3 }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, k84, k94, ka4, kb4 }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, k85, k95, ka5, kb5 }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, k86, k96, ka6, kb6 }, \
{ k17, k27, k37, k47, k57, k67, KC_NO, k87, k97, ka7, kb7 }, \
{ k18, KC_NO, k38, k48, k58, k68, k78, KC_NO, k98, ka8, kb8 }, \
{ k19, KC_NO, k39, k49, k59, k69, k79, k89, KC_NO, ka9, kb9 }, \
{ k1a, KC_NO, k3a, k4a, k5a, k6a, k7a, k8a, k9a, KC_NO, KC_NO }, \
{ k1b, k2b, k3b, k4b, KC_NO, k6b, KC_NO, k8b, k9b, kab, KC_NO } \
}
/* FULL 11x11 ROUND-ROBIN MATRIX
{ KC_NO, k21, k31, k41, k51, k61, k71, k81, k91, ka1, kb1 }, \
{ k12, KC_NO, k32, k42, k52, k62, k72, k82, k92, ka2, kb2 }, \
{ k13, k23, KC_NO, k43, k53, k63, k73, k83, k93, ka3, kb3 }, \
{ k14, k24, k34, KC_NO, k54, k64, k74, k84, k94, ka4, kb4 }, \
{ k15, k25, k35, k45, KC_NO, k65, k75, k85, k95, ka5, kb5 }, \
{ k16, k26, k36, k46, k56, KC_NO, k76, k86, k96, ka6, kb6 }, \
{ k17, k27, k37, k47, k57, k67, KC_NO, k87, k97, ka7, kb7 }, \
{ k18, k28, k38, k48, k58, k68, k78, KC_NO, k98, ka8, kb8 }, \
{ k19, k29, k39, k49, k59, k69, k79, k89, KC_NO, ka9, kb9 }, \
{ k1a, k2a, k3a, k4a, k5a, k6a, k7a, k8a, k9a, KC_NO, kba }, \
{ k1b, k2b, k3b, k4b, k5b, k6b, k7b, k8b, k9b, kab, KC_NO } \
*/