SRC += $(COMMON_DIR)/host.c \ | SRC += $(COMMON_DIR)/host.c \ | ||||
$(COMMON_DIR)/keyboard.c \ | $(COMMON_DIR)/keyboard.c \ | ||||
$(COMMON_DIR)/action.c \ | $(COMMON_DIR)/action.c \ | ||||
$(COMMON_DIR)/action_macro.c \ | |||||
$(COMMON_DIR)/keymap.c \ | $(COMMON_DIR)/keymap.c \ | ||||
$(COMMON_DIR)/command.c \ | $(COMMON_DIR)/command.c \ | ||||
$(COMMON_DIR)/timer.c \ | $(COMMON_DIR)/timer.c \ |
break; | break; | ||||
case ACT_FUNCTION: | case ACT_FUNCTION: | ||||
// TODO | // TODO | ||||
keymap_call_function(record, action.func.id); | |||||
keymap_call_function(record, action.func.id, action.func.opt); | |||||
break; | break; | ||||
default: | default: | ||||
break; | break; |
uint16_t code; | uint16_t code; | ||||
struct action_kind { | struct action_kind { | ||||
uint16_t param :12; | uint16_t param :12; | ||||
uint16_t id :4; | |||||
uint8_t id :4; | |||||
} kind; | } kind; | ||||
struct action_key { | struct action_key { | ||||
uint16_t code :8; | |||||
uint16_t mods :4; | |||||
uint16_t kind :4; | |||||
uint8_t code :8; | |||||
uint8_t mods :4; | |||||
uint8_t kind :4; | |||||
} key; | } key; | ||||
struct action_layer { | struct action_layer { | ||||
uint16_t code :8; | |||||
uint16_t val :4; | |||||
uint16_t kind :4; | |||||
uint8_t code :8; | |||||
uint8_t val :4; | |||||
uint8_t kind :4; | |||||
} layer; | } layer; | ||||
struct action_usage { | struct action_usage { | ||||
uint16_t code :10; | uint16_t code :10; | ||||
uint16_t page :2; | |||||
uint16_t kind :4; | |||||
uint8_t page :2; | |||||
uint8_t kind :4; | |||||
} usage; | } usage; | ||||
struct action_command { | struct action_command { | ||||
uint16_t id :8; | |||||
uint16_t opt :4; | |||||
uint16_t kind :4; | |||||
uint8_t id :8; | |||||
uint8_t opt :4; | |||||
uint8_t kind :4; | |||||
} command; | } command; | ||||
struct action_function { | struct action_function { | ||||
uint8_t id :8; | uint8_t id :8; |
/* | |||||
Copyright 2013 Jun Wako <[email protected]> | |||||
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 <util/delay.h> | |||||
#include "debug.h" | |||||
#include "action.h" | |||||
#include "action_macro.h" | |||||
#define MACRO_READ() (macro = pgm_read_byte(macro_p++)) | |||||
void action_macro_play(const prog_macro_t *macro_p) | |||||
{ | |||||
macro_t macro = END; | |||||
uint8_t interval = 0; | |||||
if (!macro_p) return; | |||||
while (true) { | |||||
switch (MACRO_READ()) { | |||||
case INTERVAL: | |||||
interval = MACRO_READ(); | |||||
debug("INTERVAL("); debug_dec(interval); debug(")\n"); | |||||
break; | |||||
case WAIT: | |||||
MACRO_READ(); | |||||
debug("WAIT("); debug_dec(macro); debug(")\n"); | |||||
{ uint8_t ms = macro; while (ms--) _delay_ms(1); } | |||||
break; | |||||
case MODS_DOWN: | |||||
MACRO_READ(); | |||||
debug("MODS_DOWN("); debug_hex(macro); debug(")\n"); | |||||
debug("MODS_UP("); debug_hex(macro); debug(")\n"); | |||||
add_mods(macro); | |||||
break; | |||||
case MODS_UP: | |||||
MACRO_READ(); | |||||
debug("MODS_UP("); debug_hex(macro); debug(")\n"); | |||||
del_mods(macro); | |||||
break; | |||||
case 0x04 ... 0x73: | |||||
debug("DOWN("); debug_hex(macro); debug(")\n"); | |||||
register_code(macro); | |||||
break; | |||||
case 0x84 ... 0xF3: | |||||
debug("UP("); debug_hex(macro); debug(")\n"); | |||||
unregister_code(macro&0x7F); | |||||
break; | |||||
case END: | |||||
default: | |||||
return; | |||||
} | |||||
// interval | |||||
{ uint8_t ms = interval; while (ms--) _delay_ms(1); } | |||||
} | |||||
} |
/* | |||||
Copyright 2013 Jun Wako <[email protected]> | |||||
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/>. | |||||
*/ | |||||
#ifndef ACTION_MACRO_H | |||||
#define ACTION_MACRO_H | |||||
#include <stdint.h> | |||||
#include <avr/pgmspace.h> | |||||
typedef uint8_t macro_t; | |||||
typedef macro_t prog_macro_t PROGMEM; | |||||
void action_macro_play(const prog_macro_t *macro); | |||||
/* TODO: NOT FINISHED | |||||
normal mode command: | |||||
key(down): 0x04-7f/73(F24) | |||||
key(up): 0x84-ff | |||||
command: 0x00-03, 0x80-83(0x74-7f, 0xf4-ff) | |||||
mods down 0x00 | |||||
mods up 0x01 | |||||
wait 0x02 | |||||
interval 0x03 | |||||
extkey down 0x80 | |||||
extkey up 0x81 | |||||
ext commad 0x82 | |||||
ext mode 0x83 | |||||
end 0xff | |||||
extension mode command: NOT IMPLEMENTED | |||||
key down 0x00 | |||||
key up 0x01 | |||||
key down + wait | |||||
key up + wait | |||||
mods push | |||||
mods pop | |||||
wait | |||||
interval | |||||
if | |||||
loop | |||||
push | |||||
pop | |||||
all up | |||||
end | |||||
*/ | |||||
enum macro_command_id{ | |||||
/* 0x00 - 0x03 */ | |||||
END = 0x00, | |||||
MODS_DOWN = 0x01, | |||||
MODS_UP = 0x02, | |||||
MODS_SET, | |||||
MODS_PUSH, | |||||
MODS_POP, | |||||
WAIT = 0x74, | |||||
INTERVAL, | |||||
/* 0x74 - 0x7f */ | |||||
/* 0x80 - 0x84 */ | |||||
EXT_DOWN, | |||||
EXT_UP, | |||||
EXT_WAIT, | |||||
EXT_INTERVAL, | |||||
COMPRESSION_MODE, | |||||
EXTENSION_MODE = 0xff, | |||||
}; | |||||
/* normal mode */ | |||||
#define DOWN(key) (key) | |||||
#define UP(key) ((key) | 0x80) | |||||
#define TYPE(key) (key), (key | 0x80) | |||||
#define MODS_DOWN(mods) MODS_DOWN, (mods) | |||||
#define MODS_UP(mods) MODS_UP, (mods) | |||||
#define WAIT(ms) WAIT, (ms) | |||||
#define INTERVAL(ms) INTERVAL, (ms) | |||||
#define D(key) DOWN(KC_##key) | |||||
#define U(key) UP(KC_##key) | |||||
#define T(key) TYPE(KC_##key) | |||||
#define MD(key) MODS_DOWN(MOD_BIT(KC_##key)) | |||||
#define MU(key) MODS_UP(MOD_BIT(KC_##key)) | |||||
#define W(ms) WAIT(ms) | |||||
#define I(ms) INTERVAL(ms) | |||||
/* extension mode */ | |||||
#endif /* ACTION_MACRO_H */ |
#endif | #endif | ||||
__attribute__ ((weak)) | __attribute__ ((weak)) | ||||
void keymap_call_function(keyrecord_t *event, uint8_t id) | |||||
void keymap_call_function(keyrecord_t *event, uint8_t id, uint8_t opt) | |||||
{ | { | ||||
} | } |
#include "action.h" | #include "action.h" | ||||
// TODO: move to action.h? | |||||
/* layer used currently */ | /* layer used currently */ | ||||
extern uint8_t current_layer; | extern uint8_t current_layer; | ||||
/* layer to return or start with */ | /* layer to return or start with */ | ||||
action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col); | action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col); | ||||
/* user defined special function */ | /* user defined special function */ | ||||
void keymap_call_function(keyrecord_t *record, uint8_t id); | |||||
void keymap_call_function(keyrecord_t *record, uint8_t id, uint8_t opt); | |||||
#ifndef NO_LEGACY_KEYMAP_SUPPORT | #ifndef NO_LEGACY_KEYMAP_SUPPORT |
#include <stdint.h> | #include <stdint.h> | ||||
#include <stdbool.h> | #include <stdbool.h> | ||||
#include <avr/pgmspace.h> | #include <avr/pgmspace.h> | ||||
#include "host.h" | |||||
#include "keycode.h" | #include "keycode.h" | ||||
#include "print.h" | |||||
#include "debug.h" | |||||
#include "util.h" | |||||
#include "action.h" | #include "action.h" | ||||
#include "action_macro.h" | |||||
#include "host.h" | |||||
#include "debug.h" | |||||
#include "keymap.h" | #include "keymap.h" | ||||
TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \ | TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \ | ||||
FN6, A, S, D, F, G, H, J, K, L, FN3, QUOT,FN7, \ | FN6, A, S, D, F, G, H, J, K, L, FN3, QUOT,FN7, \ | ||||
FN8, Z, X, C, V, B, N, M, COMM,DOT, FN2, FN12,FN10, \ | FN8, Z, X, C, V, B, N, M, COMM,DOT, FN2, FN12,FN10, \ | ||||
LGUI,LALT, FN5, RALT,FN4), | |||||
LGUI,LALT, FN5, FN13,FN4), | |||||
/* Layer 1: HHKB mode (HHKB Fn) | /* Layer 1: HHKB mode (HHKB Fn) | ||||
* ,-----------------------------------------------------------. | * ,-----------------------------------------------------------. | ||||
enum function_id { | enum function_id { | ||||
LSHIFT_LPAREN, | LSHIFT_LPAREN, | ||||
RSHIFT_RPAREN, | RSHIFT_RPAREN, | ||||
MACRO = 0xff | |||||
}; | }; | ||||
/* | /* | ||||
ACTION_LAYER_SET(1), // FN1 | ACTION_LAYER_SET(1), // FN1 | ||||
ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // FN2 | ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // FN2 | ||||
ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // FN3 | ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // FN3 | ||||
ACTION_LAYER_SET(3), // FN4 | |||||
//ACTION_LAYER_SET(3), // FN4 | |||||
ACTION_FUNCTION(MACRO, 0), // FN4 | |||||
ACTION_LAYER_SET_TAP_KEY(5, KC_SPC), // FN5 | ACTION_LAYER_SET_TAP_KEY(5, KC_SPC), // FN5 | ||||
ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // FN6 | ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // FN6 | ||||
ACTION_RMOD_TAP_KEY(KC_RCTL, KC_ENT), // FN7 | ACTION_RMOD_TAP_KEY(KC_RCTL, KC_ENT), // FN7 | ||||
//ACTION_LAYER_BIT_TAP_TOGGLE(1), // FN10 | //ACTION_LAYER_BIT_TAP_TOGGLE(1), // FN10 | ||||
ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // FN11 | ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // FN11 | ||||
ACTION_FUNCTION_TAP(RSHIFT_RPAREN), // FN12 | ACTION_FUNCTION_TAP(RSHIFT_RPAREN), // FN12 | ||||
ACTION_FUNCTION(MACRO, 1), // FN13 | |||||
}; | }; | ||||
/* | |||||
* Macro definition | |||||
*/ | |||||
#define MACRO(...) ({ static prog_macro_t _m[] PROGMEM = { __VA_ARGS__ }; _m; }) | |||||
#define MACRO_NONE 0 | |||||
static const prog_macro_t *get_macro(uint8_t id, bool pressed) | |||||
{ | |||||
switch (id) { | |||||
case 0: | |||||
return (pressed ? | |||||
MACRO( MD(LSHIFT), D(D), END ) : | |||||
MACRO( U(D), MU(LSHIFT), END ) ); | |||||
case 1: | |||||
return (pressed ? | |||||
MACRO( I(255), T(H), T(E), T(L), T(L), W(255), T(O), END ) : | |||||
MACRO_NONE ); | |||||
} | |||||
return 0; | |||||
} | |||||
/* | /* | ||||
* user defined action function | * user defined action function | ||||
*/ | */ | ||||
void keymap_call_function(keyrecord_t *record, uint8_t id) | |||||
void keymap_call_function(keyrecord_t *record, uint8_t id, uint8_t opt) | |||||
{ | { | ||||
keyevent_t event = record->event; | keyevent_t event = record->event; | ||||
uint8_t tap_count = record->tap_count; | uint8_t tap_count = record->tap_count; | ||||
} | } | ||||
} | } | ||||
break; | break; | ||||
case MACRO: | |||||
action_macro_play(get_macro(opt, event.pressed)); | |||||
break; | |||||
} | } | ||||
} | } | ||||