forked from mirrors/qmk_userspace
Added wireless support; Added Lemokey L3; Added Keychron V1 Max
This commit is contained in:
lokher
parent
9539f135d8
commit
4ae5990fcc
31585 changed files with 99327 additions and 1763186 deletions
147
keyboards/keychron/common/wireless/bat_level_animation.c
Normal file
147
keyboards/keychron/common/wireless/bat_level_animation.c
Normal 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/keychron/common/wireless/bat_level_animation.h
Normal file
23
keyboards/keychron/common/wireless/bat_level_animation.h
Normal 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/keychron/common/wireless/battery.c
Normal file
239
keyboards/keychron/common/wireless/battery.c
Normal file
|
|
@ -0,0 +1,239 @@
|
|||
/* Copyright 2022~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 "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/keychron/common/wireless/battery.h
Normal file
62
keyboards/keychron/common/wireless/battery.h
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
/* Copyright 2022~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
|
||||
|
||||
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/keychron/common/wireless/indicator.c
Normal file
723
keyboards/keychron/common/wireless/indicator.c
Normal 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 "keychron_common.h"
|
||||
#include "usb_main.h"
|
||||
#ifdef FACTORY_TEST_ENABLE
|
||||
# include "factory_test.h"
|
||||
#endif
|
||||
#include "lpm.h"
|
||||
|
||||
#include "keychron_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 KEYCHRON_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/keychron/common/wireless/indicator.h
Normal file
117
keyboards/keychron/common/wireless/indicator.h
Normal 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 {
|
||||
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 {
|
||||
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/keychron/common/wireless/keychron_wireless_common.c
Normal file
155
keyboards/keychron/common/wireless/keychron_wireless_common.c
Normal 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 "keychron_wireless_common.h"
|
||||
# include "keychron_task.h"
|
||||
#endif
|
||||
#include "keychron_common.h"
|
||||
|
||||
bool firstDisconnect = true;
|
||||
|
||||
static uint32_t pairing_key_timer;
|
||||
static uint8_t host_idx = 0;
|
||||
|
||||
bool process_record_keychron_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 = 0x3434, // Must be 0x3434
|
||||
.product_id = PRODUCT_ID};
|
||||
// clang-format on
|
||||
lkbt51_set_param(¶m);
|
||||
}
|
||||
|
||||
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 keychron_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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
/* 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 "stdint.h"
|
||||
#ifdef VIA_ENABLE
|
||||
# include "via.h"
|
||||
#endif
|
||||
#include "quantum_keycodes.h"
|
||||
|
||||
void lkbt51_param_init(void);
|
||||
|
||||
bool process_record_keychron_wireless(uint16_t keycode, keyrecord_t *record);
|
||||
void keychron_wireless_common_task(void);
|
||||
867
keyboards/keychron/common/wireless/lkbt51.c
Normal file
867
keyboards/keychron/common/wireless/lkbt51.c
Normal file
|
|
@ -0,0 +1,867 @@
|
|||
/* 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 "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/keychron/common/wireless/lkbt51.h
Normal file
131
keyboards/keychron/common/wireless/lkbt51.h
Normal 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 0x3434 */
|
||||
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/keychron/common/wireless/lpm.c
Normal file
277
keyboards/keychron/common/wireless/lpm.c
Normal file
|
|
@ -0,0 +1,277 @@
|
|||
/* Copyright 2022~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 "keychron_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/keychron/common/wireless/lpm.h
Normal file
36
keyboards/keychron/common/wireless/lpm.h
Normal 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/keychron/common/wireless/lpm_stm32f401.c
Normal file
114
keyboards/keychron/common/wireless/lpm_stm32f401.c
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
/* 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_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/keychron/common/wireless/lpm_stm32f401.h
Normal file
33
keyboards/keychron/common/wireless/lpm_stm32f401.h
Normal 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/keychron/common/wireless/report_buffer.c
Normal file
148
keyboards/keychron/common/wireless/report_buffer.c
Normal 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 KEYCHRON_CALLBACK_ENABLE
|
||||
register_keychron_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/keychron/common/wireless/report_buffer.h
Normal file
61
keyboards/keychron/common/wireless/report_buffer.h
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
/* Copyright 2022~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 "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/keychron/common/wireless/rtc_timer.c
Normal file
43
keyboards/keychron/common/wireless/rtc_timer.c
Normal 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/keychron/common/wireless/rtc_timer.h
Normal file
35
keyboards/keychron/common/wireless/rtc_timer.h
Normal 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/keychron/common/wireless/transport.c
Normal file
272
keyboards/keychron/common/wireless/transport.c
Normal file
|
|
@ -0,0 +1,272 @@
|
|||
/* Copyright 2022~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/keychron/common/wireless/transport.h
Normal file
42
keyboards/keychron/common/wireless/transport.h
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/* Copyright 2022~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/keychron/common/wireless/wireless.c
Normal file
556
keyboards/keychron/common/wireless/wireless.c
Normal file
|
|
@ -0,0 +1,556 @@
|
|||
/* 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 "report_buffer.h"
|
||||
#include "lpm.h"
|
||||
#include "battery.h"
|
||||
#include "indicator.h"
|
||||
#include "transport.h"
|
||||
#include "rtc_timer.h"
|
||||
#include "keychron_wireless_common.h"
|
||||
#include "keychron_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 KEYCHRON_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();
|
||||
keychron_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_keychron_wireless(keycode, record)) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
101
keyboards/keychron/common/wireless/wireless.h
Normal file
101
keyboards/keychron/common/wireless/wireless.h
Normal 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/keychron/common/wireless/wireless.mk
Normal file
21
keyboards/keychron/common/wireless/wireless.mk
Normal 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)/keychron_wireless_common.c
|
||||
|
||||
VPATH += $(TOP_DIR)/keyboards/keychron/$(WIRELESS_DIR)
|
||||
|
||||
36
keyboards/keychron/common/wireless/wireless_config.h
Normal file
36
keyboards/keychron/common/wireless/wireless_config.h
Normal 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/keychron/common/wireless/wireless_event_type.h
Normal file
44
keyboards/keychron/common/wireless/wireless_event_type.h
Normal 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/keychron/common/wireless/wireless_main.c
Normal file
42
keyboards/keychron/common/wireless/wireless_main.c
Normal 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 "keychron_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 KEYCHRON_CALLBACK_ENABLE
|
||||
void register_wt_tasks(void) {
|
||||
register_keychron_task(wireless_tasks, true);
|
||||
}
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue