gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2025-07-21 07:02:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Optimize wireless functionality

Browse Source
This commit is contained in:
sdk 2024-10-16 17:25:53 +08:00
parent 8af4355646
commit a59a9066ca
22 changed files with 1815 additions and 350 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
keyboards/akko/yu01/.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,3 @@
{
"C_Cpp.errorSquiggles": "disabled"
}

96
keyboards/epomaker/tide65/config.h
View File

@ -3,27 +3,26 @@
#pragma once #pragma once
#ifdef WIRELESS_ENABLE #define USB_POWER_EN_PIN B1 // USB ENABLE pin
# define LPWR_TIMEOUT RGB_MATRIX_TIMEOUT #define LED_POWER_EN_PIN A5 // LED ENABLE pin
#endif #define HS_BAT_CABLE_PIN A7 // USB insertion detection pin
// #define HS_LED_BOOSTING_PIN D2 // LED BOOSTING,Power boost pin
#define USB_POWER_EN_PIN B1 //USB ENABLE pin #define BAT_FULL_PIN A15
#define LED_POWER_EN_PIN A5 //LED ENABLE pin #define BAT_FULL_STATE 1
#define HS_BAT_CABLE_PIN A7 //USB insertion detection pin
#define BAT_FULL_PIN A15 #define HS_RGB_INDICATOR_COUNT 69
#define BAT_FULL_STATE 1 #define HS_RGB_BAT_COUNT 1
/* Battery */ /* Device Name Definition */
#define BATTERY_CAPACITY_LOW 15 #define PRODUCT "EPOMAKER TIDE65"
#define BATTERY_CAPACITY_STOP 0 #define MD_BT1_NAME "EPOMAKER TIDE65"
#define MD_BT2_NAME "EPOMAKER TIDE65"
#define HS_RGB_INDICATOR_COUNT 69 #define MD_BT3_NAME "EPOMAKER TIDE65"
#define HS_RGB_BAT_COUNT 1 #define MD_DONGLE_MANUFACTURER "EPOMAKER TIDE 65"
#define RGB_MATRIX_BAT_INDEX_MAP {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
/* Device Connection RGB Indicator Light Index And Color */ /* Device Connection RGB Indicator Light Index And Color */
#define HS_RGB_BLINK_INDEX_BT1 43 #define HS_RGB_BLINK_INDEX_BT1 43
#define HS_RGB_BLINK_INDEX_BT2 42 #define HS_RGB_BLINK_INDEX_BT2 42
#define HS_RGB_BLINK_INDEX_BT3 41 #define HS_RGB_BLINK_INDEX_BT3 41
#define HS_RGB_BLINK_INDEX_2G4 34 #define HS_RGB_BLINK_INDEX_2G4 34
@ -33,23 +32,31 @@
#define HS_LBACK_COLOR_BT2 RGB_BLUE #define HS_LBACK_COLOR_BT2 RGB_BLUE
#define HS_LBACK_COLOR_BT3 RGB_BLUE #define HS_LBACK_COLOR_BT3 RGB_BLUE
#define HS_LBACK_COLOR_2G4 RGB_GREEN #define HS_LBACK_COLOR_2G4 RGB_GREEN
#define HS_LBACK_COLOR_UBS RGB_WHITE #define HS_LBACK_COLOR_USB RGB_WHITE
#define HS_PAIR_COLOR_BT1 RGB_BLUE #define HS_PAIR_COLOR_BT1 RGB_BLUE
#define HS_PAIR_COLOR_BT2 RGB_BLUE #define HS_PAIR_COLOR_BT2 RGB_BLUE
#define HS_PAIR_COLOR_BT3 RGB_BLUE #define HS_PAIR_COLOR_BT3 RGB_BLUE
#define HS_PAIR_COLOR_2G4 RGB_GREEN #define HS_PAIR_COLOR_2G4 RGB_GREEN
#define WIITE_B 0X6e
/* Battery */
#define BATTERY_CAPACITY_LOW 15
#define BATTERY_CAPACITY_STOP 0
#define RGB_MATRIX_BAT_INDEX_MAP {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
/* Status Indicator Lamp */ /* Status Indicator Lamp */
#define HS_MATRIX_BLINK_INDEX_BAT 57 #define HS_MATRIX_BLINK_INDEX_BAT 57
#define HS_RGB_INDEX_CAPS 8 #define HS_RGB_INDEX_CAPS 8
#define HS_RGB_INDEX_WIN_LOCK 5 #define HS_RGB_INDEX_WIN_LOCK 5
#define HS_RGB_BLINK_INDEX_VAI 29 #define HS_RGB_BLINK_INDEX_VAI 29
#define HS_RGB_BLINK_INDEX_VAD 28 #define HS_RGB_BLINK_INDEX_VAD 28
#define HS_RGB_BLINK_INDEX_SPI 27 #define HS_RGB_BLINK_INDEX_SPI 27
#define HS_RGB_BLINK_INDEX_SPD 56 #define HS_RGB_BLINK_INDEX_SPD 56
#define HS_RGB_BLINK_INDEX_WIN 44
#define HS_RGB_BLINK_INDEX_MAC 45 #define HS_RGB_BLINK_INDEX_WIN 44
#define HS_RGB_BLINK_INDEX_MAC 45
/* UART */ /* UART */
#define SERIAL_DRIVER SD3 #define SERIAL_DRIVER SD3
@ -57,23 +64,42 @@
#define SD1_RX_PIN C11 #define SD1_RX_PIN C11
/* Encoder */ /* Encoder */
#define ENCODER_MAP_KEY_DELAY 1 #define ENCODER_MAP_KEY_DELAY 1
#define ENCODER_RESOLUTION 2
/* SPI */ /* SPI */
#define SPI_DRIVER SPIDQ #define SPI_DRIVER SPIDQ
#define SPI_SCK_PIN B3 #define SPI_SCK_PIN B3
#define SPI_MOSI_PIN B5 #define SPI_MOSI_PIN B5
#define SPI_MISO_PIN B4 #define SPI_MISO_PIN B4
/* Flash */ /* Flash */
#define EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN C12 #define EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN C12
#define WEAR_LEVELING_LOGICAL_SIZE (WEAR_LEVELING_BACKING_SIZE / 2) #define WEAR_LEVELING_LOGICAL_SIZE (WEAR_LEVELING_BACKING_SIZE / 2)
/* RGB Matrix */ /* RGB Matrix */
#define WS2812_BYTE_ORDER WS2812_BYTE_ORDER_RGB #define WS2812_BYTE_ORDER WS2812_BYTE_ORDER_RGB
#define RGB_MATRIX_FRAMEBUFFER_EFFECTS #define RGB_MATRIX_FRAMEBUFFER_EFFECTS
#define RGB_MATRIX_KEYPRESSES #define RGB_MATRIX_KEYPRESSES
/* RGB Light */
#define RGBLED_NUM 8
#define RGBLIGHT_CUSTOM_DRIVER
#define RGBLIGHT_DISABLE_KEYCODES
#define BREATHING_VAL 40
#define RAINBOW_MOOD 40
#define LED_TYPE RGB
#define RGBLIGHT_LED_MAP {0, 1, 2, 3, 4, 5, 6, 7}
/* WS2812 */ /* WS2812 */
#define WS2812_SPI_DRIVER SPIDM2 #define WS2812_SPI_DRIVER SPIDM2
#define WS2812_SPI_DIVISOR 32 #define WS2812_SPI_DIVISOR 32
/* rgb_record */
#define ENABLE_RGB_MATRIX_RGBR_PLAY
#define RGBREC_CHANNEL_NUM 4
#define EECONFIG_CONFINFO_USE_SIZE (4 + 16)
#define EECONFIG_RGBREC_USE_SIZE (RGBREC_CHANNEL_NUM * MATRIX_ROWS * MATRIX_COLS * 2)
#define EECONFIG_USER_DATA_SIZE (EECONFIG_RGBREC_USE_SIZE + EECONFIG_CONFINFO_USE_SIZE)
#define RGBREC_EECONFIG_ADDR (uint8_t *)(EECONFIG_USER_DATABLOCK)
#define CONFINFO_EECONFIG_ADDR (uint32_t *)((uint32_t)RGBREC_EECONFIG_ADDR + (uint32_t)EECONFIG_RGBREC_USE_SIZE)

