Henry-Hiles/qmk_userspace
1
0
Fork 0
forked from mirrors/qmk_userspace
Code Pull requests Activity

Added wireless support; Added Lemokey L3; Added Keychron V1 Max

Browse source
This commit is contained in:
lokher 2024-01-10 16:22:49 +08:00
commit 4ae5990fcc
31585 changed files with 99327 additions and 1763186 deletions
Download patch file Download diff file Expand all files Collapse all files

433
keyboards/lemokey/common/factory_test.c Normal file
View file

@ -0,0 +1,433 @@
/* Copyright 2021 @ Keychron (https://www.keychron.com)
*
* 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 "quantum.h"
#include "raw_hid.h"
#include "via.h"
#include "lemokey_task.h"
#ifdef LK_WIRELESS_ENABLE
# include "transport.h"
# include "battery.h"
# include "lpm.h"
# include "lkbt51.h"
# include "indicator.h"
#endif
#include "config.h"
#include "version.h"
#ifndef RAW_EPSIZE
# define RAW_EPSIZE 32
#endif
#ifndef BL_CYCLE_KEY
# define BL_CYCLE_KEY KC_RIGHT
#endif
#ifndef BL_TRIG_KEY
# define BL_TRIG_KEY KC_HOME
#endif
#ifndef P2P4G_CELAR_MASK
# define P2P4G_CELAR_MASK P2P4G_CLEAR_PAIRING_TYPE_C
#endif
enum {
BACKLIGHT_TEST_OFF = 0,
BACKLIGHT_TEST_WHITE,
BACKLIGHT_TEST_RED,
BACKLIGHT_TEST_GREEN,
BACKLIGHT_TEST_BLUE,
BACKLIGHT_TEST_MAX,
};
enum {
KEY_PRESS_FN = 0x01 << 0,
KEY_PRESS_J = 0x01 << 1,
KEY_PRESS_Z = 0x01 << 2,
KEY_PRESS_BL_KEY1 = 0x01 << 3,
KEY_PRESS_BL_KEY2 = 0x01 << 4,
KEY_PRESS_FACTORY_RESET = KEY_PRESS_FN | KEY_PRESS_J | KEY_PRESS_Z,
KEY_PRESS_BACKLIGTH_TEST = KEY_PRESS_FN | KEY_PRESS_BL_KEY1 | KEY_PRESS_BL_KEY2,
};
enum {
FACTORY_TEST_CMD_BACKLIGHT = 0x01,
FACTORY_TEST_CMD_OS_SWITCH,
FACTORY_TEST_CMD_JUMP_TO_BL,
FACTORY_TEST_CMD_INT_PIN,
FACTORY_TEST_CMD_GET_TRANSPORT,
FACTORY_TEST_CMD_CHARGING_ADC,
FACTORY_TEST_CMD_RADIO_CARRIER,
FACTORY_TEST_CMD_GET_BUILD_TIME,
};
enum {
P2P4G_CLEAR_PAIRING_TYPE_A = 0x01 << 0,
P2P4G_CLEAR_PAIRING_TYPE_C = 0x01 << 1,
};
enum {
OS_SWITCH = 0x01,
};
static uint32_t factory_reset_timer = 0;
static uint8_t factory_reset_state = 0;
static uint8_t backlight_test_mode = BACKLIGHT_TEST_OFF;
static uint32_t factory_reset_ind_timer = 0;
static uint8_t factory_reset_ind_state = 0;
static bool report_os_sw_state = false;
static bool keys_released = true;
void factory_timer_start(void) {
factory_reset_timer = timer_read32();
}
static inline void factory_timer_check(void) {
if (timer_elapsed32(factory_reset_timer) > 3000) {
factory_reset_timer = 0;
if (factory_reset_state == KEY_PRESS_FACTORY_RESET) {
factory_reset_ind_timer = timer_read32();
factory_reset_ind_state++;
keys_released = false;
clear_keyboard(); // Avoid key being pressed after NKRO state changed
layer_state_t default_layer_tmp = default_layer_state;
eeconfig_init();
keymap_config.raw = eeconfig_read_keymap();
default_layer_set(default_layer_tmp);
#ifdef LED_MATRIX_ENABLE
if (!led_matrix_is_enabled()) led_matrix_enable();
led_matrix_init();
#endif
#ifdef RGB_MATRIX_ENABLE
if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
rgb_matrix_init();
#endif
#ifdef LK_WIRELESS_ENABLE
lkbt51_factory_reset(P2P4G_CELAR_MASK);
#endif
} else if (factory_reset_state == KEY_PRESS_BACKLIGTH_TEST) {
#ifdef LED_MATRIX_ENABLE
if (!led_matrix_is_enabled()) led_matrix_enable();
#endif
#ifdef RGB_MATRIX_ENABLE
if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
#endif
backlight_test_mode = BACKLIGHT_TEST_WHITE;
}
factory_reset_state = 0;
}
}
static inline void factory_reset_ind_timer_check(void) {
if (factory_reset_ind_timer && timer_elapsed32(factory_reset_ind_timer) > 250) {
if (factory_reset_ind_state++ > 6) {
factory_reset_ind_timer = factory_reset_ind_state = 0;
} else {
factory_reset_ind_timer = timer_read32();
}
}
}
bool process_record_factory_test(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
#if defined(FN_KEY_1) || defined(FN_KEY_2)
# if defined(FN_KEY_1)
case FN_KEY_1: /* fall through */
# endif
# if defined(FN_KEY_2)
case FN_KEY_2:
# endif
# if defined(FN_KEY_3)
case FN_KEY_3:
# endif
if (record->event.pressed) {
factory_reset_state |= KEY_PRESS_FN;
} else {
factory_reset_state &= ~KEY_PRESS_FN;
factory_reset_timer = 0;
}
break;
#endif
case KC_J:
if (record->event.pressed) {
factory_reset_state |= KEY_PRESS_J;
if (factory_reset_state == 0x07) factory_timer_start();
if (factory_reset_state & KEY_PRESS_FN) return false;
} else {
factory_reset_state &= ~KEY_PRESS_J;
factory_reset_timer = 0;
}
break;
case KC_Z:
#if defined(FN_Z_KEY)
case FN_Z_KEY:
#endif
if (record->event.pressed) {
factory_reset_state |= KEY_PRESS_Z;
if (factory_reset_state == 0x07) factory_timer_start();
if ((factory_reset_state & KEY_PRESS_FN) && keycode == KC_Z) return false;
} else {
factory_reset_state &= ~KEY_PRESS_Z;
factory_reset_timer = 0;
/* Avoid changing backlight effect on key released if FN_Z_KEY is mode*/
if (!keys_released && keycode >= QK_BACKLIGHT_ON && keycode <= RGB_MODE_TWINKLE) {
keys_released = true;
return false;
}
}
break;
#if defined(BL_CYCLE_KEY) || defined(BL_CYCLE_KEY_2)
# if defined(BL_CYCLE_KEY)
case BL_CYCLE_KEY:
# endif
# if defined(FN_BL_CYCLE_KEY)
case FN_BL_CYCLE_KEY:
# endif
if (record->event.pressed) {
if (backlight_test_mode) {
if (++backlight_test_mode >= BACKLIGHT_TEST_MAX) {
backlight_test_mode = BACKLIGHT_TEST_WHITE;
}
} else {
factory_reset_state |= KEY_PRESS_BL_KEY1;
if (factory_reset_state == 0x19) {
factory_timer_start();
}
}
} else {
factory_reset_state &= ~KEY_PRESS_BL_KEY1;
factory_reset_timer = 0;
}
break;
#endif
#if defined(BL_TRIG_KEY) || defined(BL_TRIG_KEY_2)
# if defined(BL_TRIG_KEY)
case BL_TRIG_KEY:
# endif
# if defined(FN_BL_TRIG_KEY)
case FN_BL_TRIG_KEY:
# endif
if (record->event.pressed) {
if (backlight_test_mode) {
backlight_test_mode = BACKLIGHT_TEST_OFF;
} else {
factory_reset_state |= KEY_PRESS_BL_KEY2;
if (factory_reset_state == 0x19) {
factory_timer_start();
}
}
} else {
factory_reset_state &= ~KEY_PRESS_BL_KEY2;
factory_reset_timer = 0;
}
break;
#endif
}
return true;
}
#ifdef LED_MATRIX_ENABLE
bool factory_test_indicator(void) {
if (factory_reset_ind_state) {
led_matrix_set_value_all(factory_reset_ind_state % 2 ? 0 : 255);
return false;
}
return true;
}
#endif
#ifdef RGB_MATRIX_ENABLE
bool factory_test_indicator(void) {
if (factory_reset_ind_state) {
backlight_test_mode = BACKLIGHT_TEST_OFF;
rgb_matrix_set_color_all(factory_reset_ind_state % 2 ? 0 : 255, 0, 0);
return false;
} else if (backlight_test_mode) {
switch (backlight_test_mode) {
case BACKLIGHT_TEST_WHITE:
rgb_matrix_set_color_all(255, 255, 255);
break;
case BACKLIGHT_TEST_RED:
rgb_matrix_set_color_all(255, 0, 0);
break;
case BACKLIGHT_TEST_GREEN:
rgb_matrix_set_color_all(0, 255, 0);
break;
case BACKLIGHT_TEST_BLUE:
rgb_matrix_set_color_all(0, 0, 255);
break;
}
return false;
}
return true;
}
#endif
bool factory_reset_indicating(void) {
return factory_reset_ind_timer;
}
bool factory_test_task(void) {
if (factory_reset_timer) factory_timer_check();
if (factory_reset_ind_timer) factory_reset_ind_timer_check();
return true;
}
#ifdef LEMOKEY_CALLBACK_ENABLE
void factory_test_init(void) {
register_lemokey_task(factory_test_task, false);
register_record_process(process_record_factory_test, false);
register_led_indicator_task(factory_test_indicator, false);
}
#endif
void factory_test_send(uint8_t *payload, uint8_t length) {
#ifdef RAW_ENABLE
uint16_t checksum = 0;
uint8_t data[RAW_EPSIZE] = {0};
uint8_t i = 0;
data[i++] = 0xAB;
memcpy(&data[i], payload, length);
i += length;
for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++)
checksum += data[i];
data[RAW_EPSIZE - 2] = checksum & 0xFF;
data[RAW_EPSIZE - 1] = (checksum >> 8) & 0xFF;
raw_hid_send(data, RAW_EPSIZE);
#endif
}
void factory_test_rx(uint8_t *data, uint8_t length) {
if (data[0] == 0xAB) {
uint16_t checksum = 0;
for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++) {
checksum += data[i];
}
/* Verify checksum */
if ((checksum & 0xFF) != data[RAW_EPSIZE - 2] || checksum >> 8 != data[RAW_EPSIZE - 1]) return;
#ifdef LK_WIRELESS_ENABLE
uint8_t payload[32];
uint8_t len = 0;
#endif
switch (data[1]) {
case FACTORY_TEST_CMD_BACKLIGHT:
backlight_test_mode = data[2];
factory_reset_timer = 0;
break;
case FACTORY_TEST_CMD_OS_SWITCH:
break;
case FACTORY_TEST_CMD_JUMP_TO_BL:
// if (memcmp(&data[2], "JumpToBootloader", strlen("JumpToBootloader")) == 0) bootloader_jump();
break;
#ifdef LK_WIRELESS_ENABLE
case FACTORY_TEST_CMD_INT_PIN:
switch (data[2]) {
/* Enalbe/disable test */
case 0xA1:
lkbt51_int_pin_test(data[3]);
break;
/* Set INT state */
case 0xA2:
writePin(BLUETOOTH_INT_OUTPUT_PIN, data[3]);
break;
}
break;
case FACTORY_TEST_CMD_GET_TRANSPORT:
payload[len++] = FACTORY_TEST_CMD_GET_TRANSPORT;
payload[len++] = get_transport();
payload[len++] = readPin(USB_POWER_SENSE_PIN);
factory_test_send(payload, len);
break;
#endif
#ifdef BATTERY_CHARGE_DONE_DETECT_ADC
case FACTORY_TEST_CMD_CHARGING_ADC:
case 0xA1:
battery_charging_monitor(data[3]);
break;
case 0xA2:
payload[len++] = FACTORY_TEST_CMD_CHARGING_ADC;
payload[len++] = battery_adc_read_charging_pin();
factory_test_send(payload, len);
break;
#endif
#ifdef LK_WIRELESS_ENABLE
case FACTORY_TEST_CMD_RADIO_CARRIER:
if (data[2] < 79) lkbt51_radio_test(data[2]);
break;
# ifdef WERELESS_PRESSURE_TEST
case 0x70:
switch (data[2]) {
/* Enalbe/disable test */
case 0xB1:
SEND_STRING("abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890\n");
break;
case 0xB2:
payload[len++] = 0x70;
payload[len++] = 0xB2;
payload[len++] = wireless_get_state();
factory_test_send(payload, len);
break;
}
break;
# endif
#endif
case FACTORY_TEST_CMD_GET_BUILD_TIME: {
payload[len++] = FACTORY_TEST_CMD_GET_BUILD_TIME;
payload[len++] = 'v';
if ((DEVICE_VER & 0xF000) != 0) itoa((DEVICE_VER >> 12), (char *)&payload[len++], 16);
itoa((DEVICE_VER >> 8) & 0xF, (char *)&payload[len++], 16);
payload[len++] = '.';
itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
payload[len++] = '.';
itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
payload[len++] = ' ';
memcpy(&payload[len], QMK_BUILDDATE, sizeof(QMK_BUILDDATE));
len += sizeof(QMK_BUILDDATE);
factory_test_send(payload, len);
} break;
}
}
}
bool dip_switch_update_user(uint8_t index, bool active) {
if (report_os_sw_state) {
#ifdef INVERT_OS_SWITCH_STATE
active = !active;
#endif
uint8_t payload[3] = {FACTORY_TEST_CMD_OS_SWITCH, OS_SWITCH, active};
factory_test_send(payload, 3);
}
return true;
}

34
keyboards/lemokey/common/factory_test.h Normal file
View file

@ -0,0 +1,34 @@
/* Copyright 2022 @ lokher (https://www.keychron.com)
*
* 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
#define FACTORY_RESET_CHECK process_record_factory_test
#define FACTORY_RESET_TASK factory_test_task
void factory_test_init(void);
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
bool factory_test_indicator(void);
#endif
//void process_record_factory_test(uint16_t keycode, keyrecord_t *record);
bool factory_reset_indicating(void);
void factory_test_task(void);
void factory_test_rx(uint8_t *data, uint8_t length);
bool process_record_factory_test(uint16_t keycode, keyrecord_t *record);

131
keyboards/lemokey/common/lemokey_common.c Normal file
View file

@ -0,0 +1,131 @@
/* Copyright 2022 @ Keychron (https://www.keychron.com)
*
* 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
#include "lemokey_common.h"
#ifdef FACTORY_TEST_ENABLE
# include "factory_test.h"
# include "lemokey_common.h"
#endif
#ifdef LK_WIRELESS_ENABLE
# include "lkbt51.h"
#endif
static uint8_t mac_keycode[4] = {KC_LOPT, KC_ROPT, KC_LCMD, KC_RCMD};
static key_combination_t key_comb_list[3] = {
{2, {KC_LWIN, KC_TAB}},
{2, {KC_LWIN, KC_E}},
{2, {KC_LWIN, KC_L}},
};
bool process_record_lemokey_common(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case KC_TASK_VIEW:
case KC_FILE_EXPLORER:
case KC_LOCK_SCREEN:
if (record->event.pressed) {
for (uint8_t i = 0; i < key_comb_list[keycode - KC_TASK].len; i++) {
register_code(key_comb_list[keycode - KC_TASK].keycode[i]);
}
} else {
for (uint8_t i = 0; i < key_comb_list[keycode - KC_TASK].len; i++) {
unregister_code(key_comb_list[keycode - KC_TASK].keycode[i]);
}
}
return false; // Skip all further processing of this key
case KC_MCTRL:
if (record->event.pressed) {
register_code(KC_MISSION_CONTROL);
} else {
unregister_code(KC_MISSION_CONTROL);
}
return false; // Skip all further processing of this key
case KC_LANCH:
if (record->event.pressed) {
register_code(KC_LAUNCHPAD);
} else {
unregister_code(KC_LAUNCHPAD);
}
return false; // Skip all further processing of this key
case KC_LOPTN:
case KC_ROPTN:
case KC_LCMMD:
case KC_RCMMD:
if (record->event.pressed) {
register_code(mac_keycode[keycode - KC_LOPTN]);
} else {
unregister_code(mac_keycode[keycode - KC_LOPTN]);
}
return false; // Skip all further processing of this key
default:
return true; // Process all other keycodes normally
}
}
void lemokey_common_task(void) {}
#ifdef ENCODER_ENABLE
static void encoder0_pad_cb(void *param) {
(void)param;
encoder_inerrupt_read(0);
}
void encoder_cb_init(void) {
pin_t encoders_pad_a[] = ENCODERS_PAD_A;
pin_t encoders_pad_b[] = ENCODERS_PAD_B;
palEnableLineEvent(encoders_pad_a[0], PAL_EVENT_MODE_BOTH_EDGES);
palEnableLineEvent(encoders_pad_b[0], PAL_EVENT_MODE_BOTH_EDGES);
palSetLineCallback(encoders_pad_a[0], encoder0_pad_cb, NULL);
palSetLineCallback(encoders_pad_b[0], encoder0_pad_cb, NULL);
}
#endif
//__attribute__((weak)) bool raw_hid_receive_lemokey(uint8_t *data, uint8_t length) { return true; }
bool via_command_kb(uint8_t *data, uint8_t length) {
// if (!raw_hid_receive_lemokey(data, length))
// return false;
switch (data[0]) {
#ifdef LK_WIRELESS_ENABLE
case 0xAA:
lkbt51_dfu_rx(data, length);
break;
#endif
#ifdef FACTORY_TEST_ENABLE
case 0xAB:
factory_test_rx(data, length);
break;
#endif
default:
return false;
}
return true;
}
#if !defined(VIA_ENABLE)
void raw_hid_receive(uint8_t *data, uint8_t length) {
switch (data[0]) {
case RAW_HID_CMD:
via_command_kb(data, length);
break;
}
}
#endif

64
keyboards/lemokey/common/lemokey_common.h Normal file
View file

@ -0,0 +1,64 @@
/* Copyright 2022 @ Keychron (https://www.lemokey.com)
*
* 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 "stdint.h"
// clang-format off
enum {
KC_TASK_VIEW = QK_KB_0,
KC_FILE_EXPLORER,
KC_LOCK_SCREEN, // Lock screen
KC_MCTRL,
KC_LANCH,
KC_LOPTN,
KC_ROPTN,
KC_LCMMD,
KC_RCMMD,
#ifdef LK_WIRELESS_ENABLE
BT_HST1,
BT_HST2,
BT_HST3,
P2P4G,
BAT_LVL,
#else
BT_HST1 = _______,
BT_HST2 = _______,
BT_HST3 = _______,
P2P4G = _______,
BAT_LVL = _______,
#endif
NEW_SAFE_RANGE,
};
#define KC_TASK KC_TASK_VIEW
#define KC_FILE KC_FILE_EXPLORER
#define KC_LOCK KC_LOCK_SCREEN
typedef struct PACKED {
uint8_t len;
uint8_t keycode[2];
} key_combination_t;
bool process_record_lemokey_common(uint16_t keycode, keyrecord_t *record);
void lemokey_common_task(void);
#ifdef ENCODER_ENABLE
void encoder_cb_init(void);
#endif

10
keyboards/lemokey/common/lemokey_common.mk Normal file
View file

@ -0,0 +1,10 @@
OPT_DEFS += -DFACTORY_TEST_ENABLE
LEMOKEY_COMMON_DIR = common
SRC += \
$(LEMOKEY_COMMON_DIR)/lemokey_task.c \
$(LEMOKEY_COMMON_DIR)/lemokey_common.c \
$(LEMOKEY_COMMON_DIR)/factory_test.c
VPATH += $(TOP_DIR)/keyboards/lemokey/$(LEMOKEY_COMMON_DIR)

248
keyboards/lemokey/common/lemokey_task.c Normal file
View file

@ -0,0 +1,248 @@
/* Copyright 2023 @ Keychron (https://www.keychron.com)
*
* 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 <stdlib.h>
#include "lemokey_task.h"
#include "quantum.h"
#include "lemokey_common.h"
#ifdef FACTORY_TEST_ENABLE
#include "factory_test.h"
#endif
#ifdef LEMOKEY_CALLBACK_ENABLE
typedef struct lk_node {
lemokey_cb lk_cb;
struct lk_node* next;
}lk_Node;
typedef struct lk_process_node {
lemokey_record_process_cb process_cb;
struct lk_process_node* next;
}lk_process_Node;
lk_Node *p;
lk_Node *lk_task_list = NULL;
lk_process_Node *p_process;
lk_process_Node *lk_record_process_list = NULL;
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
lk_Node *led_indicator_task_list = NULL;
#endif
void register_lemokey_cb(lk_Node **head, lemokey_cb cb, bool priority) {
/* Create task node */
lk_Node* task = (lk_Node*)malloc(sizeof(lk_Node));
task->lk_cb = cb;
task->next = NULL;
/* Add to the list*/
if (*head) {
if (priority) {
task->next = *head;
*head = task;
}
else {
p = *head;
while (p->next) p = p->next;
p->next = task;
}
}
else {
*head = task;
}
}
void deregister_lemokey_cb(lk_Node **head, lemokey_cb cb) {
p = *head;
while (p) {
if (p->lk_cb == cb) {
// lk_Node* temp = p;
//if
}
}
}
void register_lemokey_task(lemokey_cb cb, bool priority) {
register_lemokey_cb(&lk_task_list, cb, priority);
}
void register_led_indicator_task(lemokey_cb cb, bool priority) {
register_lemokey_cb(&led_indicator_task_list, cb, priority);
}
void register_record_process(lemokey_record_process_cb cb, bool priority) {
lk_process_Node* process = (lk_process_Node*)malloc(sizeof(lk_process_Node));
process->process_cb = cb;
process->next = NULL;
/* Add to the list*/
if (lk_record_process_list) {
if (priority) {
process->next = lk_record_process_list;
lk_record_process_list = process;
}
else {
p_process = lk_record_process_list;
while (p_process->next) p_process = p_process->next;
p_process->next = process;
}
}
else {
lk_record_process_list = process;
}
}
inline void lemokey_task(void) {
p = lk_task_list;
while (p) {
p->lk_cb();
p = p->next;
}
}
inline bool process_record_lemokey(uint16_t keycode, keyrecord_t *record) {
p_process = lk_record_process_list;
while (p_process) {
if (!p_process->process_cb(keycode, record)) {
return false;
}
p_process = p_process->next;
}
return true;
}
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
#if defined(LED_MATRIX_ENABLE)
inline bool led_matrix_indicators_lemokey(void) {
#else
inline bool rgb_matrix_indicators_lemokey(void) {
#endif
p = led_indicator_task_list;
while (p) {
p->lk_cb();
p = p->next;
}
return true;
}
#endif
#else
__attribute__((weak)) bool process_record_lemokey_kb(uint16_t keycode, keyrecord_t *record) { return true; }
bool process_record_lemokey(uint16_t keycode, keyrecord_t *record) {
#ifdef LK_WIRELESS_ENABLE
extern bool process_record_wireless(uint16_t keycode, keyrecord_t *record);
if (!process_record_wireless(keycode, record))
return false;
#endif
#ifdef FACTORY_TEST_ENABLE
if (!process_record_factory_test(keycode, record))
return false;
#endif
//extern bool process_record_lemokey_kb(uint16_t keycode, keyrecord_t *record);
if (!process_record_lemokey_kb(keycode, record))
return false;
return true;
}
#if defined(LED_MATRIX_ENABLE)
bool led_matrix_indicators_lemokey(void) {
#ifdef LK_WIRELESS_ENABLE
extern bool led_matrix_indicators_bt(void);
led_matrix_indicators_bt();
#endif
#ifdef FACTORY_TEST_ENABLE
factory_test_indicator();
#endif
return true;
}
#endif
#if defined(RGB_MATRIX_ENABLE)
bool rgb_matrix_indicators_lemokey(void) {
#ifdef LK_WIRELESS_ENABLE
extern bool rgb_matrix_indicators_bt(void);
rgb_matrix_indicators_bt();
#endif
#ifdef FACTORY_TEST_ENABLE
factory_test_indicator();
#endif
return true;
}
#endif
__attribute__((weak)) bool lemokey_task_kb(void){ return true; }
void lemokey_task(void) {
#ifdef LK_WIRELESS_ENABLE
extern void wireless_tasks(void);
wireless_tasks();
#endif
#ifdef FACTORY_TEST_ENABLE
factory_test_task();
#endif
lemokey_common_task();
lemokey_task_kb();
}
#endif // #ifdef LEMOKEY_CALLBACK_ENABLE
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
if (!process_record_user(keycode, record))
return false;
if (!process_record_lemokey(keycode, record))
return false;
return true;
}
#ifdef RGB_MATRIX_ENABLE
bool rgb_matrix_indicators_kb(void) {
if (!rgb_matrix_indicators_user())
return false;
rgb_matrix_indicators_lemokey();
return true;
}
#endif
#ifdef LED_MATRIX_ENABLE
bool led_matrix_indicators_kb(void) {
if (!led_matrix_indicators_user())
return false;
led_matrix_indicators_lemokey();
return true;
}
#endif
void housekeeping_task_kb(void) {
lemokey_task();
}

41
keyboards/lemokey/common/lemokey_task.h Normal file
View file

@ -0,0 +1,41 @@
/* Copyright 2022 @ Keychron (https://www.lemokey.com)
*
* 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 "stdint.h"
#include "action.h"
#ifdef LEMOKEY_CALLBACK_ENABLE
typedef bool (*lemokey_cb)(void);
typedef bool (*lemokey_record_process_cb)(uint16_t keycode, keyrecord_t *record);
bool process_record_lemokey(uint16_t keycode, keyrecord_t *record);
void register_lemokey_task(lemokey_cb cb, bool priority);
void register_record_process(lemokey_record_process_cb cb, bool priority);
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
void register_led_indicator_task(lemokey_cb cb, bool priority);
#endif
#else
bool lemokey_task_kb(void);
bool process_record_lemokey_kb(uint16_t keycode, keyrecord_t *record);
#endif
void lemokey_task(void);

147
keyboards/lemokey/common/wireless/bat_level_animation.c Normal file
View file

@ -0,0 +1,147 @@
#include "quantum.h"
#include "wireless.h"
#include "indicator.h"
#include "lpm.h"
#if defined(PROTOCOL_CHIBIOS)
# include <usb_main.h>
#elif if defined(PROTOCOL_LUFA)
# include "lufa.h"
#endif
#include "eeprom.h"
#if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
#ifndef BAT_LEVEL_GROWING_INTERVAL
# define BAT_LEVEL_GROWING_INTERVAL 150
#endif
#ifndef BAT_LEVEL_ON_INTERVAL
# define BAT_LEVEL_ON_INTERVAL 3000
#endif
#ifdef LED_MATRIX_ENABLE
# define LED_DRIVER_IS_ENABLED led_matrix_is_enabled
#endif
#ifdef RGB_MATRIX_ENABLE
# define LED_DRIVER_IS_ENABLED rgb_matrix_is_enabled
#endif
enum {
BAT_LVL_ANI_NONE,
BAT_LVL_ANI_GROWING,
BAT_LVL_ANI_BLINK_OFF,
BAT_LVL_ANI_BLINK_ON,
};
static uint8_t animation_state = 0;
static uint32_t bat_lvl_ani_timer_buffer = 0;
static uint8_t bat_percentage;
static uint8_t cur_percentage;
static uint32_t time_interval;
#ifdef RGB_MATRIX_ENABLE
static uint8_t r, g, b;
#endif
extern indicator_config_t indicator_config;
extern backlight_state_t original_backlight_state;
void bat_level_animiation_start(uint8_t percentage) {
/* Turn on backlight mode for indicator */
indicator_enable();
animation_state = BAT_LVL_ANI_GROWING;
bat_percentage = percentage;
bat_lvl_ani_timer_buffer = timer_read32();
cur_percentage = 0;
time_interval = BAT_LEVEL_GROWING_INTERVAL;
#ifdef RGB_MATRIX_ENABLE
r = g = b = 255;
#endif
}
void bat_level_animiation_stop(void) {
animation_state = BAT_LVL_ANI_NONE;
}
bool bat_level_animiation_actived(void) {
return animation_state;
}
void bat_level_animiation_indicate(void) {
#ifdef LED_MATRIX_ENABLE
uint8_t bat_lvl_led_list[10] = BAT_LEVEL_LED_LIST;
for (uint8_t i = 0; i <= LED_MATRIX_LED_COUNT; i++) {
led_matrix_set_value(i, 0);
}
if (animation_state == BAT_LVL_ANI_GROWING || animation_state == BAT_LVL_ANI_BLINK_ON)
for (uint8_t i = 0; i < cur_percentage / 10; i++)
led_matrix_set_value(bat_lvl_led_list[i], 255);
#endif
#ifdef RGB_MATRIX_ENABLE
uint8_t bat_lvl_led_list[10] = BAT_LEVEL_LED_LIST;
for (uint8_t i = 0; i <= RGB_MATRIX_LED_COUNT; i++) {
rgb_matrix_set_color(i, 0, 0, 0);
}
if (animation_state == BAT_LVL_ANI_GROWING || animation_state == BAT_LVL_ANI_BLINK_ON) {
for (uint8_t i = 0; i < cur_percentage / 10; i++) {
rgb_matrix_set_color(bat_lvl_led_list[i], r, g, b);
}
}
#endif
}
void bat_level_animiation_update(void) {
switch (animation_state) {
case BAT_LVL_ANI_GROWING:
if (cur_percentage < bat_percentage)
cur_percentage += 10;
else {
if (cur_percentage == 0) cur_percentage = 10;
animation_state = BAT_LVL_ANI_BLINK_OFF;
}
break;
case BAT_LVL_ANI_BLINK_OFF:
#ifdef RGB_MATRIX_ENABLE
if (bat_percentage < 30) {
r = 255;
b = g = 0;
} else {
r = b = 0;
g = 255;
}
#endif
time_interval = BAT_LEVEL_ON_INTERVAL;
animation_state = BAT_LVL_ANI_BLINK_ON;
break;
case BAT_LVL_ANI_BLINK_ON:
animation_state = BAT_LVL_ANI_NONE;
indicator_eeconfig_reload();
if (indicator_config.value == 0 && !LED_DRIVER_IS_ENABLED()) {
indicator_disable();
}
lpm_timer_reset();
break;
default:
break;
}
bat_lvl_ani_timer_buffer = timer_read32();
}
void bat_level_animiation_task(void) {
if (animation_state && sync_timer_elapsed32(bat_lvl_ani_timer_buffer) > time_interval) {
bat_level_animiation_update();
}
}
#endif

