The latency of the LT implement

[Hzqi]

I have found the th40 LT implement will wired, like LT need to hold for a long can switch layer, reduce the TAPPING_TEMP will not work.
Actually LT rule may follow belows:

LT down → Other key press → LT hold                       : Switch to Layer & keep it active
LT down → Other key press → LT up                         : Switch to Layer & send that key from the Layer
LT down → Released within 200ms (tapping term)           : Send assigned key (KC_SPC)

for faster i may add these two rules:

LT down → Released within 200ms → Another key within 50ms  : Switch to Layer, send key, then revert layer
LT down → Released within 200ms → Another key after 50ms  : Stay in current layer & send that key

So I implement this function ,

// Define Layer Tap keys manually
#define LT1_SPACE LT(_LAYER1, KC_SPC)
#define LT2_SPACE LT(_LAYER2, KC_SPC)

// Define layers
enum layers {
    _BASE,
    _LAYER1,
    _LAYER2,
    _LAYER3
};

// Timers and state tracking
static uint16_t lt1_press_timer = 0;
static uint16_t lt1_release_timer = 0;
static bool lt1_pressed = false;
static bool lt1_released = false;
static bool lt1_other_key_pressed = false;
static bool lt1_should_revert_layer = false;

static uint16_t lt2_press_timer = 0;
static uint16_t lt2_release_timer = 0;
static bool lt2_pressed = false;
static bool lt2_released = false;
static bool lt2_other_key_pressed = false;
static bool lt2_should_revert_layer = false;

bool custom_process_record_user(uint16_t keycode, keyrecord_t *record) {
    switch (keycode) {
        case LT1_SPACE:
        case LT2_SPACE:
            if (record->event.pressed) {  // LT Key Down
                if (keycode == LT1_SPACE) {
                    lt1_pressed = true;
                    lt1_released = false;
                    lt1_other_key_pressed = false;
                    lt1_should_revert_layer = false;
                    lt1_press_timer = timer_read();
                } else if (keycode == LT2_SPACE) {
                    lt2_pressed = true;
                    lt2_released = false;
                    lt2_other_key_pressed = false;
                    lt2_should_revert_layer = false;
                    lt2_press_timer = timer_read();
                }
            } else {  // LT Key Up
                if (keycode == LT1_SPACE) {
                    lt1_pressed = false;
                    lt1_released = true;
                    lt1_release_timer = timer_read();

                    uint16_t press_duration = timer_elapsed(lt1_press_timer);
                    if (!lt1_other_key_pressed && press_duration < 200) {
                        tap_code(KC_SPC);
                        return false;
                    }
                } else if (keycode == LT2_SPACE) {
                    lt2_pressed = false;
                    lt2_released = true;
                    lt2_release_timer = timer_read();

                    uint16_t press_duration = timer_elapsed(lt2_press_timer);
                    if (!lt2_other_key_pressed && press_duration < 200) {
                        tap_code(KC_SPC);
                        return false;
                    }
                }
            }
            return false;  // Prevent default behavior

        default:
            if (lt1_pressed) {  // If another key is pressed while LT1 is held
                if (timer_elapsed(lt1_press_timer) < 200) {
                    layer_on(_LAYER1);
                    lt1_other_key_pressed = true;
                }
            } else if (lt1_released) {
                uint16_t release_elapsed = timer_elapsed(lt1_release_timer);

                if (release_elapsed < 50) {  // If another key is pressed within 50ms of LT release
                    layer_on(_LAYER1);
                    lt1_should_revert_layer = true;
                } else {  // If another key is pressed after 50ms
                    layer_off(_LAYER1);
                }
                lt1_released = false;
            }

            if (lt2_pressed) {  // If another key is pressed while LT2 is held
                if (timer_elapsed(lt2_press_timer) < 200) {
                    layer_on(_LAYER2);
                    lt2_other_key_pressed = true;
                }
            } else if (lt2_released) {
                uint16_t release_elapsed = timer_elapsed(lt2_release_timer);

                if (release_elapsed < 50) {  // If another key is pressed within 50ms of LT release
                    layer_on(_LAYER2);
                    lt2_should_revert_layer = true;
                } else {  // If another key is pressed after 50ms
                    layer_off(_LAYER2);
                }
                lt2_released = false;
            }
            break;
    }

    // If a key was pressed within 50ms of LT release, revert the layer
    if (lt1_should_revert_layer) {
        layer_off(_LAYER1);
        lt1_should_revert_layer = false;
    }
    if (lt2_should_revert_layer) {
        layer_off(_LAYER2);
        lt2_should_revert_layer = false;
    }

    return true;  // Process other keys normally
}

But this may have some bug that i havent found.

[Hzqi]

fine! i have figure out how to implement the soomthly LT logic, this is my finally code below, we can discuss about that:

// Define Layer Tap keys manually
#define LT1_SPACE LT(_LAYER1, KC_SPC)
#define LT2_SPACE LT(_LAYER2, KC_SPC)

// Define layers
enum layers {
    _BASE,
    _LAYER1,
    _LAYER2,
    _LAYER3
};


// Structure to track LT key state
typedef struct {
    bool pressed;
    uint16_t pressed_time;
    uint16_t released_time;
    bool just_released;
    uint8_t layer;   // Layer number
    uint16_t set_key; // The key to send on tap
} lt_state_t;

// Initialize LT state tracking for each LT key
static lt_state_t lt1 = {false, 0, 0, false, 1, KC_SPC}; // Layer 1, sends KC_SPC
static lt_state_t lt2 = {false, 0, 0, false, 2, KC_SPC}; // Layer 2, sends KC_SPC
static bool other_key_pressed = false;

bool custom_process_record_user(uint16_t keycode, keyrecord_t *record) {
    lt_state_t *lt = NULL;

    // Assign LT state based on keycode 
    switch (keycode) {
        case LT(1, KC_SPC):
            lt = &lt1;
            break;
        case LT(2, KC_SPC):
            lt = &lt2;
            break;
        default:
            // Handle non-LT key presses
            if (record->event.pressed) {
                if (lt1.pressed || lt2.pressed) {
                    other_key_pressed = true; // save the tag in the LT period
                }
            }
            if (!record->event.pressed) { // Key released

                if (lt1.just_released) {
                    uint16_t time_since_lt1_released = record->event.time - lt1.released_time;
                    if (time_since_lt1_released <= 50) {
                        layer_on(lt1.layer);
                        tap_code16(keycode);
                        layer_off(lt1.layer);
                    }
                    lt1.just_released = false;
                }
                if (lt2.just_released) {
                    uint16_t time_since_lt2_released = record->event.time - lt2.released_time;
                    if (time_since_lt2_released <= 50) {
                        layer_on(lt2.layer);
                        tap_code16(keycode);
                        layer_off(lt2.layer);
                    }
                    lt2.just_released = false;
                }
            }
            return true; // Continue normal processing
    }

    // If the key is one of the LT keys, process its behavior
    if (lt) {
        if (record->event.pressed) {
            lt->pressed = true;
            lt->pressed_time = record->event.time;
            layer_on(lt->layer);
        } else {
            lt->pressed = false;
            lt->just_released = true;
            lt->released_time = record->event.time;
            layer_off(lt->layer); // Always switch off immediately

            uint16_t press_duration = lt->released_time - lt->pressed_time;
            if (press_duration <= 200) {
                if (!other_key_pressed) {
                    tap_code(lt->set_key); 
                }
            }
            other_key_pressed = false;
        }
        return false; // Prevent normal processing for LT keys
    }

    return true;
}