197
keyboards/epomaker/tide65/control/control.c Normal file
View File

@ -0,0 +1,197 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "control.h"
static ioline_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
extern bool lower_sleep;
bool hs_modeio_detection(bool update, uint8_t *mode,uint8_t lsat_btdev) {
static uint32_t scan_timer = 0x00;
if ((update != true) && (timer_elapsed32(scan_timer) <= (HS_MODEIO_DETECTION_TIME))) {
return false;
}
scan_timer = timer_read32();
#if defined(HS_BT_DEF_PIN) && defined(HS_2G4_DEF_PIN)
uint8_t now_mode = 0x00;
uint8_t hs_mode = 0x00;
static uint8_t last_mode = 0x00;
bool sw_mode = false;
now_mode = (HS_GET_MODE_PIN(HS_USB_PIN_STATE) ? 3 : (HS_GET_MODE_PIN(HS_BT_PIN_STATE) ? 1 : ((HS_GET_MODE_PIN(HS_2G4_PIN_STATE) ? 2 : 0))));
hs_mode = (*mode >= DEVS_BT1 && *mode <= DEVS_BT5) ? 1 : ((*mode == DEVS_2G4) ? 2 : ((*mode == DEVS_USB) ? 3 : 0));
sw_mode = ((update || (last_mode == now_mode)) && (hs_mode != now_mode)) ? true : false;
last_mode = now_mode;
switch (now_mode)
{
case 1:
*mode = hs_bt;
if (sw_mode) {
wireless_devs_change(wireless_get_current_devs(), lsat_btdev, false);
}
break;
case 2:
*mode = hs_2g4;
if (sw_mode) {
wireless_devs_change(wireless_get_current_devs(), DEVS_2G4, false);
}
break;
case 3:
*mode = hs_usb;
if (sw_mode)
wireless_devs_change(wireless_get_current_devs(), DEVS_USB, false);
break;
default:
break;
}
if (sw_mode) {
hs_rgb_blink_set_timer(timer_read32());
suspend_wakeup_init();
return true;
}
#else
*mode = hs_none;
#endif
return false;
}
static uint32_t hs_linker_rgb_timer = 0x00;
bool hs_mode_scan(bool update,uint8_t moude,uint8_t lsat_btdev) {
if (hs_modeio_detection(update, &moude, lsat_btdev)) {
return true;
}
hs_rgb_blink_hook();
return false;
}
void hs_rgb_blink_set_timer(uint32_t time) {
hs_linker_rgb_timer = time;
}
uint32_t hs_rgb_blink_get_timer(void) {
return hs_linker_rgb_timer;
}
bool hs_rgb_blink_hook(){
static uint8_t last_status;
if (last_status != *md_getp_state()){
last_status = *md_getp_state();
hs_rgb_blink_set_timer(0x00);
}
switch (*md_getp_state())
{
case MD_STATE_NONE: {
hs_rgb_blink_set_timer(0x00);
} break;
case MD_STATE_DISCONNECTED:
if (hs_rgb_blink_get_timer() == 0x00){
hs_rgb_blink_set_timer(timer_read32());
extern void wireless_devs_change_kb(uint8_t old_devs, uint8_t new_devs, bool reset);
wireless_devs_change_kb(wireless_get_current_devs(),wireless_get_current_devs(),false);
}
else{
if (timer_elapsed32(hs_rgb_blink_get_timer()) >= HS_LBACK_TIMEOUT) {
hs_rgb_blink_set_timer(timer_read32());
md_send_devctrl(MD_SND_CMD_DEVCTRL_USB);
wait_ms(200);
lpwr_set_timeout_manual(true);
}
}
case MD_STATE_CONNECTED:
if (hs_rgb_blink_get_timer() == 0x00){
hs_rgb_blink_set_timer(timer_read32());
}
else{
if (timer_elapsed32(hs_rgb_blink_get_timer()) >= HS_SLEEP_TIMEOUT) {
hs_rgb_blink_set_timer(timer_read32());
lpwr_set_timeout_manual(true);
}
}
default:
break;
}
return true;
}
void lpwr_exti_init_hook(void){
#ifdef HS_BT_DEF_PIN
setPinInputHigh(HS_BT_DEF_PIN);
waitInputPinDelay();
palEnableLineEvent(HS_BT_DEF_PIN, PAL_EVENT_MODE_BOTH_EDGES);
#endif
#ifdef HS_2G4_DEF_PIN
setPinInputHigh(HS_2G4_DEF_PIN);
waitInputPinDelay();
palEnableLineEvent(HS_2G4_DEF_PIN, PAL_EVENT_MODE_BOTH_EDGES);
#endif
if (lower_sleep){
#if DIODE_DIRECTION == ROW2COL
for (uint8_t i = 0; i < ARRAY_SIZE(col_pins); i++) {
if (col_pins[i] != NO_PIN) {
setPinOutput(col_pins[i]);
writePinHigh(col_pins[i]);
}
}
#endif
}
setPinInput(HS_BAT_CABLE_PIN);
waitInputPinDelay();
palEnableLineEvent(HS_BAT_CABLE_PIN, PAL_EVENT_MODE_RISING_EDGE);
}
void palcallback_cb(uint8_t line){
switch (line) {
case PAL_PAD(HS_BAT_CABLE_PIN): {
lpwr_set_sleep_wakeupcd(LPWR_WAKEUP_CABLE);
} break;
#ifdef HS_2G4_DEF_PIN
case PAL_PAD(HS_2G4_DEF_PIN): {
lpwr_set_sleep_wakeupcd(LPWR_WAKEUP_SWITCH);
} break;
#endif
#ifdef HS_BT_DEF_PIN
case PAL_PAD(HS_BT_DEF_PIN): {
lpwr_set_sleep_wakeupcd(LPWR_WAKEUP_SWITCH);
} break;
#endif
default: {
} break;
}
}
void lpwr_stop_hook_post(void){
if (lower_sleep){
switch (lpwr_get_sleep_wakeupcd()) {
case LPWR_WAKEUP_USB:
case LPWR_WAKEUP_CABLE: {
lower_sleep = false;
lpwr_set_state(LPWR_WAKEUP);
} break;
default: {
lpwr_set_state(LPWR_STOP);
} break;
}
}
}