23
keyboards/lemokey/common/wireless/bat_level_animation.h Normal file
View file

@ -0,0 +1,23 @@
/* Copyright 2022 @ lokher (https://www.keychron.com)
*
* 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
void bat_level_animiation_start(uint8_t percentage);
void bat_level_animiation_stop(void);
bool bat_level_animiation_actived(void);
void bat_level_animiation_indicate(void);
void bat_level_animiation_task(void);

239
keyboards/lemokey/common/wireless/battery.c Normal file
View file

@ -0,0 +1,239 @@
/* Copyright 2023 @ lokher (https://www.lemokey.com)
*
* 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 "quantum.h"
#include "wireless.h"
#include "battery.h"
#include "transport.h"
#include "lkbt51.h"
#include "lpm.h"
#include "indicator.h"
#include "rtc_timer.h"
#include "analog.h"
#define BATTERY_EMPTY_COUNT 10
#define CRITICAL_LOW_COUNT 20
/* Battery voltage resistive voltage divider setting of MCU */
#ifndef RVD_R1
# define RVD_R1 10 // Upper side resitor value (uint: KΩ)
#endif
#ifndef RVD_R2
# define RVD_R2 10 // Lower side resitor value (uint: KΩ)
#endif
/* Battery voltage resistive voltage divider setting of Bluetooth */
#ifndef LKBT51_RVD_R1
# define LKBT51_RVD_R1 560
#endif
#ifndef LKBT51_RVD_R2
# define LKBT51_RVD_R2 499
#endif
#ifndef VOLTAGE_TRIM_LED_MATRIX
# define VOLTAGE_TRIM_LED_MATRIX 30
#endif
#ifndef VOLTAGE_TRIM_RGB_MATRIX
# define VOLTAGE_TRIM_RGB_MATRIX 60
#endif
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
extern uint8_t g_pwm_buffer[DRIVER_COUNT][192];
#endif
static uint32_t bat_monitor_timer_buffer = 0;
static uint16_t voltage = FULL_VOLTAGE_VALUE;
static uint8_t bat_empty = 0;
static uint8_t critical_low = 0;
static uint8_t bat_state;
static uint8_t power_on_sample = 0;
void battery_init(void) {
bat_state = BAT_NOT_CHARGING;
#if defined(BAT_CHARGING_PIN)
# if (BAT_CHARGING_LEVEL == 0)
palSetLineMode(BAT_CHARGING_PIN, PAL_MODE_INPUT_PULLUP);
# else
palSetLineMode(BAT_CHARGING_PIN, PAL_MODE_INPUT_PULLDOWN);
# endif
#endif
#ifdef BAT_ADC_ENABLE_PIN
palSetLineMode(BAT_ADC_ENABLE_PIN, PAL_MODE_OUTPUT_PUSHPULL);
writePin(BAT_ADC_ENABLE_PIN, 1);
#endif
#ifdef BAT_ADC_PIN
palSetLineMode(BAT_ADC_PIN, PAL_MODE_INPUT_ANALOG);
#endif
}
void battery_stop(void) {
#if (HAL_USE_ADC)
# ifdef BAT_ADC_ENABLE_PIN
writePin(BAT_ADC_ENABLE_PIN, 0);
# endif
# ifdef BAT_ADC_PIN
palSetLineMode(BAT_ADC_PIN, PAL_MODE_INPUT_ANALOG);
analog_stop(BAT_ADC_PIN);
# endif
#endif
}
__attribute__((weak)) void battery_measure(void) {
lkbt51_read_state_reg(0x05, 0x02);
}
/* Calculate the voltage */
__attribute__((weak)) void battery_calculate_voltage(bool vol_src_bt, uint16_t value) {
uint16_t voltage;
if (vol_src_bt)
voltage = ((uint32_t)value) * (LKBT51_RVD_R1 + LKBT51_RVD_R2) / LKBT51_RVD_R2;
else
voltage = (uint32_t)value * 3300 / 1024 * (RVD_R1 + RVD_R2) / RVD_R2;
#ifdef LED_MATRIX_ENABLE
if (led_matrix_is_enabled()) {
uint32_t totalBuf = 0;
for (uint8_t i = 0; i < DRIVER_COUNT; i++)
for (uint8_t j = 0; j < 192; j++)
totalBuf += g_pwm_buffer[i][j];
/* We assumpt it is linear relationship*/
voltage += (VOLTAGE_TRIM_LED_MATRIX * totalBuf / LED_MATRIX_LED_COUNT / 255);
}
#endif
#ifdef RGB_MATRIX_ENABLE
if (rgb_matrix_is_enabled()) {
uint32_t totalBuf = 0;
for (uint8_t i = 0; i < DRIVER_COUNT; i++)
for (uint8_t j = 0; j < 192; j++)
totalBuf += g_pwm_buffer[i][j];
/* We assumpt it is linear relationship*/
uint32_t compensation = VOLTAGE_TRIM_RGB_MATRIX * totalBuf / RGB_MATRIX_LED_COUNT / 255 / 3;
voltage += compensation;
}
#endif
battery_set_voltage(voltage);
}
void battery_set_voltage(uint16_t value) {
voltage = value;
}
uint16_t battery_get_voltage(void) {
return voltage;
}
uint8_t battery_get_percentage(void) {
if (voltage > FULL_VOLTAGE_VALUE) return 100;
if (voltage > EMPTY_VOLTAGE_VALUE) {
return ((uint32_t)voltage - EMPTY_VOLTAGE_VALUE) * 80 / (FULL_VOLTAGE_VALUE - EMPTY_VOLTAGE_VALUE) + 20;
}
if (voltage > SHUTDOWN_VOLTAGE_VALUE) {
return ((uint32_t)voltage - SHUTDOWN_VOLTAGE_VALUE) * 20 / (EMPTY_VOLTAGE_VALUE - SHUTDOWN_VOLTAGE_VALUE);
} else
return 0;
}
bool battery_is_empty(void) {
return bat_empty > BATTERY_EMPTY_COUNT;
}
bool battery_is_critical_low(void) {
return critical_low > CRITICAL_LOW_COUNT;
}
void battery_check_empty(void) {
if (voltage < EMPTY_VOLTAGE_VALUE) {
if (bat_empty <= BATTERY_EMPTY_COUNT) {
if (++bat_empty > BATTERY_EMPTY_COUNT) {
#ifdef BAT_LOW_LED_PIN
indicator_battery_low_enable(true);
#endif
#if defined(LOW_BAT_IND_INDEX)
indicator_battery_low_backlit_enable(true);
#endif
power_on_sample = VOLTAGE_POWER_ON_MEASURE_COUNT;
}
}
}
}
void battery_check_critical_low(void) {
if (voltage < SHUTDOWN_VOLTAGE_VALUE) {
if (critical_low <= CRITICAL_LOW_COUNT) {
if (++critical_low > CRITICAL_LOW_COUNT) wireless_low_battery_shutdown();
}
} else if (critical_low <= CRITICAL_LOW_COUNT) {
critical_low = 0;
}
}
bool battery_power_on_sample(void) {
return power_on_sample < VOLTAGE_POWER_ON_MEASURE_COUNT;
}
void battery_task(void) {
uint32_t t = rtc_timer_elapsed_ms(bat_monitor_timer_buffer);
if ((get_transport() & TRANSPORT_WIRELESS) && (wireless_get_state() == WT_CONNECTED || battery_power_on_sample())) {
#if defined(BAT_CHARGING_PIN)
if (usb_power_connected() && t > VOLTAGE_MEASURE_INTERVAL) {
if (readPin(BAT_CHARGING_PIN) == BAT_CHARGING_LEVEL)
lkbt51_update_bat_state(BAT_CHARGING);
else
lkbt51_update_bat_state(BAT_FULL_CHARGED);
}
#endif
if ((battery_power_on_sample()
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
&& !indicator_is_enabled()
#endif
&& t > BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL) ||
t > VOLTAGE_MEASURE_INTERVAL) {
battery_check_empty();
battery_check_critical_low();
bat_monitor_timer_buffer = rtc_timer_read_ms();
if (bat_monitor_timer_buffer > RTC_MAX_TIME) {
bat_monitor_timer_buffer = 0;
rtc_timer_clear();
}
battery_measure();
if (power_on_sample < VOLTAGE_POWER_ON_MEASURE_COUNT) power_on_sample++;
}
}
if ((bat_empty || critical_low) && usb_power_connected()) {
bat_empty = false;
critical_low = false;
#ifdef BAT_LOW_LED_PIN
indicator_battery_low_enable(false);
#endif
#if defined(LOW_BAT_IND_INDEX)
indicator_battery_low_backlit_enable(false);
#endif
}
}

62
keyboards/lemokey/common/wireless/battery.h Normal file
View file

@ -0,0 +1,62 @@
/* Copyright 2023 @ lokher (https://www.lemokey.com)
*
* 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
enum {
BAT_NOT_CHARGING = 0,
BAT_CHARGING,
BAT_FULL_CHARGED,
};
#ifndef FULL_VOLTAGE_VALUE
# define FULL_VOLTAGE_VALUE 4100
#endif
#ifndef EMPTY_VOLTAGE_VALUE
# define EMPTY_VOLTAGE_VALUE 3500
#endif
#ifndef SHUTDOWN_VOLTAGE_VALUE
# define SHUTDOWN_VOLTAGE_VALUE 3300
#endif
#ifndef VOLTAGE_MEASURE_INTERVAL
# define VOLTAGE_MEASURE_INTERVAL 3000
#endif
#ifndef VOLTAGE_POWER_ON_MEASURE_COUNT
# define VOLTAGE_POWER_ON_MEASURE_COUNT 15
#endif
#ifndef BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL
# define BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL 200
#endif
void battery_init(void);
void battery_stop(void);
void battery_measure(void);
void battery_calculate_voltage(bool vol_src_bt, uint16_t value);
void battery_set_voltage(uint16_t value);
uint16_t battery_get_voltage(void);
uint8_t battery_get_percentage(void);
void indicator_battery_low_enable(bool enable);
bool battery_is_empty(void);
bool battery_is_critical_low(void);
bool battery_power_on_sample(void);
void battery_task(void);

723
keyboards/lemokey/common/wireless/indicator.c Normal file
View file

@ -0,0 +1,723 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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 "quantum.h"
#include "indicator.h"
#include "transport.h"
#include "battery.h"
#include "eeconfig.h"
#include "wireless_config.h"
#include "config.h"
#include "rtc_timer.h"
#include "lemokey_common.h"
#include "usb_main.h"
#ifdef FACTORY_TEST_ENABLE
# include "factory_test.h"
#endif
#include "lpm.h"
#include "lemokey_task.h"
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
# ifdef LED_MATRIX_ENABLE
# include "led_matrix.h"
# endif
# ifdef RGB_MATRIX_ENABLE
# include "rgb_matrix.h"
# endif
# include "bat_level_animation.h"
# include "eeprom.h"
#endif
#define HOST_INDEX_MASK 0x0F
#define HOST_P2P4G 0x10
#define LED_ON 0x80
// #define RGB_MATRIX_TIMEOUT_INFINITE 0xFFFFFFFF
#ifdef LED_MATRIX_ENABLE
# define DECIDE_TIME(t, duration) (duration == 0 ? LED_MATRIX_TIMEOUT_INFINITE : ((t > duration) ? t : duration))
#endif
#ifdef RGB_MATRIX_ENABLE
# define DECIDE_TIME(t, duration) (duration == 0 ? RGB_MATRIX_TIMEOUT_INFINITE : ((t > duration) ? t : duration))
#endif
#define INDICATOR_SET(s) memcpy(&indicator_config, &s##_config, sizeof(indicator_config_t));
enum {
BACKLIGHT_OFF = 0x00,
BACKLIGHT_ON_CONNECTED = 0x01,
BACKLIGHT_ON_UNCONNECTED = 0x02,
};
static indicator_config_t pairing_config = INDICATOR_CONFIG_PARING;
static indicator_config_t connected_config = INDICATOR_CONFIG_CONNECTD;
static indicator_config_t reconnecting_config = INDICATOR_CONFIG_RECONNECTING;
static indicator_config_t disconnected_config = INDICATOR_CONFIG_DISCONNECTED;
indicator_config_t indicator_config;
static wt_state_t indicator_state;
static uint16_t next_period;
static indicator_type_t type;
static uint32_t indicator_timer_buffer = 0;
#if defined(BAT_LOW_LED_PIN)
static uint32_t bat_low_pin_indicator = 0;
static uint32_t bat_low_blink_duration = 0;
#endif
#if defined(LOW_BAT_IND_INDEX)
static uint32_t bat_low_backlit_indicator = 0;
static uint8_t bat_low_ind_state = 0;
static uint32_t rtc_time = 0;
#endif
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
backlight_state_t original_backlight_state;
# ifdef BT_HOST_LED_MATRIX_LIST
static uint8_t bt_host_led_matrix_list[BT_HOST_DEVICES_COUNT] = BT_HOST_LED_MATRIX_LIST;
# endif
# ifdef P2P4G_HOST_LED_MATRIX_LIST
static uint8_t p2p4g_host_led_matrix_list[P2P4G_HOST_DEVICES_COUNT] = P2P4G_HOST_LED_MATRIX_LIST;
# endif
#endif
#ifdef BT_HOST_LED_PIN_LIST
static pin_t bt_led_pin_list[BT_HOST_DEVICES_COUNT] = BT_HOST_LED_PIN_LIST;
#endif
#ifdef P24G_HOST_LED_PIN_LIST
static pin_t p24g_led_pin_list[P24G_HOST_DEVICES_COUNT] = P24G_HOST_LED_PIN_LIST;
#endif
#ifdef LED_MATRIX_ENABLE
# define LED_DRIVER led_matrix_driver
# define LED_INDICATORS_KB led_matrix_indicators_bt
# define LED_INDICATORS_USER led_matrix_indicators_user
# define LED_NONE_INDICATORS_KB led_matrix_none_indicators_kb
# define SET_ALL_LED_OFF() led_matrix_set_value_all(0)
# define SET_LED_OFF(idx) led_matrix_set_value(idx, 0)
# define SET_LED_ON(idx) led_matrix_set_value(idx, 255)
# define SET_LED_BT(idx) led_matrix_set_value(idx, 255)
# define SET_LED_P24G(idx) led_matrix_set_value(idx, 255)
# define SET_LED_LOW_BAT(idx) led_matrix_set_value(idx, 255)
# define LED_DRIVER_IS_ENABLED led_matrix_is_enabled
# define LED_DRIVER_EECONFIG_RELOAD() \
eeprom_read_block(&led_matrix_eeconfig, EECONFIG_LED_MATRIX, sizeof(led_matrix_eeconfig)); \
if (!led_matrix_eeconfig.mode) { \
eeconfig_update_led_matrix_default(); \
}
# define LED_DRIVER_ALLOW_SHUTDOWN led_matrix_driver_allow_shutdown
# define LED_DRIVER_SHUTDOWN led_matrix_driver_shutdown
# define LED_DRIVER_EXIT_SHUTDOWN led_matrix_driver_exit_shutdown
# define LED_DRIVER_ENABLE_NOEEPROM led_matrix_enable_noeeprom
# define LED_DRIVER_DISABLE_NOEEPROM led_matrix_disable_noeeprom
# define LED_DRIVER_DISABLE_TIMEOUT_SET led_matrix_disable_timeout_set
# define LED_DRIVER_DISABLE_TIME_RESET led_matrix_disable_time_reset
# define LED_DRIVER_TIMEOUTED led_matrix_timeouted
#endif
#ifdef RGB_MATRIX_ENABLE
# define LED_DRIVER rgb_matrix_driver
# define LED_INDICATORS_KB rgb_matrix_indicators_bt
# define LED_INDICATORS_USER rgb_matrix_indicators_user
# define LED_NONE_INDICATORS_KB rgb_matrix_none_indicators_kb
# define SET_ALL_LED_OFF() rgb_matrix_set_color_all(0, 0, 0)
# define SET_LED_OFF(idx) rgb_matrix_set_color(idx, 0, 0, 0)
# define SET_LED_ON(idx) rgb_matrix_set_color(idx, 255, 255, 255)
# define SET_LED_BT(idx) rgb_matrix_set_color(idx, 0, 0, 255)
# define SET_LED_P24G(idx) rgb_matrix_set_color(idx, 0, 255, 0)
# define SET_LED_LOW_BAT(idx) rgb_matrix_set_color(idx, 255, 0, 0)
# define LED_DRIVER_IS_ENABLED rgb_matrix_is_enabled
# define LED_DRIVER_EECONFIG_RELOAD() \
eeprom_read_block(&rgb_matrix_config, EECONFIG_RGB_MATRIX, sizeof(rgb_matrix_config)); \
if (!rgb_matrix_config.mode) { \
eeconfig_update_rgb_matrix_default(); \
}
# define LED_DRIVER_ALLOW_SHUTDOWN rgb_matrix_driver_allow_shutdown
# define LED_DRIVER_SHUTDOWN rgb_matrix_driver_shutdown
# define LED_DRIVER_EXIT_SHUTDOWN rgb_matrix_driver_exit_shutdown
# define LED_DRIVER_ENABLE_NOEEPROM rgb_matrix_enable_noeeprom
# define LED_DRIVER_DISABLE_NOEEPROM rgb_matrix_disable_noeeprom
# define LED_DRIVER_DISABLE_TIMEOUT_SET rgb_matrix_disable_timeout_set
# define LED_DRIVER_DISABLE_TIME_RESET rgb_matrix_disable_time_reset
# define LED_DRIVER_TIMEOUTED rgb_matrix_timeouted
#endif
bool LED_INDICATORS_KB(void);
void indicator_init(void) {
memset(&indicator_config, 0, sizeof(indicator_config));
#ifdef BT_HOST_LED_PIN_LIST
for (uint8_t i = 0; i < BT_HOST_DEVICES_COUNT; i++) {
setPinOutput(bt_led_pin_list[i]);
writePin(bt_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
}
#endif
#ifdef P24G_HOST_LED_PIN_LIST
for (uint8_t i = 0; i < P24G_HOST_DEVICES_COUNT; i++) {
setPinOutput(p24g_led_pin_list[i]);
writePin(p24g_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
}
#endif
#ifdef BAT_LOW_LED_PIN
setPinOutput(BAT_LOW_LED_PIN);
writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
#endif
#ifdef LEMOKEY_CALLBACK_ENABLE
register_led_indicator_task(LED_INDICATORS_KB, false);
#endif
}
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
void indicator_enable(void) {
if (!LED_DRIVER_IS_ENABLED()) {
LED_DRIVER_ENABLE_NOEEPROM();
}
}
inline void indicator_disable(void) {
LED_DRIVER_DISABLE_NOEEPROM();
}
void indicator_set_backlit_timeout(uint32_t time) {
LED_DRIVER_DISABLE_TIMEOUT_SET(time);
}
static inline void indicator_reset_backlit_time(void) {
LED_DRIVER_DISABLE_TIME_RESET();
}
bool indicator_is_enabled(void) {
return LED_DRIVER_IS_ENABLED();
}
void indicator_eeconfig_reload(void) {
LED_DRIVER_EECONFIG_RELOAD();
}
#endif
bool indicator_is_running(void) {
return
#if defined(BAT_LOW_LED_PIN)
bat_low_blink_duration ||
#endif
#if defined(LOW_BAT_IND_INDEX)
bat_low_ind_state ||
#endif
!!indicator_config.value;
}
static void indicator_timer_cb(void *arg) {
if (*(indicator_type_t *)arg != INDICATOR_LAST) type = *(indicator_type_t *)arg;
bool time_up = false;
switch (type) {
case INDICATOR_NONE:
break;
case INDICATOR_OFF:
next_period = 0;
time_up = true;
break;
case INDICATOR_ON:
if (indicator_config.value) {
if (indicator_config.elapsed == 0) {
indicator_config.value |= LED_ON;
if (indicator_config.duration) {
indicator_config.elapsed += indicator_config.duration;
}
} else
time_up = true;
}
break;
case INDICATOR_ON_OFF:
if (indicator_config.value) {
if (indicator_config.elapsed == 0) {
indicator_config.value |= LED_ON;
next_period = indicator_config.on_time;
} else {
indicator_config.value = indicator_config.value & 0x1F;
next_period = indicator_config.duration - indicator_config.on_time;
}
if ((indicator_config.duration == 0 || indicator_config.elapsed <= indicator_config.duration) && next_period != 0) {
indicator_config.elapsed += next_period;
} else {
time_up = true;
}
}
break;
case INDICATOR_BLINK:
if (indicator_config.value) {
if (indicator_config.value & LED_ON) {
indicator_config.value = indicator_config.value & 0x1F;
next_period = indicator_config.off_time;
} else {
indicator_config.value |= LED_ON;
next_period = indicator_config.on_time;
}
if ((indicator_config.duration == 0 || indicator_config.elapsed <= indicator_config.duration) && next_period != 0) {
indicator_config.elapsed += next_period;
} else {
time_up = true;
}
}
break;
default:
time_up = true;
next_period = 0;
break;
}
#if defined(BT_HOST_LED_PIN_LIST) || defined(P24G_HOST_LED_PIN_LIST)
if (indicator_config.value) {
uint8_t idx = (indicator_config.value & HOST_INDEX_MASK) - 1;
pin_t *led_lin_list = NULL;
uint8_t led_count;
# if defined(P24G_HOST_LED_PIN_LIST)
if (indicator_config.value & HOST_P2P4G) {
if (idx < P24G_HOST_DEVICES_COUNT) led_lin_list = p24g_led_pin_list;
led_count = P24G_HOST_DEVICES_COUNT;
} else
# endif
{
if (idx < BT_HOST_DEVICES_COUNT) led_lin_list = bt_led_pin_list;
led_count = BT_HOST_DEVICES_COUNT;
}
for (uint8_t i = 0; i < led_count; i++) {
if (i != idx) writePin(led_lin_list[idx], !HOST_LED_PIN_ON_STATE);
}
if (led_lin_list) {
if ((indicator_config.value & LED_ON) && !time_up) {
writePin(led_lin_list[idx], HOST_LED_PIN_ON_STATE);
} else {
writePin(led_lin_list[idx], !HOST_LED_PIN_ON_STATE);
}
}
}
#endif
if (time_up) {
/* Set indicator to off on timeup, avoid keeping light up until next update in raindrop effect */
indicator_config.value = indicator_config.value & 0x1F;
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
LED_INDICATORS_KB();
#endif
indicator_config.value = 0;
lpm_timer_reset();
}
if (indicator_config.value == 0) {
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
indicator_eeconfig_reload();
if (!LED_DRIVER_IS_ENABLED()) indicator_disable();
#endif
}
}
void indicator_set(wt_state_t state, uint8_t host_index) {
if (get_transport() == TRANSPORT_USB) return;
static uint8_t current_state = 0;
static uint8_t current_host = 0;
bool host_index_changed = false;
if (host_index == 24) host_index = HOST_P2P4G | 0x01;
if (current_host != host_index && state != WT_DISCONNECTED) {
host_index_changed = true;
current_host = host_index;
}
if (current_state != state || host_index_changed || state == WT_RECONNECTING) {
current_state = state;
} else {
return;
}
indicator_timer_buffer = timer_read32();
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
/* Turn on backlight mode for indicator */
indicator_enable();
indicator_reset_backlit_time();
#endif
switch (state) {
case WT_DISCONNECTED:
#if defined(BT_HOST_LED_PIN_LIST)
if ((host_index & HOST_P2P4G) != HOST_P2P4G) writePin(bt_led_pin_list[(host_index & HOST_INDEX_MASK) - 1], !HOST_LED_PIN_ON_STATE);
#endif
#if defined(P24G_HOST_LED_PIN_LIST)
if (host_index & HOST_P2P4G) writePin(p24g_led_pin_list[(host_index & HOST_INDEX_MASK) - 1], !HOST_LED_PIN_ON_STATE);
#endif
INDICATOR_SET(disconnected);
indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
indicator_timer_cb((void *)&indicator_config.type);
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
if (battery_is_critical_low()) {
indicator_set_backlit_timeout(1000);
} else {
/* Set timer so that user has chance to turn on the backlight when is off */
indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
}
#endif
break;
case WT_CONNECTED:
if (indicator_state != WT_CONNECTED) {
INDICATOR_SET(connected);
indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
indicator_timer_cb((void *)&indicator_config.type);
}
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
indicator_set_backlit_timeout(DECIDE_TIME(CONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
#endif
break;
case WT_PARING:
INDICATOR_SET(pairing);
indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : LED_ON | host_index;
indicator_timer_cb((void *)&indicator_config.type);
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
#endif
break;
case WT_RECONNECTING:
INDICATOR_SET(reconnecting);
indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : LED_ON | host_index;
indicator_timer_cb((void *)&indicator_config.type);
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
#endif
break;
case WT_SUSPEND:
INDICATOR_SET(disconnected);
indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
indicator_timer_cb((void *)&indicator_config.type);
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
# ifdef FACTORY_TEST_ENABLE
if (factory_reset_indicating())
indicator_set_backlit_timeout(3000);
else
# endif
{
indicator_set_backlit_timeout(1000);
}
#endif
#if defined(BT_HOST_LED_PIN_LIST)
for (uint8_t i = 0; i < BT_HOST_DEVICES_COUNT; i++)
writePin(bt_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
#endif
#if defined(P24G_HOST_LED_PIN_LIST)
for (uint8_t i = 0; i < P24G_HOST_DEVICES_COUNT; i++)
writePin(p24g_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
#endif
break;
default:
break;
}
indicator_state = state;
}
void indicator_stop(void) {
indicator_config.value = 0;
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
indicator_eeconfig_reload();
if (indicator_is_enabled()) {
indicator_enable();
} else {
indicator_disable();
}
#endif
}
#ifdef BAT_LOW_LED_PIN
void indicator_battery_low_enable(bool enable) {
if (enable) {
if (bat_low_blink_duration == 0) {
bat_low_blink_duration = bat_low_pin_indicator = timer_read32();
} else
bat_low_blink_duration = timer_read32();
} else
writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
}
#endif
#if defined(LOW_BAT_IND_INDEX)
void indicator_battery_low_backlit_enable(bool enable) {
if (enable) {
uint32_t t = rtc_timer_read_ms();
/* Check overflow */
if (rtc_time > t) {
if (bat_low_ind_state == 0)
rtc_time = t; // Update rtc_time if indicating is not running
else {
rtc_time += t;
}
}
/* Indicating at first time or after the interval */
if ((rtc_time == 0 || t - rtc_time > LOW_BAT_LED_TRIG_INTERVAL) && bat_low_ind_state == 0) {
bat_low_backlit_indicator = enable ? timer_read32() : 0;
rtc_time = rtc_timer_read_ms();
bat_low_ind_state = 1;
indicator_enable();
}
} else {
rtc_time = 0;
bat_low_ind_state = 0;
indicator_eeconfig_reload();
if (!LED_DRIVER_IS_ENABLED()) indicator_disable();
}
}
#endif
void indicator_battery_low(void) {
#ifdef BAT_LOW_LED_PIN
if (bat_low_pin_indicator && timer_elapsed32(bat_low_pin_indicator) > (LOW_BAT_LED_BLINK_PERIOD)) {
togglePin(BAT_LOW_LED_PIN);
bat_low_pin_indicator = timer_read32();
// Turn off low battery indication if we reach the duration
if (timer_elapsed32(bat_low_blink_duration) > LOW_BAT_LED_BLINK_DURATION && palReadLine(BAT_LOW_LED_PIN) != BAT_LOW_LED_PIN_ON_STATE) {
bat_low_blink_duration = bat_low_pin_indicator = 0;
}
}
#endif
#if defined(LOW_BAT_IND_INDEX)
if (bat_low_ind_state) {
if ((bat_low_ind_state & 0x0F) <= (LOW_BAT_LED_BLINK_TIMES) && timer_elapsed32(bat_low_backlit_indicator) > (LOW_BAT_LED_BLINK_PERIOD)) {
if (bat_low_ind_state & 0x80) {
bat_low_ind_state &= 0x7F;
bat_low_ind_state++;
} else {
bat_low_ind_state |= 0x80;
}
bat_low_backlit_indicator = timer_read32();
/* Restore backligth state */
if ((bat_low_ind_state & 0x0F) > (LOW_BAT_LED_BLINK_TIMES)) {
# if defined(NUM_LOCK_INDEX) || defined(CAPS_LOCK_INDEX) || defined(SCROLL_LOCK_INDEX) || defined(COMPOSE_LOCK_INDEX) || defined(KANA_LOCK_INDEX)
if (LED_DRIVER_ALLOW_SHUTDOWN())
# endif
indicator_disable();
}
} else if ((bat_low_ind_state & 0x0F) > (LOW_BAT_LED_BLINK_TIMES)) {
bat_low_ind_state = 0;
lpm_timer_reset();
}
}
#endif
}
void indicator_task(void) {
#if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
bat_level_animiation_task();
#endif
if (indicator_config.value && timer_elapsed32(indicator_timer_buffer) >= next_period) {
indicator_timer_cb((void *)&type);
indicator_timer_buffer = timer_read32();
}
indicator_battery_low();
}
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
__attribute__((weak)) void os_state_indicate(void) {
# if defined(RGB_DISABLE_WHEN_USB_SUSPENDED) || defined(LED_DISABLE_WHEN_USB_SUSPENDED)
if (get_transport() == TRANSPORT_USB && USB_DRIVER.state == USB_SUSPENDED) return;
# endif
# if defined(NUM_LOCK_INDEX)
if (host_keyboard_led_state().num_lock) {
SET_LED_ON(NUM_LOCK_INDEX);
}
# endif
# if defined(CAPS_LOCK_INDEX)
if (host_keyboard_led_state().caps_lock) {
# if defined(DIM_CAPS_LOCK)
SET_LED_OFF(CAPS_LOCK_INDEX);
# else
SET_LED_ON(CAPS_LOCK_INDEX);
# endif
}
# endif
# if defined(SCROLL_LOCK_INDEX)
if (host_keyboard_led_state().scroll_lock) {
SET_LED_ON(SCROLL_LOCK_INDEX);
}
# endif
# if defined(COMPOSE_LOCK_INDEX)
if (host_keyboard_led_state().compose) {
SET_LED_ON(COMPOSE_LOCK_INDEX);
}
# endif
# if defined(KANA_LOCK_INDEX)
if (host_keyboard_led_state().kana) {
SET_LED_ON(KANA_LOCK_INDEX);
}
# endif
}
bool LED_INDICATORS_KB(void) {
if (get_transport() & TRANSPORT_WIRELESS) {
/* Prevent backlight flash caused by key activities */
if (battery_is_critical_low()) {
SET_ALL_LED_OFF();
return true;
}
# if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
if (battery_is_empty()) SET_ALL_LED_OFF();
# if defined(LOW_BAT_IND_INDEX)
if (bat_low_ind_state && (bat_low_ind_state & 0x0F) <= LOW_BAT_LED_BLINK_TIMES) {
uint8_t idx_list[] = LOW_BAT_IND_INDEX;
for (uint8_t i = 0; i < sizeof(idx_list); i++) {
if (bat_low_ind_state & LED_ON) {
SET_LED_LOW_BAT(idx_list[i]);
} else {
SET_LED_OFF(idx_list[i]);
}
}
}
# endif
# endif
# if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
if (bat_level_animiation_actived()) {
bat_level_animiation_indicate();
}
# endif
static uint8_t last_host_index = 0xFF;
if (indicator_config.value) {
uint8_t host_index = indicator_config.value & HOST_INDEX_MASK;
if (indicator_config.highlight) {
SET_ALL_LED_OFF();
} else if (last_host_index != host_index) {
if (indicator_config.value & HOST_P2P4G)
SET_LED_OFF(p2p4g_host_led_matrix_list[host_index - 1]);
else
SET_LED_OFF(bt_host_led_matrix_list[host_index - 1]);
last_host_index = host_index;
}
if (indicator_config.value & LED_ON) {
# ifdef P2P4G_HOST_LED_MATRIX_LIST
if (indicator_config.value & HOST_P2P4G)
SET_LED_P24G(p2p4g_host_led_matrix_list[host_index - 1]);
else
# endif
SET_LED_BT(bt_host_led_matrix_list[host_index - 1]);
} else {
# ifdef P2P4G_HOST_LED_MATRIX_LIST
if (indicator_config.value & HOST_P2P4G)
SET_LED_OFF(p2p4g_host_led_matrix_list[host_index - 1]);
else
# endif
SET_LED_OFF(bt_host_led_matrix_list[host_index - 1]);
}
} else
os_state_indicate();
} else
os_state_indicate();
if (!LED_INDICATORS_USER()) return true;
return true;
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
led_update_ports(led_state);
if (!LED_DRIVER_IS_ENABLED() || (LED_DRIVER_IS_ENABLED() && LED_DRIVER_TIMEOUTED())) {
# if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
LED_DRIVER_EXIT_SHUTDOWN();
# endif
SET_ALL_LED_OFF();
os_state_indicate();
LED_DRIVER.flush();
# if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
if (LED_DRIVER_ALLOW_SHUTDOWN()) LED_DRIVER_SHUTDOWN();
# endif
}
}
return res;
}
void LED_NONE_INDICATORS_KB(void) {
# if defined(RGB_DISABLE_WHEN_USB_SUSPENDED)
if (get_transport() == TRANSPORT_USB && USB_DRIVER.state == USB_SUSPENDED) return;
# endif
# if defined(LED_DISABLE_WHEN_USB_SUSPENDED)
if (get_transport() == TRANSPORT_USB && USB_DRIVER.state == USB_SUSPENDED) return;
# endif
os_state_indicate();
}
# if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
bool LED_DRIVER_ALLOW_SHUTDOWN(void) {
# if defined(NUM_LOCK_INDEX)
if (host_keyboard_led_state().num_lock) return false;
# endif
# if defined(CAPS_LOCK_INDEX) && !defined(DIM_CAPS_LOCK)
if (host_keyboard_led_state().caps_lock) return false;
# endif
# if defined(SCROLL_LOCK_INDEX)
if (host_keyboard_led_state().scroll_lock) return false;
# endif
# if defined(COMPOSE_LOCK_INDEX)
if (host_keyboard_led_state().compose) return false;
# endif
# if defined(KANA_LOCK_INDEX)
if (host_keyboard_led_state().kana) return false;
# endif
return true;
}
# endif
#endif

117
keyboards/lemokey/common/wireless/indicator.h Normal file
View file

@ -0,0 +1,117 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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.h"
#include "wireless.h"
/* Indication of pairing */
#ifndef INDICATOR_CONFIG_PARING
# define INDICATOR_CONFIG_PARING {INDICATOR_BLINK, 1000, 1000, 0, true, 0};
#endif
/* Indication on Connected */
#ifndef INDICATOR_CONFIG_CONNECTD
# define INDICATOR_CONFIG_CONNECTD {INDICATOR_ON_OFF, 2000, 250, 2000, true, 0};
#endif
/* Reconnecting indication */
#ifndef INDICATOR_CONFIG_RECONNECTING
# define INDICATOR_CONFIG_RECONNECTING {INDICATOR_BLINK, 100, 100, 600, true, 0};
#endif
/* Disconnected indication */
#ifndef INDICATOR_CONFIG_DISCONNECTED
# define INDICATOR_CONFIG_DISCONNECTED {INDICATOR_NONE, 100, 100, 600, false, 0};
#endif
/* Uint: Second */
#ifndef DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT
# define DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME 40
#endif
/* Uint: Second, the timer restarts on key activities. */
#ifndef CONNECTED_BACKLIGHT_DISABLE_TIMEOUT
# define CONNECTED_BACKLIGHT_OFF_DELAY_TIME 600
#endif
#ifdef BAT_LOW_LED_PIN
/* Uint: ms */
# ifndef LOW_BAT_LED_BLINK_PERIOD
# define LOW_BAT_LED_BLINK_PERIOD 1000
# endif
# ifndef LOW_BAT_LED_BLINK_DURATION
# define LOW_BAT_LED_BLINK_DURATION 10000
# endif
#endif
#ifdef LOW_BAT_IND_INDEX
/* Uint: ms */
# ifndef LOW_BAT_LED_BLINK_PERIOD
# define LOW_BAT_LED_BLINK_PERIOD 500
# endif
# ifndef LOW_BAT_LED_BLINK_TIMES
# define LOW_BAT_LED_BLINK_TIMES 3
# endif
# ifndef LOW_BAT_LED_TRIG_INTERVAL
# define LOW_BAT_LED_TRIG_INTERVAL 30000
# endif
#endif
#if BT_HOST_MAX_COUNT > 6
# pragma error("HOST_COUNT max value is 6")
#endif
typedef enum { INDICATOR_NONE, INDICATOR_OFF, INDICATOR_ON, INDICATOR_ON_OFF, INDICATOR_BLINK, INDICATOR_LAST } indicator_type_t;
typedef struct PACKED {
indicator_type_t type;
uint32_t on_time;
uint32_t off_time;
uint32_t duration;
bool highlight;
uint8_t value;
uint32_t elapsed;
} indicator_config_t;
typedef struct PACKED {
uint8_t value;
bool saved;
} backlight_state_t;
void indicator_init(void);
void indicator_set(wt_state_t state, uint8_t host_index);
void indicator_backlight_timer_reset(bool enable);
bool indicator_hook_key(uint16_t keycode);
void indicator_enable(void);
void indicator_disable(void);
void indicator_stop(void);
void indicator_eeconfig_reload(void);
bool indicator_is_enabled(void);
bool indicator_is_running(void);
#ifdef BAT_LOW_LED_PIN
void indicator_battery_low_enable(bool enable);
#endif
#if defined(LOW_BAT_IND_INDEX)
void indicator_battery_low_backlit_enable(bool enable);
#endif
void indicator_task(void);

155
keyboards/lemokey/common/wireless/lemokey_wireless_common.c Normal file
View file

@ -0,0 +1,155 @@
/* Copyright 2022 @ Keychron (https://www.keychron.com)
*
* 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 LK_WIRELESS_ENABLE
# include "lkbt51.h"
# include "wireless.h"
# include "indicator.h"
# include "transport.h"
# include "battery.h"
# include "bat_level_animation.h"
# include "lpm.h"
# include "lemokey_wireless_common.h"
# include "lemokey_task.h"
#endif
#include "lemokey_common.h"
bool firstDisconnect = true;
static uint32_t pairing_key_timer;
static uint8_t host_idx = 0;
bool process_record_lemokey_wireless(uint16_t keycode, keyrecord_t *record) {
static uint8_t host_idx;
switch (keycode) {
case BT_HST1 ... BT_HST3:
if (get_transport() == TRANSPORT_BLUETOOTH) {
if (record->event.pressed) {
host_idx = keycode - BT_HST1 + 1;
pairing_key_timer = timer_read32();
wireless_connect_ex(host_idx, 0);
} else {
host_idx = 0;
pairing_key_timer = 0;
}
}
break;
case P2P4G:
if (get_transport() == TRANSPORT_P2P4) {
if (record->event.pressed) {
host_idx = P24G_INDEX;
pairing_key_timer = timer_read32();
} else {
host_idx = 0;
pairing_key_timer = 0;
}
}
break;
#if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
case BAT_LVL:
if ((get_transport() & TRANSPORT_WIRELESS) && !usb_power_connected()) {
bat_level_animiation_start(battery_get_percentage());
}
break;
#endif
default:
break;
}
return true;
}
void lkbt51_param_init(void) {
/* Set bluetooth device name */
lkbt51_set_local_name(PRODUCT);
wait_ms(3);
// clang-format off
/* Set bluetooth parameters */
module_param_t param = {.event_mode = 0x02,
.connected_idle_timeout = 7200,
.pairing_timeout = 180,
.pairing_mode = 0,
.reconnect_timeout = 5,
.report_rate = 90,
.vendor_id_source = 1,
.verndor_id = 0x362D,
.product_id = PRODUCT_ID};
// clang-format on
lkbt51_set_param(&param);
}
void wireless_enter_reset_kb(uint8_t reason) {
lkbt51_param_init();
}
void wireless_enter_disconnected_kb(uint8_t host_idx) {
/* CKBT51 bluetooth module boot time is slower, it enters disconnected after boot,
so we place initialization here. */
if (firstDisconnect && timer_read32() < 1000) {
lkbt51_param_init();
if (get_transport() == TRANSPORT_BLUETOOTH) wireless_connect();
firstDisconnect = false;
}
}
void lemokey_wireless_common_task(void) {
if (pairing_key_timer) {
if (timer_elapsed32(pairing_key_timer) > 2000) {
pairing_key_timer = 0;
wireless_pairing_ex(host_idx, NULL);
}
}
}
void wireless_pre_task(void) {
static uint8_t mode = 0;
static uint32_t time = 0;
if (time == 0) {
if ((readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN)) != mode) {
mode = readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN);
time = timer_read32();
}
}
if ((time && timer_elapsed32(time) > 100) || get_transport() == TRANSPORT_NONE) {
if ((readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN)) == mode) {
time = 0;
switch (mode) {
case 0x01:
set_transport(TRANSPORT_BLUETOOTH);
break;
case 0x02:
set_transport(TRANSPORT_P2P4);
break;
case 0x03:
set_transport(TRANSPORT_USB);
break;
default:
break;
}
} else {
mode = readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN);
time = timer_read32();
}
}
}

