summaryrefslogtreecommitdiff
path: root/quantum
diff options
context:
space:
mode:
Diffstat (limited to 'quantum')
-rw-r--r--quantum/dynamic_macro.h86
-rw-r--r--quantum/fauxclicky.c15
-rw-r--r--quantum/fauxclicky.h10
-rw-r--r--quantum/process_keycode/process_tap_dance.c14
-rw-r--r--quantum/process_keycode/process_tap_dance.h7
-rw-r--r--quantum/process_keycode/process_unicodemap.c2
6 files changed, 99 insertions, 35 deletions
diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h
index 64093f293e..045ee95b5f 100644
--- a/quantum/dynamic_macro.h
+++ b/quantum/dynamic_macro.h
@@ -40,6 +40,7 @@
enum dynamic_macro_keycodes {
DYN_REC_START1 = DYNAMIC_MACRO_RANGE,
DYN_REC_START2,
+ DYN_REC_STOP,
DYN_MACRO_PLAY1,
DYN_MACRO_PLAY2,
};
@@ -47,11 +48,22 @@ enum dynamic_macro_keycodes {
/* Blink the LEDs to notify the user about some event. */
void dynamic_macro_led_blink(void)
{
+#ifdef BACKLIGHT_ENABLE
backlight_toggle();
_delay_ms(100);
backlight_toggle();
+#endif
}
+/* Convenience macros used for retrieving the debug info. All of them
+ * need a `direction` variable accessible at the call site.
+ */
+#define DYNAMIC_MACRO_CURRENT_SLOT() (direction > 0 ? 1 : 2)
+#define DYNAMIC_MACRO_CURRENT_LENGTH(BEGIN, POINTER) \
+ ((int)(direction * ((POINTER) - (BEGIN))))
+#define DYNAMIC_MACRO_CURRENT_CAPACITY(BEGIN, END2) \
+ ((int)(direction * ((END2) - (BEGIN)) + 1))
+
/**
* Start recording of the dynamic macro.
*
@@ -61,6 +73,8 @@ void dynamic_macro_led_blink(void)
void dynamic_macro_record_start(
keyrecord_t **macro_pointer, keyrecord_t *macro_buffer)
{
+ dprintln("dynamic macro recording: started");
+
dynamic_macro_led_blink();
clear_keyboard();
@@ -78,6 +92,8 @@ void dynamic_macro_record_start(
void dynamic_macro_play(
keyrecord_t *macro_buffer, keyrecord_t *macro_end, int8_t direction)
{
+ dprintf("dynamic macro: slot %d playback\n", DYNAMIC_MACRO_CURRENT_SLOT());
+
uint32_t saved_layer_state = layer_state;
clear_keyboard();
@@ -96,35 +112,68 @@ void dynamic_macro_play(
/**
* Record a single key in a dynamic macro.
*
+ * @param macro_buffer[in] The start of the used macro buffer.
* @param macro_pointer[in,out] The current buffer position.
- * @param macro_end2[in] The end of the other macro which shouldn't be overwritten.
+ * @param macro2_end[in] The end of the other macro.
* @param direction[in] Either +1 or -1, which way to iterate the buffer.
* @param record[in] The current keypress.
*/
void dynamic_macro_record_key(
+ keyrecord_t *macro_buffer,
keyrecord_t **macro_pointer,
- keyrecord_t *macro_end2,
+ keyrecord_t *macro2_end,
int8_t direction,
keyrecord_t *record)
{
- if (*macro_pointer + direction != macro_end2) {
+ /* If we've just started recording, ignore all the key releases. */
+ if (!record->event.pressed && *macro_pointer == macro_buffer) {
+ dprintln("dynamic macro: ignoring a leading key-up event");
+ return;
+ }
+
+ /* The other end of the other macro is the last buffer element it
+ * is safe to use before overwriting the other macro.
+ */
+ if (*macro_pointer - direction != macro2_end) {
**macro_pointer = *record;
*macro_pointer += direction;
} else {
- /* Notify about the end of buffer. The blinks are paired
- * because they should happen on both down and up events. */
- backlight_toggle();
+ dynamic_macro_led_blink();
}
+
+ dprintf(
+ "dynamic macro: slot %d length: %d/%d\n",
+ DYNAMIC_MACRO_CURRENT_SLOT(),
+ DYNAMIC_MACRO_CURRENT_LENGTH(macro_buffer, *macro_pointer),
+ DYNAMIC_MACRO_CURRENT_CAPACITY(macro_buffer, macro2_end));
}
/**
* End recording of the dynamic macro. Essentially just update the
* pointer to the end of the macro.
*/
-void dynamic_macro_record_end(keyrecord_t *macro_pointer, keyrecord_t **macro_end)
+void dynamic_macro_record_end(
+ keyrecord_t *macro_buffer,
+ keyrecord_t *macro_pointer,
+ int8_t direction,
+ keyrecord_t **macro_end)
{
dynamic_macro_led_blink();
+ /* Do not save the keys being held when stopping the recording,
+ * i.e. the keys used to access the layer DYN_REC_STOP is on.
+ */
+ while (macro_pointer != macro_buffer &&
+ (macro_pointer - direction)->event.pressed) {
+ dprintln("dynamic macro: trimming a trailing key-down event");
+ macro_pointer -= direction;
+ }
+
+ dprintf(
+ "dynamic macro: slot %d saved, length: %d\n",
+ DYNAMIC_MACRO_CURRENT_SLOT(),
+ DYNAMIC_MACRO_CURRENT_LENGTH(macro_buffer, macro_pointer));
+
*macro_end = macro_pointer;
}
@@ -152,7 +201,7 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record)
* &macro_buffer macro_end
* v v
* +------------------------------------------------------------+
- * |>>>>>> MACRO1 >>>>>>| |<<<<<<<<<<<<< MACRO2 <<<<<<<<<<<<<|
+ * |>>>>>> MACRO1 >>>>>> <<<<<<<<<<<<< MACRO2 <<<<<<<<<<<<<|
* +------------------------------------------------------------+
* ^ ^
* r_macro_end r_macro_buffer
@@ -209,31 +258,34 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record)
} else {
/* A macro is being recorded right now. */
switch (keycode) {
- case MO(_DYN):
- /* Use the layer key used to access the macro recording as
- * a stop button. */
+ case DYN_REC_STOP:
+ /* Stop the macro recording. */
if (record->event.pressed) { /* Ignore the initial release
* just after the recoding
* starts. */
switch (macro_id) {
case 1:
- dynamic_macro_record_end(macro_pointer, &macro_end);
+ dynamic_macro_record_end(macro_buffer, macro_pointer, +1, &macro_end);
break;
case 2:
- dynamic_macro_record_end(macro_pointer, &r_macro_end);
+ dynamic_macro_record_end(r_macro_buffer, macro_pointer, -1, &r_macro_end);
break;
}
macro_id = 0;
}
return false;
+ case DYN_MACRO_PLAY1:
+ case DYN_MACRO_PLAY2:
+ dprintln("dynamic macro: ignoring macro play key while recording");
+ return false;
default:
/* Store the key in the macro buffer and process it normally. */
switch (macro_id) {
case 1:
- dynamic_macro_record_key(&macro_pointer, r_macro_end, +1, record);
+ dynamic_macro_record_key(macro_buffer, &macro_pointer, r_macro_end, +1, record);
break;
case 2:
- dynamic_macro_record_key(&macro_pointer, macro_end, -1, record);
+ dynamic_macro_record_key(r_macro_buffer, &macro_pointer, macro_end, -1, record);
break;
}
return true;
@@ -244,4 +296,8 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record)
return true;
}
+#undef DYNAMIC_MACRO_CURRENT_SLOT
+#undef DYNAMIC_MACRO_CURRENT_LENGTH
+#undef DYNAMIC_MACRO_CURRENT_CAPACITY
+
#endif
diff --git a/quantum/fauxclicky.c b/quantum/fauxclicky.c
index 13273e7058..c3341ca332 100644
--- a/quantum/fauxclicky.c
+++ b/quantum/fauxclicky.c
@@ -20,13 +20,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdbool.h>
#include <musical_notes.h>
-__attribute__ ((weak))
-float fauxclicky_pressed_note[2] = MUSICAL_NOTE(_F3, 2);
-__attribute__ ((weak))
-float fauxclicky_released_note[2] = MUSICAL_NOTE(_A3, 2);
-__attribute__ ((weak))
-float fauxclicky_beep_note[2] = MUSICAL_NOTE(_C3, 2);
-
bool fauxclicky_enabled = true;
uint16_t note_start = 0;
bool note_playing = false;
@@ -48,13 +41,13 @@ void fauxclicky_stop()
note_playing = false;
}
-void fauxclicky_play(float note[2]) {
+void fauxclicky_play(float note[]) {
if (!fauxclicky_enabled) return;
if (note_playing) fauxclicky_stop();
- FAUXCLICKY_TIMER_PERIOD = (uint16_t)(((float)F_CPU) / (note[0] * FAUXCLICKY_CPU_PRESCALER));
- FAUXCLICKY_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (note[0] * FAUXCLICKY_CPU_PRESCALER)) / 2);
+ FAUXCLICKY_TIMER_PERIOD = (uint16_t)(((float)F_CPU) / (note[0] * (float)FAUXCLICKY_CPU_PRESCALER));
+ FAUXCLICKY_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (note[0] * (float)FAUXCLICKY_CPU_PRESCALER)) / (float)2);
note_playing = true;
- note_period = (note[1] / 16) * (60 / (float)FAUXCLICKY_TEMPO) * 100; // check this
+ note_period = (note[1] / (float)16) * ((float)60 / (float)FAUXCLICKY_TEMPO) * 1000;
note_start = timer_read();
FAUXCLICKY_ENABLE_OUTPUT;
}
diff --git a/quantum/fauxclicky.h b/quantum/fauxclicky.h
index 109bd0d83e..1a8e188dd5 100644
--- a/quantum/fauxclicky.h
+++ b/quantum/fauxclicky.h
@@ -21,11 +21,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdbool.h"
__attribute__ ((weak))
-float fauxclicky_pressed_note[2];
+float fauxclicky_pressed_note[2] = MUSICAL_NOTE(_D4, 0.25);
__attribute__ ((weak))
-float fauxclicky_released_note[2];
+float fauxclicky_released_note[2] = MUSICAL_NOTE(_C4, 0.125);
__attribute__ ((weak))
-float fauxclicky_beep_note[2];
+float fauxclicky_beep_note[2] = MUSICAL_NOTE(_C4, 0.25);
bool fauxclicky_enabled;
@@ -73,11 +73,11 @@ bool fauxclicky_enabled;
#endif
#ifndef FAUXCLICKY_ENABLE_OUTPUT
-#define FAUXCLICKY_ENABLE_OUTPUT TCCR3A |= _BV(COM3A1);
+#define FAUXCLICKY_ENABLE_OUTPUT TCCR3A |= _BV(COM3A1)
#endif
#ifndef FAUXCLICKY_DISABLE_OUTPUT
-#define FAUXCLICKY_DISABLE_OUTPUT TCCR3A &= ~(_BV(COM3A1) | _BV(COM3A0));
+#define FAUXCLICKY_DISABLE_OUTPUT TCCR3A &= ~(_BV(COM3A1) | _BV(COM3A0))
#endif
#ifndef FAUXCLICKY_TIMER_PERIOD
diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index b807ec3c30..4fd45810bb 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -127,14 +127,22 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
return true;
}
+
+
void matrix_scan_tap_dance () {
if (highest_td == -1)
return;
+ uint16_t tap_user_defined;
-for (int i = 0; i <= highest_td; i++) {
+for (uint8_t i = 0; i <= highest_td; i++) {
qk_tap_dance_action_t *action = &tap_dance_actions[i];
-
- if (action->state.count && timer_elapsed (action->state.timer) > TAPPING_TERM) {
+ if(action->custom_tapping_term > 0 ) {
+ tap_user_defined = action->custom_tapping_term;
+ }
+ else{
+ tap_user_defined = TAPPING_TERM;
+ }
+ if (action->state.count && timer_elapsed (action->state.timer) > tap_user_defined) {
process_tap_dance_action_on_dance_finished (action);
reset_tap_dance (&action->state);
}
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index 330809f83a..f42c154a05 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -44,6 +44,7 @@ typedef struct
qk_tap_dance_user_fn_t on_reset;
} fn;
qk_tap_dance_state_t state;
+ uint16_t custom_tapping_term;
void *user_data;
} qk_tap_dance_action_t;
@@ -68,6 +69,12 @@ typedef struct
.user_data = NULL, \
}
+#define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) { \
+ .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \
+ .user_data = NULL, \
+ .custom_tapping_term = tap_specific_tapping_term, \
+ }
+
extern qk_tap_dance_action_t tap_dance_actions[];
/* To be used internally */
diff --git a/quantum/process_keycode/process_unicodemap.c b/quantum/process_keycode/process_unicodemap.c
index 0227fbdd7b..75f35112b1 100644
--- a/quantum/process_keycode/process_unicodemap.c
+++ b/quantum/process_keycode/process_unicodemap.c
@@ -49,7 +49,7 @@ bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
const uint32_t* map = unicode_map;
uint16_t index = keycode - QK_UNICODE_MAP;
- uint32_t code = pgm_read_dword_far(&map[index]);
+ uint32_t code = pgm_read_dword(&map[index]);
if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
// Convert to UTF-16 surrogate pair
code -= 0x10000;