35
keyboards/epomaker/tide65/control/control.h Normal file
View File

@ -0,0 +1,35 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include QMK_KEYBOARD_H
#include <stdbool.h>
#include "wireless.h"
/* Use when there is a three-stage dial switch */
// # define HS_BT_DEF_PIN C14
// # define HS_2G4_DEF_PIN C15
// # define HS_BT_PIN_STATE 0, 1
// # define HS_2G4_PIN_STATE 1, 0
// # define HS_USB_PIN_STATE 1, 1
# define HS_GET_MODE_PIN_(pin_bt, pin_2g4) ((((#pin_bt)[0] == 'x') || ((readPin(HS_BT_DEF_PIN) + 0x30) == ((#pin_bt)[0]))) && (((#pin_2g4)[0] == 'x') || ((readPin(HS_2G4_DEF_PIN) + 0x30) == ((#pin_2g4)[0]))))
# define HS_GET_MODE_PIN(state) HS_GET_MODE_PIN_(state)
# define HS_MODEIO_DETECTION_TIME 50
/* Set the wireless device's reconnect timeout and connection usage sleep time */
#define HS_LBACK_TIMEOUT (30 * 1000)
#define HS_SLEEP_TIMEOUT (1 * 60000)
enum modeio_mode {
hs_none = 0,
hs_usb,
hs_bt,
hs_2g4,
hs_wireless
};
bool hs_rgb_blink_hook(void);
bool hs_mode_scan(bool update,uint8_t moude,uint8_t lsat_btdev);
bool hs_modeio_detection(bool update, uint8_t *mode,uint8_t lsat_btdev);
void hs_rgb_blink_set_timer(uint32_t time);

1
keyboards/epomaker/tide65/control/control.mk Normal file
View File

@ -0,0 +1 @@
SRC += control/control.c

4
keyboards/epomaker/tide65/halconf.h
View File

@ -3,8 +3,8 @@
#pragma once #pragma once
#define HAL_USE_SERIAL TRUE #define HAL_USE_SERIAL TRUE
#define HAL_USE_SPI TRUE #define HAL_USE_SPI TRUE
#define PAL_USE_CALLBACKS TRUE #define PAL_USE_CALLBACKS TRUE
#include_next <halconf.h> #include_next <halconf.h>

60
keyboards/epomaker/tide65/keyboard.json
View File

@ -32,9 +32,6 @@
"encoder": true "encoder": true
}, },
"keycodes": [ "keycodes": [
{
"key": "KC_USB"
},
{ {
"key": "KC_BT1" "key": "KC_BT1"
}, },
@ -44,17 +41,32 @@
{ {
"key": "KC_BT3" "key": "KC_BT3"
}, },
{
"key": "KC_BT4"
},
{
"key": "KC_BT5"
},
{ {
"key": "KC_2G4" "key": "KC_2G4"
}, },
{ {
"key": "KC_BATQ" "key": "KC_USB"
},
{
"key": "RP_P0"
},
{
"key": "RP_P1"
},
{
"key": "RP_P2"
},
{
"key": "RP_END"
},
{
"key": "RL_MOD"
},
{
"key": "HS_BATQ"
},
{
"key": "KC_TESTW"
}, },
{ {
"key": "KC_FTOG" "key": "KC_FTOG"
@ -188,19 +200,37 @@
{"matrix": [3, 1], "x": 16, "y": 48, "flags": 4} {"matrix": [3, 1], "x": 16, "y": 48, "flags": 4}
], ],
"max_brightness": 200, "max_brightness": 200,
"val_steps": 40, "val_steps": 38,
"speed_steps": 51, "speed_steps": 51,
"default": { "default": {
"val" :153, "animation": "cycle_left_right",
"val" :114,
"speed" :204 "speed" :204
}, },
"sleep": true, "sleep": true
"timeout": 60000 },
"rgblight": {
"animations": {
"alternatin":true,
"breathing": true,
"christmas":true,
"knight":true,
"rainbow_mood": true,
"rainbow_swirl": true,
"rgb_test": true,
"snake": true,
"static_gradient": true,
"twinkle": true
},
"default": {
"animation": "rainbow_swirl",
"val": 60
}
}, },
"tap_keycode_delay": 10, "tap_keycode_delay": 10,
"url": "https://www.epomaker.com", "url": "https://www.epomaker.com",
"usb": { "usb": {
"device_version": "0.3.0", "device_version": "0.4.0",
"force_nkro": true, "force_nkro": true,
"pid": "0xE463", "pid": "0xE463",
"suspend_wakeup_delay": 1000, "suspend_wakeup_delay": 1000,

120
keyboards/epomaker/tide65/keymaps/default/keymap.c
View File

@ -1,32 +1,132 @@
// Copyright 2024 SDK (@sdk66) // Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "rgb_record/rgb_record.h"
enum layers {
_BL = 0,
_FL,
_MBL,
_MFL,
_FBL,
_FFL,
_FMBL,
_FMFL,
_DEFA
};
// clang-format off // clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT( [_BL] = LAYOUT( /* win Base */
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_MUTE, KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP, KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN, KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LCMD, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(1), KC_LEFT, KC_DOWN, KC_RGHT KC_LCTL, KC_LCMD, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(_FL), KC_LEFT, KC_DOWN, KC_RGHT
), ),
[1] = LAYOUT( [_FL] = LAYOUT( /* win FN */
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, _______, KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______, _______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_BATQ, _______, _______, KC_NO, TO(_MBL), _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, HS_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, _______, RGB_VAI, _______, _______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
_______, GU_TOGG, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI KC_FTOG, GU_TOGG, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
), ),
[_MBL] = LAYOUT(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LALT, KC_LCMD, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RCMD, MO(_MFL), KC_LEFT, KC_DOWN, KC_RGHT
),
[_MFL] = LAYOUT(
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, TO(_BL), KC_NO, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, HS_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
KC_FTOG, _______, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
),
[_FBL] = LAYOUT(
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LCMD, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(_FFL), KC_LEFT, KC_DOWN, KC_RGHT
),
[_FFL] = LAYOUT(
KC_GRV, KC_MYCM, KC_WHOM, KC_MAIL, KC_CALC, KC_MSEL, KC_MSTP, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, KC_NO, TO(_FMBL),_______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, HS_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
KC_FTOG, GU_TOGG, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
),
[_FMBL] = LAYOUT(
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LALT, KC_LCMD, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RCMD, MO(_FMFL),KC_LEFT, KC_DOWN, KC_RGHT
),
[_FMFL] = LAYOUT(
KC_GRV, KC_BRID, KC_BRIU, KC_F3, KC_F4, RGB_VAD, RGB_VAI, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, TO(_FBL), KC_NO, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, HS_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
KC_FTOG, _______, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
),
[_DEFA] = LAYOUT(
KC_TILD, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, QK_BOOT,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
),
};
const uint16_t PROGMEM rgbrec_default_effects[RGBREC_CHANNEL_NUM][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT(
HS_GREEN, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________,
________, ________, HS_GREEN, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________,
________, HS_GREEN, HS_GREEN, HS_GREEN, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________,
________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, HS_GREEN, ________,
________, ________, ________, ________, ________, ________, ________, ________, ________, HS_GREEN, HS_GREEN, HS_GREEN),
[1] = LAYOUT(
________, HS_RED, HS_RED, HS_RED, HS_RED, HS_RED, ________, ________, ________, ________, ________, ________, ________, ________, ________,
HS_RED, HS_RED, HS_RED, HS_RED, HS_RED, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________,
________, HS_RED, HS_RED, HS_RED, ________, HS_RED, ________, ________, ________, ________, ________, ________, ________, ________,
HS_RED, ________, ________, ________, ________, HS_RED, ________, ________, ________, ________, ________, ________, ________, ________,
HS_RED, ________, HS_RED, ________, ________, ________, ________, ________, ________, ________, ________, ________),
[2] = LAYOUT(
________, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, ________, ________, ________, ________, ________, ________, ________,
________, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, ________, ________, ________, ________, ________, ________, ________, ________, ________,
________, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, HS_BLUE, ________, ________, ________, ________, ________, ________, ________, ________,
________, ________, ________, HS_BLUE, HS_BLUE, ________, ________, ________, ________, ________, ________, ________, ________, ________,
________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________, ________),
}; };
#ifdef ENCODER_MAP_ENABLE #ifdef ENCODER_MAP_ENABLE
const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = { const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {
[0] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)}, [0] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[1] = {ENCODER_CCW_CW(_______, _______)}, [1] = {ENCODER_CCW_CW(_______, _______)},
[2] = {ENCODER_CCW_CW(_______, _______)},
[3] = {ENCODER_CCW_CW(_______, _______)},
[4] = {ENCODER_CCW_CW(_______, _______)},
[5] = {ENCODER_CCW_CW(_______, _______)},
[6] = {ENCODER_CCW_CW(_______, _______)},
[7] = {ENCODER_CCW_CW(_______, _______)},
[8] = {ENCODER_CCW_CW(_______, _______)}
}; };
#endif #endif
// clang-format on // clang-format on