26
keyboards/lemokey/common/wireless/lemokey_wireless_common.h Normal file
View file

@ -0,0 +1,26 @@
/* Copyright 2023 @ Keychron (https://www.lemokey.com)
*
* 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"
#ifdef VIA_ENABLE
# include "via.h"
#endif
#include "quantum_keycodes.h"
void lkbt51_param_init(void);
bool process_record_lemokey_wireless(uint16_t keycode, keyrecord_t *record);
void lemokey_wireless_common_task(void);

867
keyboards/lemokey/common/wireless/lkbt51.c Normal file
View file

@ -0,0 +1,867 @@
/* Copyright 2021 @ Keychron (https://www.keychron.com)
*
* 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 "quantum.h"
#include "lkbt51.h"
#include "wireless.h"
#include "wireless_event_type.h"
#include "battery.h"
#include "raw_hid.h"
#include "report_buffer.h"
#include "factory_test.h"
extern void factory_test_send(uint8_t* payload, uint8_t length);
# ifndef RAW_EPSIZE
# define RAW_EPSIZE 32
# endif
#ifndef SPI_SCK_PIN
# define SPI_SCK_PIN A5
#endif
#ifndef SPI_MISO_PIN
# define SPI_MISO_PIN A6
#endif
#ifndef SPI_MOSI_PIN
# define SPI_MOSI_PIN A7
#endif
#ifndef SPI_CLK_PAL_MODE
# define SPI_CLK_PAL_MODE 5
#endif
#ifndef SPI_MISO_PAL_MODE
# define SPI_MISO_PAL_MODE 5
#endif
#ifndef SPI_MOSI_PAL_MODE
# define SPI_MOSI_PAL_MODE 5
#endif
#ifndef LKBT51_INT_INPUT_PIN
# error "LKBT51_INT_INPUT_PIN is not defined"
#endif
#ifndef LKBT51_TX_RETRY_COUNT
# define LKBT51_TX_RETRY_COUNT 3
#endif
// clang-format off
enum {
/* HID Report */
LKBT51_CMD_SEND_KB = 0x11,
LKBT51_CMD_SEND_KB_NKRO = 0x12,
LKBT51_CMD_SEND_CONSUMER = 0x13,
LKBT51_CMD_SEND_SYSTEM = 0x14,
LKBT51_CMD_SEND_FN = 0x15, // Not used currently
LKBT51_CMD_SEND_MOUSE = 0x16,
LKBT51_CMD_SEND_BOOT_KB = 0x17,
/* Bluetooth connections */
LKBT51_CMD_PAIRING = 0x21,
LKBT51_CMD_CONNECT = 0x22,
LKBT51_CMD_DISCONNECT = 0x23,
LKBT51_CMD_SWITCH_HOST = 0x24,
LKBT51_CMD_READ_STATE_REG = 0x25,
/* Battery */
LKBT51_CMD_BATTERY_MANAGE = 0x31,
LKBT51_CMD_UPDATE_BAT_LVL = 0x32,
LKBT51_CMD_UPDATE_BAT_STATE = 0x33,
/* Set/get parameters */
LKBT51_CMD_GET_MODULE_INFO = 0x40,
LKBT51_CMD_SET_CONFIG = 0x41,
LKBT51_CMD_GET_CONFIG = 0x42,
LKBT51_CMD_SET_BDA = 0x43,
LKBT51_CMD_GET_BDA = 0x44,
LKBT51_CMD_SET_NAME = 0x45,
LKBT51_CMD_GET_NAME = 0x46,
LKBT51_CMD_WRTE_CSTM_DATA = 0x49,
/* DFU */
LKBT51_CMD_GET_DFU_VER = 0x60,
LKBT51_CMD_HAND_SHAKE_TOKEN = 0x61,
LKBT51_CMD_START_DFU = 0x62,
LKBT51_CMD_SEND_FW_DATA = 0x63,
LKBT51_CMD_VERIFY_CRC32 = 0x64,
LKBT51_CMD_SWITCH_FW = 0x65,
/* Factory test */
LKBT51_CMD_FACTORY_RESET = 0x71,
LKBT51_CMD_IO_TEST = 0x72,
LKBT51_CMD_RADIO_TEST = 0x73,
/* Event */
LKBT51_EVT_LKBT51_CMD_RECEIVED = 0xA1,
LKBT51_EVT_OTA_RSP = 0xA3,
LKBT51_CONNECTION_EVT_ACK = 0xA4,
};
enum {
LKBT51_EVT_ACK = 0xA1,
LKBT51_EVT_QUERY_RSP = 0xA2,
LKBT51_EVT_RESET = 0xB0,
LKBT51_EVT_LE_CONNECTION = 0xB1,
LKBT51_EVT_HOST_TYPE = 0xB2,
LKBT51_EVT_CONNECTION = 0xB3,
LKBT51_EVT_HID_EVENT = 0xB4,
LKBT51_EVT_BATTERY = 0xB5,
};
enum {
LKBT51_CONNECTED = 0x20,
LKBT51_DISCOVERABLE = 0x21,
LKBT51_RECONNECTING = 0x22,
LKBT51_DISCONNECTED = 0x23,
LKBT51_PINCODE_ENTRY = 0x24,
LKBT51_EXIT_PINCODE_ENTRY = 0x25,
LKBT51_SLEEP = 0x26
};
enum {
ACK_SUCCESS = 0x00,
ACK_CHECKSUM_ERROR,
ACK_FIFO_HALF_WARNING,
ACK_FIFO_FULL_ERROR,
};
enum{
LK_EVT_MSK_CONNECTION = 0x01 << 0,
LK_EVT_MSK_LED = 0x01 << 1,
LK_EVT_MSK_BATT = 0x01 << 2,
LK_EVT_MSK_RESET = 0x01 << 3,
LK_EVT_MSK_RPT_INTERVAL = 0x01 << 4,
LK_EVT_MSK_MD = 0x01 << 7,
};
// clang-format on
static uint8_t payload[PACKET_MAX_LEN];
static uint8_t reg_offset = 0xFF;
static uint8_t expect_len = 22;
static uint16_t connection_interval = 1;
static uint32_t wake_time;
// clang-format off
wt_func_t wireless_transport = {
lkbt51_init,
lkbt51_connect,
lkbt51_become_discoverable,
lkbt51_disconnect,
lkbt51_send_keyboard,
lkbt51_send_nkro,
lkbt51_send_consumer,
lkbt51_send_system,
lkbt51_send_mouse,
lkbt51_update_bat_lvl,
lkbt51_task
};
// clang-format on
/* Init SPI */
const SPIConfig spicfg = {
.circular = false,
.slave = false,
.data_cb = NULL,
.error_cb = NULL,
.ssport = PAL_PORT(BLUETOOTH_INT_OUTPUT_PIN),
.sspad = PAL_PAD(BLUETOOTH_INT_OUTPUT_PIN),
.cr1 = SPI_CR1_MSTR | SPI_CR1_BR_1 | SPI_CR1_BR_0,
.cr2 = 0U,
};
void lkbt51_init(bool wakeup_from_low_power_mode) {
#ifdef LKBT51_RESET_PIN
if (!wakeup_from_low_power_mode) {
setPinOutput(LKBT51_RESET_PIN);
writePinLow(LKBT51_RESET_PIN);
wait_ms(1);
writePinHigh(LKBT51_RESET_PIN);
}
#endif
#if (HAL_USE_SPI == TRUE)
if (WT_DRIVER.state == SPI_UNINIT) {
setPinOutput(SPI_SCK_PIN);
writePinHigh(SPI_SCK_PIN);
palSetLineMode(SPI_SCK_PIN, PAL_MODE_ALTERNATE(SPI_CLK_PAL_MODE));
palSetLineMode(SPI_MISO_PIN, PAL_MODE_ALTERNATE(SPI_MISO_PAL_MODE));
palSetLineMode(SPI_MOSI_PIN, PAL_MODE_ALTERNATE(SPI_MOSI_PAL_MODE));
if (wakeup_from_low_power_mode) {
spiInit();
return;
}
spiInit();
}
#endif
setPinOutput(BLUETOOTH_INT_OUTPUT_PIN);
writePinHigh(BLUETOOTH_INT_OUTPUT_PIN);
setPinInputHigh(LKBT51_INT_INPUT_PIN);
}
static inline void lkbt51_wake(void) {
if (timer_elapsed32(wake_time) > 3000) {
wake_time = timer_read32();
palWriteLine(BLUETOOTH_INT_OUTPUT_PIN, 0);
wait_ms(10);
palWriteLine(BLUETOOTH_INT_OUTPUT_PIN, 1);
wait_ms(300);
}
}
void lkbt51_send_protocol_ver(uint16_t ver) {
uint8_t pkt[PACKET_MAX_LEN] = {0};
memset(pkt, 0, PACKET_MAX_LEN);
uint8_t i = 0;
pkt[i++] = 0x84;
pkt[i++] = 0x7e;
pkt[i++] = 0x00;
pkt[i++] = 0x00;
pkt[i++] = 0xAA;
pkt[i++] = 0x54;
pkt[i++] = ver & 0xFF;
pkt[i++] = (ver >> 8) & 0xFF;
pkt[i++] = (uint8_t)(~0x54);
pkt[i++] = (uint8_t)(~0xAA);
#if HAL_USE_SPI
expect_len = 10;
spiStart(&WT_DRIVER, &spicfg);
spiSelect(&WT_DRIVER);
spiSend(&WT_DRIVER, i, pkt);
spiUnselectI(&WT_DRIVER);
spiStop(&WT_DRIVER);
#endif
}
void lkbt51_send_cmd(uint8_t* payload, uint8_t len, bool ack_enable, bool retry) {
static uint8_t sn = 0;
uint8_t i;
uint8_t pkt[PACKET_MAX_LEN] = {0};
memset(pkt, 0, PACKET_MAX_LEN);
if (!retry) ++sn;
if (sn == 0) ++sn;
uint16_t checksum = 0;
for (i = 0; i < len; i++)
checksum += payload[i];
i = 0;
pkt[i++] = 0x84;
pkt[i++] = 0x7e;
pkt[i++] = 0x00;
pkt[i++] = 0x00;
pkt[i++] = 0xAA;
pkt[i++] = ack_enable ? 0x56 : 0x55;
pkt[i++] = len + 2;
pkt[i++] = ~(len + 2) & 0xFF;
pkt[i++] = sn;
memcpy(pkt + i, payload, len);
i += len;
pkt[i++] = checksum & 0xFF;
pkt[i++] = (checksum >> 8) & 0xFF;
#if HAL_USE_SPI
if ((payload[0] & 0xF0) == 0x60)
expect_len = 64;
else
expect_len = 64;
spiStart(&WT_DRIVER, &spicfg);
spiSelect(&WT_DRIVER);
spiSend(&WT_DRIVER, i, pkt);
spiUnselectI(&WT_DRIVER);
spiStop(&WT_DRIVER);
#endif
}
void lkbt51_read(uint8_t* payload, uint8_t len) {
uint8_t i;
uint8_t pkt[PACKET_MAX_LEN] = {0};
memset(pkt, 0, PACKET_MAX_LEN);
i = 0;
pkt[i++] = 0x84;
pkt[i++] = 0x7f;
pkt[i++] = 0x00;
pkt[i++] = 0x80;
i += len;
#if HAL_USE_SPI
spiStart(&WT_DRIVER, &spicfg);
spiSelect(&WT_DRIVER);
spiExchange(&WT_DRIVER, i, pkt, payload);
spiUnselect(&WT_DRIVER);
spiStop(&WT_DRIVER);
#endif
}
void lkbt51_send_keyboard(uint8_t* report) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SEND_KB;
memcpy(payload + i, report, 8);
i += 8;
lkbt51_send_cmd(payload, i, true, false);
}
void lkbt51_send_nkro(uint8_t* report) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SEND_KB_NKRO;
memcpy(payload + i, report, 20); // NKRO report lenght is limited to 20 bytes
i += 20;
lkbt51_send_cmd(payload, i, true, false);
}
void lkbt51_send_consumer(uint16_t report) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SEND_CONSUMER;
payload[i++] = report & 0xFF;
payload[i++] = ((report) >> 8) & 0xFF;
i += 4; // QMK doesn't send multiple consumer reports, just skip 2nd and 3rd consumer reports
lkbt51_send_cmd(payload, i, true, false);
}
void lkbt51_send_system(uint16_t report) {
uint8_t hid_usage = report & 0xFF;
if (hid_usage < 0x81 || hid_usage > 0x83) return;
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SEND_SYSTEM;
payload[i++] = 0x01 << (hid_usage - 0x81);
lkbt51_send_cmd(payload, i, true, false);
}
void lkbt51_send_mouse(uint8_t* report) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SEND_MOUSE; // Cmd type
payload[i++] = report[1]; // Button
payload[i++] = report[2]; // X
payload[i++] = (report[2] & 0x80) ? 0xff : 0x00; // ckbt51 use 16bit report, set high byte
payload[i++] = report[3]; // Y
payload[i++] = (report[3] & 0x80) ? 0xff : 0x00; // ckbt51 use 16bit report, set high byte
payload[i++] = report[4]; // V wheel
payload[i++] = report[5]; // H wheel
lkbt51_send_cmd(payload, i, false, false);
}
/* Send ack to connection event, wireless module will retry 2 times if no ack received */
void lkbt51_send_conn_evt_ack(void) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CONNECTION_EVT_ACK;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_become_discoverable(uint8_t host_idx, void* param) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
pairing_param_t default_pairing_param = {0, 0, PAIRING_MODE_LESC_OR_SSP, BT_MODE_CLASSIC, 0, NULL};
if (param == NULL) {
param = &default_pairing_param;
}
pairing_param_t* p = (pairing_param_t*)param;
payload[i++] = LKBT51_CMD_PAIRING; // Cmd type
payload[i++] = host_idx; // Host Index
payload[i++] = p->timeout & 0xFF; // Timeout
payload[i++] = (p->timeout >> 8) & 0xFF;
payload[i++] = p->pairingMode;
payload[i++] = p->BRorLE; // BR/LE
payload[i++] = p->txPower; // LE TX POWER
if (p->leName) {
memcpy(&payload[i], p->leName, strlen(p->leName));
i += strlen(p->leName);
}
lkbt51_wake();
lkbt51_send_cmd(payload, i, true, false);
}
/* Timeout : 2 ~ 255 seconds */
void lkbt51_connect(uint8_t hostIndex, uint16_t timeout) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_CONNECT;
payload[i++] = hostIndex; // Host index
payload[i++] = timeout & 0xFF; // Timeout
payload[i++] = (timeout >> 8) & 0xFF;
lkbt51_wake();
lkbt51_send_cmd(payload, i, true, false);
}
void lkbt51_disconnect(void) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_DISCONNECT;
payload[i++] = 0; // Sleep mode
spiSelect(&SPID1);
wait_ms(30);
// spiUnselect(&SPID1);
wait_ms(70);
lkbt51_send_cmd(payload, i, true, false);
}
void lkbt51_switch_host(uint8_t hostIndex) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SWITCH_HOST;
payload[i++] = hostIndex;
lkbt51_send_cmd(payload, i, true, false);
}
void lkbt51_read_state_reg(uint8_t reg, uint8_t len) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_READ_STATE_REG;
payload[i++] = reg_offset = reg;
payload[i++] = len;
// TODO
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_update_bat_lvl(uint8_t bat_lvl) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_UPDATE_BAT_LVL;
payload[i++] = bat_lvl;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_update_bat_state(uint8_t bat_state) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_UPDATE_BAT_STATE;
payload[i++] = bat_state;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_get_info(module_info_t* info) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_GET_MODULE_INFO;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_set_param(module_param_t* param) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SET_CONFIG;
memcpy(payload + i, param, sizeof(module_param_t));
i += sizeof(module_param_t);
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_get_param(module_param_t* param) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_GET_CONFIG;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_set_local_name(const char* name) {
uint8_t i = 0;
uint8_t len = strlen(name);
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_SET_NAME;
memcpy(payload + i, name, len);
i += len;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_get_local_name(void) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_GET_NAME;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_factory_reset(uint8_t p2p4g_clr_msk) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_FACTORY_RESET;
payload[i++] = p2p4g_clr_msk;
lkbt51_wake();
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_int_pin_test(bool enable) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_IO_TEST;
payload[i++] = enable;
lkbt51_send_cmd(payload, i, false, false);
}
void lkbt51_radio_test(uint8_t channel) {
uint8_t i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_RADIO_TEST;
payload[i++] = channel;
payload[i++] = 0;
lkbt51_send_cmd(payload, i, false, false);
}
bool lkbt51_read_customize_data(uint8_t* data, uint8_t len) {
uint8_t i;
uint8_t buf[20] = {0};
i = 0;
buf[i++] = 0x84;
buf[i++] = 0x7a;
buf[i++] = 0x00;
buf[i++] = 0x80;
#if HAL_USE_SPI
spiStart(&WT_DRIVER, &spicfg);
spiSelect(&WT_DRIVER);
spiExchange(&WT_DRIVER, 20, buf, payload);
uint16_t state = buf[5] | (buf[6] << 8);
if (state == 0x9527) spiExchange(&WT_DRIVER, len, data, payload);
spiUnselect(&WT_DRIVER);
spiStop(&WT_DRIVER);
#endif
return true;
}
void lkbt51_write_customize_data(uint8_t* data, uint8_t len) {
uint8_t i;
uint8_t pkt[PACKET_MAX_LEN] = {0};
i = 0;
pkt[i++] = 0x84;
pkt[i++] = 0x7a;
pkt[i++] = 0x00;
pkt[i++] = 0x00;
#if HAL_USE_SPI
spiStart(&WT_DRIVER, &spicfg);
spiSelect(&WT_DRIVER);
spiSend(&WT_DRIVER, i, pkt);
spiSend(&WT_DRIVER, len, data);
spiUnselectI(&WT_DRIVER);
spiStop(&WT_DRIVER);
#endif
i = 0;
memset(payload, 0, PACKET_MAX_LEN);
payload[i++] = LKBT51_CMD_WRTE_CSTM_DATA;
lkbt51_send_cmd(payload, i, false, false);
}
#ifdef RAW_ENABLE
void lkbt51_dfu_tx(uint8_t rsp, uint8_t* data, uint8_t len, uint8_t sn) {
uint16_t checksum = 0;
uint8_t buf[RAW_EPSIZE] = {0};
uint8_t i = 0;
buf[i++] = 0x03;
buf[i++] = 0xAA;
buf[i++] = 0x57;
buf[i++] = len;
buf[i++] = ~len;
buf[i++] = sn;
buf[i++] = rsp;
memcpy(&buf[i], data, len);
i += len;
for (uint8_t k = 0; k < i; k++)
checksum += buf[i];
raw_hid_send(buf, RAW_EPSIZE);
if (len > 25) {
i = 0;
memset(buf, 0, RAW_EPSIZE);
buf[i++] = 0x03;
memcpy(&buf[i], data + 25, len - 25);
i = i + len - 25;
raw_hid_send(buf, RAW_EPSIZE);
}
}
#endif
void lkbt51_dfu_rx(uint8_t* data, uint8_t length) {
if (data[0] == 0xAA && (data[1] == 0x55 || data[1] == 0x56) && data[2] == (~data[3] & 0xFF)) {
uint16_t checksum = 0;
uint8_t payload_len = data[2];
/* Check payload_len validity */
if (payload_len > RAW_EPSIZE - PACKECT_HEADER_LEN) return;
uint8_t* payload = &data[PACKECT_HEADER_LEN];
for (uint8_t i = 0; i < payload_len - 2; i++) {
checksum += payload[i];
}
/* Verify checksum */
if ((checksum & 0xFF) != payload[payload_len - 2] || checksum >> 8 != payload[payload_len - 1]) return;
static uint8_t sn = 0;
bool retry = true;
if (sn != data[4]) {
sn = data[4];
retry = false;
}
if ((payload[0] & 0xF0) == 0x60) {
lkbt51_wake();
lkbt51_send_cmd(payload, payload_len - 2, data[1] == 0x56, retry);
}
}
}
static void ack_handler(uint8_t* data, uint8_t len) {
switch (data[1]) {
case LKBT51_CMD_SEND_KB:
case LKBT51_CMD_SEND_KB_NKRO:
case LKBT51_CMD_SEND_CONSUMER:
case LKBT51_CMD_SEND_SYSTEM:
case LKBT51_CMD_SEND_MOUSE:
switch (data[2]) {
case ACK_SUCCESS:
report_buffer_set_retry(0);
report_buffer_set_inverval(connection_interval);
break;
case ACK_FIFO_HALF_WARNING:
report_buffer_set_retry(0);
report_buffer_set_inverval(connection_interval + 5);
break;
case ACK_FIFO_FULL_ERROR:
report_buffer_set_inverval(connection_interval + 10);
break;
}
break;
default:
break;
}
}
static void query_rsp_handler(uint8_t* data, uint8_t len) {
if (data[2]) return;
switch (data[1]) {
case LKBT51_CMD_IO_TEST:
factory_test_send(data, len);
break;
default:
break;
}
}
static void lkbt51_event_handler(uint8_t evt_type, uint8_t* data, uint8_t len, uint8_t sn) {
wireless_event_t event = {0};
switch (evt_type) {
case LKBT51_EVT_ACK:
ack_handler(data, len);
break;
case LKBT51_EVT_RESET:
kc_printf("LKBT51_EVT_RESET\n");
event.evt_type = EVT_RESET;
event.params.reason = data[0];
break;
case LKBT51_EVT_LE_CONNECTION:
kc_printf("LKBT51_EVT_LE_CONNECTION\n");
break;
case LKBT51_EVT_HOST_TYPE:
kc_printf("LKBT51_EVT_HOST_TYPE\n");
break;
case LKBT51_EVT_HID_EVENT:
kc_printf("LKBT51_EVT_HID_EVENT\n");
event.evt_type = EVT_HID_INDICATOR;
event.params.led = data[0];
break;
case LKBT51_EVT_QUERY_RSP:
kc_printf("LKBT51_EVT_QUERY_RSP\n\r");
query_rsp_handler(data, len);
break;
case LKBT51_EVT_OTA_RSP:
#ifdef RAW_ENABLE
kc_printf("LKBT51_EVT_OTA_RSP\n");
lkbt51_dfu_tx(LKBT51_EVT_OTA_RSP, data, len, sn);
#endif
break;
default:
kc_printf("Unknown event!!!\n");
break;
}
if (event.evt_type) wireless_event_enqueue(event);
}
void lkbt51_task(void) {
#define VALID_DATA_START_INDEX 4
#define BUFFER_SIZE 64
static bool wait_for_new_pkt = true;
static uint8_t len = 0xff;
static uint8_t sn = 0;
if (readPin(LKBT51_INT_INPUT_PIN) == 0) {
uint8_t buf[BUFFER_SIZE] = {0};
lkbt51_read(buf, expect_len);
uint8_t* pbuf = buf + VALID_DATA_START_INDEX;
if (pbuf[0] == 0xAA && pbuf[1] == 0x54 && pbuf[4] == (uint8_t)(~0x54) && pbuf[5] == (uint8_t)(~0xAA)) {
uint16_t protol_ver = pbuf[3] << 8 | pbuf[2];
kc_printf("protol_ver: %x\n\r", protol_ver);
(void)protol_ver;
} else if (pbuf[0] == 0xAA) {
wireless_event_t event = {0};
uint8_t evt_mask = pbuf[1];
if (evt_mask & LK_EVT_MSK_RESET) {
event.evt_type = EVT_RESET;
event.params.reason = pbuf[2];
wireless_event_enqueue(event);
}
if (evt_mask & LK_EVT_MSK_CONNECTION) {
lkbt51_send_conn_evt_ack();
switch (pbuf[2]) {
case LKBT51_CONNECTED:
event.evt_type = EVT_CONNECTED;
break;
case LKBT51_DISCOVERABLE:
event.evt_type = EVT_DISCOVERABLE;
break;
case LKBT51_RECONNECTING:
event.evt_type = EVT_RECONNECTING;
break;
case LKBT51_DISCONNECTED:
event.evt_type = EVT_DISCONNECTED;
break;
case LKBT51_PINCODE_ENTRY:
event.evt_type = EVT_BT_PINCODE_ENTRY;
break;
case LKBT51_EXIT_PINCODE_ENTRY:
event.evt_type = EVT_EXIT_BT_PINCODE_ENTRY;
break;
case LKBT51_SLEEP:
event.evt_type = EVT_SLEEP;
break;
}
event.params.hostIndex = pbuf[3];
wireless_event_enqueue(event);
}
if (evt_mask & LK_EVT_MSK_LED) {
memset(&event, 0, sizeof(event));
event.evt_type = EVT_HID_INDICATOR;
event.params.led = pbuf[4];
wireless_event_enqueue(event);
}
if (evt_mask & LK_EVT_MSK_RPT_INTERVAL) {
uint32_t interval;
if (pbuf[8] & 0x80) {
interval = (pbuf[8] & 0x7F) * 1250;
} else {
interval = (pbuf[8] & 0x7F) * 125;
}
connection_interval = interval / 1000;
if (connection_interval > 7) connection_interval /= 3;
memset(&event, 0, sizeof(event));
event.evt_type = EVT_CONECTION_INTERVAL;
event.params.interval = connection_interval;
wireless_event_enqueue(event);
}
if (evt_mask & LK_EVT_MSK_BATT) {
battery_calculate_voltage(true, pbuf[6] << 8 | pbuf[5]);
}
}
pbuf = buf;
if (wait_for_new_pkt) {
for (uint8_t i = 10; i < BUFFER_SIZE - 5; i++) {
if (buf[i] == 0xAA && buf[i + 1] == 0x57 // Packet Head
&& (~buf[i + 2] & 0xFF) == buf[i + 3]) { // Check wheather len is valid
len = buf[i + 2];
sn = buf[i + 4];
pbuf = &buf[i + 5];
wait_for_new_pkt = false;
}
}
}
if (!wait_for_new_pkt && BUFFER_SIZE - 5 >= len) {
wait_for_new_pkt = true;
uint16_t checksum = 0;
for (int i = 0; i < len - 2; i++) {
checksum += pbuf[i];
}
if ((checksum & 0xff) == pbuf[len - 2] && ((checksum >> 8) & 0xff) == pbuf[len - 1]) {
lkbt51_event_handler(pbuf[0], pbuf + 1, len - 3, sn);
} else {
// TODO: Error handle
}
}
}
}

