@@ -2,6 +2,7 @@ COMMON_DIR = common | |||
SRC += $(COMMON_DIR)/host.c \ | |||
$(COMMON_DIR)/keyboard.c \ | |||
$(COMMON_DIR)/action.c \ | |||
$(COMMON_DIR)/action_macro.c \ | |||
$(COMMON_DIR)/keymap.c \ | |||
$(COMMON_DIR)/command.c \ | |||
$(COMMON_DIR)/timer.c \ |
@@ -620,7 +620,7 @@ static void process_action(keyrecord_t *record) | |||
break; | |||
case ACT_FUNCTION: | |||
// TODO | |||
keymap_call_function(record, action.func.id); | |||
keymap_call_function(record, action.func.id, action.func.opt); | |||
break; | |||
default: | |||
break; |
@@ -49,27 +49,27 @@ typedef union { | |||
uint16_t code; | |||
struct action_kind { | |||
uint16_t param :12; | |||
uint16_t id :4; | |||
uint8_t id :4; | |||
} kind; | |||
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; | |||
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; | |||
struct action_usage { | |||
uint16_t code :10; | |||
uint16_t page :2; | |||
uint16_t kind :4; | |||
uint8_t page :2; | |||
uint8_t kind :4; | |||
} usage; | |||
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; | |||
struct action_function { | |||
uint8_t id :8; |
@@ -0,0 +1,67 @@ | |||
/* | |||
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); } | |||
} | |||
} |
@@ -0,0 +1,107 @@ | |||
/* | |||
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 */ |
@@ -68,6 +68,6 @@ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) | |||
#endif | |||
__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) | |||
{ | |||
} |
@@ -23,6 +23,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
#include "action.h" | |||
// TODO: move to action.h? | |||
/* layer used currently */ | |||
extern uint8_t current_layer; | |||
/* layer to return or start with */ | |||
@@ -34,7 +35,7 @@ extern uint8_t default_layer; | |||
action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col); | |||
/* 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 |
@@ -21,12 +21,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
#include <stdint.h> | |||
#include <stdbool.h> | |||
#include <avr/pgmspace.h> | |||
#include "host.h" | |||
#include "keycode.h" | |||
#include "print.h" | |||
#include "debug.h" | |||
#include "util.h" | |||
#include "action.h" | |||
#include "action_macro.h" | |||
#include "host.h" | |||
#include "debug.h" | |||
#include "keymap.h" | |||
@@ -69,7 +68,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
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, \ | |||
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) | |||
* ,-----------------------------------------------------------. | |||
@@ -162,6 +161,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
enum function_id { | |||
LSHIFT_LPAREN, | |||
RSHIFT_RPAREN, | |||
MACRO = 0xff | |||
}; | |||
/* | |||
@@ -172,7 +172,8 @@ static const uint16_t PROGMEM fn_actions[] = { | |||
ACTION_LAYER_SET(1), // FN1 | |||
ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // FN2 | |||
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_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // FN6 | |||
ACTION_RMOD_TAP_KEY(KC_RCTL, KC_ENT), // FN7 | |||
@@ -183,12 +184,36 @@ static const uint16_t PROGMEM fn_actions[] = { | |||
//ACTION_LAYER_BIT_TAP_TOGGLE(1), // FN10 | |||
ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // FN11 | |||
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 | |||
*/ | |||
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; | |||
uint8_t tap_count = record->tap_count; | |||
@@ -261,6 +286,9 @@ void keymap_call_function(keyrecord_t *record, uint8_t id) | |||
} | |||
} | |||
break; | |||
case MACRO: | |||
action_macro_play(get_macro(opt, event.pressed)); | |||
break; | |||
} | |||
} | |||