108
keyboards/epomaker/tide65/keymaps/via/keymap.c
View File

@ -1,108 +0,0 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include QMK_KEYBOARD_H
enum layers {
_BL = 0,
_FL,
_MBL,
_MFL,
_FBL,
_FFL,
_FMBL,
_FMFL,
_DEFA
};
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_BL] = LAYOUT( /* win Base */
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LCMD, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(_FL), KC_LEFT, KC_DOWN, KC_RGHT
),
[_FL] = LAYOUT( /* win FN */
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, KC_NO, TO(_MBL), _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
KC_FTOG, GU_TOGG, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
),
[_MBL] = LAYOUT(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LALT, KC_LCMD, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RCMD, MO(_MFL), KC_LEFT, KC_DOWN, KC_RGHT
),
[_MFL] = LAYOUT(
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, TO(_BL), KC_NO, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
KC_FTOG, _______, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
),
[_FBL] = LAYOUT(
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LCMD, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(_FFL), KC_LEFT, KC_DOWN, KC_RGHT
),
[_FFL] = LAYOUT(
KC_GRV, KC_MYCM, KC_WHOM, KC_MAIL, KC_CALC, KC_MSEL, KC_MSTP, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, KC_NO, TO(_FMBL),_______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
KC_FTOG, GU_TOGG, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
),
[_FMBL] = LAYOUT(
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_BSPC, KC_MUTE,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END,
KC_LCTL, KC_LALT, KC_LCMD, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RCMD, MO(_FMFL),KC_LEFT, KC_DOWN, KC_RGHT
),
[_FMFL] = LAYOUT(
KC_GRV, KC_BRID, KC_BRIU, KC_F3, KC_F4, RGB_VAD, RGB_VAI, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______,
_______, KC_BT1, KC_BT2, KC_BT3, _______, KC_USB, _______, _______, _______, _______, KC_2G4, KC_HOME, KC_SCRL, RGB_MOD, _______,
_______, TO(_FBL), KC_NO, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_BATQ, _______,
_______, RGB_TOG, _______, _______, _______, _______, _______, _______, RGB_HUI, _______, _______, MO(_DEFA),RGB_VAI, _______,
KC_FTOG, _______, _______, EE_CLR, EE_CLR, EE_CLR, EE_CLR, KC_RCTL, _______, RGB_SPD, RGB_VAD, RGB_SPI
),
[_DEFA] = LAYOUT(
KC_TILD, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, QK_BOOT,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
),
};
#ifdef ENCODER_MAP_ENABLE
const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {
[0] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[1] = {ENCODER_CCW_CW(_______, _______)},
[2] = {ENCODER_CCW_CW(_______, _______)},
[3] = {ENCODER_CCW_CW(_______, _______)},
[4] = {ENCODER_CCW_CW(_______, _______)},
[5] = {ENCODER_CCW_CW(_______, _______)},
[6] = {ENCODER_CCW_CW(_______, _______)},
[7] = {ENCODER_CCW_CW(_______, _______)},
[8] = {ENCODER_CCW_CW(_______, _______)}
};
#endif
// clang-format on

2
keyboards/epomaker/tide65/keymaps/via/rules.mk
View File

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

2
keyboards/epomaker/tide65/mcuconf.h
View File

@ -22,7 +22,7 @@
#define WB32_SPI_SPIM2_IRQ_PRIORITY 9 #define WB32_SPI_SPIM2_IRQ_PRIORITY 9
#undef WB32_SPI_QSPI_IRQ_PRIORITY #undef WB32_SPI_QSPI_IRQ_PRIORITY
#define WB32_SPI_QSPI_IRQ_PRIORITY 10 #define WB32_SPI_QSPI_IRQ_PRIORITY 10
#undef WB32_SERIAL_UART3_PRIORITY #undef WB32_SERIAL_UART3_PRIORITY
#define WB32_SERIAL_UART3_PRIORITY 8 #define WB32_SERIAL_UART3_PRIORITY 8

4
keyboards/epomaker/tide65/post_rules.mk
View File

@ -1 +1,5 @@
RGB_MATRIX_CUSTOM_USER = yes
RGBLIGHT_DRIVER = custom
include keyboards/epomaker/tide65/rgb_record/rgb_record.mk
include keyboards/epomaker/tide65/control/control.mk
include keyboards/linker/wireless/wireless.mk include keyboards/linker/wireless/wireless.mk