131
keyboards/lemokey/common/wireless/lkbt51.h Normal file
View file

@ -0,0 +1,131 @@
/* Copyright 2023 @ Keychron (https://www.keychron.com)
*
* 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 "stdint.h"
#include "hal.h"
#ifndef WT_DRIVER
# define WT_DRIVER SPID1
#endif
// Error checking
#if HAL_USE_SPI == FALSE
# error "Please enable SPI to use LKBT51"
#endif
#if !STM32_SPI_USE_SPI1 && !STM32_SPI_USE_SPI2 && !STM32_SPI_USE_SPI3
# error "WT driver activated but no SPI peripheral assigned"
#endif
#define PACKECT_HEADER_LEN 5
#define BDA_LEN 6
#define PACKET_MAX_LEN 64
#define P24G_INDEX 24
enum {
PAIRING_MODE_DEFAULT = 0x00,
PAIRING_MODE_JUST_WORK,
PAIRING_MODE_PASSKEY_ENTRY,
PAIRING_MODE_LESC_OR_SSP,
PAIRING_MODE_INVALID,
};
enum {
BT_MODE_DEFAUL,
BT_MODE_CLASSIC,
BT_MODE_LE,
BT_MODE_INVALID,
};
typedef struct {
uint8_t hostIndex;
uint16_t timeout; /* Pairing timeout, valid value range from 30 to 3600 seconds, 0 for default */
uint8_t pairingMode; /* 0: default, 1: Just Works, 2: Passkey Entry */
uint8_t BRorLE; /* Only available for dual mode module. Keep 0 for single mode module */
uint8_t txPower; /* Only available for BLE module */
const char* leName; /* Only available for BLE module */
} pairing_param_t;
typedef struct {
uint8_t type;
uint16_t full_votage;
uint16_t empty_voltage;
uint16_t shutdown_voltage;
} battery_param_t;
typedef struct {
uint8_t model_name[11];
uint8_t mode;
uint8_t bluetooth_version;
uint8_t firmware_version[11];
uint8_t hardware_version[11];
uint16_t cmd_set_verson;
} __attribute__((packed)) module_info_t;
typedef struct {
uint8_t event_mode; /* Must be 0x02 */
uint16_t connected_idle_timeout;
uint16_t pairing_timeout; /* Range: 30 ~ 3600 second, 0 for default */
uint8_t pairing_mode; /* 0: default, 1: Just Works, 2: Passkey Entry */
uint16_t reconnect_timeout; /* 0: default, 0xFF: Unlimited time, 2 ~ 254 seconds */
uint8_t report_rate; /* 90 or 133 */
uint8_t rsvd1;
uint8_t rsvd2;
uint8_t vendor_id_source; /* 0: From Bluetooth SIG, 1: From USB-IF */
uint16_t verndor_id; /* No effect, the vendor ID is 0x362D*/
uint16_t product_id;
/* Below parametes is only available for BLE module */
uint16_t le_connection_interval_min;
uint16_t le_connection_interval_max;
uint16_t le_connection_interval_timeout;
} __attribute__((packed)) module_param_t;
void lkbt51_init(bool wakeup_from_low_power_mode);
void lkbt51_send_protocol_ver(uint16_t ver);
void lkbt51_send_cmd(uint8_t* payload, uint8_t len, bool ack_enable, bool retry);
void lkbt51_send_keyboard(uint8_t* report);
void lkbt51_send_nkro(uint8_t* report);
void lkbt51_send_consumer(uint16_t report);
void lkbt51_send_system(uint16_t report);
void lkbt51_send_mouse(uint8_t* report);
void lkbt51_become_discoverable(uint8_t host_idx, void* param);
void lkbt51_connect(uint8_t hostIndex, uint16_t timeout);
void lkbt51_disconnect(void);
void lkbt51_switch_host(uint8_t hostIndex);
void lkbt51_read_state_reg(uint8_t reg, uint8_t len);
void lkbt51_update_bat_lvl(uint8_t bat_lvl);
void lkbt51_update_bat_state(uint8_t bat_state);
void lkbt51_get_info(module_info_t* info);
void lkbt51_set_param(module_param_t* param);
void lkbt51_get_param(module_param_t* param);
void lkbt51_set_local_name(const char* name);
void lkbt51_get_local_name(void);
void lkbt51_factory_reset(uint8_t p2p4g_clr_msk);
void lkbt51_int_pin_test(bool enable);
void lkbt51_dfu_rx(uint8_t* data, uint8_t length);
void lkbt51_radio_test(uint8_t channel);
void lkbt51_write_customize_data(uint8_t* data, uint8_t len);
bool lkbt51_read_customize_data(uint8_t* data, uint8_t len);
void lkbt51_task(void);

277
keyboards/lemokey/common/wireless/lpm.c Normal file
View file

@ -0,0 +1,277 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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/>.
*/
/******************************************************************************
*
* Filename: lpm.c
*
* Description: Contains low power mode implementation
*
******************************************************************************/
#include "quantum.h"
#if defined(PROTOCOL_CHIBIOS)
# include <usb_main.h>
#endif
#include "debounce.h"
#include "wireless.h"
#include "indicator.h"
#include "lpm.h"
#include "transport.h"
#include "battery.h"
#include "report_buffer.h"
#include "lemokey_common.h"
extern matrix_row_t matrix[MATRIX_ROWS];
extern wt_func_t wireless_transport;
static uint32_t lpm_timer_buffer;
static bool lpm_time_up = false;
#ifndef OPTICAL_SWITCH
static matrix_row_t empty_matrix[MATRIX_ROWS] = {0};
#endif
pin_t pins_row[MATRIX_ROWS] = MATRIX_ROW_PINS;
pin_t pins_col[MATRIX_COLS] = MATRIX_COL_PINS;
;
__attribute__((weak)) void select_all_cols(void) {
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
setPinOutput(pins_col[i]);
writePinLow(pins_col[i]);
}
}
void lpm_init(void) {
#ifdef USB_POWER_SENSE_PIN
# if (USB_POWER_CONNECTED_LEVEL == 0)
setPinInputHigh(USB_POWER_SENSE_PIN);
# else
setPinInputLow(USB_POWER_SENSE_PIN);
# endif
#endif
lpm_timer_reset();
}
inline void lpm_timer_reset(void) {
lpm_time_up = false;
lpm_timer_buffer = timer_read32();
}
void lpm_timer_stop(void) {
lpm_time_up = false;
lpm_timer_buffer = 0;
}
static inline bool lpm_any_matrix_action(void) {
#ifdef OPTICAL_SWITCH
bool any_key = false;
for (uint8_t i = 0; i < MATRIX_ROWS; i++)
if (matrix_get_row(i) != 0) {
any_key = true;
}
return any_key;
#else
return memcmp(matrix, empty_matrix, sizeof(empty_matrix));
#endif
}
/* Implement of entering low power mode and wakeup varies per mcu or platform */
__attribute__((weak)) void enter_power_mode(pm_t mode) {}
__attribute__((weak)) bool usb_power_connected(void) {
#ifdef USB_POWER_SENSE_PIN
return readPin(USB_POWER_SENSE_PIN) == USB_POWER_CONNECTED_LEVEL;
#else
return true;
#endif
}
__attribute__((weak)) bool lpm_is_kb_idle(void) {
return true;
}
__attribute__((weak)) bool lpm_set(pm_t mode) {
return false;
}
bool pre_enter_low_power_mode(pm_t mode) {
#if defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
/* Don't enter low power mode if attached to the host */
if (mode > PM_SLEEP && usb_power_connected()) return false;
#endif
if (!lpm_set(mode)) return false;
#if defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
/* Usb unit is actived and running, stop and disconnect first */
usbStop(&USBD1);
usbDisconnectBus(&USBD1);
/* Isolate USB to save power.*/
// PWR->CR2 &= ~PWR_CR2_USV; /*PWR_CR2_USV is available on STM32L4x2xx and STM32L4x3xx devices only. */
#endif
palEnableLineEvent(LKBT51_INT_INPUT_PIN, PAL_EVENT_MODE_FALLING_EDGE);
#ifdef USB_POWER_SENSE_PIN
palEnableLineEvent(USB_POWER_SENSE_PIN, PAL_EVENT_MODE_BOTH_EDGES);
#endif
#ifdef P2P4_MODE_SELECT_PIN
palEnableLineEvent(P2P4_MODE_SELECT_PIN, PAL_EVENT_MODE_BOTH_EDGES);
#endif
#ifdef BT_MODE_SELECT_PIN
palEnableLineEvent(BT_MODE_SELECT_PIN, PAL_EVENT_MODE_BOTH_EDGES);
#endif
#ifdef OPTICAL_SWITCH
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
if (pins_row[x] != NO_PIN) {
writePinLow(pins_row[x]);
}
}
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (pins_col[x] != NO_PIN) {
setPinInputLow(pins_col[x]);
}
}
#else
/* Enable key matrix wake up */
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
if (pins_row[x] != NO_PIN) {
palEnableLineEvent(pins_row[x], PAL_EVENT_MODE_BOTH_EDGES);
}
}
#endif
select_all_cols();
#if (HAL_USE_SPI == TRUE)
palSetLineMode(SPI_SCK_PIN, PAL_MODE_INPUT_PULLDOWN);
palSetLineMode(SPI_MISO_PIN, PAL_MODE_INPUT_PULLDOWN);
palSetLineMode(SPI_MOSI_PIN, PAL_MODE_INPUT_PULLDOWN);
#endif
palSetLineMode(A12, PAL_MODE_INPUT_PULLDOWN);
palSetLineMode(A11, PAL_MODE_INPUT_PULLDOWN);
#if defined(DIP_SWITCH_PINS)
# define NUMBER_OF_DIP_SWITCHES (sizeof(dip_switch_pad) / sizeof(pin_t))
static pin_t dip_switch_pad[] = DIP_SWITCH_PINS;
for (uint8_t i = 0; i < NUMBER_OF_DIP_SWITCHES; i++) {
setPinInputLow(dip_switch_pad[i]);
}
#endif
battery_stop();
return true;
}
static inline void lpm_wakeup(void) {
palSetLineMode(A11, PAL_STM32_OTYPE_PUSHPULL | PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUPDR_FLOATING | PAL_MODE_ALTERNATE(10U));
palSetLineMode(A12, PAL_STM32_OTYPE_PUSHPULL | PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUPDR_FLOATING | PAL_MODE_ALTERNATE(10U));
#if (HAL_USE_SPI == TRUE)
palSetLineMode(SPI_SCK_PIN, PAL_MODE_ALTERNATE(5));
palSetLineMode(SPI_MISO_PIN, PAL_MODE_ALTERNATE(5));
palSetLineMode(SPI_MOSI_PIN, PAL_MODE_ALTERNATE(5));
#endif
halInit();
#ifdef ENCODER_ENABLE
encoder_cb_init();
#endif
if (wireless_transport.init) wireless_transport.init(true);
battery_init();
/* Disable all wake up pins */
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
if (pins_row[x] != NO_PIN) {
palDisableLineEvent(pins_row[x]);
}
}
palDisableLineEvent(LKBT51_INT_INPUT_PIN);
#ifdef P2P4_MODE_SELECT_PIN
palDisableLineEvent(P2P4_MODE_SELECT_PIN);
#endif
#ifdef BT_MODE_SELECT_PIN
palDisableLineEvent(BT_MODE_SELECT_PIN);
#endif
#ifdef USB_POWER_SENSE_PIN
palDisableLineEvent(USB_POWER_SENSE_PIN);
# if defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
if (usb_power_connected()) {
usb_event_queue_init();
init_usb_driver(&USB_DRIVER);
}
# endif
#endif
#if defined(DIP_SWITCH_PINS)
dip_switch_init();
dip_switch_read(true);
#endif
/* Call debounce_free() to avoiding memory leak of debounce_counters as debounce_init()
invoked in matrix_init() alloc new memory to debounce_counters */
debounce_free();
matrix_init();
}
void lpm_task(void) {
if (!lpm_time_up && sync_timer_elapsed32(lpm_timer_buffer) > RUN_MODE_PROCESS_TIME) {
lpm_time_up = true;
lpm_timer_buffer = 0;
}
if (usb_power_connected() && USBD1.state == USB_STOP) {
usb_event_queue_init();
init_usb_driver(&USB_DRIVER);
}
if ((get_transport() == TRANSPORT_BLUETOOTH || get_transport() == TRANSPORT_P2P4) && lpm_time_up && !indicator_is_running() && lpm_is_kb_idle()) {
#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
if (
# ifdef LED_MATRIX_ENABLE
!led_matrix_is_enabled() ||
(led_matrix_is_enabled() && led_matrix_is_driver_shutdown())
# endif
# ifdef RGB_MATRIX_ENABLE
!rgb_matrix_is_enabled() ||
(rgb_matrix_is_enabled() && rgb_matrix_is_driver_shutdown())
# endif
)
#endif
{
if (!lpm_any_matrix_action()) {
if (pre_enter_low_power_mode(LOW_POWER_MODE)) {
enter_power_mode(LOW_POWER_MODE);
lpm_wakeup();
lpm_timer_reset();
report_buffer_init();
lpm_set(PM_RUN);
}
}
}
}
}

36
keyboards/lemokey/common/wireless/lpm.h Normal file
View file

@ -0,0 +1,36 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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
#ifndef RUN_MODE_PROCESS_TIME
# define RUN_MODE_PROCESS_TIME 1000
#endif
typedef enum {
PM_RUN,
PM_SLEEP,
PM_STOP,
PM_STANDBY,
} pm_t;
void lpm_init(void);
void lpm_timer_reset(void);
void lpm_timer_stop(void);
bool usb_power_connected(void);
bool lpm_is_kb_idle(void);
void enter_power_mode(pm_t mode);
void lpm_task(void);

114
keyboards/lemokey/common/wireless/lpm_stm32f401.c Normal file
View file

@ -0,0 +1,114 @@
/* Copyright 2022 @ lokher (https://www.keychron.com)
*
* 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/>.
*/
/******************************************************************************
*
* Filename: lpm_stm32f401.c
*
* Description: Contains low power mode implementation
*
******************************************************************************/
#include "quantum.h"
#include <usb_main.h>
#include "wireless.h"
#include "lpm.h"
#include "lpm_stm32f401.h"
#include "config.h"
static pm_t power_mode = PM_RUN;
bool lpm_set(pm_t mode) {
bool ret = true;
switch (mode) {
case PM_SLEEP:
/* Wake source: Any interrupt or event */
if (power_mode != PM_RUN)
ret = false;
else
SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
break;
case PM_STOP:
/* Wake source: Reset pin, all I/Os, BOR, PVD, PVM, RTC, LCD, IWDG,
COMPx, USARTx, LPUART1, I2Cx, LPTIMx, USB, SWPMI */
if (power_mode != PM_RUN)
ret = false;
else {
SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
PWR->CR |=
#if STOP_MODE_MAIN_REGULATOR_LOW_VOLTAGE
PWR_CR_MRLVDS |
#endif
#if STOP_MODE_LOW_POWER_REGULATOR_LOW_VOLTAG
PWR_CR_LPLVDS |
#endif
#if STOP_MODE_FLASH_POWER_DOWN
PWR_CR_FPDS |
#endif
#if STOP_MODE_LOW_POWER_DEEPSLEEP
PWR_CR_LPDS |
#endif
0;
}
break;
case PM_STANDBY:
if (power_mode != PM_RUN)
ret = false;
else {
SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
}
break;
default:
break;
}
power_mode = mode;
return ret;
}
void enter_power_mode(pm_t mode) {
#if STM32_HSE_ENABLED
/* Switch to HSI */
RCC->CFGR = (RCC->CFGR & (~STM32_SW_MASK)) | STM32_SW_HSI;
while ((RCC->CFGR & RCC_CFGR_SWS) != (STM32_SW_HSI << 2))
;
/* Set HSE off */
RCC->CR &= ~RCC_CR_HSEON;
while ((RCC->CR & RCC_CR_HSERDY))
;
/* To avoid power consumption of floating GPIO */
palSetLineMode(H0, PAL_MODE_INPUT_PULLDOWN);
palSetLineMode(H1, PAL_MODE_INPUT_PULLDOWN);
#endif
__WFI();
SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
writePinLow(BLUETOOTH_INT_OUTPUT_PIN);
stm32_clock_init();
writePinHigh(BLUETOOTH_INT_OUTPUT_PIN);
}
void usb_power_connect(void) {}
void usb_power_disconnect(void) {}