18
keyboards/epomaker/tide65/rgb_matrix_user.inc Normal file
View File

@ -0,0 +1,18 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#ifdef ENABLE_RGB_MATRIX_RGBR_PLAY
RGB_MATRIX_EFFECT(RGBR_PLAY)
# ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
bool RGBR_PLAY(effect_params_t *params) {
RGB_MATRIX_USE_LIMITS(led_min, led_max);
extern void rgbrec_play(uint8_t led_min, uint8_t led_max);
rgbrec_play(led_min, led_max);
return rgb_matrix_check_finished_leds(led_max);
}
# endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS
#endif

241
keyboards/epomaker/tide65/rgb_record/rgb_effect.c Normal file
View File

@ -0,0 +1,241 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "rgb_effect.h"
void rgblight_effect_breathing(animation_status_t *anim) {
static uint8_t i, r, g, b, dir;
switch (i) {
case 0: {
if (dir == 0) {
if (r < BREATHING_VAL - 1)
r += 2;
else
r++;
}
if (r == BREATHING_VAL) dir = 1;
if (dir == 1) {
if (r > 1)
r -= 2;
else
r--;
if (r == 0) {
dir = 0;
i = 1;
}
}
} break;
case 1: {
if (dir == 0) {
if (g < BREATHING_VAL - 1)
g += 2;
else
g++;
}
if (g == BREATHING_VAL) dir = 1;
if (dir == 1) {
if (g > 1)
g -= 2;
else
g--;
if (g == 0) {
dir = 0;
i = 2;
}
}
} break;
case 2: {
if (dir == 0) {
if (b < BREATHING_VAL - 1)
b += 2;
else
b++;
}
if (b == BREATHING_VAL) dir = 1;
if (dir == 1) {
if (b > 1)
b -= 2;
else
b--;
if (b == 0) {
dir = 0;
i = 3;
}
}
} break;
case 3: {
if (dir == 0) {
if (r < BREATHING_VAL - 1) {
r += 2;
b += 2;
} else {
r++;
b++;
}
}
if (r == BREATHING_VAL) dir = 1;
if (dir == 1) {
if (r > 1) {
r -= 2;
b -= 2;
} else {
r--;
b--;
}
if (r == 0) {
dir = 0;
i = 4;
}
}
} break;
case 4: {
if (dir == 0) {
if (r < BREATHING_VAL - 1) {
r += 2;
g += 2;
} else {
r++;
g++;
}
}
if (r == BREATHING_VAL) dir = 1;
if (dir == 1) {
if (r > 1) {
r -= 2;
g -= 2;
} else {
r--;
g--;
}
if (r == 0) {
dir = 0;
i = 5;
}
}
} break;
case 5: {
if (dir == 0) {
if (g < BREATHING_VAL - 1) {
g += 2;
b += 2;
} else {
g++;
b++;
}
}
if (g == BREATHING_VAL) dir = 1;
if (dir == 1) {
if (g > 1) {
g -= 2;
b -= 2;
} else {
g--;
b--;
}
if (g == 0) {
dir = 0;
i = 6;
}
}
} break;
case 6: {
if (dir == 0) {
if (g < BREATHING_VAL - 1) {
g += 2;
b += 2;
r += 2;
} else {
g++;
r++;
b++;
}
}
if (g == BREATHING_VAL) dir = 1;
if (dir == 1) {
if (g > 1) {
g -= 2;
b -= 2;
r -= 2;
} else {
g--;
r--;
b--;
}
if (g == 0) {
dir = 0;
i = 0;
}
}
} break;
default:
break;
}
for (uint8_t j = 0; j < RGBLED_NUM; j++)
rgblight_setrgb_at(r, g, b, j);
}
void rgblight_effect_rainbow_mood(animation_status_t *anim) {
static uint8_t i = 0, r = RAINBOW_MOOD, g = 0, b = 0;
if (rgblight_config.enable) {
for (uint8_t j = 0; j < RGBLED_NUM; j++)
rgblight_setrgb_at(r, g, b, j);
if (i == 0) {
if (g < RAINBOW_MOOD - 1) {
r -= 2;
g += 2;
} else {
r--;
g++;
}
if (g == RAINBOW_MOOD) i = 1;
}
if (i == 1) {
if (b < RAINBOW_MOOD - 1) {
g -= 2;
b += 2;
} else {
g--;
b++;
}
if (b == RAINBOW_MOOD) i = 2;
}
if (i == 2) {
if (r < RAINBOW_MOOD - 1) {
b -= 2;
r += 2;
} else {
b--;
r++;
}
if (r == RAINBOW_MOOD) i = 0;
}
}
}
bool rgblight_effect_custom_rainbow_swirl(animation_status_t *anim) {
uint8_t hue;
uint8_t i;
for (i = 0; i < rgblight_ranges.effect_num_leds / 2; i++) {
hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / rgblight_ranges.effect_num_leds * i + anim->current_hue);
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i + rgblight_ranges.effect_start_pos]);
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[rgblight_ranges.effect_num_leds - 1 - i + rgblight_ranges.effect_start_pos]);
}
rgblight_set();
if (anim->delta % 2) {
anim->current_hue++;
anim->current_hue++;
anim->current_hue++;
} else {
anim->current_hue--;
anim->current_hue--;
anim->current_hue--;
}
return false;
}

11
keyboards/epomaker/tide65/rgb_record/rgb_effect.h Normal file
View File

@ -0,0 +1,11 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "rgblight.h"
#define RGBLIGHT_RAINBOW_SWIRL_RANGE 255
extern rgblight_config_t rgblight_config;
extern rgb_led_t led[RGBLIGHT_LED_COUNT];
extern void sethsv(uint8_t hue, uint8_t sat, uint8_t val, rgb_led_t *led1);

327
keyboards/epomaker/tide65/rgb_record/rgb_record.c Normal file
View File

@ -0,0 +1,327 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "rgb_record.h"
#include "rgb_matrix.h"
#include "eeprom.h"
#define RGBREC_STATE_ON 1
#define RGBREC_STATE_OFF 0
#define RGBREC_COLOR_NUM (sizeof(rgbrec_hs_lists) / sizeof(rgbrec_hs_lists[0]))
typedef struct {
uint8_t state;
uint8_t channel;
uint16_t value;
} rgbrec_info_t;
typedef uint16_t (*rgbrec_effects_t)[MATRIX_COLS];
rgbrec_effects_t p_rgbrec_effects = NULL;
static uint16_t rgbrec_hs_lists[] = RGB_RECORD_HS_LISTS;
static uint8_t rgbrec_buffer[MATRIX_ROWS * MATRIX_COLS * 2];
//clang-format off
static const uint8_t rgbmatrix_buff[] = {13, 15, 16, 24, 25, 26, 29, 37, 33, 34, 35, 43, 2, 5, 6, 9};
static const uint8_t sixth_gear_buff[] = {6, 13, 15, 16, 25, 26, 34};
static uint8_t rgb_hsvs[RGB_HSV_MAX][2] = {
{0, 255},
{85, 255},
{170, 255},
{43, 255},
{191, 255},
{128, 255},
{4, 80 },
};
//clang-format on
static rgbrec_info_t rgbrec_info = {
.state = RGBREC_STATE_OFF,
.channel = 0,
.value = 0xFF,
};
static uint8_t rgbrec_buffer[MATRIX_ROWS * MATRIX_COLS * 2];
extern const uint16_t PROGMEM rgbrec_default_effects[RGBREC_CHANNEL_NUM][MATRIX_ROWS][MATRIX_COLS];
static bool find_matrix_row_col(uint8_t index, uint8_t *row, uint8_t *col) {
uint8_t i, j;
for (i = 0; i < MATRIX_ROWS; i++) {
for (j = 0; j < MATRIX_COLS; j++) {
if (g_led_config.matrix_co[i][j] != NO_LED) {
if (g_led_config.matrix_co[i][j] == index) {
*row = i;
*col = j;
return true;
}
}
}
}
return false;
}
static inline RGB hs_to_rgb(uint8_t h, uint8_t s) {
if ((h == 0) && (s == 0)) {
return hsv_to_rgb((HSV){0, 0, 0});
} else if ((h == 1) && (s == 1)) {
return hsv_to_rgb((HSV){0, 0, rgbrec_info.value});
} else {
return hsv_to_rgb((HSV){h, s, rgbrec_info.value});
}
}
void rgbrec_init(uint8_t channel) {
p_rgbrec_effects = (rgbrec_effects_t)rgbrec_buffer;
rgbrec_info.state = RGBREC_STATE_OFF;
rgbrec_info.channel = channel;
rgbrec_info.value = rgb_matrix_get_val();
rgbrec_read_current_channel(rgbrec_info.channel);
}
bool rgbrec_show(uint8_t channel) {
if (channel >= RGBREC_CHANNEL_NUM) {
return false;
}
rgbrec_info.channel = channel;
rgbrec_read_current_channel(rgbrec_info.channel);
if (rgb_matrix_get_mode() != RGB_MATRIX_CUSTOM_RGBR_PLAY) {
rgb_matrix_mode(RGB_MATRIX_CUSTOM_RGBR_PLAY);
}
return true;
}
bool rgbrec_start(uint8_t channel) {
if (channel >= RGBREC_CHANNEL_NUM) {
return false;
}
if (rgbrec_info.state == RGBREC_STATE_OFF) {
rgbrec_info.state = RGBREC_STATE_ON;
rgbrec_info.channel = channel;
rgbrec_read_current_channel(rgbrec_info.channel);
if (rgb_matrix_get_mode() != RGB_MATRIX_CUSTOM_RGBR_PLAY) {
rgb_matrix_mode(RGB_MATRIX_CUSTOM_RGBR_PLAY);
}
return true;
}
return false;
}
void rgbrec_update_current_channel(uint8_t channel) {
uint32_t addr = 0;
if (channel >= RGBREC_CHANNEL_NUM) {
return;
}
addr = (uint32_t)(RGBREC_EECONFIG_ADDR) + (channel * sizeof(rgbrec_buffer));
eeprom_update_block(rgbrec_buffer, (void *)addr, sizeof(rgbrec_buffer));
}
bool rgbrec_end(uint8_t channel) {
if (channel >= RGBREC_CHANNEL_NUM) {
return false;
}
if ((rgbrec_info.state == RGBREC_STATE_ON) && (channel == rgbrec_info.channel)) {
rgbrec_info.state = RGBREC_STATE_OFF;
rgbrec_update_current_channel(rgbrec_info.channel);
return true;
}
return false;
}
static inline void rgb_matrix_set_hs(int index, uint16_t hs) {
RGB rgb = hs_to_rgb(HS_GET_H(hs), HS_GET_S(hs));
rgb_matrix_set_color(index, rgb.r, rgb.g, rgb.b);
}
void rgbrec_play(uint8_t led_min, uint8_t led_max) {
uint8_t row = 0xFF, col = 0xFF;
uint16_t hs_color;
rgbrec_info.value = rgb_matrix_get_val();
for (uint8_t i = led_min; i < led_max; i++) {
if (find_matrix_row_col(i, &row, &col)) {
if (p_rgbrec_effects != NULL) {
hs_color = p_rgbrec_effects[row][col];
rgb_matrix_set_hs(i, hs_color);
}
}
}
}
void rgbrec_set_close_all(uint8_t h, uint8_t s, uint8_t v) {
if (!h && !s && !v) {
memset(rgbrec_buffer, 0, sizeof(rgbrec_buffer));
} else {
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
rgbrec_buffer[row * MATRIX_COLS * col * 2] = s;
rgbrec_buffer[(row * MATRIX_COLS * col * 2) + 1] = v;
}
}
}
}
void rgbrec_read_current_channel(uint8_t channel) {
uint32_t addr = 0;
if (channel >= RGBREC_CHANNEL_NUM) {
return;
}
addr = (uint32_t)(RGBREC_EECONFIG_ADDR) + (channel * sizeof(rgbrec_buffer));
eeprom_read_block(rgbrec_buffer, (void *)addr, sizeof(rgbrec_buffer));
}
bool rgbrec_is_started(void) {
return (rgbrec_info.state == RGBREC_STATE_ON);
}
static inline void cycle_rgb_next_color(uint8_t row, uint8_t col) {
if (p_rgbrec_effects == NULL) {
return;
}
for (uint8_t index = 0; index < RGBREC_COLOR_NUM; index++) {
if (rgbrec_hs_lists[index] == p_rgbrec_effects[row][col]) {
index = ((index + 1) % RGBREC_COLOR_NUM);
p_rgbrec_effects[row][col] = rgbrec_hs_lists[index];
return;
}
}
p_rgbrec_effects[row][col] = rgbrec_hs_lists[0];
}
bool rgbrec_register_record(uint16_t keycode, keyrecord_t *record) {
(void)keycode;
if (rgbrec_info.state == RGBREC_STATE_ON) {
cycle_rgb_next_color(record->event.key.row, record->event.key.col);
return true;
}
return false;
}
void eeconfig_init_user_datablock(void) {
uint32_t addr = 0;
addr = (uint32_t)(RGBREC_EECONFIG_ADDR);
eeprom_update_block(rgbrec_default_effects, (void *)addr, sizeof(rgbrec_default_effects));
}
uint8_t find_index(void) {
for (uint8_t index = 0; index < (sizeof(rgbmatrix_buff) / sizeof(rgbmatrix_buff[0])); index++) {
if (rgb_matrix_get_mode() == rgbmatrix_buff[index]) {
return index;
}
}
return 0;
}
void record_rgbmatrix_increase(uint8_t *last_mode) {
uint8_t index;
index = find_index();
if (rgbrec_info.state != RGBREC_STATE_ON) {
index = (index + 1) % (sizeof(rgbmatrix_buff) / sizeof(rgbmatrix_buff[0]));
}
*last_mode = rgbmatrix_buff[index];
rgb_matrix_mode(rgbmatrix_buff[index]);
record_color_hsv(false);
}
uint8_t record_color_read_data(void) {
uint8_t hs_mode = find_index();
const uint8_t *ptr = (const uint8_t *)(((uint32_t)CONFINFO_EECONFIG_ADDR + 4) + hs_mode);
uint8_t hs_c = eeprom_read_byte(ptr);
if (hs_c > RGB_HSV_MAX) {
return 0;
} else {
return hs_c;
}
}
void record_color_hsv(bool status) {
uint8_t temp;
uint8_t rgb_hsv_index = record_color_read_data();
for (uint8_t i = 0; i < (sizeof(sixth_gear_buff) / sizeof(sixth_gear_buff[0])); i++) {
if (rgb_matrix_get_mode() == sixth_gear_buff[i]) {
temp = RGB_HSV_MAX - 1;
break;
} else if (i == (sizeof(sixth_gear_buff) / sizeof(sixth_gear_buff[0]) - 1)) {
temp = RGB_HSV_MAX;
}
}
if (status) rgb_hsv_index = (rgb_hsv_index + 1) % temp;
rgb_matrix_sethsv(rgb_hsvs[rgb_hsv_index][0], rgb_hsvs[rgb_hsv_index][1], rgb_matrix_get_val());
uint8_t *ptr = (uint8_t *)(((uint32_t)CONFINFO_EECONFIG_ADDR + 4) + find_index());
eeprom_write_byte(ptr, rgb_hsv_index);
}
bool rk_bat_req_flag;
void query(void){
if (rk_bat_req_flag) {
# ifdef RGBLIGHT_ENABLE
for (uint8_t i = 0; i < (RGB_MATRIX_LED_COUNT - RGBLED_NUM); i++) {
rgb_matrix_set_color(i, 0, 0, 0);
}
# else
rgb_matrix_set_color_all(0x00, 0x00, 0x00);
# endif
for (uint8_t i = 0; i < 10; i++) {
uint8_t mi_index[10] = RGB_MATRIX_BAT_INDEX_MAP;
if ((i < (*md_getp_bat() / 10)) || (i < 1)) {
if (*md_getp_bat() >= (IM_BAT_REQ_LEVEL1_VAL)) {
rgb_matrix_set_color(mi_index[i], IM_BAT_REQ_LEVEL1_COLOR);
} else if (*md_getp_bat() >= (IM_BAT_REQ_LEVEL2_VAL)) {
rgb_matrix_set_color(mi_index[i], IM_BAT_REQ_LEVEL2_COLOR);
} else {
rgb_matrix_set_color(mi_index[i], IM_BAT_REQ_LEVEL3_COLOR);
}
} else {
rgb_matrix_set_color(mi_index[i], 0x00, 0x00, 0x00);
}
}
}
}