33
keyboards/lemokey/common/wireless/lpm_stm32f401.h Normal file
View file

@ -0,0 +1,33 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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
#ifndef STOP_MODE_MAIN_REGULATOR_LOW_VOLTAGE
# define STOP_MODE_MAIN_REGULATOR_LOW_VOLTAGE TRUE
#endif
#ifndef STOP_MODE_LOW_POWER_REGULATOR_LOW_VOLTAG
# define STOP_MODE_LOW_POWER_REGULATOR_LOW_VOLTAG TRUE
#endif
#ifndef STOP_MODE_FLASH_POWER_DOWN
# define STOP_MODE_FLASH_POWER_DOWN TRUE
#endif
#ifndef STOP_MODE_LOW_POWER_DEEPSLEEP
# define STOP_MODE_LOW_POWER_DEEPSLEEP TRUE
#endif

148
keyboards/lemokey/common/wireless/report_buffer.c Normal file
View file

@ -0,0 +1,148 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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 "quantum.h"
#include "report_buffer.h"
#include "wireless.h"
#include "lpm.h"
/* The report buffer is mainly used to fix key press lost issue of macro
* when wireless module fifo isn't large enough. The maximun macro
* string length is determined by this queue size, and should be
* REPORT_BUFFER_QUEUE_SIZE devided by 2 since each character is implemented
* by sending a key pressing then a key releasing report.
* Please note that it cosume sizeof(report_buffer_t) * REPORT_BUFFER_QUEUE_SIZE
* bytes RAM, with default setting, used RAM size is
* sizeof(report_buffer_t) * 256 = 34* 256 = 8704 bytes
*/
#ifndef REPORT_BUFFER_QUEUE_SIZE
# define REPORT_BUFFER_QUEUE_SIZE 256
#endif
extern wt_func_t wireless_transport;
/* report_interval value should be less than bluetooth connection interval because
* it takes some time for communicating between mcu and bluetooth module. Carefully
* set this value to feed the bt module so that we don't lost the key report nor lost
* the anchor point of bluetooth interval. The bluetooth connection interval varies
* if BLE is used, invoke report_buffer_set_inverval() to update the value
*/
uint8_t report_interval = DEFAULT_2P4G_REPORT_INVERVAL_MS;
static uint32_t report_timer_buffer = 0;
uint32_t retry_time_buffer = 0;
report_buffer_t report_buffer_queue[REPORT_BUFFER_QUEUE_SIZE];
uint16_t report_buffer_queue_head;
uint16_t report_buffer_queue_tail;
report_buffer_t kb_rpt;
uint8_t retry = 0;
void report_buffer_task(void);
void report_buffer_init(void) {
// Initialise the report queue
memset(&report_buffer_queue, 0, sizeof(report_buffer_queue));
report_buffer_queue_head = 0;
report_buffer_queue_tail = 0;
retry = 0;
report_timer_buffer = timer_read32();
#ifdef LEMOKEY_CALLBACK_ENABLE
register_lemokey_task(report_buffer_task, true);
#endif
}
bool report_buffer_enqueue(report_buffer_t *report) {
uint16_t next = (report_buffer_queue_head + 1) % REPORT_BUFFER_QUEUE_SIZE;
if (next == report_buffer_queue_tail) {
return false;
}
report_buffer_queue[report_buffer_queue_head] = *report;
report_buffer_queue_head = next;
return true;
}
inline bool report_buffer_dequeue(report_buffer_t *report) {
if (report_buffer_queue_head == report_buffer_queue_tail) {
return false;
}
*report = report_buffer_queue[report_buffer_queue_tail];
report_buffer_queue_tail = (report_buffer_queue_tail + 1) % REPORT_BUFFER_QUEUE_SIZE;
return true;
}
bool report_buffer_is_empty() {
return report_buffer_queue_head == report_buffer_queue_tail;
}
void report_buffer_update_timer(void) {
report_timer_buffer = timer_read32();
}
bool report_buffer_next_inverval(void) {
return timer_elapsed32(report_timer_buffer) > report_interval;
}
void report_buffer_set_inverval(uint8_t interval) {
// OG_TRACE("report_buffer_set_inverval: %d\n\r", interval);
report_interval = interval;
}
uint8_t report_buffer_get_retry(void) {
return retry;
}
void report_buffer_set_retry(uint8_t times) {
retry = times;
}
void report_buffer_task(void) {
if (wireless_get_state() == WT_CONNECTED && (!report_buffer_is_empty() || retry) && report_buffer_next_inverval()) {
bool pending_data = false;
if (!retry) {
if (report_buffer_dequeue(&kb_rpt) && kb_rpt.type != REPORT_TYPE_NONE) {
if (timer_read32() > 2) {
pending_data = true;
retry = RETPORT_RETRY_COUNT;
retry_time_buffer = timer_read32();
}
}
} else {
if (timer_elapsed32(retry_time_buffer) > 2) {
pending_data = true;
--retry;
retry_time_buffer = timer_read32();
}
}
if (pending_data) {
#if defined(NKRO_ENABLE) && defined(WIRELESS_NKRO_ENABLE)
if (kb_rpt.type == REPORT_TYPE_NKRO && wireless_transport.send_nkro) {
wireless_transport.send_nkro(&kb_rpt.nkro.mods);
} else if (kb_rpt.type == REPORT_TYPE_KB && wireless_transport.send_keyboard)
wireless_transport.send_keyboard(&kb_rpt.keyboard.mods);
#else
if (kb_rpt.type == REPORT_TYPE_KB && wireless_transport.send_keyboard) wireless_transport.send_keyboard(&kb_rpt.keyboard.mods);
#endif
if (kb_rpt.type == REPORT_TYPE_CONSUMER && wireless_transport.send_consumer) wireless_transport.send_consumer(kb_rpt.consumer);
report_timer_buffer = timer_read32();
lpm_timer_reset();
}
}
}

61
keyboards/lemokey/common/wireless/report_buffer.h Normal file
View file

@ -0,0 +1,61 @@
/* Copyright 2022 @ lokher (https://www.keychron.com)
*
* 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 "report.h"
/* Default report interval value */
#ifndef DEFAULT_BLE_REPORT_INVERVAL_MS
# define DEFAULT_BLE_REPORT_INVERVAL_MS 3
#endif
/* Default report interval value */
#ifndef DEFAULT_2P4G_REPORT_INVERVAL_MS
# define DEFAULT_2P4G_REPORT_INVERVAL_MS 1
#endif
/* Default report interval value */
#ifndef RETPORT_RETRY_COUNT
# define RETPORT_RETRY_COUNT 30
#endif
enum {
REPORT_TYPE_NONE,
REPORT_TYPE_KB,
REPORT_TYPE_NKRO,
REPORT_TYPE_CONSUMER,
};
typedef struct {
uint8_t type;
union {
report_keyboard_t keyboard;
report_nkro_t nkro;
uint16_t consumer;
};
} report_buffer_t;
void report_buffer_init(void);
bool report_buffer_enqueue(report_buffer_t *report);
bool report_buffer_dequeue(report_buffer_t *report);
bool report_buffer_is_empty(void);
void report_buffer_update_timer(void);
bool report_buffer_next_inverval(void);
void report_buffer_set_inverval(uint8_t interval);
uint8_t report_buffer_get_retry(void);
void report_buffer_set_retry(uint8_t times);
void report_buffer_task(void);

43
keyboards/lemokey/common/wireless/rtc_timer.c Normal file
View file

@ -0,0 +1,43 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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 "hal.h"
#if (HAL_USE_RTC)
# include "rtc_timer.h"
void rtc_timer_init(void) {
rtc_timer_clear();
}
void rtc_timer_clear(void) {
RTCDateTime tm = {0, 0, 0, 0, 0, 0};
rtcSetTime(&RTCD1, &tm);
}
uint32_t rtc_timer_read_ms(void) {
RTCDateTime tm;
rtcGetTime(&RTCD1, &tm);
return tm.millisecond;
}
uint32_t rtc_timer_elapsed_ms(uint32_t last) {
return TIMER_DIFF_32(rtc_timer_read_ms(), last);
}
#endif

35
keyboards/lemokey/common/wireless/rtc_timer.h Normal file
View file

@ -0,0 +1,35 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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 "timer.h"
#include <stdint.h>
#define RTC_MAX_TIME (24 * 3600 * 1000) // Set to 1 day
#ifdef __cplusplus
extern "C" {
#endif
void rtc_timer_init(void);
void rtc_timer_clear(void);
uint32_t rtc_timer_read_ms(void);
uint32_t rtc_timer_elapsed_ms(uint32_t last);
#ifdef __cplusplus
}
#endif

272
keyboards/lemokey/common/wireless/transport.c Normal file
View file

@ -0,0 +1,272 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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 "quantum.h"
#include "wireless.h"
#include "indicator.h"
#include "lpm.h"
#include "mousekey.h"
#if defined(PROTOCOL_CHIBIOS)
# include <usb_main.h>
#endif
#include "transport.h"
#include "lkbt51.h"
#ifndef REINIT_LED_DRIVER
# define REINIT_LED_DRIVER 0
#endif
#if defined(PROTOCOL_CHIBIOS)
extern host_driver_t chibios_driver;
#endif
extern host_driver_t wireless_driver;
extern keymap_config_t keymap_config;
extern wt_func_t wireless_transport;
static transport_t transport = TRANSPORT_NONE;
#ifdef NKRO_ENABLE
nkro_t nkro = {false, false};
#endif
static void transport_changed(transport_t new_transport);
__attribute__((weak)) void bt_transport_enable(bool enable) {
if (enable) {
// if (host_get_driver() != &wireless_driver) {
host_set_driver(&wireless_driver);
/* Disconnect and reconnect to sync the wireless state
* TODO: query wireless state to sync
*/
wireless_disconnect();
uint32_t t = timer_read32();
while (timer_elapsed32(t) < 50) {
wireless_transport.task();
}
// wireless_connect();
wireless_connect_ex(30, 0);
// TODO: Clear USB report
//}
} else {
indicator_stop();
if (wireless_get_state() == WT_CONNECTED && transport == TRANSPORT_BLUETOOTH) {
report_keyboard_t empty_report = {0};
wireless_driver.send_keyboard(&empty_report);
}
}
}
__attribute__((weak)) void p24g_transport_enable(bool enable) {
if (enable) {
// if (host_get_driver() != &wireless_driver) {
host_set_driver(&wireless_driver);
/* Disconnect and reconnect to sync the wireless state
* TODO: query bluetooth state to sync
*/
wireless_disconnect();
uint32_t t = timer_read32();
while (timer_elapsed32(t) < 50) {
wireless_transport.task();
}
wireless_connect_ex(P24G_INDEX, 0);
// wireless_connect();
// TODO: Clear USB report
//}
} else {
indicator_stop();
if (wireless_get_state() == WT_CONNECTED && transport == TRANSPORT_P2P4) {
report_keyboard_t empty_report = {0};
wireless_driver.send_keyboard(&empty_report);
}
}
}
__attribute__((weak)) void usb_power_connect(void) {}
__attribute__((weak)) void usb_power_disconnect(void) {}
__attribute__((weak)) void usb_transport_enable(bool enable) {
if (enable) {
if (host_get_driver() != &chibios_driver) {
#if !defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
usb_power_connect();
usb_start(&USBD1);
#endif
host_set_driver(&chibios_driver);
}
} else {
if (USB_DRIVER.state == USB_ACTIVE) {
report_keyboard_t empty_report = {0};
chibios_driver.send_keyboard(&empty_report);
}
#if !defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
usbStop(&USBD1);
usbDisconnectBus(&USBD1);
usb_power_disconnect();
#endif
}
}
void set_transport(transport_t new_transport) {
if (transport != new_transport) {
if (transport == TRANSPORT_USB || ((transport != TRANSPORT_USB) && wireless_get_state() == WT_CONNECTED)) clear_keyboard();
transport = new_transport;
switch (transport) {
case TRANSPORT_USB:
usb_transport_enable(true);
bt_transport_enable(false);
wait_ms(5);
p24g_transport_enable(false);
wireless_disconnect();
lpm_timer_stop();
#ifdef NKRO_ENABLE
# if defined(WIRELESS_NKRO_ENABLE)
nkro.bluetooth = keymap_config.nkro;
# endif
keymap_config.nkro = nkro.usb;
#endif
break;
case TRANSPORT_BLUETOOTH:
p24g_transport_enable(false);
wait_ms(1);
bt_transport_enable(true);
usb_transport_enable(false);
lpm_timer_reset();
#if defined(NKRO_ENABLE)
nkro.usb = keymap_config.nkro;
# if defined(WIRELESS_NKRO_ENABLE)
keymap_config.nkro = nkro.bluetooth;
# else
keymap_config.nkro = FALSE;
# endif
#endif
break;
case TRANSPORT_P2P4:
bt_transport_enable(false);
wait_ms(1);
p24g_transport_enable(true);
usb_transport_enable(false);
lpm_timer_reset();
#if defined(NKRO_ENABLE)
nkro.usb = keymap_config.nkro;
# if defined(WIRELESS_NKRO_ENABLE)
keymap_config.nkro = nkro.bluetooth;
# else
keymap_config.nkro = FALSE;
# endif
#endif
break;
default:
break;
}
transport_changed(transport);
}
}
transport_t get_transport(void) {
return transport;
}
#if (REINIT_LED_DRIVER)
/* Changing transport may cause bronw-out reset of led driver
* withoug MCU reset, which lead backlight to not work,
* reinit the led driver workgound this issue */
static void reinit_led_drvier(void) {
/* Wait circuit to discharge for a while */
systime_t start = chVTGetSystemTime();
while (chTimeI2MS(chVTTimeElapsedSinceX(start)) < 100) {
};
# ifdef LED_MATRIX_ENABLE
led_matrix_init();
# endif
# ifdef RGB_MATRIX_ENABLE
rgb_matrix_init();
# endif
}
#endif
void transport_changed(transport_t new_transport) {
kc_printf("transport_changed %d\n\r", new_transport);
indicator_init();
#if (REINIT_LED_DRIVER)
reinit_led_drvier();
#endif
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_TIMEOUT)
# if (RGB_MATRIX_TIMEOUT > 0)
rgb_matrix_disable_timeout_set(RGB_MATRIX_TIMEOUT_INFINITE);
rgb_matrix_disable_time_reset();
# endif
#endif
#if defined(LED_MATRIX_ENABLE) && defined(LED_MATRIX_TIMEOUT)
# if (LED_MATRIX_TIMEOUT > 0)
led_matrix_disable_timeout_set(LED_MATRIX_TIMEOUT_INFINITE);
led_matrix_disable_time_reset();
# endif
#endif
}
void usb_remote_wakeup(void) {
if (USB_DRIVER.state == USB_SUSPENDED) {
while (USB_DRIVER.state == USB_SUSPENDED) {
/* Do this in the suspended state */
suspend_power_down(); // on AVR this deep sleeps for 15ms
/* Remote wakeup */
if (suspend_wakeup_condition()) {
usbWakeupHost(&USB_DRIVER);
wait_ms(300);
#ifdef MOUSEKEY_ENABLE
// Wiggle to wakeup
mousekey_on(KC_MS_LEFT);
mousekey_send();
wait_ms(10);
mousekey_on(KC_MS_RIGHT);
mousekey_send();
wait_ms(10);
mousekey_off((KC_MS_RIGHT));
mousekey_send();
#else
set_mods(0x02);
send_keyboard_report();
wait_ms(10);
del_mods(0x02);
send_keyboard_report();
#endif
}
}
/* Woken up */
// variables has been already cleared by the wakeup hook
send_keyboard_report();
#ifdef MOUSEKEY_ENABLE
mousekey_send();
#endif /* MOUSEKEY_ENABLE */
usb_event_queue_task();
}
}

42
keyboards/lemokey/common/wireless/transport.h Normal file
View file

@ -0,0 +1,42 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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
typedef enum {
TRANSPORT_NONE,
TRANSPORT_USB = 0x01 << 0,
TRANSPORT_BLUETOOTH = 0x01 << 1,
TRANSPORT_P2P4 = 0x01 << 2,
TRANSPORT_MAX,
} transport_t;
#ifdef NKRO_ENABLE
typedef struct {
bool usb : 1;
bool bluetooth : 1;
} nkro_t;
#endif
#define TRANSPORT_WIRELESS (TRANSPORT_BLUETOOTH | TRANSPORT_P2P4)
void set_transport(transport_t new_transport);
transport_t get_transport(void);
void usb_power_connect(void);
void usb_power_disconnect(void);
void usb_transport_enable(bool enable);
void usb_remote_wakeup(void);

556
keyboards/lemokey/common/wireless/wireless.c Normal file
View file

@ -0,0 +1,556 @@
/* Copyright 2022 @ lokher (https://www.keychron.com)
*
* 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 "quantum.h"
#include "wireless.h"
#include "report_buffer.h"
#include "lpm.h"
#include "battery.h"
#include "indicator.h"
#include "transport.h"
#include "rtc_timer.h"
#include "lemokey_wireless_common.h"
#include "lemokey_task.h"
extern uint8_t pairing_indication;
extern host_driver_t chibios_driver;
extern report_buffer_t kb_rpt;
extern uint32_t retry_time_buffer;
extern uint8_t retry;
#ifdef NKRO_ENABLE
extern nkro_t nkro;
#endif
static uint8_t host_index = 0;
static uint8_t led_state = 0;
extern wt_func_t wireless_transport;
static wt_state_t wireless_state = WT_RESET;
static bool pincodeEntry = false;
uint8_t wireless_report_protocol = true;
/* declarations */
uint8_t wreless_keyboard_leds(void);
void wireless_send_keyboard(report_keyboard_t *report);
void wireless_send_nkro(report_nkro_t *report);
void wireless_send_mouse(report_mouse_t *report);
void wireless_send_extra(report_extra_t *report);
bool process_record_wireless(uint16_t keycode, keyrecord_t *record);
/* host struct */
host_driver_t wireless_driver = {wreless_keyboard_leds, wireless_send_keyboard, wireless_send_nkro, wireless_send_mouse, wireless_send_extra};
#define WT_EVENT_QUEUE_SIZE 16
wireless_event_t wireless_event_queue[WT_EVENT_QUEUE_SIZE];
uint8_t wireless_event_queue_head;
uint8_t wireless_event_queue_tail;
void wireless_event_queue_init(void) {
// Initialise the event queue
memset(&wireless_event_queue, 0, sizeof(wireless_event_queue));
wireless_event_queue_head = 0;
wireless_event_queue_tail = 0;
}
bool wireless_event_enqueue(wireless_event_t event) {
uint8_t next = (wireless_event_queue_head + 1) % WT_EVENT_QUEUE_SIZE;
if (next == wireless_event_queue_tail) {
/* Override the first report */
wireless_event_queue_tail = (wireless_event_queue_tail + 1) % WT_EVENT_QUEUE_SIZE;
}
wireless_event_queue[wireless_event_queue_head] = event;
wireless_event_queue_head = next;
return true;
}
static inline bool wireless_event_dequeue(wireless_event_t *event) {
if (wireless_event_queue_head == wireless_event_queue_tail) {
return false;
}
*event = wireless_event_queue[wireless_event_queue_tail];
wireless_event_queue_tail = (wireless_event_queue_tail + 1) % WT_EVENT_QUEUE_SIZE;
return true;
}
/*
* Bluetooth init.
*/
void wireless_init(void) {
wireless_state = WT_INITIALIZED;
wireless_event_queue_init();
#ifndef DISABLE_REPORT_BUFFER
report_buffer_init();
#endif
indicator_init();
#ifdef BLUETOOTH_INT_INPUT_PIN
setPinInputHigh(BLUETOOTH_INT_INPUT_PIN);
#endif
battery_init();
lpm_init();
#if HAL_USE_RTC
rtc_timer_init();
#endif
#ifdef NKRO_ENABLE
keymap_config.raw = eeconfig_read_keymap();
nkro.usb = keymap_config.nkro;
# ifdef WIRELESS_NKRO_ENABLE
nkro.bluetooth = keymap_config.nkro;
# endif
#endif
#ifdef LEMOKEY_CALLBACK_ENABLE
register_wt_tasks();
register_record_process(process_record_wireless, false);
#endif
}
/*
* Bluetooth trasponrt init. Bluetooth module driver shall use this function to register a callback
* to its implementation.
*/
void wireless_set_transport(wt_func_t *transport) {
if (transport) memcpy(&wireless_transport, transport, sizeof(wt_func_t));
}
/*
* Enter pairing with current host index
*/
void wireless_pairing(void) {
if (battery_is_critical_low()) return;
wireless_pairing_ex(0, NULL);
wireless_state = WT_PARING;
}
/*
* Enter pairing with specified host index and param
*/
void wireless_pairing_ex(uint8_t host_idx, void *param) {
kc_printf("wireless_pairing_ex %d\n\r", host_idx);
if (battery_is_critical_low()) return;
if (wireless_transport.pairing_ex) wireless_transport.pairing_ex(host_idx, param);
wireless_state = WT_PARING;
host_index = host_idx;
}
/*
* Initiate connection request to paired host
*/
void wireless_connect(void) {
/* Work around empty report after wakeup, which leads to reconneect/disconnected loop */
if (battery_is_critical_low() || timer_read32() == 0) return;
if (wireless_state == WT_RECONNECTING && !indicator_is_running()) {
indicator_set(wireless_state, host_index);
}
wireless_transport.connect_ex(0, 0);
wireless_state = WT_RECONNECTING;
}
/*
* Initiate connection request to paired host with argument
*/
void wireless_connect_ex(uint8_t host_idx, uint16_t timeout) {
kc_printf("wireless_connect_ex %d\n\r", host_idx);
if (battery_is_critical_low()) return;
if (host_idx != 0) {
/* Do nothing when trying to connect to current connected host*/
if (host_index == host_idx && wireless_state == WT_CONNECTED) return;
host_index = host_idx;
led_state = 0;
}
wireless_transport.connect_ex(host_idx, timeout);
wireless_state = WT_RECONNECTING;
}
/* Initiate a disconnection */
void wireless_disconnect(void) {
kc_printf("wireless_disconnect\n\r");
if (wireless_transport.disconnect) wireless_transport.disconnect();
}
/* Called when the BT device is reset. */
static void wireless_enter_reset(uint8_t reason) {
kc_printf("wireless_enter_reset\n\r");
wireless_state = WT_RESET;
wireless_enter_reset_kb(reason);
}
/* Enters discoverable state. Upon entering this state we perform the following actions:
* - change state to WT_PARING
* - set pairing indication
*/
static void wireless_enter_discoverable(uint8_t host_idx) {
kc_printf("wireless_enter_discoverable: %d\n\r", host_idx);
host_index = host_idx;
wireless_state = WT_PARING;
indicator_set(wireless_state, host_idx);
wireless_enter_discoverable_kb(host_idx);
}
/*
* Enters reconnecting state. Upon entering this state we perform the following actions:
* - change state to RECONNECTING
* - set reconnect indication
*/
static void wireless_enter_reconnecting(uint8_t host_idx) {
host_index = host_idx;
kc_printf("wireless_reconnecting %d\n\r", host_idx);
wireless_state = WT_RECONNECTING;
indicator_set(wireless_state, host_idx);
wireless_enter_reconnecting_kb(host_idx);
}
/* Enters connected state. Upon entering this state we perform the following actions:
* - change state to CONNECTED
* - set connected indication
* - enable NKRO if it is support
*/
static void wireless_enter_connected(uint8_t host_idx) {
kc_printf("wireless_connected %d\n\r", host_idx);
wireless_state = WT_CONNECTED;
indicator_set(wireless_state, host_idx);
host_index = host_idx;
clear_keyboard();
/* Enable NKRO since it may be disabled in pin code entry */
#if defined(NKRO_ENABLE) && defined(WIRELESS_NKRO_ENABLE)
keymap_config.nkro = nkro.bluetooth;
#else
keymap_config.nkro = false;
#endif
wireless_enter_connected_kb(host_idx);
#ifdef BAT_LOW_LED_PIN
if (battery_is_empty()) {
indicator_battery_low_enable(true);
}
#endif
if (wireless_transport.update_bat_level) wireless_transport.update_bat_level(battery_get_percentage());
}
/* Enters disconnected state. Upon entering this state we perform the following actions:
* - change state to DISCONNECTED
* - set disconnected indication
*/
static void wireless_enter_disconnected(uint8_t host_idx) {
kc_printf("wireless_disconnected %d\n\r", host_idx);
uint8_t previous_state = wireless_state;
led_state = 0;
led_update_kb((led_t)led_state);
wireless_state = WT_DISCONNECTED;
if (previous_state == WT_CONNECTED) {
lpm_timer_reset();
indicator_set(WT_SUSPEND, host_idx);
} else
indicator_set(wireless_state, host_idx);
#ifndef DISABLE_REPORT_BUFFER
report_buffer_init();
#endif
retry = 0;
wireless_enter_disconnected_kb(host_idx);
#ifdef BAT_LOW_LED_PIN
indicator_battery_low_enable(false);
#endif
#if defined(LOW_BAT_IND_INDEX)
indicator_battery_low_backlit_enable(false);
#endif
}
/* Enter pin code entry state. */
static void wireless_enter_bluetooth_pin_code_entry(void) {
#if defined(NKRO_ENABLE)
keymap_config.nkro = FALSE;
#endif
pincodeEntry = true;
wireless_enter_bluetooth_pin_code_entry_kb();
}
/* Exit pin code entry state. */
static void wireless_exit_bluetooth_pin_code_entry(void) {
#if defined(NKRO_ENABLE)
keymap_config.nkro = true;
#endif
pincodeEntry = false;
wireless_exit_bluetooth_pin_code_entry_kb();
}
/* Enters disconnected state. Upon entering this state we perform the following actions:
* - change state to DISCONNECTED
* - set disconnected indication
*/
static void wireless_enter_sleep(void) {
kc_printf("wireless_enter_sleep %d\n\r", wireless_state);
led_state = 0;
if (wireless_state == WT_PARING) {
wireless_state = WT_SUSPEND;
kc_printf("WT_SUSPEND\n\r");
wireless_enter_sleep_kb();
indicator_set(wireless_state, 0);
#ifdef BAT_LOW_LED_PIN
indicator_battery_low_enable(false);
#endif
#if defined(LOW_BAT_IND_INDEX)
indicator_battery_low_backlit_enable(false);
#endif
}
}
__attribute__((weak)) void wireless_enter_reset_kb(uint8_t reason) {}
__attribute__((weak)) void wireless_enter_discoverable_kb(uint8_t host_idx) {}
__attribute__((weak)) void wireless_enter_reconnecting_kb(uint8_t host_idx) {}
__attribute__((weak)) void wireless_enter_connected_kb(uint8_t host_idx) {}
__attribute__((weak)) void wireless_enter_disconnected_kb(uint8_t host_idx) {}
__attribute__((weak)) void wireless_enter_bluetooth_pin_code_entry_kb(void) {}
__attribute__((weak)) void wireless_exit_bluetooth_pin_code_entry_kb(void) {}
__attribute__((weak)) void wireless_enter_sleep_kb(void) {}
/* */
static void wireless_hid_set_protocol(bool report_protocol) {
wireless_report_protocol = false;
}
uint8_t wreless_keyboard_leds(void) {
if (wireless_state == WT_CONNECTED) {
return led_state;
}
return 0;
}
extern keymap_config_t keymap_config;
void wireless_send_keyboard(report_keyboard_t *report) {
if (battery_is_critical_low()) return;
if (wireless_state == WT_PARING && !pincodeEntry) return;
if (wireless_state == WT_CONNECTED || (wireless_state == WT_PARING && pincodeEntry)) {
if (wireless_transport.send_keyboard) {
#ifndef DISABLE_REPORT_BUFFER
report_buffer_t report_buffer;
report_buffer.type = REPORT_TYPE_KB;
memcpy(&report_buffer.keyboard, report, sizeof(report_keyboard_t));
report_buffer_enqueue(&report_buffer);
#else
wireless_transport.send_keyboard(&report->mods);
#endif
}
} else if (wireless_state != WT_RESET) {
wireless_connect();
}
}
void wireless_send_nkro(report_nkro_t *report) {
if (battery_is_critical_low()) return;
if (wireless_state == WT_PARING && !pincodeEntry) return;
if (wireless_state == WT_CONNECTED || (wireless_state == WT_PARING && pincodeEntry)) {
if (wireless_transport.send_nkro) {
#ifndef DISABLE_REPORT_BUFFER
report_buffer_t report_buffer;
report_buffer.type = REPORT_TYPE_NKRO;
memcpy(&report_buffer.nkro, report, sizeof(report_nkro_t));
report_buffer_enqueue(&report_buffer);
wireless_transport.send_nkro(&report->mods);
#else
wireless_transport.send_nkro(&report->mods);
#endif
}
} else if (wireless_state != WT_RESET) {
wireless_connect();
}
}
void wireless_send_mouse(report_mouse_t *report) {
if (battery_is_critical_low()) return;
if (wireless_state == WT_CONNECTED) {
if (wireless_transport.send_mouse) wireless_transport.send_mouse((uint8_t *)report);
} else if (wireless_state != WT_RESET) {
wireless_connect();
}
}
void wireless_send_system(uint16_t data) {
if (wireless_state == WT_CONNECTED) {
if (wireless_transport.send_system) wireless_transport.send_system(data);
} else if (wireless_state != WT_RESET) {
wireless_connect();
}
}
void wireless_send_consumer(uint16_t data) {
if (wireless_state == WT_CONNECTED) {
#ifndef DISABLE_REPORT_BUFFER
if (report_buffer_is_empty() && report_buffer_next_inverval()) {
if (wireless_transport.send_consumer) wireless_transport.send_consumer(data);
report_buffer_update_timer();
} else {
report_buffer_t report_buffer;
report_buffer.type = REPORT_TYPE_CONSUMER;
report_buffer.consumer = data;
report_buffer_enqueue(&report_buffer);
}
#else
if (wireless_transport.send_consumer) wireless_transport.send_consumer(data);
#endif
} else if (wireless_state != WT_RESET) {
wireless_connect();
}
}
void wireless_send_extra(report_extra_t *report) {
if (battery_is_critical_low()) return;
if (report->report_id == REPORT_ID_SYSTEM) {
wireless_send_system(report->usage);
} else if (report->report_id == REPORT_ID_CONSUMER) {
wireless_send_consumer(report->usage);
}
}
void wireless_low_battery_shutdown(void) {
#ifdef BAT_LOW_LED_PIN
indicator_battery_low_enable(false);
#endif
#if defined(LOW_BAT_IND_INDEX)
indicator_battery_low_backlit_enable(false);
#endif
report_buffer_init();
clear_keyboard(); //
wait_ms(50); // wait a while for bt module to free buffer by sending report
// Release all keys by sending empty reports
if (keymap_config.nkro) {
report_nkro_t empty_nkro_report;
memset(&empty_nkro_report, 0, sizeof(empty_nkro_report));
wireless_transport.send_nkro(&empty_nkro_report.mods);
} else {
report_keyboard_t empty_report;
memset(&empty_report, 0, sizeof(empty_report));
wireless_transport.send_keyboard(&empty_report.mods);
}
wait_ms(10);
wireless_transport.send_consumer(0);
wait_ms(10);
report_mouse_t empty_mouse_report;
memset(&empty_mouse_report, 0, sizeof(empty_mouse_report));
wireless_transport.send_mouse((uint8_t *)&empty_mouse_report);
wait_ms(300); // Wait for bt module to send all buffered report
wireless_disconnect();
}
void wireless_event_task(void) {
wireless_event_t event;
while (wireless_event_dequeue(&event)) {
switch (event.evt_type) {
case EVT_RESET:
wireless_enter_reset(event.params.reason);
break;
case EVT_CONNECTED:
wireless_enter_connected(event.params.hostIndex);
break;
case EVT_DISCOVERABLE:
wireless_enter_discoverable(event.params.hostIndex);
break;
case EVT_RECONNECTING:
wireless_enter_reconnecting(event.params.hostIndex);
break;
case EVT_DISCONNECTED:
wireless_enter_disconnected(event.params.hostIndex);
break;
case EVT_BT_PINCODE_ENTRY:
wireless_enter_bluetooth_pin_code_entry();
break;
case EVT_EXIT_BT_PINCODE_ENTRY:
wireless_exit_bluetooth_pin_code_entry();
break;
case EVT_SLEEP:
wireless_enter_sleep();
break;
case EVT_HID_INDICATOR:
led_state = event.params.led;
break;
case EVT_HID_SET_PROTOCOL:
wireless_hid_set_protocol(event.params.protocol);
break;
case EVT_CONECTION_INTERVAL:
report_buffer_set_inverval(event.params.interval);
break;
default:
break;
}
}
}
void wireless_task(void) {
wireless_transport.task();
wireless_event_task();
#ifndef DISABLE_REPORT_BUFFER
report_buffer_task();
#endif
indicator_task();
lemokey_wireless_common_task();
battery_task();
lpm_task();
}
wt_state_t wireless_get_state(void) {
return wireless_state;
};
bool process_record_wireless(uint16_t keycode, keyrecord_t *record) {
if (get_transport() & TRANSPORT_WIRELESS) {
lpm_timer_reset();
#if defined(BAT_LOW_LED_PIN) || defined(LOW_BAT_IND_INDEX)
if (battery_is_empty() && wireless_get_state() == WT_CONNECTED && record->event.pressed) {
# if defined(BAT_LOW_LED_PIN)
indicator_battery_low_enable(true);
# endif
# if defined(LOW_BAT_IND_INDEX)
indicator_battery_low_backlit_enable(true);
# endif
}
#endif
}
if (!process_record_lemokey_wireless(keycode, record)) return false;
return true;
}