82
keyboards/epomaker/tide65/rgb_record/rgb_record.h Normal file
View File

@ -0,0 +1,82 @@
/*
* 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 <stdbool.h>
#include <string.h>
#include <math.h>
#include "color.h"
#include "eeprom.h"
#include "quantum.h"
#include "wireless.h"
#define HS_GET_H(value) ((uint8_t)(value >> 8))
#define HS_GET_S(value) ((uint8_t)(value & 0xFF))
/* HSV Color bit[15:8] H bit[7:0] S */
#define HS_AZURE 0x8466
#define HS_BLACK 0x0000
#define HS_BLUE 0xAAFF
#define HS_CHARTREUSE 0x40FF
#define HS_CORAL 0x0BB0
#define HS_GOLD 0x24FF
#define HS_GOLDENROD 0x1EDA
#define HS_GREEN 0x55FF
#define HS_MAGENTA 0xD5FF
#define HS_ORANGE 0x15FF
#define HS_PINK 0xEA80
#define HS_PURPLE 0xBFFF
#define HS_RED 0x00FF
#define HS_CYAN 0x6AFF
#define HS_TEAL 0x80FF
#define HS_TURQUOISE 0x7B5A
#define HS_WHITE 0x0101
#define HS_YELLOW 0x2BFF
#define LASET_MOD_NO 0xFF
#define RGB_HSV_MAX 7
#define ________ HS_BLACK
#ifndef RGB_RECORD_HS_LISTS
# define RGB_RECORD_HS_LISTS \
{HS_BLACK, HS_RED, HS_GREEN, HS_BLUE, HS_YELLOW, HS_PURPLE, HS_CYAN, HS_WHITE}
#endif
#define RGB_MATRIX_BAT_VAL 150
#define IM_BAT_REQ_LEVEL1_VAL 50
#define IM_BAT_REQ_LEVEL1_COLOR 0x00, RGB_MATRIX_BAT_VAL, 0x00
#define IM_BAT_REQ_LEVEL2_VAL 30
#define IM_BAT_REQ_LEVEL2_COLOR 0x00, RGB_MATRIX_BAT_VAL, 0x00
#define IM_BAT_REQ_LEVEL3_COLOR RGB_MATRIX_BAT_VAL, 0x00, 0x00
void rgbrec_read_current_channel(uint8_t channel);
void rgbrec_set_close_all(uint8_t h, uint8_t s, uint8_t v);
void rgbrec_play(uint8_t led_min, uint8_t led_max);
bool rgbrec_end(uint8_t channel);
bool rgbrec_start(uint8_t channel);
bool rgbrec_show(uint8_t channel);
void rgbrec_init(uint8_t channel);
bool rgbrec_is_started(void);
void eeconfig_init_user_datablock(void);
bool rgbrec_register_record(uint16_t keycode, keyrecord_t *record);
void record_rgbmatrix_increase(uint8_t *last_mode);
void record_color_hsv(bool status);
void query(void);

6
keyboards/epomaker/tide65/rgb_record/rgb_record.mk Normal file
View File

@ -0,0 +1,6 @@
SRC += rgb_record/rgb_record.c
ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
SRC += rgb_record/rgb_rgblight.c
SRC += rgb_record/rgb_effect.c
endif

42
keyboards/epomaker/tide65/rgb_record/rgb_rgblight.c Normal file
View File

@ -0,0 +1,42 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "rgb_rgblight.h"
#include "rgblight.h"
LED_TYPE led[RGBLED_NUM];
extern rgblight_config_t rgblight_config;
void rgblight_call_driver(LED_TYPE *start_led, uint8_t num_leds) {
memcpy(led, start_led, sizeof(LED_TYPE) * num_leds);
}
void rgblight_set(void) {
LED_TYPE *start_led;
uint8_t num_leds = rgblight_ranges.clipping_num_leds;
const uint8_t led_map[] = RGBLIGHT_LED_MAP;
if (!rgblight_config.enable) {
for (uint8_t i = rgblight_ranges.effect_start_pos; i < rgblight_ranges.effect_end_pos; i++) {
led[i].r = 0;
led[i].g = 0;
led[i].b = 0;
}
}
LED_TYPE led0[RGBLED_NUM];
for (uint8_t i = 0; i < RGBLED_NUM; i++) {
led0[i] = led[pgm_read_byte(&led_map[i])];
}
start_led = led0 + rgblight_ranges.clipping_start_pos;
rgblight_call_driver(start_led, num_leds);
}
bool rgb_matrix_indicators_advanced_rgblight(uint8_t led_min, uint8_t led_max) {
for (uint8_t i = 0; i < RGBLED_NUM; i++) {
rgb_matrix_set_color(RGB_MATRIX_LED_COUNT - RGBLED_NUM + i, led[i].r, led[i].g, led[i].b); // rgb light
}
return true;
}

6
keyboards/epomaker/tide65/rgb_record/rgb_rgblight.h Normal file
View File

@ -0,0 +1,6 @@
// Copyright 2024 SDK (@sdk66)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "rgb_matrix.h"
bool rgb_matrix_indicators_advanced_rgblight(uint8_t led_min, uint8_t led_max);

757
keyboards/epomaker/tide65/tide65.c
View File

File diff suppressed because it is too large Load Diff

43
quantum/rgblight/rgblight.c
View File

@ -243,7 +243,7 @@ void rgblight_init(void) {
rgblight_timer_init(); // setup the timer rgblight_timer_init(); // setup the timer
rgblight_driver.init(); // rgblight_driver.init();
if (rgblight_config.enable) { if (rgblight_config.enable) {
rgblight_mode_noeeprom(rgblight_config.mode); rgblight_mode_noeeprom(rgblight_config.mode);
@ -896,51 +896,55 @@ void rgblight_wakeup(void) {
#endif #endif
#ifndef RGBLIGHT_CUSTOM_DRIVER
void rgblight_set(void) { void rgblight_set(void) {
rgb_led_t *start_led; rgb_led_t *start_led;
uint8_t num_leds = rgblight_ranges.clipping_num_leds; uint8_t num_leds = rgblight_ranges.clipping_num_leds;
if (!rgblight_config.enable) { if (!rgblight_config.enable) {
for (uint8_t i = rgblight_ranges.effect_start_pos; i < rgblight_ranges.effect_end_pos; i++) { for (uint8_t i = rgblight_ranges.effect_start_pos; i < rgblight_ranges.effect_end_pos; i++) {
led[i].r = 0; led[i].r = 0;
led[i].g = 0; led[i].g = 0;
led[i].b = 0; led[i].b = 0;
#ifdef WS2812_RGBW # ifdef WS2812_RGBW
led[i].w = 0; led[i].w = 0;
#endif # endif
} }
} }
#ifdef RGBLIGHT_LAYERS # ifdef RGBLIGHT_LAYERS
if (rgblight_layers != NULL if (rgblight_layers != NULL
# if !defined(RGBLIGHT_LAYERS_OVERRIDE_RGB_OFF) # if !defined(RGBLIGHT_LAYERS_OVERRIDE_RGB_OFF)
&& rgblight_config.enable && rgblight_config.enable
# elif defined(RGBLIGHT_SLEEP) # elif defined(RGBLIGHT_SLEEP)
&& !is_suspended && !is_suspended
# endif # endif
) { ) {
rgblight_layers_write(); rgblight_layers_write();
} }
#endif # endif
#ifdef RGBLIGHT_LED_MAP # ifdef RGBLIGHT_LED_MAP
rgb_led_t led0[RGBLIGHT_LED_COUNT]; rgb_led_t led0[RGBLIGHT_LED_COUNT];
for (uint8_t i = 0; i < RGBLIGHT_LED_COUNT; i++) { for (uint8_t i = 0; i < RGBLIGHT_LED_COUNT; i++) {
led0[i] = led[pgm_read_byte(&led_map[i])]; led0[i] = led[pgm_read_byte(&led_map[i])];
} }
start_led = led0 + rgblight_ranges.clipping_start_pos; start_led = led0 + rgblight_ranges.clipping_start_pos;
#else # else
start_led = led + rgblight_ranges.clipping_start_pos; start_led = led + rgblight_ranges.clipping_start_pos;
#endif # endif
#ifdef WS2812_RGBW # ifdef WS2812_RGBW
for (uint8_t i = 0; i < num_leds; i++) { for (uint8_t i = 0; i < num_leds; i++) {
convert_rgb_to_rgbw(&start_led[i]); convert_rgb_to_rgbw(&start_led[i]);
} }
#endif # endif
rgblight_driver.setleds(start_led, num_leds); rgblight_driver.setleds(start_led, num_leds);
} }
#endif
#ifdef RGBLIGHT_SPLIT #ifdef RGBLIGHT_SPLIT
/* for split keyboard master side */ /* for split keyboard master side */
uint8_t rgblight_get_change_flags(void) { uint8_t rgblight_get_change_flags(void) {
@ -1193,7 +1197,7 @@ static uint8_t breathe_calc(uint8_t pos) {
__attribute__((weak)) const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5}; __attribute__((weak)) const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
void rgblight_effect_breathing(animation_status_t *anim) { __attribute__((weak)) void rgblight_effect_breathing(animation_status_t *anim) {
uint8_t val = breathe_calc(anim->pos); uint8_t val = breathe_calc(anim->pos);
rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val); rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val);
anim->pos = (anim->pos + 1); anim->pos = (anim->pos + 1);
@ -1203,7 +1207,7 @@ void rgblight_effect_breathing(animation_status_t *anim) {
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
__attribute__((weak)) const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30}; __attribute__((weak)) const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
void rgblight_effect_rainbow_mood(animation_status_t *anim) { __attribute__((weak)) void rgblight_effect_rainbow_mood(animation_status_t *anim) {
rgblight_sethsv_noeeprom_old(anim->current_hue, rgblight_config.sat, rgblight_config.val); rgblight_sethsv_noeeprom_old(anim->current_hue, rgblight_config.sat, rgblight_config.val);
anim->current_hue++; anim->current_hue++;
} }
@ -1216,10 +1220,17 @@ void rgblight_effect_rainbow_mood(animation_status_t *anim) {
__attribute__((weak)) const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20}; __attribute__((weak)) const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
__attribute__((weak)) bool rgblight_effect_custom_rainbow_swirl(animation_status_t *anim);
void rgblight_effect_rainbow_swirl(animation_status_t *anim) { void rgblight_effect_rainbow_swirl(animation_status_t *anim) {
uint8_t hue; uint8_t hue;
uint8_t i; uint8_t i;
if (rgblight_effect_custom_rainbow_swirl(anim) != true){
return;
}
for (i = 0; i < rgblight_ranges.effect_num_leds; i++) { for (i = 0; i < rgblight_ranges.effect_num_leds; i++) {
hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / rgblight_ranges.effect_num_leds * i + anim->current_hue); hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / rgblight_ranges.effect_num_leds * i + anim->current_hue);
sethsv(hue, rgblight_config.sat, rgblight_config.val, (rgb_led_t *)&led[i + rgblight_ranges.effect_start_pos]); sethsv(hue, rgblight_config.sat, rgblight_config.val, (rgb_led_t *)&led[i + rgblight_ranges.effect_start_pos]);