101
keyboards/lemokey/common/wireless/wireless.h Normal file
View file

@ -0,0 +1,101 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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 "wireless_event_type.h"
#include "action.h"
#ifdef KC_DEBUG
#define kc_printf dprintf
#else
#define kc_printf(format,...)
#endif
/* Low power mode */
#ifndef LOW_POWER_MODE
# define LOW_POWER_MODE PM_STOP
#endif
/* Wake pin used for blueooth module/controller to wake up MCU in low power mode*/
#ifndef BLUETOOTH_INT_INPUT_PIN
# define WAKE_PIN A5
#endif
// clang-format off
/* Type of an enumeration of the possible wireless transport state.*/
typedef enum {
WT_RESET,
WT_INITIALIZED, // 1
WT_DISCONNECTED, // 2
WT_CONNECTED, // 3
WT_PARING, // 4
WT_RECONNECTING, // 5
WT_SUSPEND
} wt_state_t;
//extern event_listener_t wireless_driver;
typedef struct {
void (*init)(bool);
void (*connect_ex)(uint8_t, uint16_t);
void (*pairing_ex)(uint8_t, void *);
void (*disconnect)(void);
void (*send_keyboard)(uint8_t *);
void (*send_nkro)(uint8_t *);
void (*send_consumer)(uint16_t);
void (*send_system)(uint16_t);
void (*send_mouse)(uint8_t *);
void (*update_bat_level)(uint8_t);
void (*task)(void);
} wt_func_t;
// clang-format on
extern void register_wt_tasks(void);
void wireless_init(void);
void wireless_set_transport(wt_func_t *transport);
void wireless(void);
bool wireless_event_enqueue(wireless_event_t event);
void wireless_connect(void);
void wireless_connect_ex(uint8_t host_idx, uint16_t timeout);
void wireless_disconnect(void);
void wireless_pairing(void);
void wireless_pairing_ex(uint8_t host_idx, void *param);
//bool bluetooth_is_activated(void);
void wireless_enter_reset_kb(uint8_t reason);
void wireless_enter_discoverable_kb(uint8_t host_idx);
void wireless_enter_reconnecting_kb(uint8_t host_idx);
void wireless_enter_connected_kb(uint8_t host_idx);
void wireless_enter_disconnected_kb(uint8_t host_idx);
void wireless_enter_bluetooth_pin_code_entry_kb(void);
void wireless_exit_bluetooth_pin_code_entry_kb(void);
void wireless_enter_sleep_kb(void);
void wireless_task(void);
void wireless_pre_task(void);
void wireless_post_task(void);
wt_state_t wireless_get_state(void);
void wireless_low_battery_shutdown(void);
bool process_record_wireless(uint16_t keycode, keyrecord_t *record);

21
keyboards/lemokey/common/wireless/wireless.mk Normal file
View file

@ -0,0 +1,21 @@
OPT_DEFS += -DLK_WIRELESS_ENABLE
OPT_DEFS += -DNO_USB_STARTUP_CHECK
OPT_DEFS += -DCORTEX_ENABLE_WFI_IDLE=TRUE
WIRELESS_DIR = common/wireless
SRC += \
$(WIRELESS_DIR)/wireless.c \
$(WIRELESS_DIR)/report_buffer.c \
$(WIRELESS_DIR)/lkbt51.c \
$(WIRELESS_DIR)/indicator.c \
$(WIRELESS_DIR)/wireless_main.c \
$(WIRELESS_DIR)/transport.c \
$(WIRELESS_DIR)/lpm.c \
$(WIRELESS_DIR)/lpm_stm32f401.c \
$(WIRELESS_DIR)/battery.c \
$(WIRELESS_DIR)/bat_level_animation.c \
$(WIRELESS_DIR)/rtc_timer.c \
$(WIRELESS_DIR)/lemokey_wireless_common.c
VPATH += $(TOP_DIR)/keyboards/lemokey/$(WIRELESS_DIR)

36
keyboards/lemokey/common/wireless/wireless_config.h Normal file
View file

@ -0,0 +1,36 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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.h"
//
#ifndef BT_HOST_DEVICES_COUNT
# define BT_HOST_DEVICES_COUNT 3
#endif
#define P2P4G_HOST_DEVICES_COUNT 1
// Uint: Second
#ifndef DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME
# define DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME 40
#endif
// Uint: Second, the timer restarts on key activities.
#ifndef CONNECTED_BACKLIGHT_OFF_DELAY_TIME
# define CONNECTED_BACKLIGHT_OFF_DELAY_TIME 600
#endif

44
keyboards/lemokey/common/wireless/wireless_event_type.h Normal file
View file

@ -0,0 +1,44 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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
/* Type of an enumeration of the possible wireless events.*/
typedef enum {
EVT_NONE = 0,
EVT_RESET,
EVT_DISCOVERABLE,
EVT_RECONNECTING,
EVT_CONNECTED,
EVT_DISCONNECTED,
EVT_BT_PINCODE_ENTRY,
EVT_EXIT_BT_PINCODE_ENTRY,
EVT_SLEEP,
EVT_HID_SET_PROTOCOL,
EVT_HID_INDICATOR,
EVT_CONECTION_INTERVAL,
} event_type_t;
typedef struct {
event_type_t evt_type; /*The type of the event. */
union {
uint8_t reason; /* Parameters to WT_RESET event */
uint8_t hostIndex; /* Parameters to connection event from EVT_DISCOVERABLE to EVT_DISCONECTED */
uint8_t led; /* Parameters to EVT_HID_INDICATOR event */
uint8_t protocol; /* Parameters to EVT_HID_SET_PROTOCOL event */
uint8_t interval; /* Parameters to EVT_CONECTION_INTERVAL event */
} params;
} wireless_event_t;

42
keyboards/lemokey/common/wireless/wireless_main.c Normal file
View file

@ -0,0 +1,42 @@
/* Copyright 2023 @ lokher (https://www.keychron.com)
*
* 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 "quantum.h"
#include "wireless.h"
#include "transport.h"
#include "factory_test.h"
#include "lemokey_task.h"
__attribute__((weak)) void wireless_pre_task(void) {}
__attribute__((weak)) void wireless_post_task(void) {}
bool wireless_tasks(void) {
wireless_pre_task();
wireless_task();
wireless_post_task();
/* usb_remote_wakeup() should be invoked last so that we have chance
* to switch to wireless after start-up when usb is not connected
*/
if (get_transport() == TRANSPORT_USB) usb_remote_wakeup();
return true;
}
#ifdef LEMOKEY_CALLBACK_ENABLE
void register_wt_tasks(void) {
register_lemokey_task(wireless_tasks, true);
}
#endif

152
keyboards/lemokey/l3/ansi/ansi.c Normal file
View file

@ -0,0 +1,152 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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 "quantum.h"
// clang-format off
#ifdef RGB_MATRIX_ENABLE
const snled27351_led_t g_snled27351_leds[RGB_MATRIX_LED_COUNT] = {
/* Refer to SNLED27351 manual for these locations
* driver
* | R location
* | | G location
* | | | B location
* | | | | */
{0, G_2, I_2, H_2},
{0, G_3, I_3, H_3},
{0, G_4, I_4, H_4},
{0, G_5, I_5, H_5},
{0, G_6, I_6, H_6},
{0, G_7, I_7, H_7},
{0, G_8, I_8, H_8},
{0, G_9, I_9, H_9},
{0, G_10, I_10, H_10},
{0, G_11, I_11, H_11},
{0, G_12, I_12, H_12},
{0, G_13, I_13, H_13},
{0, G_14, I_14, H_14},
{0, G_15, I_15, H_15},
{0, G_16, I_16, H_16},
{1, A_4, C_4, B_4},
{0, A_1, C_1, B_1},
{0, A_2, C_2, B_2},
{0, A_3, C_3, B_3},
{0, A_4, C_4, B_4},
{0, A_5, C_5, B_5},
{0, A_6, C_6, B_6},
{0, A_7, C_7, B_7},
{0, A_8, C_8, B_8},
{0, A_9, C_9, B_9},
{0, A_10, C_10, B_10},
{0, A_11, C_11, B_11},
{0, A_12, C_12, B_12},
{0, A_13, C_13, B_13},
{0, A_14, C_14, B_14},
{0, A_15, C_15, B_15},
{0, A_16, C_16, B_16},
{1, A_2, C_2, B_2},
{1, D_13, F_13, E_13},
{0, D_1, F_1, E_1},
{0, D_2, F_2, E_2},
{0, D_3, F_3, E_3},
{0, D_4, F_4, E_4},
{0, D_5, F_5, E_5},
{0, D_6, F_6, E_6},
{0, D_7, F_7, E_7},
{0, D_8, F_8, E_8},
{0, D_9, F_9, E_9},
{0, D_10, F_10, E_10},
{0, D_11, F_11, E_11},
{0, D_12, F_12, E_12},
{0, D_13, F_13, E_13},
{0, D_14, F_14, E_14},
{0, D_15, F_15, E_15},
{0, D_16, F_16, E_16},
{1, A_1, C_1, B_1},
{1, D_12, F_12, E_12},
{1, A_16, C_16, B_16},
{1, A_15, C_15, B_15},
{1, A_14, C_14, B_14},
{1, A_13, C_13, B_13},
{1, A_12, C_12, B_12},
{1, A_11, C_11, B_11},
{1, A_10, C_10, B_10},
{1, A_9, C_9, B_9},
{1, A_8, C_8, B_8},
{1, A_7, C_7, B_7},
{1, A_6, C_6, B_6},
{1, A_5, C_5, B_5},
{1, A_3, C_3, B_3},
{1, D_11, F_11, E_11},
{1, G_16, I_16, H_16},
{1, G_14, I_14, H_14},
{1, G_13, I_13, H_13},
{1, G_12, I_12, H_12},
{1, G_11, I_11, H_11},
{1, G_10, I_10, H_10},
{1, G_9, I_9, H_9},
{1, G_8, I_8, H_8},
{1, G_7, I_7, H_7},
{1, G_6, I_6, H_6},
{1, G_5, I_5, H_5},
{1, G_3, I_3, H_3},
{1, G_1, I_1, H_1},
{1, D_9, F_9, E_9},
{1, D_16, F_16, E_16},
{1, D_15, F_15, E_15},
{1, D_14, F_14, E_14},
{1, D_10, F_10, E_10},
{1, D_6, F_6, E_6},
{1, D_5, F_5, E_5},
{1, D_4, F_4, E_4},
{1, D_3, F_3, E_3},
{1, D_2, F_2, E_2},
{1, D_1, F_1, E_1},
{1, G_2, I_2, H_2}
};
led_config_t g_led_config = {
{
{ NO_LED, NO_LED, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, },
{ NO_LED, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, },
{ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, },
{ 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, NO_LED, 64, NO_LED, NO_LED, NO_LED, },
{ 65, 66, NO_LED, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, NO_LED, 77, NO_LED, 78, NO_LED, },
{ 79, 80, 81, 82, NO_LED, NO_LED, NO_LED, 83, NO_LED, NO_LED, NO_LED, 84, 85, 86, 87, 88, 89, 90, }
},
{
{21, 0}, {44, 0}, {56, 0}, {68, 0}, {79, 0}, { 97, 0}, {109, 0}, {120, 0}, {132, 0}, {150, 0}, {162, 0}, {173, 0}, {185, 0}, {200, 0}, {212, 0}, {224, 0},
{21,15}, {32,15}, {44,15}, {56,15}, {68,15}, {79,15}, { 91, 15}, {103, 15}, {115, 15}, {126, 15}, {138, 15}, {150, 15}, {162, 15}, {179, 15}, {200, 15}, {212, 15}, {224, 15},
{0,27}, {24,27}, {38,27}, {50,27}, {62,27}, {73,27}, {85,27}, { 97, 27}, {109, 27}, {121, 27}, {132, 27}, {144, 27}, {156, 27}, {168, 27}, {182, 27}, {200, 27}, {212, 27}, {224, 27},
{0,39}, {25,39}, {41,39}, {53,39}, {65,39}, {76,39}, {88,39}, {100, 39}, {112, 39}, {123, 39}, {135, 39}, {147, 39}, {159, 39}, {178, 39},
{0,51}, {28,51}, {47,51}, {59,51}, {71,51}, {82,51}, { 94, 51}, {106, 51}, {118, 51}, {129, 51}, {141, 51}, {153, 51}, {175, 51}, {212, 51},
{0,64}, {22,64}, {37,64}, {51,64}, { 96, 64}, {140, 64}, {154, 64}, {169, 64}, {184, 64}, {200, 64}, {212, 64}, {224, 64}
},
{
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
}
};
#endif

53
keyboards/lemokey/l3/ansi/config.h Normal file
View file

@ -0,0 +1,53 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
#ifdef RGB_MATRIX_ENABLE
/* RGB Matrix driver configuration */
# define DRIVER_COUNT 2
# define DRIVER_1_LED_COUNT 47
# define DRIVER_2_LED_COUNT 44
# define RGB_MATRIX_LED_COUNT (DRIVER_1_LED_COUNT + DRIVER_2_LED_COUNT)
# define SPI_SCK_PIN A5
# define SPI_MISO_PIN A6
# define SPI_MOSI_PIN A7
# define DRIVER_CS_PINS \
{ B8, B9 }
# define SNLED23751_SPI_DIVISOR 16
# define SPI_DRIVER SPID1
/* Scan phase of led driver set as MSKPHASE_9CHANNEL(defined as 0x03 in snled27351.h) */
# define PHASE_CHANNEL MSKPHASE_9CHANNEL
/* Set LED driver current */
# define SNLED27351_CURRENT_TUNE \
{ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }
/* Set to infinit, which is use in USB mode by default */
# define RGB_MATRIX_TIMEOUT RGB_MATRIX_TIMEOUT_INFINITE
/* Allow shutdown of led driver to save power */
# define RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
/* Turn off backlight on low brightness to save power */
# define RGB_MATRIX_BRIGHTNESS_TURN_OFF_VAL 32
# define RGB_MATRIX_KEYPRESSES
# define RGB_MATRIX_FRAMEBUFFER_EFFECTS
#endif

114
keyboards/lemokey/l3/ansi/info.json Normal file
View file

@ -0,0 +1,114 @@
{
"usb": {
"pid": "0x0130",
"device_version": "1.0.0"
},
"layouts": {
"LAYOUT_ansi_tkl": {
"layout": [
{"matrix":[0,1], "x":0, "y":0.25},
{"matrix":[0,2], "x":1.25, "y":0},
{"matrix":[0,3], "x":3.25, "y":0},
{"matrix":[0,4], "x":4.25, "y":0},
{"matrix":[0,5], "x":5.25, "y":0},
{"matrix":[0,6], "x":6.25, "y":0},
{"matrix":[0,7], "x":7.75, "y":0},
{"matrix":[0,8], "x":8.75, "y":0},
{"matrix":[0,9], "x":9.75, "y":0},
{"matrix":[0,10], "x":10.75, "y":0},
{"matrix":[0,11], "x":12.25, "y":0},
{"matrix":[0,12], "x":13.25, "y":0},
{"matrix":[0,13], "x":14.25, "y":0},
{"matrix":[0,14], "x":15.25, "y":0},
{"matrix":[0,15], "x":16.5, "y":0},
{"matrix":[0,16], "x":17.5, "y":0},
{"matrix":[0,17], "x":18.5, "y":0},
{"matrix":[1,1], "x":1.25, "y":1.25},
{"matrix":[1,2], "x":2.25, "y":1.25},
{"matrix":[1,3], "x":3.25, "y":1.25},
{"matrix":[1,4], "x":4.25, "y":1.25},
{"matrix":[1,5], "x":5.25, "y":1.25},
{"matrix":[1,6], "x":6.25, "y":1.25},
{"matrix":[1,7], "x":7.25, "y":1.25},
{"matrix":[1,8], "x":8.25, "y":1.25},
{"matrix":[1,9], "x":9.25, "y":1.25},
{"matrix":[1,10], "x":10.25, "y":1.25},
{"matrix":[1,11], "x":11.25, "y":1.25},
{"matrix":[1,12], "x":12.25, "y":1.25},
{"matrix":[1,13], "x":13.25, "y":1.25},
{"matrix":[1,14], "x":14.25, "y":1.25, "w":2},
{"matrix":[1,15], "x":16.5, "y":1.25},
{"matrix":[1,16], "x":17.5, "y":1.25},
{"matrix":[1,17], "x":18.5, "y":1.25},
{"matrix":[2,0], "x":0, "y":1.5},
{"matrix":[2,1], "x":1.25, "y":2.25, "w":1.5},
{"matrix":[2,2], "x":2.75, "y":2.25},
{"matrix":[2,3], "x":3.75, "y":2.25},
{"matrix":[2,4], "x":4.75, "y":2.25},
{"matrix":[2,5], "x":5.75, "y":2.25},
{"matrix":[2,6], "x":6.75, "y":2.25},
{"matrix":[2,7], "x":7.75, "y":2.25},
{"matrix":[2,8], "x":8.75, "y":2.25},
{"matrix":[2,9], "x":9.75, "y":2.25},
{"matrix":[2,10], "x":10.75, "y":2.25},
{"matrix":[2,11], "x":11.75, "y":2.25},
{"matrix":[2,12], "x":12.75, "y":2.25},
{"matrix":[2,13], "x":13.75, "y":2.25},
{"matrix":[2,14], "x":14.75, "y":2.25, "w":1.5},
{"matrix":[2,15], "x":16.5, "y":2.25},
{"matrix":[2,16], "x":17.5, "y":2.25},
{"matrix":[2,17], "x":18.5, "y":2.25},
{"matrix":[3,0], "x":0, "y":2.75},
{"matrix":[3,1], "x":1.25, "y":3.25, "w":1.75},
{"matrix":[3,2], "x":3, "y":3.25},
{"matrix":[3,3], "x":4, "y":3.25},
{"matrix":[3,4], "x":5, "y":3.25},
{"matrix":[3,5], "x":6, "y":3.25},
{"matrix":[3,6], "x":7, "y":3.25},
{"matrix":[3,7], "x":8, "y":3.25},
{"matrix":[3,8], "x":9, "y":3.25},
{"matrix":[3,9], "x":10, "y":3.25},
{"matrix":[3,10], "x":11, "y":3.25},
{"matrix":[3,11], "x":12, "y":3.25},
{"matrix":[3,12], "x":13, "y":3.25},
{"matrix":[3,14], "x":14, "y":3.25, "w":2.25},
{"matrix":[4,0], "x":0, "y":4},
{"matrix":[4,1], "x":1.25, "y":4.25, "w":2.25},
{"matrix":[4,3], "x":3.5, "y":4.25},
{"matrix":[4,4], "x":4.5, "y":4.25},
{"matrix":[4,5], "x":5.5, "y":4.25},
{"matrix":[4,6], "x":6.5, "y":4.25},
{"matrix":[4,7], "x":7.5, "y":4.25},
{"matrix":[4,8], "x":8.5, "y":4.25},
{"matrix":[4,9], "x":9.5, "y":4.25},
{"matrix":[4,10], "x":10.5, "y":4.25},
{"matrix":[4,11], "x":11.5, "y":4.25},
{"matrix":[4,12], "x":12.5, "y":4.25},
{"matrix":[4,14], "x":13.5, "y":4.25, "w":2.75},
{"matrix":[4,16], "x":17.5, "y":4.25},
{"matrix":[5,0], "x":0, "y":5.25},
{"matrix":[5,1], "x":1.25, "y":5.25, "w":1.25},
{"matrix":[5,2], "x":2.5, "y":5.25, "w":1.25},
{"matrix":[5,3], "x":3.75, "y":5.25, "w":1.25},
{"matrix":[5,7], "x":5, "y":5.25, "w":6.25},
{"matrix":[5,11], "x":11.25, "y":5.25, "w":1.25},
{"matrix":[5,12], "x":12.5, "y":5.25, "w":1.25},
{"matrix":[5,13], "x":13.75, "y":5.25, "w":1.25},
{"matrix":[5,14], "x":15, "y":5.25, "w":1.25},
{"matrix":[5,15], "x":16.5, "y":5.25},
{"matrix":[5,16], "x":17.5, "y":5.25},
{"matrix":[5,17], "x":18.5, "y":5.25}
]
}
}
}

56
keyboards/lemokey/l3/ansi/keymaps/default/keymap.c Normal file
View file

@ -0,0 +1,56 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
#include "lemokey_common.h"
enum layer_names {
BASE = 0,
FN,
};
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[BASE] = LAYOUT_ansi_tkl(
KC_MUTE, KC_ESC, 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_PSCR, KC_SCRL, KC_PAUS,
KC_GRV, 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_BSPC, KC_INS, KC_HOME, KC_PGUP,
MC_0, KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL, KC_END, KC_PGDN,
MC_1, KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
MC_2, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP,
MC_3, KC_LCTL, KC_LWIN, KC_LALT, KC_SPC, KC_RALT, MO(FN), KC_APP, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT),
[FN] = LAYOUT_ansi_tkl(
RGB_TOG, _______, KC_BRID, KC_BRIU, KC_TASK, KC_FILE, RGB_VAD, RGB_VAI, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, _______,
_______, BT_HST1, BT_HST2, BT_HST3, P2P4G, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, RGB_TOG, RGB_MOD, RGB_VAI, RGB_HUI, RGB_SAI, RGB_SPI, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, RGB_RMOD, RGB_VAD, RGB_HUD, RGB_SAD, RGB_SPD, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, BAT_LVL, NK_TOGG, _______, _______, _______, _______, _______, _______,
_______, _______, GUI_TOG, _______, _______, _______, _______, _______, _______, _______, _______, _______),
};
// clang-format on
#if defined(ENCODER_MAP_ENABLE)
const uint16_t PROGMEM encoder_map[][1][2] = {
[BASE] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[FN] = {ENCODER_CCW_CW(RGB_VAD, RGB_VAI)},
};
#endif // ENCODER_MAP_ENABLE
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (!process_record_lemokey_common(keycode, record)) {
return false;
}
return true;
}

56
keyboards/lemokey/l3/ansi/keymaps/via/keymap.c Normal file
View file

@ -0,0 +1,56 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
#include "lemokey_common.h"
enum layer_names {
BASE = 0,
FN,
};
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[BASE] = LAYOUT_ansi_tkl(
KC_MUTE, KC_ESC, 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_PSCR, KC_SCRL, KC_PAUS,
KC_GRV, 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_BSPC, KC_INS, KC_HOME, KC_PGUP,
MC_0, KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL, KC_END, KC_PGDN,
MC_1, KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
MC_2, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP,
MC_3, KC_LCTL, KC_LWIN, KC_LALT, KC_SPC, KC_RALT, MO(FN), KC_APP, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT),
[FN] = LAYOUT_ansi_tkl(
RGB_TOG, _______, KC_BRID, KC_BRIU, KC_TASK, KC_FILE, RGB_VAD, RGB_VAI, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, _______,
_______, BT_HST1, BT_HST2, BT_HST3, P2P4G, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, RGB_TOG, RGB_MOD, RGB_VAI, RGB_HUI, RGB_SAI, RGB_SPI, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, RGB_RMOD, RGB_VAD, RGB_HUD, RGB_SAD, RGB_SPD, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, BAT_LVL, NK_TOGG, _______, _______, _______, _______, _______, _______,
_______, _______, GUI_TOG, _______, _______, _______, _______, _______, _______, _______, _______, _______),
};
// clang-format on
#if defined(ENCODER_MAP_ENABLE)
const uint16_t PROGMEM encoder_map[][1][2] = {
[BASE] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[FN] = {ENCODER_CCW_CW(RGB_VAD, RGB_VAI)},
};
#endif // ENCODER_MAP_ENABLE
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (!process_record_lemokey_common(keycode, record)) {
return false;
}
return true;
}

1
keyboards/lemokey/l3/ansi/keymaps/via/rules.mk Normal file
View file

@ -0,0 +1 @@
VIA_ENABLE = yes

0
keyboards/lemokey/l3/ansi/rules.mk Normal file
View file

226
keyboards/lemokey/l3/board.h Normal file
View file

@ -0,0 +1,226 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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_next <board.h>
// clang-format off
/* Set GPIOA_SWDIO to INPUT and NOT FLOATING */
#undef VAL_GPIOA_MODER
#define VAL_GPIOA_MODER (PIN_MODE_INPUT(GPIOA_BUTTON) | \
PIN_MODE_INPUT(GPIOA_PIN1) | \
PIN_MODE_INPUT(GPIOA_PIN2) | \
PIN_MODE_INPUT(GPIOA_PIN3) | \
PIN_MODE_ALTERNATE(GPIOA_CS43L22_LRCK) |\
PIN_MODE_ALTERNATE(GPIOA_L3GD20_SCL) | \
PIN_MODE_ALTERNATE(GPIOA_L3GD20_SD0) | \
PIN_MODE_ALTERNATE(GPIOA_L3GD20_SDI) | \
PIN_MODE_INPUT(GPIOA_PIN8) | \
PIN_MODE_INPUT(GPIOA_VBUS_FS) | \
PIN_MODE_ALTERNATE(GPIOA_OTG_FS_ID) | \
PIN_MODE_ALTERNATE(GPIOA_OTG_FS_DM) | \
PIN_MODE_ALTERNATE(GPIOA_OTG_FS_DP) | \
PIN_MODE_INPUT(GPIOA_SWDIO) | \
PIN_MODE_INPUT(GPIOA_SWCLK) | \
PIN_MODE_INPUT(GPIOA_PIN15))
#undef VAL_GPIOA_PUPDR
#define VAL_GPIOA_PUPDR (PIN_PUPDR_FLOATING(GPIOA_BUTTON) | \
PIN_PUPDR_PULLUP(GPIOA_PIN1) | \
PIN_PUPDR_PULLUP(GPIOA_PIN2) | \
PIN_PUPDR_PULLUP(GPIOA_PIN3) | \
PIN_PUPDR_FLOATING(GPIOA_CS43L22_LRCK) |\
PIN_PUPDR_FLOATING(GPIOA_L3GD20_SCL) | \
PIN_PUPDR_PULLUP(GPIOA_L3GD20_SD0) | \
PIN_PUPDR_PULLUP(GPIOA_L3GD20_SDI) | \
PIN_PUPDR_PULLUP(GPIOA_PIN8) | \
PIN_PUPDR_FLOATING(GPIOA_VBUS_FS) | \
PIN_PUPDR_FLOATING(GPIOA_OTG_FS_ID) | \
PIN_PUPDR_FLOATING(GPIOA_OTG_FS_DM) | \
PIN_PUPDR_FLOATING(GPIOA_OTG_FS_DP) | \
PIN_PUPDR_PULLUP(GPIOA_SWDIO) | \
PIN_PUPDR_PULLUP(GPIOA_SWCLK) | \
PIN_PUPDR_PULLUP(GPIOA_PIN15))
#undef VAL_GPIOB_MODER
#define VAL_GPIOB_MODER (PIN_MODE_INPUT(GPIOB_PIN0) | \
PIN_MODE_INPUT(GPIOB_PIN1) | \
PIN_MODE_INPUT(GPIOB_PIN2) | \
PIN_MODE_INPUT(GPIOB_SWO) | \
PIN_MODE_INPUT(GPIOB_PIN4) | \
PIN_MODE_INPUT(GPIOB_PIN5) | \
PIN_MODE_INPUT(GPIOB_LSM303DLHC_SCL) | \
PIN_MODE_INPUT(GPIOB_PIN7) | \
PIN_MODE_INPUT(GPIOB_PIN8) | \
PIN_MODE_INPUT(GPIOB_LSM303DLHC_SDA) | \
PIN_MODE_INPUT(GPIOB_MP45DT02_CLK_IN) |\
PIN_MODE_INPUT(GPIOB_PIN11) | \
PIN_MODE_INPUT(GPIOB_PIN12) | \
PIN_MODE_INPUT(GPIOB_PIN13) | \
PIN_MODE_INPUT(GPIOB_PIN14) | \
PIN_MODE_INPUT(GPIOB_PIN15))
#undef VAL_GPIOB_PUPDR
#define VAL_GPIOB_PUPDR (PIN_PUPDR_PULLDOWN(GPIOB_PIN0) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN1) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN2) | \
PIN_PUPDR_PULLDOWN(GPIOB_SWO) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN4) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN5) | \
PIN_PUPDR_PULLDOWN(GPIOB_LSM303DLHC_SCL) |\
PIN_PUPDR_PULLDOWN(GPIOB_PIN7) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN8) | \
PIN_PUPDR_PULLDOWN(GPIOB_LSM303DLHC_SDA) |\
PIN_PUPDR_PULLDOWN(GPIOB_MP45DT02_CLK_IN) |\
PIN_PUPDR_PULLDOWN(GPIOB_PIN11) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN12) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN13) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN14) | \
PIN_PUPDR_PULLDOWN(GPIOB_PIN15))
#undef VAL_GPIOB_AFRL
#define VAL_GPIOB_AFRL (PIN_AFIO_AF(GPIOB_PIN0, 0U) | \
PIN_AFIO_AF(GPIOB_PIN1, 0U) | \
PIN_AFIO_AF(GPIOB_PIN2, 0U) | \
PIN_AFIO_AF(GPIOB_SWO, 0U) | \
PIN_AFIO_AF(GPIOB_PIN4, 0U) | \
PIN_AFIO_AF(GPIOB_PIN5, 0U) | \
PIN_AFIO_AF(GPIOB_LSM303DLHC_SCL, 0) | \
PIN_AFIO_AF(GPIOB_PIN7, 0U))
#undef VAL_GPIOB_AFRH
#define VAL_GPIOB_AFRH (PIN_AFIO_AF(GPIOB_PIN8, 0U) | \
PIN_AFIO_AF(GPIOB_LSM303DLHC_SDA, 0) | \
PIN_AFIO_AF(GPIOB_MP45DT02_CLK_IN, 0U) |\
PIN_AFIO_AF(GPIOB_PIN11, 0U) | \
PIN_AFIO_AF(GPIOB_PIN12, 0U) | \
PIN_AFIO_AF(GPIOB_PIN13, 0U) | \
PIN_AFIO_AF(GPIOB_PIN14, 0U) | \
PIN_AFIO_AF(GPIOB_PIN15, 0U))
/* C5 Need to be pulldown */
#undef VAL_GPIOC_MODER
#define VAL_GPIOC_MODER (PIN_MODE_INPUT(GPIOC_OTG_FS_POWER_ON) |\
PIN_MODE_INPUT(GPIOC_PIN1) | \
PIN_MODE_INPUT(GPIOC_PIN2) | \
PIN_MODE_INPUT(GPIOC_CS43L22_AIN4x) | \
PIN_MODE_INPUT(GPIOC_PIN4) | \
PIN_MODE_INPUT(GPIOC_PIN5) | \
PIN_MODE_INPUT(GPIOC_PIN6) | \
PIN_MODE_INPUT(GPIOC_CS43L22_MCLK) | \
PIN_MODE_INPUT(GPIOC_PIN8) | \
PIN_MODE_INPUT(GPIOC_PIN9) | \
PIN_MODE_INPUT(GPIOC_CS43L22_SCLK) | \
PIN_MODE_INPUT(GPIOC_PIN11) | \
PIN_MODE_INPUT(GPIOC_CS43L22_SDIN) | \
PIN_MODE_INPUT(GPIOC_PIN13) | \
PIN_MODE_INPUT(GPIOC_OSC32_IN) | \
PIN_MODE_INPUT(GPIOC_OSC32_OUT))
#undef VAL_GPIOC_PUPDR
#define VAL_GPIOC_PUPDR (PIN_PUPDR_PULLUP(GPIOC_OTG_FS_POWER_ON) |\
PIN_PUPDR_PULLUP(GPIOC_PIN1) | \
PIN_PUPDR_PULLUP(GPIOC_PIN2) | \
PIN_PUPDR_PULLUP(GPIOC_CS43L22_AIN4x) |\
PIN_PUPDR_PULLUP(GPIOC_PIN4) | \
PIN_PUPDR_PULLDOWN(GPIOC_PIN5) | \
PIN_PUPDR_PULLUP(GPIOC_PIN6) | \
PIN_PUPDR_PULLUP(GPIOC_CS43L22_MCLK) | \
PIN_PUPDR_PULLUP(GPIOC_PIN8) | \
PIN_PUPDR_PULLUP(GPIOC_PIN9) | \
PIN_PUPDR_PULLUP(GPIOC_CS43L22_SCLK) | \
PIN_PUPDR_PULLUP(GPIOC_PIN11) | \
PIN_PUPDR_PULLUP(GPIOC_CS43L22_SDIN) | \
PIN_PUPDR_PULLUP(GPIOC_PIN13) | \
PIN_PUPDR_PULLUP(GPIOC_OSC32_IN) | \
PIN_PUPDR_PULLUP(GPIOC_OSC32_OUT))
/* Set all GPIOD pins to INPUT & PULLUP to avoid FLOATING */
#undef VAL_GPIOD_MODER
#define VAL_GPIOD_MODER (PIN_MODE_INPUT(GPIOD_PIN0) | \
PIN_MODE_INPUT(GPIOD_PIN1) | \
PIN_MODE_INPUT(GPIOD_PIN2) | \
PIN_MODE_INPUT(GPIOD_PIN3) | \
PIN_MODE_INPUT(GPIOD_CS43L22_RESET) | \
PIN_MODE_INPUT(GPIOD_OverCurrent) | \
PIN_MODE_INPUT(GPIOD_PIN6) | \
PIN_MODE_INPUT(GPIOD_PIN7) | \
PIN_MODE_INPUT(GPIOD_PIN8) | \
PIN_MODE_INPUT(GPIOD_PIN9) | \
PIN_MODE_INPUT(GPIOD_PIN10) | \
PIN_MODE_INPUT(GPIOD_PIN11) | \
PIN_MODE_INPUT(GPIOD_LED4) | \
PIN_MODE_INPUT(GPIOD_LED3) | \
PIN_MODE_INPUT(GPIOD_LED5) | \
PIN_MODE_INPUT(GPIOD_LED6))
#undef VAL_GPIOD_PUPDR
#define VAL_GPIOD_PUPDR (PIN_PUPDR_PULLUP(GPIOD_PIN0) | \
PIN_PUPDR_PULLUP(GPIOD_PIN1) | \
PIN_PUPDR_PULLUP(GPIOD_PIN2) | \
PIN_PUPDR_PULLUP(GPIOD_PIN3) | \
PIN_PUPDR_PULLUP(GPIOD_CS43L22_RESET) |\
PIN_PUPDR_PULLUP(GPIOD_OverCurrent) | \
PIN_PUPDR_PULLUP(GPIOD_PIN6) | \
PIN_PUPDR_PULLUP(GPIOD_PIN7) | \
PIN_PUPDR_PULLUP(GPIOD_PIN8) | \
PIN_PUPDR_PULLUP(GPIOD_PIN9) | \
PIN_PUPDR_PULLUP(GPIOD_PIN10) | \
PIN_PUPDR_PULLUP(GPIOD_PIN11) | \
PIN_PUPDR_PULLUP(GPIOD_LED4) | \
PIN_PUPDR_PULLUP(GPIOD_LED3) | \
PIN_PUPDR_PULLUP(GPIOD_LED5) | \
PIN_PUPDR_PULLUP(GPIOD_LED6))
/* Set all GPIOE pins to INPUT & PULLUP to avoid FLOATING */
#undef VAL_GPIOE_MODER
#define VAL_GPIOE_MODER (PIN_MODE_INPUT(GPIOE_L3GD20_INT1) | \
PIN_MODE_INPUT(GPIOE_L3GD20_INT2) | \
PIN_MODE_INPUT(GPIOE_LSM303DLHC_DRDY) |\
PIN_MODE_INPUT(GPIOE_L3GD20_CS) | \
PIN_MODE_INPUT(GPIOE_LSM303DLHC_INT1) |\
PIN_MODE_INPUT(GPIOE_LSM303DLHC_INT2) |\
PIN_MODE_INPUT(GPIOE_PIN6) | \
PIN_MODE_INPUT(GPIOE_PIN7) | \
PIN_MODE_INPUT(GPIOE_PIN8) | \
PIN_MODE_INPUT(GPIOE_PIN9) | \
PIN_MODE_INPUT(GPIOE_PIN10) | \
PIN_MODE_INPUT(GPIOE_PIN11) | \
PIN_MODE_INPUT(GPIOE_PIN12) | \
PIN_MODE_INPUT(GPIOE_PIN13) | \
PIN_MODE_INPUT(GPIOE_PIN14) | \
PIN_MODE_INPUT(GPIOE_PIN15))
#undef VAL_GPIOE_PUPDR
#define VAL_GPIOE_PUPDR (PIN_PUPDR_PULLUP(GPIOE_L3GD20_INT1) | \
PIN_PUPDR_PULLUP(GPIOE_L3GD20_INT2) | \
PIN_PUPDR_PULLUP(GPIOE_LSM303DLHC_DRDY) |\
PIN_PUPDR_PULLUP(GPIOE_L3GD20_CS) | \
PIN_PUPDR_PULLUP(GPIOE_LSM303DLHC_INT1) |\
PIN_PUPDR_PULLUP(GPIOE_LSM303DLHC_INT2) |\
PIN_PUPDR_PULLUP(GPIOE_PIN6) | \
PIN_PUPDR_PULLUP(GPIOE_PIN7) | \
PIN_PUPDR_PULLUP(GPIOE_PIN8) | \
PIN_PUPDR_PULLUP(GPIOE_PIN9) | \
PIN_PUPDR_PULLUP(GPIOE_PIN10) | \
PIN_PUPDR_PULLUP(GPIOE_PIN11) | \
PIN_PUPDR_PULLUP(GPIOE_PIN12) | \
PIN_PUPDR_PULLUP(GPIOE_PIN13) | \
PIN_PUPDR_PULLUP(GPIOE_PIN14) | \
PIN_PUPDR_PULLUP(GPIOE_PIN15))

96
keyboards/lemokey/l3/config.h Normal file
View file

@ -0,0 +1,96 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
/* Turn off effects when suspended */
#define RGB_DISABLE_WHEN_USB_SUSPENDED
/* Encoder Configuration */
#define ENCODER_DEFAULT_POS 0x3
#define ENCODER_MAP_KEY_DELAY 2
/* Caps lock LED */
#define LED_CAPS_LOCK_PIN A13
#define LED_PIN_ON_STATE 1
#ifdef LK_WIRELESS_ENABLE
/* Hardware configuration */
# define P2P4_MODE_SELECT_PIN A10
# define BT_MODE_SELECT_PIN A9
# define LKBT51_RESET_PIN C4
# define LKBT51_INT_INPUT_PIN B1
# define BLUETOOTH_INT_OUTPUT_PIN A4
# define USB_POWER_SENSE_PIN B0
# define USB_POWER_CONNECTED_LEVEL 0
# define BAT_LOW_LED_PIN B12
# define BAT_LOW_LED_PIN_ON_STATE 1
# define BT_HOST_DEVICES_COUNT 3
# define BT_HOST_LED_PIN_LIST \
{ C9, C9, C9 }
# define HOST_LED_PIN_ON_STATE 0
# define P24G_HOST_DEVICES_COUNT 1
# define P24G_HOST_LED_PIN_LIST \
{ A8 }
# if defined(RGB_MATRIX_ENABLE) || defined(LED_MATRIX_ENABLE)
# define LED_DRIVER_SHUTDOWN_PIN B7
# define BT_HOST_LED_MATRIX_LIST \
{ 17, 18, 19 }
# define P2P4G_HOST_LED_MATRIX_LIST \
{ 20 }
# define BAT_LEVEL_LED_LIST \
{ 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
/* Backlit disable timeout when keyboard is disconnected(unit: second) */
# define DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT 40
/* Backlit disable timeout when keyboard is connected(unit: second) */
# define CONNECTED_BACKLIGHT_DISABLE_TIMEOUT 600
/* Reinit LED driver on tranport changed */
# define REINIT_LED_DRIVER 1
# endif
/* Keep USB connection in blueooth mode */
# define KEEP_USB_CONNECTION_IN_WIRELESS_MODE
/* Enable bluetooth NKRO */
# define WIRELESS_NKRO_ENABLE
/* Raw hid command for factory test and bluetooth DFU */
# define RAW_HID_CMD 0xAA ... 0xAB
#else
/* Raw hid command for factory test */
# define RAW_HID_CMD 0xAB
#endif
/* Factory test keys */
#define FN_KEY_1 MO(1)
#define MATRIX_IO_DELAY 10

30
keyboards/lemokey/l3/halconf.h Normal file
View file

@ -0,0 +1,30 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
#define _CHIBIOS_HAL_CONF_VER_8_0_
#define HAL_USE_SPI TRUE
#ifdef LK_WIRELESS_ENABLE
# define HAL_USE_RTC TRUE
#endif
#if defined(LK_WIRELESS_ENABLE) || defined(ENCODER_ENABLE)
# define PAL_USE_CALLBACKS TRUE
#endif
#include_next <halconf.h>

76
keyboards/lemokey/l3/info.json Normal file
View file

@ -0,0 +1,76 @@
{
"keyboard_name": "Lemokey L3",
"manufacturer": "Lemokey",
"url": "https://github.com/Keychron",
"maintainer": "lokher",
"processor": "STM32F401",
"bootloader": "stm32-dfu",
"usb": {
"vid": "0x362D"
},
"features": {
"bootmagic": true,
"extrakey" : true,
"mousekey" : true,
"nkro" : true,
"encoder": true,
"encoder_map": true,
"rgb_matrix": true,
"raw" : true,
"send_string": true
},
"matrix_pins": {
"rows": ["C12", "D2", "B3", "B4", "B5", "B6"],
"cols": ["A3", "C6", "C7", "C8", "A14", "A15", "C10", "C11", "C13", "C14", "C15", "C0", "C1", "C2", "C3", "A0", "A1", "A2"],
},
"diode_direction": "ROW2COL",
"encoder": {
"rotary": [
{
"pin_a": "B15",
"pin_b": "B14",
"resolution": 4
}
]
},
"rgb_matrix": {
"driver": "snled27351_spi",
"animations": {
"band_spiral_val": true,
"breathing": true,
"cycle_all": true,
"cycle_left_right": true,
"cycle_out_in": true,
"cycle_out_in_dual": true,
"cycle_pinwheel": true,
"cycle_spiral": true,
"cycle_up_down": true,
"digital_rain": true,
"dual_beacon": true,
"jellybean_raindrops": true,
"pixel_rain": true,
"rainbow_beacon": true,
"rainbow_moving_chevron": true,
"solid_reactive_multinexus": true,
"solid_reactive_multiwide": true,
"solid_reactive_simple": true,
"solid_splash": true,
"splash": true,
"typing_heatmap": true
}
},
"eeprom": {
"wear_leveling": {
"driver": "embedded_flash",
"logical_size": 2048,
"backing_size": 4096
}
},
"build": {
"debounce_type": "sym_eager_pk"
},
"debounce": 20,
"bootmagic": {
"matrix": [0,2]
}
}

53
keyboards/lemokey/l3/iso/config.h Normal file
View file

@ -0,0 +1,53 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
#ifdef RGB_MATRIX_ENABLE
/* RGB Matrix driver configuration */
# define DRIVER_COUNT 2
# define DRIVER_1_LED_COUNT 47
# define DRIVER_2_LED_COUNT 45
# define RGB_MATRIX_LED_COUNT (DRIVER_1_LED_COUNT + DRIVER_2_LED_COUNT)
# define SPI_SCK_PIN A5
# define SPI_MISO_PIN A6
# define SPI_MOSI_PIN A7
# define DRIVER_CS_PINS \
{ B8, B9 }
# define SNLED23751_SPI_DIVISOR 16
# define SPI_DRIVER SPID1
/* Scan phase of led driver set as MSKPHASE_9CHANNEL(defined as 0x03 in snled27351.h) */
# define PHASE_CHANNEL MSKPHASE_9CHANNEL
/* Set LED driver current */
# define SNLED27351_CURRENT_TUNE \
{ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }
/* Set to infinit, which is use in USB mode by default */
# define RGB_MATRIX_TIMEOUT RGB_MATRIX_TIMEOUT_INFINITE
/* Allow shutdown of led driver to save power */
# define RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
/* Turn off backlight on low brightness to save power */
# define RGB_MATRIX_BRIGHTNESS_TURN_OFF_VAL 32
# define RGB_MATRIX_KEYPRESSES
# define RGB_MATRIX_FRAMEBUFFER_EFFECTS
#endif

115
keyboards/lemokey/l3/iso/info.json Normal file
View file

@ -0,0 +1,115 @@
{
"usb": {
"pid": "0x0131",
"device_version": "1.0.1"
},
"layouts": {
"LAYOUT_iso_tkl": {
"layout": [
{"matrix":[0,1], "x":0, "y":0.25},
{"matrix":[0,2], "x":1.25, "y":0},
{"matrix":[0,3], "x":3.25, "y":0},
{"matrix":[0,4], "x":4.25, "y":0},
{"matrix":[0,5], "x":5.25, "y":0},
{"matrix":[0,6], "x":6.25, "y":0},
{"matrix":[0,7], "x":7.75, "y":0},
{"matrix":[0,8], "x":8.75, "y":0},
{"matrix":[0,9], "x":9.75, "y":0},
{"matrix":[0,10], "x":10.75, "y":0},
{"matrix":[0,11], "x":12.25, "y":0},
{"matrix":[0,12], "x":13.25, "y":0},
{"matrix":[0,13], "x":14.25, "y":0},
{"matrix":[0,14], "x":15.25, "y":0},
{"matrix":[0,15], "x":16.5, "y":0},
{"matrix":[0,16], "x":17.5, "y":0},
{"matrix":[0,17], "x":18.5, "y":0},
{"matrix":[1,1], "x":1.25, "y":1.25},
{"matrix":[1,2], "x":2.25, "y":1.25},
{"matrix":[1,3], "x":3.25, "y":1.25},
{"matrix":[1,4], "x":4.25, "y":1.25},
{"matrix":[1,5], "x":5.25, "y":1.25},
{"matrix":[1,6], "x":6.25, "y":1.25},
{"matrix":[1,7], "x":7.25, "y":1.25},
{"matrix":[1,8], "x":8.25, "y":1.25},
{"matrix":[1,9], "x":9.25, "y":1.25},
{"matrix":[1,10], "x":10.25, "y":1.25},
{"matrix":[1,11], "x":11.25, "y":1.25},
{"matrix":[1,12], "x":12.25, "y":1.25},
{"matrix":[1,13], "x":13.25, "y":1.25},
{"matrix":[1,14], "x":14.25, "y":1.25, "w":2},
{"matrix":[1,15], "x":16.5, "y":1.25},
{"matrix":[1,16], "x":17.5, "y":1.25},
{"matrix":[1,17], "x":18.5, "y":1.25},
{"matrix":[2,0], "x":0, "y":1.5},
{"matrix":[2,1], "x":1.25, "y":2.25, "w":1.5},
{"matrix":[2,2], "x":2.75, "y":2.25},
{"matrix":[2,3], "x":3.75, "y":2.25},
{"matrix":[2,4], "x":4.75, "y":2.25},
{"matrix":[2,5], "x":5.75, "y":2.25},
{"matrix":[2,6], "x":6.75, "y":2.25},
{"matrix":[2,7], "x":7.75, "y":2.25},
{"matrix":[2,8], "x":8.75, "y":2.25},
{"matrix":[2,9], "x":9.75, "y":2.25},
{"matrix":[2,10], "x":10.75, "y":2.25},
{"matrix":[2,11], "x":11.75, "y":2.25},
{"matrix":[2,12], "x":12.75, "y":2.25},
{"matrix":[2,13], "x":13.75, "y":2.25},
{"matrix":[2,14], "x":14.75, "y":2.25, "w":1.5},
{"matrix":[2,15], "x":16.5, "y":2.25},
{"matrix":[2,16], "x":17.5, "y":2.25},
{"matrix":[2,17], "x":18.5, "y":2.25},
{"matrix":[3,0], "x":0, "y":2.75},
{"matrix":[3,1], "x":1.25, "y":3.25, "w":1.75},
{"matrix":[3,2], "x":3, "y":3.25},
{"matrix":[3,3], "x":4, "y":3.25},
{"matrix":[3,4], "x":5, "y":3.25},
{"matrix":[3,5], "x":6, "y":3.25},
{"matrix":[3,6], "x":7, "y":3.25},
{"matrix":[3,7], "x":8, "y":3.25},
{"matrix":[3,8], "x":9, "y":3.25},
{"matrix":[3,9], "x":10, "y":3.25},
{"matrix":[3,10], "x":11, "y":3.25},
{"matrix":[3,11], "x":12, "y":3.25},
{"matrix":[3,12], "x":13, "y":3.25},
{"matrix":[3,14], "x":14, "y":3.25, "w":2.25},
{"matrix":[4,0], "x":0, "y":4},
{"matrix":[4,1], "x":1.25, "y":4.25, "w":1.25},
{"matrix":[4,2], "x":2.5, "y":4.25},
{"matrix":[4,3], "x":3.5, "y":4.25},
{"matrix":[4,4], "x":4.5, "y":4.25},
{"matrix":[4,5], "x":5.5, "y":4.25},
{"matrix":[4,6], "x":6.5, "y":4.25},
{"matrix":[4,7], "x":7.5, "y":4.25},
{"matrix":[4,8], "x":8.5, "y":4.25},
{"matrix":[4,9], "x":9.5, "y":4.25},
{"matrix":[4,10], "x":10.5, "y":4.25},
{"matrix":[4,11], "x":11.5, "y":4.25},
{"matrix":[4,12], "x":12.5, "y":4.25},
{"matrix":[4,14], "x":13.5, "y":4.25, "w":2.75},
{"matrix":[4,16], "x":17.5, "y":4.25},
{"matrix":[5,0], "x":0, "y":5.25},
{"matrix":[5,1], "x":1.25, "y":5.25, "w":1.25},
{"matrix":[5,2], "x":2.5, "y":5.25, "w":1.25},
{"matrix":[5,3], "x":3.75, "y":5.25, "w":1.25},
{"matrix":[5,7], "x":5, "y":5.25, "w":6.25},
{"matrix":[5,11], "x":11.25, "y":5.25, "w":1.25},
{"matrix":[5,12], "x":12.5, "y":5.25, "w":1.25},
{"matrix":[5,13], "x":13.75, "y":5.25, "w":1.25},
{"matrix":[5,14], "x":15, "y":5.25, "w":1.25},
{"matrix":[5,15], "x":16.5, "y":5.25},
{"matrix":[5,16], "x":17.5, "y":5.25},
{"matrix":[5,17], "x":18.5, "y":5.25}
]
}
}
}

154
keyboards/lemokey/l3/iso/iso.c Normal file
View file

@ -0,0 +1,154 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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 "quantum.h"
// clang-format off
#ifdef RGB_MATRIX_ENABLE
const snled27351_led_t g_snled27351_leds[RGB_MATRIX_LED_COUNT] = {
/* Refer to SNLED27351 manual for these locations
* driver
* | R location
* | | G location
* | | | B location
* | | | | */
{0, G_2, I_2, H_2},
{0, G_3, I_3, H_3},
{0, G_4, I_4, H_4},
{0, G_5, I_5, H_5},
{0, G_6, I_6, H_6},
{0, G_7, I_7, H_7},
{0, G_8, I_8, H_8},
{0, G_9, I_9, H_9},
{0, G_10, I_10, H_10},
{0, G_11, I_11, H_11},
{0, G_12, I_12, H_12},
{0, G_13, I_13, H_13},
{0, G_14, I_14, H_14},
{0, G_15, I_15, H_15},
{0, G_16, I_16, H_16},
{1, A_4, C_4, B_4},
{0, A_1, C_1, B_1},
{0, A_2, C_2, B_2},
{0, A_3, C_3, B_3},
{0, A_4, C_4, B_4},
{0, A_5, C_5, B_5},
{0, A_6, C_6, B_6},
{0, A_7, C_7, B_7},
{0, A_8, C_8, B_8},
{0, A_9, C_9, B_9},
{0, A_10, C_10, B_10},
{0, A_11, C_11, B_11},
{0, A_12, C_12, B_12},
{0, A_13, C_13, B_13},
{0, A_14, C_14, B_14},
{0, A_15, C_15, B_15},
{0, A_16, C_16, B_16},
{1, A_2, C_2, B_2},
{1, D_13, F_13, E_13},
{0, D_1, F_1, E_1},
{0, D_2, F_2, E_2},
{0, D_3, F_3, E_3},
{0, D_4, F_4, E_4},
{0, D_5, F_5, E_5},
{0, D_6, F_6, E_6},
{0, D_7, F_7, E_7},
{0, D_8, F_8, E_8},
{0, D_9, F_9, E_9},
{0, D_10, F_10, E_10},
{0, D_11, F_11, E_11},
{0, D_12, F_12, E_12},
{0, D_13, F_13, E_13},
{0, D_14, F_14, E_14},
{0, D_15, F_15, E_15},
{0, D_16, F_16, E_16},
{1, A_1, C_1, B_1},
{1, D_12, F_12, E_12},
{1, A_16, C_16, B_16},
{1, A_15, C_15, B_15},
{1, A_14, C_14, B_14},
{1, A_13, C_13, B_13},
{1, A_12, C_12, B_12},
{1, A_11, C_11, B_11},
{1, A_10, C_10, B_10},
{1, A_9, C_9, B_9},
{1, A_8, C_8, B_8},
{1, A_7, C_7, B_7},
{1, A_6, C_6, B_6},
{1, A_5, C_5, B_5},
{1, A_3, C_3, B_3},
{1, D_11, F_11, E_11},
{1, G_16, I_16, H_16},
{1, G_15, I_15, H_15},
{1, G_14, I_14, H_14},
{1, G_13, I_13, H_13},
{1, G_12, I_12, H_12},
{1, G_11, I_11, H_11},
{1, G_10, I_10, H_10},
{1, G_9, I_9, H_9},
{1, G_8, I_8, H_8},
{1, G_7, I_7, H_7},
{1, G_6, I_6, H_6},
{1, G_5, I_5, H_5},
{1, G_3, I_3, H_3},
{1, G_1, I_1, H_1},
{1, D_9, F_9, E_9},
{1, D_16, F_16, E_16},
{1, D_15, F_15, E_15},
{1, D_14, F_14, E_14},
{1, D_10, F_10, E_10},
{1, D_6, F_6, E_6},
{1, D_5, F_5, E_5},
{1, D_4, F_4, E_4},
{1, D_3, F_3, E_3},
{1, D_2, F_2, E_2},
{1, D_1, F_1, E_1},
{1, G_2, I_2, H_2}
};
led_config_t g_led_config = {
{
{ NO_LED, NO_LED, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, },
{ NO_LED, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, },
{ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, },
{ 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, NO_LED, 64, NO_LED, NO_LED, NO_LED, },
{ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, NO_LED, 78, NO_LED, 79, NO_LED, },
{ 80, 81, 82, 83, NO_LED, NO_LED, NO_LED, 84, NO_LED, NO_LED, NO_LED, 85, 86, 87, 88, 89, 90, 91, }
},
{
{21, 0}, {44, 0}, {56, 0}, {68, 0}, {79, 0}, { 97, 0}, {109, 0}, {120, 0}, {132, 0}, {150, 0}, {162, 0}, {173, 0}, {185, 0}, {200, 0}, {212, 0}, {224, 0},
{21,15}, {32,15}, {44,15}, {56,15}, {68,15}, {79,15}, { 91, 15}, {103, 15}, {115, 15}, {126, 15}, {138, 15}, {150, 15}, {162, 15}, {179, 15}, {200, 15}, {212, 15}, {224, 15},
{0,27}, {24,27}, {38,27}, {50,27}, {62,27}, {73,27}, {85,27}, { 97, 27}, {109, 27}, {121, 27}, {132, 27}, {144, 27}, {156, 27}, {168, 27}, {182, 27}, {200, 27}, {212, 27}, {224, 27},
{0,39}, {25,39}, {41,39}, {53,39}, {65,39}, {76,39}, {88,39}, {100, 39}, {112, 39}, {123, 39}, {135, 39}, {147, 39}, {159, 39}, {178, 39},
{0,51}, {22,51}, {35,51}, {47,51}, {59,51}, {71,51}, {82,51}, { 94, 51}, {106, 51}, {118, 51}, {129, 51}, {141, 51}, {153, 51}, {175, 51}, {212, 51},
{0,64}, {22,64}, {37,64}, {51,64}, { 96, 64}, {140, 64}, {154, 64}, {169, 64}, {184, 64}, {200, 64}, {212, 64}, {224, 64}
},
{
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
}
};
#endif

52
keyboards/lemokey/l3/iso/keymaps/default/keymap.c Normal file
View file

@ -0,0 +1,52 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
#include "l3.h"
#include "rgb.h"
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[BASE] = LAYOUT_iso_92(
KC_MUTE, KC_ESC, 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_PSCR, KC_SCRL, KC_PAUS,
KC_GRV, 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_BSPC, KC_INS, KC_HOME, KC_PGUP,
MC_0, KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_ENT, KC_DEL, KC_END, KC_PGDN,
MC_1, KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_NUHS,
MC_2, KC_LSFT, KC_NUBS, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP,
MC_3, KC_LCTL, KC_LWIN, KC_LALT, KC_SPC, KC_RALT, MO(FN), KC_APP, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT),
[FN] = LAYOUT_iso_92(
RGB_TOG, _______, KC_BRID, KC_BRIU, KC_TASK, KC_FLXP, RGB_VAD, RGB_VAI, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, _______,
_______, BT_HST1, BT_HST2, BT_HST3, P2P4G, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, RGB_TOG, RGB_MOD, RGB_VAI, RGB_HUI, RGB_SAI, RGB_SPI, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, RGB_RMOD, RGB_VAD, RGB_HUD, RGB_SAD, RGB_SPD, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, BAT_LVL, NK_TOGG, _______, _______, _______, _______, _______, _______,
_______, _______, GUI_TOG, _______, _______, _______, _______, _______, _______, _______, _______, _______),
};
// clang-format on
#if defined(ENCODER_MAP_ENABLE)
const uint16_t PROGMEM encoder_map[][1][2] = {
[BASE] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[FN] = {ENCODER_CCW_CW(RGB_VAD, RGB_VAI)},
};
#endif // ENCODER_MAP_ENABLE
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (!process_record_lemokey_common(keycode, record)) {
return false;
}
return true;
}

56
keyboards/lemokey/l3/iso/keymaps/via/keymap.c Normal file
View file

@ -0,0 +1,56 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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
#include "lemokey_common.h"
enum layer_names {
BASE = 0,
FN,
};
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[BASE] = LAYOUT_iso_tkl(
KC_MUTE, KC_ESC, 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_PSCR, KC_LOCK, RGB_MOD,
KC_GRV, 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_BSPC, KC_INS, KC_HOME, KC_PGUP,
MC_0, KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_DEL, KC_END, KC_PGDN,
MC_1, KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_NUHS, KC_ENT,
MC_2, KC_LSFT, KC_NUBS, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP,
MC_3, KC_LCTL, KC_LWIN, KC_LALT, KC_SPC, KC_RALT, KC_RWIN, MO(FN), KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT),
[FN] = LAYOUT_iso_tkl(
_______, _______, KC_BRID, KC_BRIU, KC_TASK, KC_FILE, RGB_VAD, RGB_VAI, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, RGB_TOG,
_______, BT_HST1, BT_HST2, BT_HST3, P2P4G, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, RGB_TOG, RGB_MOD, RGB_VAI, RGB_HUI, RGB_SAI, RGB_SPI, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, RGB_RMOD, RGB_VAD, RGB_HUD, RGB_SAD, RGB_SPD, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, BAT_LVL, NK_TOGG, _______, _______, _______, _______, _______, _______,
_______, _______, GUI_TOG, _______, _______, _______, _______, _______, _______, _______, _______, _______),
};
// clang-format on
#if defined(ENCODER_MAP_ENABLE)
const uint16_t PROGMEM encoder_map[][1][2] = {
[BASE] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[FN] = {ENCODER_CCW_CW(RGB_VAD, RGB_VAI)},
};
#endif // ENCODER_MAP_ENABLE
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (!process_record_lemokey_common(keycode, record)) {
return false;
}
return true;
}

1
keyboards/lemokey/l3/iso/keymaps/via/rules.mk Normal file
View file

@ -0,0 +1 @@
VIA_ENABLE = yes

0
keyboards/lemokey/l3/iso/rules.mk Normal file
View file

106
keyboards/lemokey/l3/l3.c Normal file
View file

@ -0,0 +1,106 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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 "l3.h"
#include "lemokey_task.h"
#ifdef FACTORY_TEST_ENABLE
# include "factory_test.h"
# include "lemokey_common.h"
#endif
#ifdef LK_WIRELESS_ENABLE
# include "lkbt51.h"
# include "wireless.h"
# include "lemokey_wireless_common.h"
# include "battery.h"
# include "transport.h"
#endif
#define POWER_ON_LED_DURATION 3000
static uint32_t power_on_indicator_timer_buffer;
#ifdef LK_WIRELESS_ENABLE
pin_t bt_led_pins[] = BT_HOST_LED_PIN_LIST;
pin_t p24g_led_pins[] = P24G_HOST_LED_PIN_LIST;
#endif
#ifdef LEMOKEY_CALLBACK_ENABLE
bool lemokey_task_kb(void);
#endif
bool process_record_lemokey_kb(uint16_t keycode, keyrecord_t *record) {
return true;
}
void keyboard_post_init_kb(void) {
#ifdef LK_WIRELESS_ENABLE
palSetLineMode(P2P4_MODE_SELECT_PIN, PAL_MODE_INPUT);
palSetLineMode(BT_MODE_SELECT_PIN, PAL_MODE_INPUT);
writePin(BAT_LOW_LED_PIN, BAT_LOW_LED_PIN_ON_STATE);
lkbt51_init(false);
wireless_init();
#endif
// writePin(LED_CAPS_LOCK_PIN, LED_PIN_ON_STATE);
power_on_indicator_timer_buffer = timer_read32();
#ifdef ENCODER_ENABLE
encoder_cb_init();
#endif
#ifdef LEMOKEY_CALLBACK_ENABLE
factory_test_init();
register_record_process(process_record_lemokey_kb, false);
register_lemokey_task(lemokey_task_kb, false);
#endif
keyboard_post_init_user();
}
bool lemokey_task_kb(void) {
if (power_on_indicator_timer_buffer) {
if (timer_elapsed32(power_on_indicator_timer_buffer) > POWER_ON_LED_DURATION) {
power_on_indicator_timer_buffer = 0;
if (!host_keyboard_led_state().caps_lock) writePin(LED_CAPS_LOCK_PIN, !LED_PIN_ON_STATE);
#ifdef LK_WIRELESS_ENABLE
writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
for (uint8_t i = 0; i < sizeof(bt_led_pins) / sizeof(pin_t); i++)
writePin(bt_led_pins[i], 1);
for (uint8_t i = 0; i < sizeof(p24g_led_pins) / sizeof(pin_t); i++)
writePin(p24g_led_pins[i], 1);
#endif
} else {
writePin(LED_CAPS_LOCK_PIN, LED_PIN_ON_STATE);
#ifdef LK_WIRELESS_ENABLE
writePin(BAT_LOW_LED_PIN, BAT_LOW_LED_PIN_ON_STATE);
if (get_transport() != TRANSPORT_P2P4)
for (uint8_t i = 0; i < sizeof(bt_led_pins) / sizeof(pin_t); i++)
writePin(bt_led_pins[i], 0);
if (get_transport() != TRANSPORT_BLUETOOTH)
for (uint8_t i = 0; i < sizeof(p24g_led_pins) / sizeof(pin_t); i++)
writePin(p24g_led_pins[i], 0);
#endif
}
}
return true;
}
#ifdef LK_WIRELESS_ENABLE
bool lpm_is_kb_idle(void) {
return power_on_indicator_timer_buffer == 0 && !factory_reset_indicating();
}
#endif

22
keyboards/lemokey/l3/l3.h Normal file
View file

@ -0,0 +1,22 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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"
#ifdef VIA_ENABLE
# include "via.h"
#endif

40
keyboards/lemokey/l3/mcuconf.h Normal file
View file

@ -0,0 +1,40 @@
/* Copyright 2023 @ Lemokey (https://www.lemokey.com)
*
* 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_next <mcuconf.h>
#undef STM32_HSECLK
#define STM32_HSECLK 16000000
#undef STM32_PLLM_VALUE
#define STM32_PLLM_VALUE 8
#undef STM32_PLLN_VALUE
#define STM32_PLLN_VALUE 96
#undef STM32_PLLP_VALUE
#define STM32_PLLP_VALUE 4
#undef STM32_PLLQ_VALUE
#define STM32_PLLQ_VALUE 4
#undef STM32_I2C_USE_I2C1
#define STM32_I2C_USE_I2C1 TRUE
#undef STM32_SPI_USE_SPI1
#define STM32_SPI_USE_SPI1 TRUE

23
keyboards/lemokey/l3/readme.md Normal file
View file

@ -0,0 +1,23 @@
# Lemokey L3
![Lemokey L3 QMK/VIA Wireless Mechanical Keyboard](https://cdn.shopify.com/s/files/1/0059/0630/1017/files/Lemokey-L3-QMK-VIA-Wireless-Mechanical-Keyboard-Full-Metal_1200x.jpg?v=1690365749)
A customizable wireless TKL keyboard.
* Keyboard Maintainer: [Keychron](https://github.com/keychron)
* Hardware Supported: Lemokey L3
* Hardware Availability: [Lemokey L3 Wireless Custom Mechanical Keyboard](https://www.lemokey.com/products/lemokey-l3-qmk-via-wireless-custom-mechanical-keyboard)
Make example for this keyboard (after setting up your build environment):
make lemokey/l3/ansi:default
Flashing example for this keyboard:
```
make lemokey/l3/ansi:default:flash
```
**Reset Key**: Toggle mode switch to "Cable", hold down the *Esc* key or reset button underneath space bar while connecting the USB cable,
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).

4
keyboards/lemokey/l3/rules.mk Normal file
View file

@ -0,0 +1,4 @@
include keyboards/lemokey/common/wireless/wireless.mk
include keyboards/lemokey/common/lemokey_common.mk
VPATH += $(TOP_DIR)/keyboards/lemokey

340
keyboards/lemokey/l3/via_json/l3_ansi.json Normal file
View file

@ -0,0 +1,340 @@
{
"name": "Lemokey L3",
"vendorId": "0x362D",
"productId": "0x0130",
"keycodes": ["qmk_lighting"],
"menus": [
{
"label": "Lighting",
"content": [
{
"label": "Backlight",
"content": [
{
"label": "Brightness",
"type": "range",
"options": [0, 255],
"content": ["id_qmk_rgb_matrix_brightness", 3, 1]
},
{
"label": "Effect",
"type": "dropdown",
"content": ["id_qmk_rgb_matrix_effect", 3, 2],
"options": [
["None", 0],
["Solid Color", 1],
["Breathing", 2],
["Band Spiral Val", 3],
["Cycle All", 4],
["Cycle Left Right", 5],
["Cycle Up Down", 6],
["Rainbow Moving Chevron", 7],
["Cycle Out In", 8],
["Cycle Out In Dual", 9],
["Cycle Pinwheel", 10],
["Cycle Spiral", 11],
["Dual Beacon", 12],
["Rainbow Beacon", 13],
["Jellybean Raindrops", 14],
["Pixel Rain", 15],
["Typing Heatmap", 16],
["Digital Rain", 17],
["Reactive Simple", 18],
["Reactive Multiwide", 19],
["Reactive Multinexus", 20],
["Splash", 21],
["Solid Splash", 22]
]
},
{
"showIf": "{id_qmk_rgb_matrix_effect} > 1",
"label": "Effect Speed",
"type": "range",
"options": [0, 255],
"content": ["id_qmk_rgb_matrix_effect_speed", 3, 3]
},
{
"showIf": "{id_qmk_rgb_matrix_effect} != 0 && ( {id_qmk_rgb_matrix_effect} < 4 || {id_qmk_rgb_matrix_effect} == 18 || ({id_qmk_rgb_matrix_effect} > 17 && {id_qmk_rgb_matrix_effect} != 21) ) ",
"label": "Color",
"type": "color",
"content": ["id_qmk_rgb_matrix_color", 3, 4]
}
]
}
]
}
],
"customKeycodes": [
{"name": "Task View", "title": "Task View in Windows", "shortName": "Task"},
{"name": "File Explorer", "title": "File Explorer in Windows", "shortName": "File"},
{"name": "Lock Sreen", "title": "Lock Screen Windows", "shortName": "Lock"},
{"name": "Misson Control", "title": "Misson Control in Mac", "shortName": "MCtl"},
{"name": "Lanuch Pad", "title": "Lanuch Pad in Windows", "shortName": "LPad"},
{"name": "Left Option", "title": "Left Option", "shortName": "LOpt"},
{"name": "Right Option", "title": "Right Option", "shortName": "ROpt"},
{"name": "Left Cmd", "title": "Left Command", "shortName": "LCmd"},
{"name": "Right Cmd", "title": "Right Command", "shortName": "RCmd"},
{"name": "Bluetooth Host 1", "title": "Bluetooth Host 1", "shortName": "BTH1"},
{"name": "Bluetooth Host 2", "title": "Bluetooth Host 2", "shortName": "BTH2"},
{"name": "Bluetooth Host 3", "title": "Bluetooth Host 3", "shortName": "BTH3"},
{"name": "2.4G Host", "title": "2.4G Host", "shortName": "2.4G"},
{"name": "Battery Level", "title": "Show battery level", "shortName": "Batt"}
],
"matrix": {"rows": 6, "cols": 18},
"layouts": {
"keymap":[
[
{
"w": 1.5,
"h": 1.5
},
"0,1\n\n\n\n\n\n\n\n\ne0",
{
"y": 0,
"x": 0.6,
"c": "#777777"
},
"0,2\nESC",
{
"x": 1,
"c": "#cccccc"
},
"0,3",
"0,4",
"0,5",
"0,6",
{
"x": 0.5,
"c": "#aaaaaa"
},
"0,7",
"0,8",
"0,9",
"0,10",
{
"x": 0.5,
"c": "#cccccc"
},
"0,11",
"0,12",
"0,13",
"0,14",
{
"x": 0.25,
"c": "#aaaaaa"
},
"0,15",
"0,16",
"0,17"
],
[
{
"x": 2.1,
"y": 0.25,
"c": "#cccccc"
},
"1,1",
"1,2",
"1,3",
"1,4",
"1,5",
"1,6",
"1,7",
"1,8",
"1,9",
"1,10",
"1,11",
"1,12",
"1,13",
{
"c": "#aaaaaa",
"w": 2
},
"1,14",
{
"x": 0.25
},
"1,15",
"1,16",
"1,17",
{
"c": "#cccccc",
"x": 0.25
}
],
[
{
"x": 0.25,
"y": -0.4,
"h": 1.1,
"w": 1.1
},
"2,0",
{
"x": 0.75,
"y": 0.4,
"c": "#aaaaaa",
"w": 1.5
},
"2,1",
{
"c": "#cccccc"
},
"2,2",
"2,3",
"2,4",
"2,5",
"2,6",
"2,7",
"2,8",
"2,9",
"2,10",
"2,11",
"2,12",
"2,13",
{
"w": 1.5,
"c": "#aaaaaa"
},
"2,14",
{
"x": 0.25
},
"2,15",
"2,16",
"2,17"
],
[
{
"x": 0.25,
"y": -0.3,
"h": 1.1,
"w": 1.1,
"c": "#cccccc"
},
"3,0",
{
"x": 0.75,
"y": 0.3,
"c": "#aaaaaa",
"w": 1.75
},
"3,1",
{
"c": "#cccccc"
},
"3,2",
"3,3",
"3,4",
"3,5",
"3,6",
"3,7",
"3,8",
"3,9",
"3,10",
"3,11",
"3,12",
{
"c": "#777777",
"w": 2.25
},
"3,14"
],
[
{
"x": 0.25,
"y": -0.2,
"h": 1.1,
"w": 1.1,
"c": "#cccccc"
},
"4,0",
{
"x": 0.75,
"y": 0.2,
"c": "#aaaaaa",
"w": 2.25
},
"4,1",
{
"c": "#cccccc"
},
"4,3",
"4,4",
"4,5",
"4,6",
"4,7",
"4,8",
"4,9",
"4,10",
"4,11",
"4,12",
{
"c": "#aaaaaa",
"w": 2.75
},
"4,14",
{
"c": "#cccccc",
"x": 1.25,
"w": 1
},
"4,16"
],
[
{
"x": 0.25,
"y": -0.1,
"h": 1.1,
"w": 1.1
},
"5,0",
{
"x": 0.75,
"y": 0.1,
"c": "#aaaaaa",
"w": 1.25
},
"5,1",
{
"w": 1.25
},
"5,2",
{
"w": 1.25
},
"5,3",
{
"c": "#cccccc",
"w": 6.25
},
"5,7",
{
"c": "#aaaaaa",
"w": 1.25
},
"5,11",
{
"w": 1.25
},
"5,12",
{
"w": 1.25
},
"5,13",
{
"w": 1.25
},
"5,14",
{
"c": "#cccccc",
"w": 1,
"x": 0.25
},
"5,15",
"5,16",
"5,17"
]
]
}
}

347
keyboards/lemokey/l3/via_json/l3_iso.json Normal file
View file

@ -0,0 +1,347 @@
{
"name": "Lemokey L3",
"vendorId": "0x362D",
"productId": "0x0131",
"keycodes": ["qmk_lighting"],
"menus": [
{
"label": "Lighting",
"content": [
{
"label": "Backlight",
"content": [
{
"label": "Brightness",
"type": "range",
"options": [0, 255],
"content": ["id_qmk_rgb_matrix_brightness", 3, 1]
},
{
"label": "Effect",
"type": "dropdown",
"content": ["id_qmk_rgb_matrix_effect", 3, 2],
"options": [
["None", 0],
["Solid Color", 1],
["Breathing", 2],
["Band Spiral Val", 3],
["Cycle All", 4],
["Cycle Left Right", 5],
["Cycle Up Down", 6],
["Rainbow Moving Chevron", 7],
["Cycle Out In", 8],
["Cycle Out In Dual", 9],
["Cycle Pinwheel", 10],
["Cycle Spiral", 11],
["Dual Beacon", 12],
["Rainbow Beacon", 13],
["Jellybean Raindrops", 14],
["Pixel Rain", 15],
["Typing Heatmap", 16],
["Digital Rain", 17],
["Reactive Simple", 18],
["Reactive Multiwide", 19],
["Reactive Multinexus", 20],
["Splash", 21],
["Solid Splash", 22]
]
},
{
"showIf": "{id_qmk_rgb_matrix_effect} > 1",
"label": "Effect Speed",
"type": "range",
"options": [0, 255],
"content": ["id_qmk_rgb_matrix_effect_speed", 3, 3]
},
{
"showIf": "{id_qmk_rgb_matrix_effect} != 0 && ( {id_qmk_rgb_matrix_effect} < 4 || {id_qmk_rgb_matrix_effect} == 18 || ({id_qmk_rgb_matrix_effect} > 17 && {id_qmk_rgb_matrix_effect} != 21) ) ",
"label": "Color",
"type": "color",
"content": ["id_qmk_rgb_matrix_color", 3, 4]
}
]
}
]
}
],
"customKeycodes": [
{"name": "Task View", "title": "Task View in Windows", "shortName": "Task"},
{"name": "File Explorer", "title": "File Explorer in Windows", "shortName": "File"},
{"name": "Lock Sreen", "title": "Lock Screen Windows", "shortName": "Lock"},
{"name": "Misson Control", "title": "Misson Control in Mac", "shortName": "MCtl"},
{"name": "Lanuch Pad", "title": "Lanuch Pad in Windows", "shortName": "LPad"},
{"name": "Left Option", "title": "Left Option", "shortName": "LOpt"},
{"name": "Right Option", "title": "Right Option", "shortName": "ROpt"},
{"name": "Left Cmd", "title": "Left Command", "shortName": "LCmd"},
{"name": "Right Cmd", "title": "Right Command", "shortName": "RCmd"},
{"name": "Bluetooth Host 1", "title": "Bluetooth Host 1", "shortName": "BTH1"},
{"name": "Bluetooth Host 2", "title": "Bluetooth Host 2", "shortName": "BTH2"},
{"name": "Bluetooth Host 3", "title": "Bluetooth Host 3", "shortName": "BTH3"},
{"name": "2.4G Host", "title": "2.4G Host", "shortName": "2.4G"},
{"name": "Battery Level", "title": "Show battery level", "shortName": "Batt"}
],
"matrix": {"rows": 6, "cols": 18},
"layouts": {
"keymap":[
[
{
"w": 1.5,
"h": 1.5
},
"0,1\n\n\n\n\n\n\n\n\ne0",
{
"y": 0,
"x": 0.6,
"c": "#777777"
},
"0,2\nESC",
{
"x": 1,
"c": "#cccccc"
},
"0,3",
"0,4",
"0,5",
"0,6",
{
"x": 0.5,
"c": "#aaaaaa"
},
"0,7",
"0,8",
"0,9",
"0,10",
{
"x": 0.5,
"c": "#cccccc"
},
"0,11",
"0,12",
"0,13",
"0,14",
{
"x": 0.25,
"c": "#aaaaaa"
},
"0,15",
"0,16",
"0,17"
],
[
{
"x": 2.1,
"y": 0.25,
"c": "#cccccc"
},
"1,1",
"1,2",
"1,3",
"1,4",
"1,5",
"1,6",
"1,7",
"1,8",
"1,9",
"1,10",
"1,11",
"1,12",
"1,13",
{
"c": "#aaaaaa",
"w": 2
},
"1,14",
{
"x": 0.25
},
"1,15",
"1,16",
"1,17",
{
"c": "#cccccc",
"x": 0.25
}
],
[
{
"x": 0.25,
"y": -0.4,
"h": 1.1,
"w": 1.1
},
"2,0",
{
"x": 0.75,
"y": 0.4,
"c": "#aaaaaa",
"w": 1.5
},
"2,1",
{
"c": "#cccccc"
},
"2,2",
"2,3",
"2,4",
"2,5",
"2,6",
"2,7",
"2,8",
"2,9",
"2,10",
"2,11",
"2,12",
"2,13",
{
"x": 0.25,
"c": "#777777",
"w": 1.25,
"h": 2,
"w2": 1.5,
"h2": 1,
"x2": -0.25
},
"2,14",
{
"x": 0.25,
"c": "#aaaaaa"
},
"2,15",
"2,16",
"2,17"
],
[
{
"x": 0.25,
"y": -0.3,
"h": 1.1,
"w": 1.1,
"c": "#cccccc"
},
"3,0",
{
"x": 0.75,
"y": 0.3,
"c": "#aaaaaa",
"w": 1.75
},
"3,1",
{
"c": "#cccccc"
},
"3,2",
"3,3",
"3,4",
"3,5",
"3,6",
"3,7",
"3,8",
"3,9",
"3,10",
"3,11",
"3,12",
"3,14",
{
"c": "#777777",
"w": 1.25
}
],
[
{
"x": 0.25,
"y": -0.2,
"h": 1.1,
"w": 1.1,
"c": "#cccccc"
},
"4,0",
{
"x": 0.75,
"y": 0.2,
"c": "#aaaaaa",
"w": 1.25
},
"4,1",
{
"c": "#cccccc"
},
"4,2",
"4,3",
"4,4",
"4,5",
"4,6",
"4,7",
"4,8",
"4,9",
"4,10",
"4,11",
"4,12",
{
"c": "#aaaaaa",
"w": 2.75
},
"4,14",
{
"c": "#cccccc",
"x": 1.25,
"w": 1
},
"4,16"
],
[
{
"x": 0.25,
"y": -0.1,
"h": 1.1,
"w": 1.1
},
"5,0",
{
"x": 0.75,
"y": 0.1,
"c": "#aaaaaa",
"w": 1.25
},
"5,1",
{
"w": 1.25
},
"5,2",
{
"w": 1.25
},
"5,3",
{
"c": "#cccccc",
"w": 6.25
},
"5,7",
{
"c": "#aaaaaa",
"w": 1.25
},
"5,11",
{
"w": 1.25
},
"5,12",
{
"w": 1.25
},
"5,13",
{
"w": 1.25
},
"5,14",
{
"c": "#cccccc",
"w": 1,
"x": 0.25
},
"5,15",
"5,16",
"5,17"
]
]
}
}