summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorFlorian Didron <fdidron@users.noreply.github.com>2019-04-23 08:46:07 +0900
committerGitHub <noreply@github.com>2019-04-23 08:46:07 +0900
commitd22fda3ca4e2c6fd82f1275ee2f59882371a1794 (patch)
treef6b0142e8eb195418110dd86e7622c679d3766e9
parent9f180afb25e2831f6640539b6ab1a3806abe6cee (diff)
parentff2838d2dd288537a8bf48d02872e8223b3ff7a3 (diff)
Merge branch 'master' into mouse_keys
-rw-r--r--build_keyboard.mk18
-rw-r--r--changelog.md3
-rw-r--r--common_features.mk9
-rw-r--r--drivers/arm/i2c_master.c40
-rw-r--r--drivers/arm/i2c_master.h20
-rwxr-xr-xdrivers/avr/i2c_master.c4
-rwxr-xr-xdrivers/avr/i2c_master.h6
-rw-r--r--drivers/oled/glcdfont.c240
-rw-r--r--drivers/oled/oled_driver.c528
-rw-r--r--drivers/oled/oled_driver.h183
-rw-r--r--quantum/quantum.c16
-rw-r--r--quantum/quantum.h4
-rw-r--r--quantum/rgb_matrix.c33
-rw-r--r--quantum/rgb_matrix.h18
-rw-r--r--quantum/rgb_matrix_animations/solid_reactive_cross.h50
-rw-r--r--quantum/rgb_matrix_animations/solid_reactive_nexus.h48
-rw-r--r--quantum/rgb_matrix_animations/solid_reactive_wide.h42
-rw-r--r--quantum/rgblight.c390
-rw-r--r--quantum/rgblight.h134
-rw-r--r--quantum/rgblight_modes.h67
-rw-r--r--quantum/rgblight_post_config.h5
-rw-r--r--quantum/split_common/post_config.h15
-rw-r--r--quantum/split_common/transport.c184
23 files changed, 1750 insertions, 307 deletions
diff --git a/build_keyboard.mk b/build_keyboard.mk
index ee6a69fc79..5d633f2716 100644
--- a/build_keyboard.mk
+++ b/build_keyboard.mk
@@ -280,6 +280,23 @@ ifneq ("$(wildcard $(KEYBOARD_PATH_1)/config.h)","")
CONFIG_H += $(KEYBOARD_PATH_1)/config.h
endif
+POST_CONFIG_H :=
+ifneq ("$(wildcard $(KEYBOARD_PATH_1)/post_config.h)","")
+ POST_CONFIG_H += $(KEYBOARD_PATH_1)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_2)/post_config.h)","")
+ POST_CONFIG_H += $(KEYBOARD_PATH_2)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_3)/post_config.h)","")
+ POST_CONFIG_H += $(KEYBOARD_PATH_3)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_4)/post_config.h)","")
+ POST_CONFIG_H += $(KEYBOARD_PATH_4)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_5)/post_config.h)","")
+ POST_CONFIG_H += $(KEYBOARD_PATH_5)/post_config.h
+endif
+
# Save the defines and includes here, so we don't include any keymap specific ones
PROJECT_DEFS := $(OPT_DEFS)
PROJECT_INC := $(VPATH) $(EXTRAINCDIRS) $(KEYBOARD_PATHS)
@@ -355,6 +372,7 @@ ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
include $(VISUALIZER_PATH)/visualizer.mk
endif
+CONFIG_H += $(POST_CONFIG_H)
ALL_CONFIGS := $(PROJECT_CONFIG) $(CONFIG_H)
OUTPUTS := $(KEYMAP_OUTPUT) $(KEYBOARD_OUTPUT)
diff --git a/changelog.md b/changelog.md
index 4f6fbf8def..e10ef915d7 100644
--- a/changelog.md
+++ b/changelog.md
@@ -6,3 +6,6 @@
04-16-2019 - Add support for WS2812 based RGB Matrix
04-18-2019 - Fix Eager Per Row Debouncing bug
04-22-2019 - Improve Mousekey constant speed mode
+04-22-2019 - Add new reactive modes (wide, cross, nexus) for RGB Matrix
+04-22-2019 - OLED Driver Features
+04-22-2019 - Add Split RGB support
diff --git a/common_features.mk b/common_features.mk
index bd1685869d..fbfbc3ebc6 100644
--- a/common_features.mk
+++ b/common_features.mk
@@ -103,6 +103,7 @@ ifeq ($(strip $(UNICODE_COMMON)), yes)
endif
ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
+ POST_CONFIG_H += $(QUANTUM_DIR)/rgblight_post_config.h
OPT_DEFS += -DRGBLIGHT_ENABLE
SRC += $(QUANTUM_DIR)/rgblight.c
CIE1931_CURVE = yes
@@ -318,6 +319,7 @@ ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
endif
ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
+ POST_CONFIG_H += $(QUANTUM_DIR)/split_common/post_config.h
OPT_DEFS += -DSPLIT_KEYBOARD
# Include files used by all split keyboards
@@ -334,3 +336,10 @@ ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
endif
COMMON_VPATH += $(QUANTUM_PATH)/split_common
endif
+
+ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
+ OPT_DEFS += -DOLED_DRIVER_ENABLE
+ COMMON_VPATH += $(DRIVER_PATH)/oled
+ QUANTUM_LIB_SRC += i2c_master.c
+ SRC += oled_driver.c
+endif
diff --git a/drivers/arm/i2c_master.c b/drivers/arm/i2c_master.c
index 0e5edcc380..7369398cc4 100644
--- a/drivers/arm/i2c_master.c
+++ b/drivers/arm/i2c_master.c
@@ -42,6 +42,18 @@ static const I2CConfig i2cconfig = {
0
};
+static i2c_status_t chibios_to_qmk(const msg_t* status) {
+ switch (*status) {
+ case I2C_NO_ERROR:
+ return I2C_STATUS_SUCCESS;
+ case I2C_TIMEOUT:
+ return I2C_STATUS_TIMEOUT;
+ // I2C_BUS_ERROR, I2C_ARBITRATION_LOST, I2C_ACK_FAILURE, I2C_OVERRUN, I2C_PEC_ERROR, I2C_SMB_ALERT
+ default:
+ return I2C_STATUS_ERROR;
+ }
+}
+
__attribute__ ((weak))
void i2c_init(void)
{
@@ -57,29 +69,30 @@ void i2c_init(void)
//i2cInit(); //This is invoked by halInit() so no need to redo it.
}
-// This is usually not needed
-uint8_t i2c_start(uint8_t address)
+i2c_status_t i2c_start(uint8_t address)
{
i2c_address = address;
i2cStart(&I2C_DRIVER, &i2cconfig);
- return 0;
+ return I2C_STATUS_SUCCESS;
}
-uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout)
{
i2c_address = address;
i2cStart(&I2C_DRIVER, &i2cconfig);
- return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
+ msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
+ return chibios_to_qmk(&status);
}
-uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
{
i2c_address = address;
i2cStart(&I2C_DRIVER, &i2cconfig);
- return i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+ msg_t status = i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+ return chibios_to_qmk(&status);
}
-uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout)
{
i2c_address = devaddr;
i2cStart(&I2C_DRIVER, &i2cconfig);
@@ -91,18 +104,19 @@ uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t l
}
complete_packet[0] = regaddr;
- return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+ msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+ return chibios_to_qmk(&status);
}
-uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
{
i2c_address = devaddr;
i2cStart(&I2C_DRIVER, &i2cconfig);
- return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+ msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+ return chibios_to_qmk(&status);
}
-uint8_t i2c_stop(void)
+void i2c_stop(void)
{
i2cStop(&I2C_DRIVER);
- return 0;
}
diff --git a/drivers/arm/i2c_master.h b/drivers/arm/i2c_master.h
index 4ab2301f8c..a15f1702dd 100644
--- a/drivers/arm/i2c_master.h
+++ b/drivers/arm/i2c_master.h
@@ -40,11 +40,17 @@
#define I2C_DRIVER I2CD1
#endif
+typedef int16_t i2c_status_t;
+
+#define I2C_STATUS_SUCCESS (0)
+#define I2C_STATUS_ERROR (-1)
+#define I2C_STATUS_TIMEOUT (-2)
+
void i2c_init(void);
-uint8_t i2c_start(uint8_t address);
-uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
-uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_stop(void);
+i2c_status_t i2c_start(uint8_t address);
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+void i2c_stop(void);
diff --git a/drivers/avr/i2c_master.c b/drivers/avr/i2c_master.c
index 0db949db4a..6137f9b15f 100755
--- a/drivers/avr/i2c_master.c
+++ b/drivers/avr/i2c_master.c
@@ -109,7 +109,7 @@ int16_t i2c_read_nack(uint16_t timeout) {
return TWDR;
}
-i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout) {
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout) {
i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
for (uint16_t i = 0; i < length && status >= 0; i++) {
@@ -143,7 +143,7 @@ i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16
return (status < 0) ? status : I2C_STATUS_SUCCESS;
}
-i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout) {
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout) {
i2c_status_t status = i2c_start(devaddr | 0x00, timeout);
if (status >= 0) {
status = i2c_write(regaddr, timeout);
diff --git a/drivers/avr/i2c_master.h b/drivers/avr/i2c_master.h
index 81a7fb5e32..b4613115d9 100755
--- a/drivers/avr/i2c_master.h
+++ b/drivers/avr/i2c_master.h
@@ -22,10 +22,10 @@ i2c_status_t i2c_start(uint8_t address, uint16_t timeout);
i2c_status_t i2c_write(uint8_t data, uint16_t timeout);
int16_t i2c_read_ack(uint16_t timeout);
int16_t i2c_read_nack(uint16_t timeout);
-i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout);
i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout);
i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
void i2c_stop(void);
-#endif // I2C_MASTER_H \ No newline at end of file
+#endif // I2C_MASTER_H
diff --git a/drivers/oled/glcdfont.c b/drivers/oled/glcdfont.c
new file mode 100644
index 0000000000..150be9e944
--- /dev/null
+++ b/drivers/oled/glcdfont.c
@@ -0,0 +1,240 @@
+#pragma once
+
+#ifdef __AVR__
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+ #include <pgmspace.h>
+#else
+ #define PROGMEM
+#endif
+
+// Helidox 8x6 font with QMK Firmware Logo
+// Online editor: http://teripom.x0.com/
+
+static const unsigned char font[] PROGMEM = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
+ 0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
+ 0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
+ 0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
+ 0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
+ 0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
+ 0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
+ 0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
+ 0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
+ 0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
+ 0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
+ 0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
+ 0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
+ 0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
+ 0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
+ 0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
+ 0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
+ 0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
+ 0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
+ 0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
+ 0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
+ 0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
+ 0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
+ 0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
+ 0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
+ 0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
+ 0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
+ 0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
+ 0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
+ 0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
+ 0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
+ 0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
+ 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
+ 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
+ 0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
+ 0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
+ 0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
+ 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
+ 0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
+ 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
+ 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
+ 0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
+ 0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
+ 0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
+ 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
+ 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
+ 0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
+ 0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
+ 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
+ 0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
+ 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
+ 0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
+ 0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
+ 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
+ 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+ 0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
+ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
+ 0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
+ 0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
+ 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
+ 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
+ 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
+ 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
+ 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
+ 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
+ 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
+ 0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
+ 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
+ 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
+ 0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
+ 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
+ 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
+ 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
+ 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
+ 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
+ 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
+ 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
+ 0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
+ 0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
+ 0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
+ 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
+ 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
+ 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
+ 0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
+ 0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
+ 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
+ 0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
+ 0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
+ 0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
+ 0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
+ 0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
+ 0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
+ 0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
+ 0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
+ 0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
+ 0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
+ 0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
+ 0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x00,
+ 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
+ 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
+ 0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
+ 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
+ 0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
+ 0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
+ 0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
+ 0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
+ 0xFC, 0x18, 0x24, 0x24, 0x18, 0x00,
+ 0x18, 0x24, 0x24, 0x18, 0xFC, 0x00,
+ 0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
+ 0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
+ 0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
+ 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
+ 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
+ 0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
+ 0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
+ 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00,
+ 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
+ 0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
+ 0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
+ 0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
+ 0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
+ 0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x40, 0x40, 0x40, 0xF0, 0xF8, 0xF8,
+ 0xFF, 0x38, 0xFF, 0xF8, 0xF8, 0x3F,
+ 0xF8, 0xF8, 0xFF, 0x38, 0xFF, 0xF8,
+ 0xF8, 0xF0, 0x40, 0x40, 0x40, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+ 0xC0, 0xC0, 0xC0, 0x80, 0x00, 0x00,
+ 0xC0, 0xC0, 0x80, 0x00, 0x00, 0x00,
+ 0x80, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,
+ 0x00, 0x00, 0x80, 0xC0, 0xC0, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0,
+ 0xC0, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xE0, 0xF0, 0xF0, 0xF0, 0xE0, 0xEC,
+ 0xEE, 0xF7, 0xF3, 0x70, 0x20, 0x00,
+ 0x7C, 0x7C, 0x7C, 0x7E, 0x00, 0x7E,
+ 0x7E, 0x7E, 0x7F, 0x7F, 0x7F, 0x00,
+ 0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B,
+ 0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00,
+ 0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE,
+ 0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00,
+ 0x00, 0x00, 0x00, 0xE0, 0xEC, 0xDF,
+ 0xFC, 0xE0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x49, 0x49, 0x49, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xE0, 0xDF, 0xBF, 0xBF, 0x00,
+ 0xBF, 0xBF, 0xDF, 0xE0, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x49, 0x49, 0x49, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x1F, 0x3F,
+ 0x60, 0x60, 0xE0, 0xBF, 0x1F, 0x00,
+ 0x7F, 0x7F, 0x07, 0x1E, 0x38, 0x1E,
+ 0x07, 0x7F, 0x7F, 0x00, 0x7F, 0x7F,
+ 0x0E, 0x1F, 0x3B, 0x71, 0x60, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F,
+ 0x0C, 0x0C, 0x0C, 0x00, 0x7E, 0x7E,
+ 0x00, 0x7F, 0x7E, 0x03, 0x03, 0x00,
+ 0x7F, 0x7E, 0x03, 0x03, 0x7E, 0x7E,
+ 0x03, 0x03, 0x7F, 0x7E, 0x00, 0x0F,
+ 0x3E, 0x70, 0x3C, 0x06, 0x3C, 0x70,
+ 0x3E, 0x0F, 0x00, 0x32, 0x7B, 0x49,
+ 0x49, 0x3F, 0x7E, 0x00, 0x7F, 0x7E,
+ 0x03, 0x03, 0x00, 0x1E, 0x3F, 0x69,
+ 0x69, 0x6F, 0x26, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F,
+ 0x7F, 0x7F, 0x3F, 0x1E, 0x0C, 0x00,
+ 0x1F, 0x1F, 0x1F, 0x3F, 0x00, 0x3F,
+ 0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x00,
+ 0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20,
+ 0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00,
+ 0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F,
+ 0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00,
+ 0x40, 0x7C, 0x3F, 0x3F, 0x23, 0x01,
+ 0x23, 0x3F, 0x37, 0x6C, 0x40, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x01, 0x01, 0x01, 0x07, 0x0F, 0x0F,
+ 0x7F, 0x0F, 0x7F, 0x0F, 0x0F, 0x7E,
+ 0x0F, 0x0F, 0x7F, 0x0F, 0x7F, 0x0F,
+ 0x0F, 0x07, 0x01, 0x01, 0x01, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
diff --git a/drivers/oled/oled_driver.c b/drivers/oled/oled_driver.c
new file mode 100644
index 0000000000..aa025d7a4c
--- /dev/null
+++ b/drivers/oled/oled_driver.c
@@ -0,0 +1,528 @@
+/*
+Copyright 2019 Ryan Caltabiano <https://github.com/XScorpion2>
+
+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 "i2c_master.h"
+#include "oled_driver.h"
+#include OLED_FONT_H
+#include "timer.h"
+#include "print.h"
+
+#include <string.h>
+
+#if defined(__AVR__)
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+ #include <pgmspace.h>
+#else // defined(ESP8266)
+ #define PROGMEM
+ #define memcpy_P(des, src, len) memcpy(des, src, len)
+#endif // defined(__AVR__)
+
+// Used commands from spec sheet: https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf
+// Fundamental Commands
+#define CONTRAST 0x81
+#define DISPLAY_ALL_ON 0xA5
+#define DISPLAY_ALL_ON_RESUME 0xA4
+#define NORMAL_DISPLAY 0xA6
+#define DISPLAY_ON 0xAF
+#define DISPLAY_OFF 0xAE
+
+// Scrolling Commands
+#define ACTIVATE_SCROLL 0x2F
+#define DEACTIVATE_SCROLL 0x2E
+#define SCROLL_RIGHT 0x26
+#define SCROLL_LEFT 0x27
+#define SCROLL_RIGHT_UP 0x29
+#define SCROLL_LEFT_UP 0x2A
+
+// Addressing Setting Commands
+#define MEMORY_MODE 0x20
+#define COLUMN_ADDR 0x21
+#define PAGE_ADDR 0x22
+
+// Hardware Configuration Commands
+#define DISPLAY_START_LINE 0x40
+#define SEGMENT_REMAP 0xA0
+#define SEGMENT_REMAP_INV 0xA1
+#define MULTIPLEX_RATIO 0xA8
+#define COM_SCAN_INC 0xC0
+#define COM_SCAN_DEC 0xC8
+#define DISPLAY_OFFSET 0xD3
+#define COM_PINS 0xDA
+
+// Timing & Driving Commands
+#define DISPLAY_CLOCK 0xD5
+#define PRE_CHARGE_PERIOD 0xD9
+#define VCOM_DETECT 0xDB
+
+// Charge Pump Commands
+#define CHARGE_PUMP 0x8D
+
+// Misc defines
+#define OLED_TIMEOUT 60000
+#define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8)
+#define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)
+
+// i2c defines
+#define I2C_CMD 0x00
+#define I2C_DATA 0x40
+#if defined(__AVR__)
+ // already defined on ARM
+ #define I2C_TIMEOUT 100
+ #define I2C_TRANSMIT_P(data) i2c_transmit_P((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#else // defined(__AVR__)
+ #define I2C_TRANSMIT_P(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#endif // defined(__AVR__)
+#define I2C_TRANSMIT(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#define I2C_WRITE_REG(mode, data, size) i2c_writeReg((OLED_DISPLAY_ADDRESS << 1), mode, data, size, I2C_TIMEOUT)
+
+#define HAS_FLAGS(bits, flags) ((bits & flags) == flags)
+
+// Display buffer's is the same as the OLED memory layout
+// this is so we don't end up with rounding errors with
+// parts of the display unusable or don't get cleared correctly
+// and also allows for drawing & inverting
+uint8_t oled_buffer[OLED_MATRIX_SIZE];
+uint8_t* oled_cursor;
+OLED_BLOCK_TYPE oled_dirty = 0;
+bool oled_initialized = false;
+bool oled_active = false;
+bool oled_scrolling = false;
+uint8_t oled_rotation = 0;
+uint8_t oled_rotation_width = 0;
+#if !defined(OLED_DISABLE_TIMEOUT)
+ uint16_t oled_last_activity;
+#endif
+
+// Internal variables to reduce math instructions
+
+#if defined(__AVR__)
+// identical to i2c_transmit, but for PROGMEM since all initialization is in PROGMEM arrays currently
+// probably should move this into i2c_master...
+static i2c_status_t i2c_transmit_P(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout) {
+ i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
+
+ for (uint16_t i = 0; i < length && status >= 0; i++) {
+ status = i2c_write(pgm_read_byte((const char*)data++), timeout);
+ if (status) break;
+ }
+
+ i2c_stop();
+
+ return status;
+}
+#endif
+
+// Flips the rendering bits for a character at the current cursor position
+static void InvertCharacter(uint8_t *cursor)
+{
+ const uint8_t *end = cursor + OLED_FONT_WIDTH;
+ while (cursor < end) {
+ *cursor = ~(*cursor);
+ cursor++;
+ }
+}
+
+bool oled_init(uint8_t rotation) {
+ oled_rotation = oled_init_user(rotation);
+ if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+ oled_rotation_width = OLED_DISPLAY_WIDTH;
+ } else {
+ oled_rotation_width = OLED_DISPLAY_HEIGHT;
+ }
+ i2c_init();
+
+ static const uint8_t PROGMEM display_setup1[] = {
+ I2C_CMD,
+ DISPLAY_OFF,
+ DISPLAY_CLOCK, 0x80,
+ MULTIPLEX_RATIO, OLED_DISPLAY_HEIGHT - 1,
+ DISPLAY_OFFSET, 0x00,
+ DISPLAY_START_LINE | 0x00,
+ CHARGE_PUMP, 0x14,
+ MEMORY_MODE, 0x00, }; // Horizontal addressing mode
+ if (I2C_TRANSMIT_P(display_setup1) != I2C_STATUS_SUCCESS) {
+ print("oled_init cmd set 1 failed\n");
+ return false;
+ }
+
+ if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_180)) {
+ static const uint8_t PROGMEM display_normal[] = {
+ I2C_CMD,
+ SEGMENT_REMAP_INV,
+ COM_SCAN_DEC };
+ if (I2C_TRANSMIT_P(display_normal) != I2C_STATUS_SUCCESS) {
+ print("oled_init cmd normal rotation failed\n");
+ return false;
+ }
+ } else {
+ static const uint8_t PROGMEM display_flipped[] = {
+ I2C_CMD,
+ SEGMENT_REMAP,
+ COM_SCAN_INC };
+ if (I2C_TRANSMIT_P(display_flipped) != I2C_STATUS_SUCCESS) {
+ print("display_flipped failed\n");
+ return false;
+ }
+ }
+
+ static const uint8_t PROGMEM display_setup2[] = {
+ I2C_CMD,
+ COM_PINS, 0x02,
+ CONTRAST, 0x8F,
+ PRE_CHARGE_PERIOD, 0xF1,
+ VCOM_DETECT, 0x40,
+ DISPLAY_ALL_ON_RESUME,
+ NORMAL_DISPLAY,
+ DEACTIVATE_SCROLL,
+ DISPLAY_ON };
+ if (I2C_TRANSMIT_P(display_setup2) != I2C_STATUS_SUCCESS) {
+ print("display_setup2 failed\n");
+ return false;
+ }
+
+ oled_clear();
+ oled_initialized = true;
+ oled_active = true;
+ oled_scrolling = false;
+ return true;
+}
+
+__attribute__((weak))
+uint8_t oled_init_user(uint8_t rotation) {
+ return rotation;
+}
+
+void oled_clear(void) {
+ memset(oled_buffer, 0, sizeof(oled_buffer));
+ oled_cursor = &oled_buffer[0];
+ oled_dirty = -1; // -1 will be max value as long as display_dirty is unsigned type
+}
+
+static void calc_bounds(uint8_t update_start, uint8_t* cmd_array)
+{
+ cmd_array[1] = OLED_BLOCK_SIZE * update_start % OLED_DISPLAY_WIDTH;
+ cmd_array[4] = OLED_BLOCK_SIZE * update_start / OLED_DISPLAY_WIDTH;
+ cmd_array[2] = (OLED_BLOCK_SIZE + OLED_DISPLAY_WIDTH - 1) % OLED_DISPLAY_WIDTH + cmd_array[1];
+ cmd_array[5] = (OLED_BLOCK_SIZE + OLED_DISPLAY_WIDTH - 1) / OLED_DISPLAY_WIDTH - 1;
+}
+
+static void calc_bounds_90(uint8_t update_start, uint8_t* cmd_array)
+{
+ cmd_array[1] = OLED_BLOCK_SIZE * update_start / OLED_DISPLAY_HEIGHT * 8;
+ cmd_array[4] = OLED_BLOCK_SIZE * update_start % OLED_DISPLAY_HEIGHT;
+ cmd_array[2] = (OLED_BLOCK_SIZE + OLED_DISPLAY_HEIGHT - 1) / OLED_DISPLAY_HEIGHT * 8 - 1 + cmd_array[1];;
+ cmd_array[5] = (OLED_BLOCK_SIZE + OLED_DISPLAY_HEIGHT - 1) % OLED_DISPLAY_HEIGHT / 8;
+}
+
+uint8_t crot(uint8_t a, int8_t n)
+{
+ const uint8_t mask = 0x7;
+ n &= mask;
+ return a << n | a >> (-n & mask);
+}
+
+static void rotate_90(const uint8_t* src, uint8_t* dest)
+{
+ for (uint8_t i = 0, shift = 7; i < 8; ++i, --shift) {
+ uint8_t selector = (1 << i);
+ for (uint8_t j = 0; j < 8; ++j) {
+ dest[i] |= crot(src[j] & selector, shift - (int8_t)j);
+ }
+ }
+}
+
+void oled_render(void) {
+ // Do we have work to do?
+ if (!oled_dirty || oled_scrolling) {
+ return;
+ }
+
+ // Find first dirty block
+ uint8_t update_start = 0;
+ while (!(oled_dirty & (1 << update_start))) { ++update_start; }
+
+ // Set column & page position
+ static uint8_t display_start[] = {
+ I2C_CMD,
+ COLUMN_ADDR, 0, OLED_DISPLAY_WIDTH - 1,
+ PAGE_ADDR, 0, OLED_DISPLAY_HEIGHT / 8 - 1 };
+ if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+ calc_bounds(update_start, &display_start[1]); // Offset from I2C_CMD byte at the start
+ } else {
+ calc_bounds_90(update_start, &display_start[1]); // Offset from I2C_CMD byte at the start
+ }
+
+ // Send column & page position
+ if (I2C_TRANSMIT(display_start) != I2C_STATUS_SUCCESS) {
+ print("oled_render offset command failed\n");
+ return;
+ }
+
+ if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+ // Send render data chunk as is
+ if (I2C_WRITE_REG(I2C_DATA, &oled_buffer[OLED_BLOCK_SIZE * update_start], OLED_BLOCK_SIZE) != I2C_STATUS_SUCCESS) {
+ print("oled_render data failed\n");
+ return;
+ }
+ } else {
+ // Rotate the render chunks
+ const static uint8_t source_map[] = OLED_SOURCE_MAP;
+ const static uint8_t target_map[] = OLED_TARGET_MAP;
+
+ static uint8_t temp_buffer[OLED_BLOCK_SIZE];
+ memset(temp_buffer, 0, sizeof(temp_buffer));
+ for(uint8_t i = 0; i < sizeof(source_map); ++i) {
+ rotate_90(&oled_buffer[OLED_BLOCK_SIZE * update_start + source_map[i]], &temp_buffer[target_map[i]]);
+ }
+
+ // Send render data chunk after rotating
+ if (I2C_WRITE_REG(I2C_DATA, &temp_buffer[0], OLED_BLOCK_SIZE) != I2C_STATUS_SUCCESS) {
+ print("oled_render data failed\n");
+ return;
+ }
+ }
+
+ // Turn on display if it is off
+ oled_on();
+
+ // Clear dirty flag
+ oled_dirty &= ~(1 << update_start);
+}
+
+void oled_set_cursor(uint8_t col, uint8_t line) {
+ uint16_t index = line * oled_rotation_width + col * OLED_FONT_WIDTH;
+
+ // Out of bounds?
+ if (index >= OLED_MATRIX_SIZE) {
+ index = 0;
+ }
+
+ oled_cursor = &oled_buffer[index];
+}
+
+void oled_advance_page(bool clearPageRemainder) {
+ uint16_t index = oled_cursor - &oled_buffer[0];
+ uint8_t remaining = oled_rotation_width - (index % oled_rotation_width);
+
+ if (clearPageRemainder) {
+ // Remaining Char count
+ remaining = remaining / OLED_FONT_WIDTH;
+
+ // Write empty character until next line
+ while (remaining--)
+ oled_write_char(' ', false);
+ } else {
+ // Next page index out of bounds?
+ if (index + remaining >= OLED_MATRIX_SIZE) {
+ index = 0;
+ remaining = 0;
+ }
+
+ oled_cursor = &oled_buffer[index + remaining];
+ }
+}
+
+void oled_advance_char(void) {
+ uint16_t nextIndex = oled_cursor - &oled_buffer[0] + OLED_FONT_WIDTH;
+ uint8_t remainingSpace = oled_rotation_width - (nextIndex % oled_rotation_width);
+
+ // Do we have enough space on the current line for the next character
+ if (remainingSpace < OLED_FONT_WIDTH) {
+ nextIndex += remainingSpace;
+ }
+
+ // Did we go out of bounds
+ if (nextIndex >= OLED_MATRIX_SIZE) {
+ nextIndex = 0;
+ }
+
+ // Update cursor position
+ oled_cursor = &oled_buffer[nextIndex];
+}
+
+// Main handler that writes character data to the display buffer
+void oled_write_char(const char data, bool invert) {
+ // Advance to the next line if newline
+ if (data == '\n') {
+ // Old source wrote ' ' until end of line...
+ oled_advance_page(true);
+ return;
+ }
+
+ // copy the current render buffer to check for dirty after
+ static uint8_t oled_temp_buffer[OLED_FONT_WIDTH];
+ memcpy(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH);
+
+ // set the reder buffer data
+ uint8_t cast_data = (uint8_t)data; // font based on unsigned type for index
+ if (cast_data < OLED_FONT_START || cast_data > OLED_FONT_END) {
+ memset(oled_cursor, 0x00, OLED_FONT_WIDTH);
+ } else {
+ const uint8_t *glyph = &font[(cast_data - OLED_FONT_START) * OLED_FONT_WIDTH];
+ memcpy_P(oled_cursor, glyph, OLED_FONT_WIDTH);
+ }
+
+ // Invert if needed
+ if (invert) {
+ InvertCharacter(oled_cursor);
+ }
+
+ // Dirty check
+ if (memcmp(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH)) {
+ oled_dirty |= (1 << ((oled_cursor - &oled_buffer[0]) / OLED_BLOCK_SIZE));
+ }
+
+ // Finally move to the next char
+ oled_advance_char();
+}
+
+void oled_write(const char *data, bool invert) {
+ const char *end = data + strlen(data);
+ while (data < end) {
+ oled_write_char(*data, invert);
+ data++;
+ }
+}
+
+void oled_write_ln(const char *data, bool invert) {
+ oled_write(data, invert);
+ oled_advance_page(true);
+}
+
+#if defined(__AVR__)
+void oled_write_P(const char *data, bool invert) {
+ uint8_t c = pgm_read_byte(data);
+ while (c != 0) {
+ oled_write_char(c, invert);
+ c = pgm_read_byte(++data);
+ }
+}
+
+void oled_write_ln_P(const char *data, bool invert) {
+ oled_write_P(data, invert);
+ oled_advance_page(true);
+}
+#endif // defined(__AVR__)
+
+bool oled_on(void) {
+#if !defined(OLED_DISABLE_TIMEOUT)
+ oled_last_activity = timer_read();
+#endif
+
+ static const uint8_t PROGMEM display_on[] = { I2C_CMD, DISPLAY_ON };
+ if (!oled_active) {
+ if (I2C_TRANSMIT_P(display_on) != I2C_STATUS_SUCCESS) {
+ print("oled_on cmd failed\n");
+ return oled_active;
+ }
+ oled_active = true;
+ }
+ return oled_active;
+}
+
+bool oled_off(void) {
+ static const uint8_t PROGMEM display_off[] = { I2C_CMD, DISPLAY_OFF };
+ if (oled_active) {
+ if (I2C_TRANSMIT_P(display_off) != I2C_STATUS_SUCCESS) {
+ print("oled_off cmd failed\n");
+ return oled_active;
+ }
+ oled_active = false;
+ }
+ return !oled_active;
+}
+
+bool oled_scroll_right(void) {
+ // Dont enable scrolling if we need to update the display
+ // This prevents scrolling of bad data from starting the scroll too early after init
+ if (!oled_dirty && !oled_scrolling) {
+ static const uint8_t PROGMEM display_scroll_right[] = {
+ I2C_CMD, SCROLL_RIGHT, 0x00, 0x00, 0x00, 0x0F, 0x00, 0xFF, ACTIVATE_SCROLL };
+ if (I2C_TRANSMIT_P(display_scroll_right) != I2C_STATUS_SUCCESS) {
+ print("oled_scroll_right cmd failed\n");
+ return oled_scrolling;
+ }
+ oled_scrolling = true;
+ }
+ return oled_scrolling;
+}
+
+bool oled_scroll_left(void) {
+ // Dont enable scrolling if we need to update the display
+ // This prevents scrolling of bad data from starting the scroll too early after init
+ if (!oled_dirty && !oled_scrolling) {
+ static const uint8_t PROGMEM display_scroll_left[] = {
+ I2C_CMD, SCROLL_LEFT, 0x00, 0x00, 0x00, 0x0F, 0x00, 0xFF, ACTIVATE_SCROLL };
+ if (I2C_TRANSMIT_P(display_scroll_left) != I2C_STATUS_SUCCESS) {
+ print("oled_scroll_left cmd failed\n");
+ return oled_scrolling;
+ }
+ oled_scrolling = true;
+ }
+ return oled_scrolling;
+}
+
+bool oled_scroll_off(void) {
+ if (oled_scrolling) {
+ static const uint8_t PROGMEM display_scroll_off[] = { I2C_CMD, DEACTIVATE_SCROLL };
+ if (I2C_TRANSMIT_P(display_scroll_off) != I2C_STATUS_SUCCESS) {
+ print("oled_scroll_off cmd failed\n");
+ return oled_scrolling;
+ }
+ oled_scrolling = false;
+ }
+ return !oled_scrolling;
+}
+
+uint8_t oled_max_chars(void) {
+ if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+ return OLED_DISPLAY_WIDTH / OLED_FONT_WIDTH;
+ }
+ return OLED_DISPLAY_HEIGHT / OLED_FONT_WIDTH;
+}
+
+uint8_t oled_max_lines(void) {
+ if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+ return OLED_DISPLAY_HEIGHT / OLED_FONT_HEIGHT;
+ }
+ return OLED_DISPLAY_WIDTH / OLED_FONT_HEIGHT;
+}
+
+void oled_task(void) {
+ if (!oled_initialized) {
+ return;
+ }
+
+ oled_set_cursor(0, 0);
+
+ oled_task_user();
+
+ // Smart render system, no need to check for dirty
+ oled_render();
+
+ // Display timeout check
+#if !defined(OLED_DISABLE_TIMEOUT)
+ if (oled_active && timer_elapsed(oled_last_activity) > OLED_TIMEOUT) {
+ oled_off();
+ }
+#endif
+}
+
+__attribute__((weak))
+void oled_task_user(void) {
+}
diff --git a/drivers/oled/oled_driver.h b/drivers/oled/oled_driver.h
new file mode 100644
index 0000000000..1ca31df114
--- /dev/null
+++ b/drivers/oled/oled_driver.h
@@ -0,0 +1,183 @@
+/*
+Copyright 2019 Ryan Caltabiano <https://github.com/XScorpion2>
+
+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>
+
+
+#if defined(OLED_DISPLAY_CUSTOM)
+ // Expected user to implement the necessary defines
+#elif defined(OLED_DISPLAY_128X64)
+ // Double height 128x64
+ #define OLED_DISPLAY_WIDTH 128
+ #define OLED_DISPLAY_HEIGHT 64
+ #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 1024 (compile time mathed)
+ #define OLED_BLOCK_TYPE uint16_t
+ #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 16 (compile time mathed)
+ #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 64 (compile time mathed)
+
+ // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
+ // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
+ #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+ #define OLED_TARGET_MAP { 56, 48, 40, 32, 24, 16, 8, 0 }
+ // If OLED_BLOCK_TYPE is uint8_t, these tables would look like:
+ // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 }
+ // #define OLED_TARGET_MAP { 56, 120, 48, 112, 40, 104, 32, 96, 24, 88, 16, 80, 8, 72, 0, 64 }
+#else // defined(OLED_DISPLAY_128X64)
+ // Default 128x32
+ #define OLED_DISPLAY_WIDTH 128
+ #define OLED_DISPLAY_HEIGHT 32
+ #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 512 (compile time mathed)
+ #define OLED_BLOCK_TYPE uint8_t // Type to use for segmenting the oled display for smart rendering, use unsigned types only
+ #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 8 (compile time mathed)
+ #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 128 (compile time mathed)
+
+ // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
+ // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
+ #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+ #define OLED_TARGET_MAP { 48, 32, 16, 0, 56, 40, 24, 8 }
+#endif // defined(OLED_DISPLAY_CUSTOM)
+
+// Address to use for tthe i2d oled communication
+#if !defined(OLED_DISPLAY_ADDRESS)
+ #define OLED_DISPLAY_ADDRESS 0x3C
+#endif
+
+// Custom font file to use
+#if !defined(OLED_FONT_H)
+ #define OLED_FONT_H "glcdfont.c"
+#endif
+// unsigned char value of the first character in the font file
+#if !defined(OLED_FONT_START)
+ #define OLED_FONT_START 0
+#endif
+// unsigned char value of the last character in the font file
+#if !defined(OLED_FONT_END)
+ #define OLED_FONT_END 224
+#endif
+// Font render width
+#if !defined(OLED_FONT_WIDTH)
+ #define OLED_FONT_WIDTH 6
+#endif
+// Font render height
+#if !defined(OLED_FONT_HEIGHT)
+ #define OLED_FONT_HEIGHT 8
+#endif
+
+#define OLED_ROTATION_0 0x00
+#define OLED_ROTATION_90 0x01
+#define OLED_ROTATION_180 0x02
+#define OLED_ROTATION_270 0x03
+
+// Initialize the oled display, rotating the rendered output based on the define passed in.
+// Returns true if the OLED was initialized successfully
+bool oled_init(uint8_t rotation);
+
+// Called at the start of oled_init, weak function overridable by the user
+// rotation - the value passed into oled_init
+// Return new uint8_t if you want to override default rotation
+uint8_t oled_init_user(uint8_t rotation);
+
+// Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
+void oled_clear(void);
+
+// Renders the dirty chunks of the buffer to oled display
+void oled_render(void);
+
+// Moves cursor to character position indicated by column and line, wraps if out of bounds
+// Max column denoted by 'oled_max_chars()' and max lines by 'oled_max_lines()' functions
+void oled_set_cursor(uint8_t col, uint8_t line);
+
+// Advances the cursor to the next page, writing ' ' if true
+// Wraps to the begining when out of bounds
+void oled_advance_page(bool clearPageRemainder);
+
+// Moves the cursor forward 1 character length
+// Advance page if there is not enough room for the next character
+// Wraps to the begining when out of bounds
+void oled_advance_char(void);
+
+// Writes a single character to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Main handler that writes character data to the display buffer
+void oled_write_char(const char data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+void oled_write(const char *data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+void oled_write_ln(const char *data, bool invert);
+
+#if defined(__AVR__)
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Remapped to call 'void oled_write(const char *data, bool invert);' on ARM
+void oled_write_P(const char *data, bool invert);
+
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+// Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
+void oled_write_ln_P(const char *data, bool invert);
+#else
+ // Writes a string to the buffer at current cursor position
+ // Advances the cursor while writing, inverts the pixels if true
+ #define oled_write_P(data, invert) oled_write(data, invert)
+
+ // Writes a string to the buffer at current cursor position
+ // Advances the cursor while writing, inverts the pixels if true
+ // Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+ #define oled_write_ln_P(data, invert) oled_write(data, invert)
+#endif // defined(__AVR__)
+
+// Can be used to manually turn on the screen if it is off
+// Returns true if the screen was on or turns on
+bool oled_on(void);
+
+// Can be used to manually turn off the screen if it is on
+// Returns true if the screen was off or turns off
+bool oled_off(void);
+
+// Basically it's oled_render, but with timeout management and oled_task_user calling!
+void oled_task(void);
+
+// Called at the start of oled_task, weak function overridable by the user
+void oled_task_user(void);
+
+// Scrolls the entire display right
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_right(void);
+
+// Scrolls the entire display left
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_left(void);
+
+// Turns off display scrolling
+// Returns true if the screen was not scrolling or stops scrolling
+bool oled_scroll_off(void);
+
+// Returns the maximum number of characters that will fit on a line
+uint8_t oled_max_chars(void);
+
+// Returns the maximum number of lines that will fit on the oled
+uint8_t oled_max_lines(void);
diff --git a/quantum/quantum.c b/quantum/quantum.c
index 4d8d2482d0..86dc00381e 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -275,6 +275,12 @@ bool process_record_quantum(keyrecord_t *record) {
preprocess_tap_dance(keycode, record);
#endif
+ #if defined(OLED_DRIVER_ENABLE) && !defined(OLED_DISABLE_TIMEOUT)
+ // Wake up oled if user is using those fabulous keys!
+ if (record->event.pressed)
+ oled_on();
+ #endif
+
if (!(
#if defined(KEY_LOCK_ENABLE)
// Must run first to be able to mask key_up events.
@@ -1084,6 +1090,12 @@ void matrix_init_quantum() {
#ifdef HAPTIC_ENABLE
haptic_init();
#endif
+ #ifdef OUTPUT_AUTO_ENABLE
+ set_output(OUTPUT_AUTO);
+ #endif
+ #ifdef OLED_DRIVER_ENABLE
+ oled_init(OLED_ROTATION_0);
+ #endif
matrix_init_kb();
}
@@ -1120,6 +1132,10 @@ void matrix_scan_quantum() {
haptic_task();
#endif
+ #ifdef OLED_DRIVER_ENABLE
+ oled_task();
+ #endif
+
matrix_scan_kb();
}
#if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
diff --git a/quantum/quantum.h b/quantum/quantum.h
index e2f467125e..987516dedb 100644
--- a/quantum/quantum.h
+++ b/quantum/quantum.h
@@ -139,6 +139,10 @@ extern uint32_t default_layer_state;
#include "haptic.h"
#endif
+#ifdef OLED_DRIVER_ENABLE
+ #include "oled_driver.h"
+#endif
+
//Function substitutions to ease GPIO manipulation
#ifdef __AVR__
#define PIN_ADDRESS(p, offset) _SFR_IO8(ADDRESS_BASE + (p >> PORT_SHIFTER) + offset)
diff --git a/quantum/rgb_matrix.c b/quantum/rgb_matrix.c
index 3e49f9fc0a..0edca6847f 100644
--- a/quantum/rgb_matrix.c
+++ b/quantum/rgb_matrix.c
@@ -41,6 +41,9 @@
#include "rgb_matrix_animations/digital_rain_anim.h"
#include "rgb_matrix_animations/solid_reactive_simple_anim.h"
#include "rgb_matrix_animations/solid_reactive_anim.h"
+#include "rgb_matrix_animations/solid_reactive_wide.h"
+#include "rgb_matrix_animations/solid_reactive_cross.h"
+#include "rgb_matrix_animations/solid_reactive_nexus.h"
#include "rgb_matrix_animations/splash_anim.h"
#include "rgb_matrix_animations/solid_splash_anim.h"
#include "rgb_matrix_animations/breathing_anim.h"
@@ -380,6 +383,36 @@ static void rgb_task_render(uint8_t effect) {
rendering = rgb_matrix_solid_reactive(&rgb_effect_params); // Max 4ms Avg 3ms
break;
#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
+ case RGB_MATRIX_SOLID_REACTIVE_WIDE:
+ rendering = rgb_matrix_solid_reactive_wide(&rgb_effect_params); // Max ?? ms Avg ?? ms
+ break;
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+ case RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE:
+ rendering = rgb_matrix_solid_reactive_multiwide(&rgb_effect_params); // Max ?? ms Avg ?? ms
+ break;
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
+ case RGB_MATRIX_SOLID_REACTIVE_CROSS:
+ rendering = rgb_matrix_solid_reactive_cross(&rgb_effect_params); // Max ?? ms Avg ?? ms
+ break;
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
+ case RGB_MATRIX_SOLID_REACTIVE_MULTICROSS:
+ rendering = rgb_matrix_solid_reactive_multicross(&rgb_effect_params); // Max ?? ms Avg ?? ms
+ break;
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
+ case RGB_MATRIX_SOLID_REACTIVE_NEXUS:
+ rendering = rgb_matrix_solid_reactive_nexus(&rgb_effect_params); // Max ?? ms Avg ?? ms
+ break;
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
+ case RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS:
+ rendering = rgb_matrix_solid_reactive_multinexus(&rgb_effect_params); // Max ?? ms Avg ?? ms
+ break;
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
#ifndef DISABLE_RGB_MATRIX_SPLASH
case RGB_MATRIX_SPLASH:
rendering = rgb_matrix_splash(&rgb_effect_params); // Max 5ms Avg 3ms
diff --git a/quantum/rgb_matrix.h b/quantum/rgb_matrix.h
index 0a11f26920..f24798d9f9 100644
--- a/quantum/rgb_matrix.h
+++ b/quantum/rgb_matrix.h
@@ -110,6 +110,24 @@ enum rgb_matrix_effects {
#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE
RGB_MATRIX_SOLID_REACTIVE,
#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
+ RGB_MATRIX_SOLID_REACTIVE_WIDE,
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+ RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE,
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
+ RGB_MATRIX_SOLID_REACTIVE_CROSS,
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
+ RGB_MATRIX_SOLID_REACTIVE_MULTICROSS,
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
+ RGB_MATRIX_SOLID_REACTIVE_NEXUS,
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
+#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
+ RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS,
+#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
#ifndef DISABLE_RGB_MATRIX_SPLASH
RGB_MATRIX_SPLASH,
#endif // DISABLE_RGB_MATRIX_SPLASH
diff --git a/quantum/rgb_matrix_animations/solid_reactive_cross.h b/quantum/rgb_matrix_animations/solid_reactive_cross.h
new file mode 100644
index 0000000000..af602cba15
--- /dev/null
+++ b/quantum/rgb_matrix_animations/solid_reactive_cross.h
@@ -0,0 +1,50 @@
+#pragma once
+#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
+#if !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS)
+
+extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
+extern rgb_config_t rgb_matrix_config;
+extern last_hit_t g_last_hit_tracker;
+
+static bool rgb_matrix_solid_reactive_multicross_range(uint8_t start, effect_params_t* params) {
+ RGB_MATRIX_USE_LIMITS(led_min, led_max);
+
+ HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 };
+ uint8_t count = g_last_hit_tracker.count;
+ for (uint8_t i = led_min; i < led_max; i++) {
+ hsv.v = 0;
+ point_t point = g_rgb_leds[i].point;
+ for (uint8_t j = start; j < count; j++) {
+ int16_t dx = point.x - g_last_hit_tracker.x[j];
+ int16_t dy = point.y - g_last_hit_tracker.y[j];
+ uint8_t dist = sqrt16(dx * dx + dy * dy);
+ int16_t dist2 = 16;
+ uint8_t dist3;
+ uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) + dist;
+ dx = dx < 0 ? dx * -1 : dx;
+ dy = dy < 0 ? dy * -1 : dy;
+ dx = dx * dist2 > 255 ? 255 : dx * dist2;
+ dy = dy * dist2 > 255 ? 255 : dy * dist2;
+ dist3 = dx > dy ? dy : dx;
+ effect += dist3;
+ if (effect > 255)
+ effect = 255;
+ hsv.v = qadd8(hsv.v, 255 - effect);
+ }
+ hsv.v = scale8(hsv.v, rgb_matrix_config.val);
+ RGB rgb = hsv_to_rgb(hsv);
+ rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
+ }
+ return led_max < DRIVER_LED_TOTAL;
+}
+
+bool rgb_matrix_solid_reactive_multicross(effect_params_t* params) {
+ return rgb_matrix_solid_reactive_multicross_range(0, params);
+}
+
+bool rgb_matrix_solid_reactive_cross(effect_params_t* params) {
+ return rgb_matrix_solid_reactive_multicross_range(qsub8(g_last_hit_tracker.count, 1), params);
+}
+
+#endif // !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS)
+#endif // RGB_MATRIX_KEYREACTIVE_ENABLED
diff --git a/quantum/rgb_matrix_animations/solid_reactive_nexus.h b/quantum/rgb_matrix_animations/solid_reactive_nexus.h
new file mode 100644
index 0000000000..8b4a139dc9
--- /dev/null
+++ b/quantum/rgb_matrix_animations/solid_reactive_nexus.h
@@ -0,0 +1,48 @@
+#pragma once
+#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
+#if !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS)
+
+extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
+extern rgb_config_t rgb_matrix_config;
+extern last_hit_t g_last_hit_tracker;
+
+static bool rgb_matrix_solid_reactive_multinexus_range(uint8_t start, effect_params_t* params) {
+ RGB_MATRIX_USE_LIMITS(led_min, led_max);
+
+ HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 };
+ uint8_t count = g_last_hit_tracker.count;
+ for (uint8_t i = led_min; i < led_max; i++) {
+ hsv.v = 0;
+ point_t point = g_rgb_leds[i].point;
+ for (uint8_t j = start; j < count; j++) {
+ int16_t dx = point.x - g_last_hit_tracker.x[j];
+ int16_t dy = point.y - g_last_hit_tracker.y[j];
+ uint8_t dist = sqrt16(dx * dx + dy * dy);
+ int16_t dist2 = 8;
+ uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) - dist;
+ if (effect > 255)
+ effect = 255;
+ if (dist > 72)
+ effect = 255;
+ if ((dx > dist2 || dx < -dist2) && (dy > dist2 || dy < -dist2))
+ effect = 255;
+ hsv.v = qadd8(hsv.v, 255 - effect);
+ hsv.h = rgb_matrix_config.hue + dy / 4;
+ }
+ hsv.v = scale8(hsv.v, rgb_matrix_config.val);
+ RGB rgb = hsv_to_rgb(hsv);
+ rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
+ }
+ return led_max < DRIVER_LED_TOTAL;
+}
+
+bool rgb_matrix_solid_reactive_multinexus(effect_params_t* params) {
+ return rgb_matrix_solid_reactive_multinexus_range(0, params);
+}
+
+bool rgb_matrix_solid_reactive_nexus(effect_params_t* params) {
+ return rgb_matrix_solid_reactive_multinexus_range(qsub8(g_last_hit_tracker.count, 1), params);
+}
+
+#endif // !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS)
+#endif // RGB_MATRIX_KEYREACTIVE_ENABLED
diff --git a/quantum/rgb_matrix_animations/solid_reactive_wide.h b/quantum/rgb_matrix_animations/solid_reactive_wide.h
new file mode 100644
index 0000000000..abb01892ed
--- /dev/null
+++ b/quantum/rgb_matrix_animations/solid_reactive_wide.h
@@ -0,0 +1,42 @@
+#pragma once
+#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
+#if !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE)
+
+extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
+extern rgb_config_t rgb_matrix_config;
+extern last_hit_t g_last_hit_tracker;
+
+static bool rgb_matrix_solid_reactive_multiwide_range(uint8_t start, effect_params_t* params) {
+ RGB_MATRIX_USE_LIMITS(led_min, led_max);
+
+ HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 };
+ uint8_t count = g_last_hit_tracker.count;
+ for (uint8_t i = led_min; i < led_max; i++) {
+ hsv.v = 0;
+ point_t point = g_rgb_leds[i].point;
+ for (uint8_t j = start; j < count; j++) {
+ int16_t dx = point.x - g_last_hit_tracker.x[j];
+ int16_t dy = point.y - g_last_hit_tracker.y[j];
+ uint8_t dist = sqrt16(dx * dx + dy * dy);
+ uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) + dist * 5;
+ if (effect > 255)
+ effect = 255;
+ hsv.v = qadd8(hsv.v, 255 - effect);
+ }
+ hsv.v = scale8(hsv.v, rgb_matrix_config.val);
+ RGB rgb = hsv_to_rgb(hsv);
+ rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
+ }
+ return led_max < DRIVER_LED_TOTAL;
+}
+
+bool rgb_matrix_solid_reactive_multiwide(effect_params_t* params) {
+ return rgb_matrix_solid_reactive_multiwide_range(0, params);
+}
+
+bool rgb_matrix_solid_reactive_wide(effect_params_t* params) {
+ return rgb_matrix_solid_reactive_multiwide_range(qsub8(g_last_hit_tracker.count, 1), params);
+}
+
+#endif // !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE)
+#endif // RGB_MATRIX_KEYREACTIVE_ENABLED
diff --git a/quantum/rgblight.c b/quantum/rgblight.c
index e2410424e4..5ec11bc077 100644
--- a/quantum/rgblight.c
+++ b/quantum/rgblight.c
@@ -34,14 +34,38 @@
#include "velocikey.h"
#endif
+#ifdef RGBLIGHT_SPLIT
+ /* for split keyboard */
+ #define RGBLIGHT_SPLIT_SET_CHANGE_MODE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_MODE
+ #define RGBLIGHT_SPLIT_SET_CHANGE_HSVS rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_HSVS
+ #define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_TIMER
+ #define RGBLIGHT_SPLIT_ANIMATION_TICK rgblight_status.change_flags |= RGBLIGHT_STATUS_ANIMATION_TICK
+#else
+ #define RGBLIGHT_SPLIT_SET_CHANGE_MODE
+ #define RGBLIGHT_SPLIT_SET_CHANGE_HSVS
+ #define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
+ #define RGBLIGHT_SPLIT_ANIMATION_TICK
+#endif
+
#define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_SINGLE_DYNAMIC(sym)
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_DYNAMIC(sym)
-#define _RGBM_TMP_STATIC(sym) RGBLIGHT_MODE_ ## sym,
-#define _RGBM_TMP_DYNAMIC(sym)
+#define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_ ## sym,
+#define _RGBM_TMP_DYNAMIC(sym, msym)
static uint8_t static_effect_table [] = {
-#include "rgblight.h"
+#include "rgblight_modes.h"
+};
+
+#define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_ ## sym,
+#define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
+#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
+#define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
+#define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_ ## msym,
+#define _RGBM_TMP_DYNAMIC(sym, msym) RGBLIGHT_MODE_ ## msym,
+static uint8_t mode_base_table [] = {
+ 0, // RGBLIGHT_MODE_zero
+#include "rgblight_modes.h"
};
static inline int is_static_effect(uint8_t mode) {
@@ -61,14 +85,18 @@ const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
#endif
rgblight_config_t rgblight_config;
+rgblight_status_t rgblight_status = { .timer_enabled = false };
bool is_rgblight_initialized = false;
+#ifdef RGBLIGHT_USE_TIMER
+animation_status_t animation_status = {};
+#endif
+
#ifndef LED_ARRAY
LED_TYPE led[RGBLED_NUM];
#define LED_ARRAY led
#endif
-bool rgblight_timer_enabled = false;
static uint8_t clipping_start_pos = 0;
static uint8_t clipping_num_leds = RGBLED_NUM;
@@ -221,6 +249,7 @@ void rgblight_init(void) {
eeconfig_update_rgblight_default();
}
rgblight_config.raw = eeconfig_read_rgblight();
+ RGBLIGHT_SPLIT_SET_CHANGE_HSVS;
if (!rgblight_config.mode) {
dprintf("rgblight_init rgblight_config.mode = 0. Write default values to EEPROM.\n");
eeconfig_update_rgblight_default();
@@ -321,6 +350,7 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
} else {
rgblight_config.mode = mode;
}
+ RGBLIGHT_SPLIT_SET_CHANGE_MODE;
if (write_to_eeprom) {
eeconfig_update_rgblight(rgblight_config.raw);
xprintf("rgblight mode [EEPROM]: %u\n", rgblight_config.mode);
@@ -336,6 +366,9 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
rgblight_timer_enable();
#endif
}
+#ifdef RGBLIGHT_USE_TIMER
+ animation_status.restart = true;
+#endif
rgblight_sethsv_noeeprom(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
}
@@ -389,6 +422,7 @@ void rgblight_disable(void) {
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable();
#endif
+ RGBLIGHT_SPLIT_SET_CHANGE_MODE;
wait_ms(50);
rgblight_set();
}
@@ -399,6 +433,7 @@ void rgblight_disable_noeeprom(void) {
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable();
#endif
+ RGBLIGHT_SPLIT_SET_CHANGE_MODE;
wait_ms(50);
rgblight_set();
}
@@ -505,11 +540,13 @@ void rgblight_decrease_val(void) {
}
void rgblight_increase_speed(void) {
rgblight_config.speed = increment( rgblight_config.speed, 1, 0, 3 );
+ //RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED?
eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this
}
void rgblight_decrease_speed(void) {
rgblight_config.speed = decrement( rgblight_config.speed, 1, 0, 3 );
+ //RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED??
eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this
}
@@ -524,6 +561,7 @@ void rgblight_sethsv_noeeprom_old(uint16_t hue, uint8_t sat, uint8_t val) {
void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) {
if (rgblight_config.enable) {
+ rgblight_status.base_mode = mode_base_table[rgblight_config.mode];
if (rgblight_config.mode == RGBLIGHT_MODE_STATIC_LIGHT) {
// same static color
LED_TYPE tmp_led;
@@ -534,33 +572,30 @@ void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool
if ( 1 == 0 ) { //dummy
}
#ifdef RGBLIGHT_EFFECT_BREATHING
- else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING &&
- rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_BREATHING ) {
// breathing mode, ignore the change of val, use in memory value instead
val = rgblight_config.val;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
- else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD &&
- rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_MOOD) {
// rainbow mood, ignore the change of hue
hue = rgblight_config.hue;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
- else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL &&
- rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_SWIRL) {
// rainbow swirl, ignore the change of hue
hue = rgblight_config.hue;
}
#endif
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
- else if (rgblight_config.mode >= RGBLIGHT_MODE_STATIC_GRADIENT &&
- rgblight_config.mode <= RGBLIGHT_MODE_STATIC_GRADIENT_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_STATIC_GRADIENT) {
// static gradient
uint16_t _hue;
- int8_t direction = ((rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) % 2) ? -1 : 1;
- uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[(rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) / 2]);
+ uint8_t delta = rgblight_config.mode - rgblight_status.base_mode;
+ int8_t direction = (delta % 2) ? -1 : 1;
+ uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[delta / 2]);
for (uint8_t i = 0; i < RGBLED_NUM; i++) {
_hue = (range / RGBLED_NUM * i * direction + hue + 360) % 360;
dprintf("rgblight rainbow set hsv: %u,%u,%d,%u\n", i, _hue, direction, range);
@@ -570,6 +605,13 @@ void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool
}
#endif
}
+#ifdef RGBLIGHT_SPLIT
+ if( rgblight_config.hue != hue ||
+ rgblight_config.sat != sat ||
+ rgblight_config.val != val ) {
+ RGBLIGHT_SPLIT_SET_CHANGE_HSVS;
+ }
+#endif
rgblight_config.hue = hue;
rgblight_config.sat = sat;
rgblight_config.val = val;
@@ -711,10 +753,59 @@ void rgblight_set(void) {
}
#endif
+#ifdef RGBLIGHT_SPLIT
+/* for split keyboard master side */
+uint8_t rgblight_get_change_flags(void) {
+ return rgblight_status.change_flags;
+}
+
+void rgblight_clear_change_flags(void) {
+ rgblight_status.change_flags = 0;
+}
+
+void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo) {
+ syncinfo->config = rgblight_config;
+ syncinfo->status = rgblight_status;
+}
+
+/* for split keyboard slave side */
+void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom) {
+ if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_MODE) {
+ if (syncinfo->config.enable) {
+ rgblight_config.enable = 1; // == rgblight_enable_noeeprom();
+ rgblight_mode_eeprom_helper(syncinfo->config.mode, write_to_eeprom);
+ } else {
+ rgblight_disable_noeeprom();
+ }
+ }
+ if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_HSVS) {
+ rgblight_sethsv_eeprom_helper(syncinfo->config.hue, syncinfo->config.sat, syncinfo->config.val, write_to_eeprom);
+ // rgblight_config.speed = config->speed; // NEED???
+ }
+ #ifdef RGBLIGHT_USE_TIMER
+ if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_TIMER) {
+ if (syncinfo->status.timer_enabled) {
+ rgblight_timer_enable();
+ } else {
+ rgblight_timer_disable();
+ }
+ }
+ #ifndef RGBLIGHT_SPLIT_NO_ANIMATION_SYNC
+ if (syncinfo->status.change_flags & RGBLIGHT_STATUS_ANIMATION_TICK) {
+ animation_status.restart = true;
+ }
+ #endif /* RGBLIGHT_SPLIT_NO_ANIMATION_SYNC */
+ #endif /* RGBLIGHT_USE_TIMER */
+}
+#endif /* RGBLIGHT_SPLIT */
+
#ifdef RGBLIGHT_USE_TIMER
-// Animation timer -- AVR Timer3
+typedef void (*effect_func_t)(animation_status_t *anim);
+
+// Animation timer -- use system timer (AVR Timer0)
void rgblight_timer_init(void) {
+ // OLD!!!! Animation timer -- AVR Timer3
// static uint8_t rgblight_timer_is_init = 0;
// if (rgblight_timer_is_init) {
// return;
@@ -730,19 +821,29 @@ void rgblight_timer_init(void) {
// OCR3AL = RGBLED_TIMER_TOP & 0xff;
// SREG = sreg;
- rgblight_timer_enabled = true;
+ rgblight_status.timer_enabled = false;
+ RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
}
void rgblight_timer_enable(void) {
- rgblight_timer_enabled = true;
- dprintf("TIMER3 enabled.\n");
+ if( !is_static_effect(rgblight_config.mode) ) {
+ rgblight_status.timer_enabled = true;
+ }
+ animation_status.last_timer = timer_read();
+ RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
+ dprintf("rgblight timer enabled.\n");
}
void rgblight_timer_disable(void) {
- rgblight_timer_enabled = false;
- dprintf("TIMER3 disabled.\n");
+ rgblight_status.timer_enabled = false;
+ RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
+ dprintf("rgblight timer disable.\n");
}
void rgblight_timer_toggle(void) {
- rgblight_timer_enabled ^= rgblight_timer_enabled;
- dprintf("TIMER3 toggled.\n");
+ dprintf("rgblight timer toggle.\n");
+ if(rgblight_status.timer_enabled) {
+ rgblight_timer_disable();
+ } else {
+ rgblight_timer_enable();
+ }
}
void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) {
@@ -751,64 +852,116 @@ void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) {
rgblight_setrgb(r, g, b);
}
+static void rgblight_effect_dummy(animation_status_t *anim) {
+ // do nothing
+ /********
+ dprintf("rgblight_task() what happened?\n");
+ dprintf("is_static_effect %d\n", is_static_effect(rgblight_config.mode));
+ dprintf("mode = %d, base_mode = %d, timer_enabled %d, ",
+ rgblight_config.mode, rgblight_status.base_mode,
+ rgblight_status.timer_enabled);
+ dprintf("last_timer = %d\n",anim->last_timer);
+ **/
+}
+
void rgblight_task(void) {
+ if (rgblight_status.timer_enabled) {
+ effect_func_t effect_func = rgblight_effect_dummy;
+ uint16_t interval_time = 2000; // dummy interval
+ uint8_t delta = rgblight_config.mode - rgblight_status.base_mode;
+ animation_status.delta = delta;
- if (rgblight_timer_enabled) {
// static light mode, do nothing here
if ( 1 == 0 ) { //dummy
}
#ifdef RGBLIGHT_EFFECT_BREATHING
- else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING &&
- rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_BREATHING) {
// breathing mode
- rgblight_effect_breathing(rgblight_config.mode - RGBLIGHT_MODE_BREATHING );
+ interval_time = get_interval_time(&RGBLED_BREATHING_INTERVALS[delta], 1, 100);
+ effect_func = rgblight_effect_breathing;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
- else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD &&
- rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_MOOD) {
// rainbow mood mode
- rgblight_effect_rainbow_mood(rgblight_config.mode - RGBLIGHT_MODE_RAINBOW_MOOD);
+ interval_time = get_interval_time(&RGBLED_RAINBOW_MOOD_INTERVALS[delta], 5, 100);
+ effect_func = rgblight_effect_rainbow_mood;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
- else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL &&
- rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_SWIRL) {
// rainbow swirl mode
- rgblight_effect_rainbow_swirl(rgblight_config.mode - RGBLIGHT_MODE_RAINBOW_SWIRL);
+ interval_time = get_interval_time(&RGBLED_RAINBOW_SWIRL_INTERVALS[delta / 2], 1, 100);
+ effect_func = rgblight_effect_rainbow_swirl;
}
#endif
#ifdef RGBLIGHT_EFFECT_SNAKE
- else if (rgblight_config.mode >= RGBLIGHT_MODE_SNAKE &&
- rgblight_config.mode <= RGBLIGHT_MODE_SNAKE_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_SNAKE) {
// snake mode
- rgblight_effect_snake(rgblight_config.mode - RGBLIGHT_MODE_SNAKE);
+ interval_time = get_interval_time(&RGBLED_SNAKE_INTERVALS[delta / 2], 1, 200);
+ effect_func = rgblight_effect_snake;
}
#endif
#ifdef RGBLIGHT_EFFECT_KNIGHT
- else if (rgblight_config.mode >= RGBLIGHT_MODE_KNIGHT &&
- rgblight_config.mode <= RGBLIGHT_MODE_KNIGHT_end) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_KNIGHT) {
// knight mode
- rgblight_effect_knight(rgblight_config.mode - RGBLIGHT_MODE_KNIGHT);
+ interval_time = get_interval_time(&RGBLED_KNIGHT_INTERVALS[delta], 5, 100);
+ effect_func = rgblight_effect_knight;
}
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
- else if (rgblight_config.mode == RGBLIGHT_MODE_CHRISTMAS) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_CHRISTMAS) {
// christmas mode
- rgblight_effect_christmas();
+ interval_time = RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL;
+ effect_func = (effect_func_t)rgblight_effect_christmas;
}
#endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST
- else if (rgblight_config.mode == RGBLIGHT_MODE_RGB_TEST) {
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_RGB_TEST) {
// RGB test mode
- rgblight_effect_rgbtest();
+ interval_time = pgm_read_word(&RGBLED_RGBTEST_INTERVALS[0]);
+ effect_func = (effect_func_t)rgblight_effect_rgbtest;
}
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
- else if (rgblight_config.mode == RGBLIGHT_MODE_ALTERNATING){
- rgblight_effect_alternating();
+ else if (rgblight_status.base_mode == RGBLIGHT_MODE_ALTERNATING){
+ interval_time = 500;
+ effect_func = (effect_func_t)rgblight_effect_alternating;
+ }
+#endif
+ if (animation_status.restart) {
+ animation_status.restart = false;
+ animation_status.last_timer = timer_read() - interval_time - 1;
+ animation_status.pos16 = 0; // restart signal to local each effect
}
+ if (timer_elapsed(animation_status.last_timer) >= interval_time) {
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ static uint16_t report_last_timer = 0;
+ static bool tick_flag = false;
+ uint16_t oldpos16;
+ if (tick_flag) {
+ tick_flag = false;
+ //dprintf("rgblight animation tick\n");
+ if (timer_elapsed(report_last_timer) >= 30000) {
+ report_last_timer = timer_read();
+ dprintf("rgblight animation tick report to slave\n");
+ RGBLIGHT_SPLIT_ANIMATION_TICK;
+ }
+ }
+ oldpos16 = animation_status.pos16;
+ //dprintf("call effect function\n");
+#endif
+ animation_status.last_timer += interval_time;
+ effect_func(&animation_status);
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ //dprintf("pos16, oldpos16 = %d %d\n",
+ // animation_status.pos16,oldpos16);
+ if (animation_status.pos16 == 0 && oldpos16 != 0) {
+ //dprintf("flag on\n");
+ tick_flag = true;
+ }
#endif
+ }
}
}
@@ -819,22 +972,13 @@ void rgblight_task(void) {
__attribute__ ((weak))
const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
-void rgblight_effect_breathing(uint8_t interval) {
- static uint8_t pos = 0;
- static uint16_t last_timer = 0;
+void rgblight_effect_breathing(animation_status_t *anim) {
float val;
- uint8_t interval_time = get_interval_time(&RGBLED_BREATHING_INTERVALS[interval], 1, 100);
-
- if (timer_elapsed(last_timer) < interval_time) {
- return;
- }
- last_timer = timer_read();
-
// http://sean.voisen.org/blog/2011/10/breathing-led-with-arduino/
- val = (exp(sin((pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E));
+ val = (exp(sin((anim->pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E));
rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val);
- pos = (pos + 1) % 256;
+ anim->pos = (anim->pos + 1) % 256;
}
#endif
@@ -842,18 +986,9 @@ void rgblight_effect_breathing(uint8_t interval) {
__attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
-void rgblight_effect_rainbow_mood(uint8_t interval) {
- static uint16_t current_hue = 0;
- static uint16_t last_timer = 0;
-
- uint8_t interval_time = get_interval_time(&RGBLED_RAINBOW_MOOD_INTERVALS[interval], 5, 100);
-
- if (timer_elapsed(last_timer) < interval_time) {
- return;
- }
- last_timer = timer_read();
- rgblight_sethsv_noeeprom_old(current_hue, rgblight_config.sat, rgblight_config.val);
- current_hue = (current_hue + 1) % 360;
+void rgblight_effect_rainbow_mood(animation_status_t *anim) {
+ rgblight_sethsv_noeeprom_old(anim->current_hue, rgblight_config.sat, rgblight_config.val);
+ anim->current_hue = (anim->current_hue + 1) % 360;
}
#endif
@@ -865,31 +1000,23 @@ void rgblight_effect_rainbow_mood(uint8_t interval) {
__attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
-void rgblight_effect_rainbow_swirl(uint8_t interval) {
- static uint16_t current_hue = 0;
- static uint16_t last_timer = 0;
+void rgblight_effect_rainbow_swirl(animation_status_t *anim) {
uint16_t hue;
uint8_t i;
- uint8_t interval_time = get_interval_time(&RGBLED_RAINBOW_SWIRL_INTERVALS[interval / 2], 1, 100);
-
- if (timer_elapsed(last_timer) < interval_time) {
- return;
- }
- last_timer = timer_read();
for (i = 0; i < RGBLED_NUM; i++) {
- hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / RGBLED_NUM * i + current_hue) % 360;
+ hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / RGBLED_NUM * i + anim->current_hue) % 360;
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}
rgblight_set();
- if (interval % 2) {
- current_hue = (current_hue + 1) % 360;
+ if (anim->delta % 2) {
+ anim->current_hue = (anim->current_hue + 1) % 360;
} else {
- if (current_hue - 1 < 0) {
- current_hue = 359;
+ if (anim->current_hue - 1 < 0) {
+ anim->current_hue = 359;
} else {
- current_hue = current_hue - 1;
+ anim->current_hue = anim->current_hue - 1;
}
}
}
@@ -899,22 +1026,27 @@ void rgblight_effect_rainbow_swirl(uint8_t interval) {
__attribute__ ((weak))
const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
-void rgblight_effect_snake(uint8_t interval) {
+void rgblight_effect_snake(animation_status_t *anim) {
static uint8_t pos = 0;
- static uint16_t last_timer = 0;
uint8_t i, j;
int8_t k;
int8_t increment = 1;
- if (interval % 2) {
+
+ if (anim->delta % 2) {
increment = -1;
}
- uint8_t interval_time = get_interval_time(&RGBLED_SNAKE_INTERVALS[interval / 2], 1, 200);
-
- if (timer_elapsed(last_timer) < interval_time) {
- return;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ if (anim->pos == 0) { // restart signal
+ if (increment == 1) {
+ pos = RGBLED_NUM - 1;
+ } else {
+ pos = 0;
+ }
+ anim->pos = 1;
}
- last_timer = timer_read();
+#endif
+
for (i = 0; i < RGBLED_NUM; i++) {
led[i].r = 0;
led[i].g = 0;
@@ -925,7 +1057,9 @@ void rgblight_effect_snake(uint8_t interval) {
k = k + RGBLED_NUM;
}
if (i == k) {
- sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), (LED_TYPE *)&led[i]);
+ sethsv(rgblight_config.hue, rgblight_config.sat,
+ (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH),
+ (LED_TYPE *)&led[i]);
}
}
}
@@ -933,11 +1067,20 @@ void rgblight_effect_snake(uint8_t interval) {
if (increment == 1) {
if (pos - 1 < 0) {
pos = RGBLED_NUM - 1;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ anim->pos = 0;
+#endif
} else {
pos -= 1;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ anim->pos = 1;
+#endif
}
} else {
pos = (pos + 1) % RGBLED_NUM;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ anim->pos = pos;
+#endif
}
}
#endif
@@ -946,21 +1089,21 @@ void rgblight_effect_snake(uint8_t interval) {
__attribute__ ((weak))
const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
-void rgblight_effect_knight(uint8_t interval) {
- static uint16_t last_timer = 0;
-
- uint8_t interval_time = get_interval_time(&RGBLED_KNIGHT_INTERVALS[interval], 5, 100);
-
- if (timer_elapsed(last_timer) < interval_time) {
- return;
- }
- last_timer = timer_read();
+void rgblight_effect_knight(animation_status_t *anim) {
static int8_t low_bound = 0;
static int8_t high_bound = RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1;
static int8_t increment = 1;
uint8_t i, cur;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ if (anim->pos == 0) { // restart signal
+ anim->pos = 1;
+ low_bound = 0;
+ high_bound = RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1;
+ increment = 1;
+ }
+#endif
// Set all the LEDs to 0
for (i = 0; i < RGBLED_NUM; i++) {
led[i].r = 0;
@@ -988,23 +1131,23 @@ void rgblight_effect_knight(uint8_t interval) {
if (high_bound <= 0 || low_bound >= RGBLIGHT_EFFECT_KNIGHT_LED_NUM - 1) {
increment = -increment;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+ if (increment == 1) {
+ anim->pos = 0;
+ }
+#endif
}
}
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
-void rgblight_effect_christmas(void) {
- static uint16_t current_offset = 0;
- static uint16_t last_timer = 0;
+void rgblight_effect_christmas(animation_status_t *anim) {
uint16_t hue;
uint8_t i;
- if (timer_elapsed(last_timer) < RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL) {
- return;
- }
- last_timer = timer_read();
- current_offset = (current_offset + 1) % 2;
+
+ anim->current_offset = (anim->current_offset + 1) % 2;
for (i = 0; i < RGBLED_NUM; i++) {
- hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + current_offset) % 2) * 120;
+ hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + anim->current_offset) % 2) * 120;
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}
rgblight_set();
@@ -1015,52 +1158,39 @@ void rgblight_effect_christmas(void) {
__attribute__ ((weak))
const uint16_t RGBLED_RGBTEST_INTERVALS[] PROGMEM = {1024};
-void rgblight_effect_rgbtest(void) {
- static uint8_t pos = 0;
- static uint16_t last_timer = 0;
+void rgblight_effect_rgbtest(animation_status_t *anim) {
static uint8_t maxval = 0;
uint8_t g; uint8_t r; uint8_t b;
- if (timer_elapsed(last_timer) < pgm_read_word(&RGBLED_RGBTEST_INTERVALS[0])) {
- return;
- }
-
if( maxval == 0 ) {
LED_TYPE tmp_led;
sethsv(0, 255, RGBLIGHT_LIMIT_VAL, &tmp_led);
maxval = tmp_led.r;
}
- last_timer = timer_read();
g = r = b = 0;
- switch( pos ) {
+ switch( anim->pos ) {
case 0: r = maxval; break;
case 1: g = maxval; break;
case 2: b = maxval; break;
}
rgblight_setrgb(r, g, b);
- pos = (pos + 1) % 3;
+ anim->pos = (anim->pos + 1) % 3;
}
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
-void rgblight_effect_alternating(void){
- static uint16_t last_timer = 0;
- static uint16_t pos = 0;
- if (timer_elapsed(last_timer) < 500) {
- return;
- }
- last_timer = timer_read();
+void rgblight_effect_alternating(animation_status_t *anim) {
for(int i = 0; i<RGBLED_NUM; i++){
- if(i<RGBLED_NUM/2 && pos){
+ if(i<RGBLED_NUM/2 && anim->pos){
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
- }else if (i>=RGBLED_NUM/2 && !pos){
+ }else if (i>=RGBLED_NUM/2 && !anim->pos){
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}else{
sethsv(rgblight_config.hue, rgblight_config.sat, 0, (LED_TYPE *)&led[i]);
}
}
rgblight_set();
- pos = (pos + 1) % 2;
+ anim->pos = (anim->pos + 1) % 2;
}
#endif
diff --git a/quantum/rgblight.h b/quantum/rgblight.h
index 1769f719d9..748d009dcf 100644
--- a/quantum/rgblight.h
+++ b/quantum/rgblight.h
@@ -68,11 +68,11 @@
#define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
-#define _RGBM_TMP_STATIC(sym) RGBLIGHT_MODE_ ## sym,
-#define _RGBM_TMP_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
+#define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_ ## sym,
+#define _RGBM_TMP_DYNAMIC(sym, msym) RGBLIGHT_MODE_ ## sym,
enum RGBLIGHT_EFFECT_MODE {
RGBLIGHT_MODE_zero = 0,
-#include "rgblight.h"
+#include "rgblight_modes.h"
RGBLIGHT_MODE_last
};
@@ -163,6 +163,33 @@ typedef union {
};
} rgblight_config_t;
+typedef struct _rgblight_status_t {
+ uint8_t base_mode;
+ bool timer_enabled;
+#ifdef RGBLIGHT_SPLIT
+ uint8_t change_flags;
+#endif
+} rgblight_status_t;
+
+#ifdef RGBLIGHT_SPLIT
+ #define RGBLIGHT_STATUS_CHANGE_MODE (1<<0)
+ #define RGBLIGHT_STATUS_CHANGE_HSVS (1<<1)
+ #define RGBLIGHT_STATUS_CHANGE_TIMER (1<<2)
+ #define RGBLIGHT_STATUS_ANIMATION_TICK (1<<3)
+
+ typedef struct _rgblight_syncinfo_t {
+ rgblight_config_t config;
+ rgblight_status_t status;
+ } rgblight_syncinfo_t;
+
+ /* for split keyboard master side */
+ uint8_t rgblight_get_change_flags(void);
+ void rgblight_clear_change_flags(void);
+ void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo);
+ /* for split keyboard slave side */
+ void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom);
+#endif
+
void rgblight_init(void);
void rgblight_increase(void);
void rgblight_decrease(void);
@@ -237,82 +264,33 @@ void rgblight_timer_init(void);
void rgblight_timer_enable(void);
void rgblight_timer_disable(void);
void rgblight_timer_toggle(void);
-void rgblight_effect_breathing(uint8_t interval);
-void rgblight_effect_rainbow_mood(uint8_t interval);
-void rgblight_effect_rainbow_swirl(uint8_t interval);
-void rgblight_effect_snake(uint8_t interval);
-void rgblight_effect_knight(uint8_t interval);
-void rgblight_effect_christmas(void);
-void rgblight_effect_rgbtest(void);
-void rgblight_effect_alternating(void);
-#endif // #ifndef RGBLIGHT_H_DUMMY_DEFINE
-#endif // RGBLIGHT_H
+#ifdef RGBLIGHT_USE_TIMER
+
+typedef struct _animation_status_t {
+ uint16_t last_timer;
+ uint8_t delta; /* mode - base_mode */
+ bool restart;
+ union {
+ uint16_t pos16;
+ uint8_t pos;
+ int16_t current_hue;
+ uint16_t current_offset;
+ };
+} animation_status_t;
+
+extern animation_status_t animation_status;
+
+void rgblight_effect_breathing(animation_status_t *anim);
+void rgblight_effect_rainbow_mood(animation_status_t *anim);
+void rgblight_effect_rainbow_swirl(animation_status_t *anim);
+void rgblight_effect_snake(animation_status_t *anim);
+void rgblight_effect_knight(animation_status_t *anim);
+void rgblight_effect_christmas(animation_status_t *anim);
+void rgblight_effect_rgbtest(animation_status_t *anim);
+void rgblight_effect_alternating(animation_status_t *anim);
-#ifdef _RGBM_SINGLE_STATIC
- _RGBM_SINGLE_STATIC( STATIC_LIGHT )
- #ifdef RGBLIGHT_EFFECT_BREATHING
- _RGBM_MULTI_DYNAMIC( BREATHING )
- _RGBM_TMP_DYNAMIC( breathing_3 )
- _RGBM_TMP_DYNAMIC( breathing_4 )
- _RGBM_TMP_DYNAMIC( BREATHING_end )
- #endif
- #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
- _RGBM_MULTI_DYNAMIC( RAINBOW_MOOD )
- _RGBM_TMP_DYNAMIC( rainbow_mood_7 )
- _RGBM_TMP_DYNAMIC( RAINBOW_MOOD_end )
- #endif
- #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
- _RGBM_MULTI_DYNAMIC( RAINBOW_SWIRL )
- _RGBM_TMP_DYNAMIC( rainbow_swirl_10 )
- _RGBM_TMP_DYNAMIC( rainbow_swirl_11 )
- _RGBM_TMP_DYNAMIC( rainbow_swirl_12 )
- _RGBM_TMP_DYNAMIC( rainbow_swirl_13 )
- _RGBM_TMP_DYNAMIC( RAINBOW_SWIRL_end )
- #endif
- #ifdef RGBLIGHT_EFFECT_SNAKE
- _RGBM_MULTI_DYNAMIC( SNAKE )
- _RGBM_TMP_DYNAMIC( snake_16 )
- _RGBM_TMP_DYNAMIC( snake_17 )
- _RGBM_TMP_DYNAMIC( snake_18 )
- _RGBM_TMP_DYNAMIC( snake_19 )
- _RGBM_TMP_DYNAMIC( SNAKE_end )
- #endif
- #ifdef RGBLIGHT_EFFECT_KNIGHT
- _RGBM_MULTI_DYNAMIC( KNIGHT )
- _RGBM_TMP_DYNAMIC( knight_22 )
- _RGBM_TMP_DYNAMIC( KNIGHT_end )
- #endif
- #ifdef RGBLIGHT_EFFECT_CHRISTMAS
- _RGBM_SINGLE_DYNAMIC( CHRISTMAS )
- #endif
- #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
- _RGBM_MULTI_STATIC( STATIC_GRADIENT )
- _RGBM_TMP_STATIC( static_gradient_26 )
- _RGBM_TMP_STATIC( static_gradient_27 )
- _RGBM_TMP_STATIC( static_gradient_28 )
- _RGBM_TMP_STATIC( static_gradient_29 )
- _RGBM_TMP_STATIC( static_gradient_30 )
- _RGBM_TMP_STATIC( static_gradient_31 )
- _RGBM_TMP_STATIC( static_gradient_32 )
- _RGBM_TMP_STATIC( static_gradient_33 )
- _RGBM_TMP_STATIC( STATIC_GRADIENT_end )
- #endif
- #ifdef RGBLIGHT_EFFECT_RGB_TEST
- _RGBM_SINGLE_DYNAMIC( RGB_TEST )
- #endif
- #ifdef RGBLIGHT_EFFECT_ALTERNATING
- _RGBM_SINGLE_DYNAMIC( ALTERNATING )
- #endif
- //// Add a new mode here.
- // #ifdef RGBLIGHT_EFFECT_<name>
- // _RGBM_<SINGLE|MULTI>_<STATIC|DYNAMIC>( <name> )
- // #endif
#endif
-#undef _RGBM_SINGLE_STATIC
-#undef _RGBM_SINGLE_DYNAMIC
-#undef _RGBM_MULTI_STATIC
-#undef _RGBM_MULTI_DYNAMIC
-#undef _RGBM_TMP_STATIC
-#undef _RGBM_TMP_DYNAMIC
+#endif // #ifndef RGBLIGHT_H_DUMMY_DEFINE
+#endif // RGBLIGHT_H
diff --git a/quantum/rgblight_modes.h b/quantum/rgblight_modes.h
new file mode 100644
index 0000000000..8a8f9bdda9
--- /dev/null
+++ b/quantum/rgblight_modes.h
@@ -0,0 +1,67 @@
+#ifdef _RGBM_SINGLE_STATIC
+ _RGBM_SINGLE_STATIC( STATIC_LIGHT )
+ #ifdef RGBLIGHT_EFFECT_BREATHING
+ _RGBM_MULTI_DYNAMIC( BREATHING )
+ _RGBM_TMP_DYNAMIC( breathing_3, BREATHING )
+ _RGBM_TMP_DYNAMIC( breathing_4, BREATHING )
+ _RGBM_TMP_DYNAMIC( BREATHING_end, BREATHING )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
+ _RGBM_MULTI_DYNAMIC( RAINBOW_MOOD )
+ _RGBM_TMP_DYNAMIC( rainbow_mood_7, RAINBOW_MOOD )
+ _RGBM_TMP_DYNAMIC( RAINBOW_MOOD_end, RAINBOW_MOOD )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
+ _RGBM_MULTI_DYNAMIC( RAINBOW_SWIRL )
+ _RGBM_TMP_DYNAMIC( rainbow_swirl_10, RAINBOW_SWIRL )
+ _RGBM_TMP_DYNAMIC( rainbow_swirl_11, RAINBOW_SWIRL )
+ _RGBM_TMP_DYNAMIC( rainbow_swirl_12, RAINBOW_SWIRL )
+ _RGBM_TMP_DYNAMIC( rainbow_swirl_13, RAINBOW_SWIRL )
+ _RGBM_TMP_DYNAMIC( RAINBOW_SWIRL_end, RAINBOW_SWIRL )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_SNAKE
+ _RGBM_MULTI_DYNAMIC( SNAKE )
+ _RGBM_TMP_DYNAMIC( snake_16, SNAKE )
+ _RGBM_TMP_DYNAMIC( snake_17, SNAKE )
+ _RGBM_TMP_DYNAMIC( snake_18, SNAKE )
+ _RGBM_TMP_DYNAMIC( snake_19, SNAKE )
+ _RGBM_TMP_DYNAMIC( SNAKE_end, SNAKE )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_KNIGHT
+ _RGBM_MULTI_DYNAMIC( KNIGHT )
+ _RGBM_TMP_DYNAMIC( knight_22, KNIGHT )
+ _RGBM_TMP_DYNAMIC( KNIGHT_end, KNIGHT )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_CHRISTMAS
+ _RGBM_SINGLE_DYNAMIC( CHRISTMAS )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
+ _RGBM_MULTI_STATIC( STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_26, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_27, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_28, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_29, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_30, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_31, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_32, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( static_gradient_33, STATIC_GRADIENT )
+ _RGBM_TMP_STATIC( STATIC_GRADIENT_end, STATIC_GRADIENT )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_RGB_TEST
+ _RGBM_SINGLE_DYNAMIC( RGB_TEST )
+ #endif
+ #ifdef RGBLIGHT_EFFECT_ALTERNATING
+ _RGBM_SINGLE_DYNAMIC( ALTERNATING )
+ #endif
+ //// Add a new mode here.
+ // #ifdef RGBLIGHT_EFFECT_<name>
+ // _RGBM_<SINGLE|MULTI>_<STATIC|DYNAMIC>( <name> )
+ // #endif
+#endif
+
+#undef _RGBM_SINGLE_STATIC
+#undef _RGBM_SINGLE_DYNAMIC
+#undef _RGBM_MULTI_STATIC
+#undef _RGBM_MULTI_DYNAMIC
+#undef _RGBM_TMP_STATIC
+#undef _RGBM_TMP_DYNAMIC
diff --git a/quantum/rgblight_post_config.h b/quantum/rgblight_post_config.h
new file mode 100644
index 0000000000..048746c4b7
--- /dev/null
+++ b/quantum/rgblight_post_config.h
@@ -0,0 +1,5 @@
+#if defined(RGBLED_SPLIT) && !defined(RGBLIGHT_SPLIT)
+ // When RGBLED_SPLIT is defined,
+ // it is considered that RGBLIGHT_SPLIT is defined implicitly.
+ #define RGBLIGHT_SPLIT
+#endif
diff --git a/quantum/split_common/post_config.h b/quantum/split_common/post_config.h
new file mode 100644
index 0000000000..0e59df3d06
--- /dev/null
+++ b/quantum/split_common/post_config.h
@@ -0,0 +1,15 @@
+#if defined(USE_I2C) || defined(EH)
+ // When using I2C, using rgblight implicitly involves split support.
+ #if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_SPLIT)
+ #define RGBLIGHT_SPLIT
+ #endif
+
+#else // use serial
+ // When using serial, the user must define RGBLIGHT_SPLIT explicitly
+ // in config.h as needed.
+ // see quantum/rgblight_post_config.h
+ #if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ // When using serial and RGBLIGHT_SPLIT need separate transaction
+ #define SERIAL_USE_MULTI_TRANSACTION
+ #endif
+#endif
diff --git a/quantum/split_common/transport.c b/quantum/split_common/transport.c
index ab055ee656..7ea1a9cec9 100644
--- a/quantum/split_common/transport.c
+++ b/quantum/split_common/transport.c
@@ -25,36 +25,23 @@ extern backlight_config_t backlight_config;
# include "i2c_master.h"
# include "i2c_slave.h"
-typedef struct __attribute__ ((__packed__)) {
-#ifdef BACKLIGHT_ENABLE
- uint8_t backlight_level;
-#endif
-#ifdef RGBLIGHT_ENABLE
- uint32_t rgb_settings;
+typedef struct _I2C_slave_buffer_t {
+ matrix_row_t smatrix[ROWS_PER_HAND];
+ uint8_t backlight_level;
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ rgblight_syncinfo_t rgblight_sync;
#endif
#ifdef ENCODER_ENABLE
- uint8_t encoder_state[NUMBER_OF_ENCODERS];
-#endif
- // Keep matrix last, we are only using this for it's offset
- uint8_t matrix_start[0];
-} transport_values_t;
-
-__attribute__ ((unused))
-static transport_values_t transport_values;
-
-#ifdef BACKLIGHT_ENABLE
-# define I2C_BACKLIT_START (uint8_t)offsetof(transport_values_t, backlight_level)
-#endif
-
-#ifdef RGBLIGHT_ENABLE
-# define I2C_RGB_START (uint8_t)offsetof(transport_values_t, rgb_settings)
+ uint8_t encoder_state[NUMBER_OF_ENCODERS];
#endif
+} I2C_slave_buffer_t;
-#ifdef ENCODER_ENABLE
-# define I2C_ENCODER_START (uint8_t)offsetof(transport_values_t, encoder_state)
-#endif
+static I2C_slave_buffer_t * const i2c_buffer = (I2C_slave_buffer_t *)i2c_slave_reg;
-#define I2C_KEYMAP_START (uint8_t)offsetof(transport_values_t, matrix_start)
+# define I2C_BACKLIGHT_START offsetof(I2C_slave_buffer_t, backlight_level)
+# define I2C_RGB_START offsetof(I2C_slave_buffer_t, rgblight_sync)
+# define I2C_KEYMAP_START offsetof(I2C_slave_buffer_t, smatrix)
+# define I2C_ENCODER_START offsetof(I2C_slave_buffer_t, encoder_state)
# define TIMEOUT 100
@@ -64,30 +51,32 @@ static transport_values_t transport_values;
// Get rows from other half over i2c
bool transport_master(matrix_row_t matrix[]) {
- i2c_readReg(SLAVE_I2C_ADDRESS, I2C_KEYMAP_START, (void *)matrix, ROWS_PER_HAND * sizeof(matrix_row_t), TIMEOUT);
+ i2c_readReg(SLAVE_I2C_ADDRESS, I2C_KEYMAP_START, (void *)matrix, sizeof(i2c_buffer->smatrix), TIMEOUT);
// write backlight info
# ifdef BACKLIGHT_ENABLE
uint8_t level = get_backlight_level();
- if (level != transport_values.backlight_level) {
- if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_BACKLIT_START, (void *)&level, sizeof(level), TIMEOUT) >= 0) {
- transport_values.backlight_level = level;
+ if (level != i2c_buffer->backlight_level) {
+ if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_BACKLIGHT_START, (void *)&level, sizeof(level), TIMEOUT) >= 0) {
+ i2c_buffer->backlight_level = level;
}
}
# endif
-# ifdef RGBLIGHT_ENABLE
- uint32_t rgb = rgblight_read_dword();
- if (rgb != transport_values.rgb_settings) {
- if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_START, (void *)&rgb, sizeof(rgb), TIMEOUT) >= 0) {
- transport_values.rgb_settings = rgb;
+# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ if (rgblight_get_change_flags()) {
+ rgblight_syncinfo_t rgblight_sync;
+ rgblight_get_syncinfo(&rgblight_sync);
+ if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_START,
+ (void *)&rgblight_sync, sizeof(rgblight_sync), TIMEOUT) >= 0) {
+ rgblight_clear_change_flags();
}
}
# endif
# ifdef ENCODER_ENABLE
- i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)transport_values.encoder_state, sizeof(transport_values.encoder_state), TIMEOUT);
- encoder_update_raw(&transport_values.encoder_state[0]);
+ i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)i2c_buffer->encoder_state, sizeof(I2C_slave_buffer_t.encoder_state), TIMEOUT);
+ encoder_update_raw(i2c_buffer->encoder_state);
# endif
return true;
@@ -95,21 +84,23 @@ bool transport_master(matrix_row_t matrix[]) {
void transport_slave(matrix_row_t matrix[]) {
// Copy matrix to I2C buffer
- memcpy((void*)(i2c_slave_reg + I2C_KEYMAP_START), (void *)matrix, ROWS_PER_HAND * sizeof(matrix_row_t) );
+ memcpy((void*)i2c_buffer->smatrix, (void *)matrix, sizeof(i2c_buffer->smatrix));
// Read Backlight Info
# ifdef BACKLIGHT_ENABLE
- backlight_set(i2c_slave_reg[I2C_BACKLIT_START]);
+ backlight_set(i2c_buffer->backlight_level);
# endif
-# ifdef RGBLIGHT_ENABLE
- uint32_t rgb = *(uint32_t *)(i2c_slave_reg + I2C_RGB_START);
+# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
// Update the RGB with the new data
- rgblight_update_dword(rgb);
+ if (i2c_buffer->rgblight_sync.status.change_flags != 0) {
+ rgblight_update_sync(&i2c_buffer->rgblight_sync, false);
+ i2c_buffer->rgblight_sync.status.change_flags = 0;
+ }
# endif
# ifdef ENCODER_ENABLE
- encoder_state_raw((uint8_t*)(i2c_slave_reg + I2C_ENCODER_START));
+ encoder_state_raw(i2c_buffer->encoder_state);
# endif
}
@@ -121,53 +112,109 @@ void transport_slave_init(void) { i2c_slave_init(SLAVE_I2C_ADDRESS); }
# include "serial.h"
-typedef struct __attribute__ ((__packed__)) {
+typedef struct _Serial_s2m_buffer_t {
+ // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
+ matrix_row_t smatrix[ROWS_PER_HAND];
+
# ifdef ENCODER_ENABLE
uint8_t encoder_state[NUMBER_OF_ENCODERS];
# endif
- // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
- matrix_row_t smatrix[ROWS_PER_HAND];
+
} Serial_s2m_buffer_t;
-typedef struct __attribute__ ((__packed__)) {
+typedef struct _Serial_m2s_buffer_t {
# ifdef BACKLIGHT_ENABLE
uint8_t backlight_level;
# endif
-# if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
- rgblight_config_t rgblight_config; // not yet use
- //
- // When MCUs on both sides drive their respective RGB LED chains,
- // it is necessary to synchronize, so it is necessary to communicate RGB
- // information. In that case, define RGBLED_SPLIT with info on the number
- // of LEDs on each half.
- //
- // Otherwise, if the master side MCU drives both sides RGB LED chains,
- // there is no need to communicate.
-# endif
} Serial_m2s_buffer_t;
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+// When MCUs on both sides drive their respective RGB LED chains,
+// it is necessary to synchronize, so it is necessary to communicate RGB
+// information. In that case, define RGBLIGHT_SPLIT with info on the number
+// of LEDs on each half.
+//
+// Otherwise, if the master side MCU drives both sides RGB LED chains,
+// there is no need to communicate.
+
+typedef struct _Serial_rgblight_t {
+ rgblight_syncinfo_t rgblight_sync;
+} Serial_rgblight_t;
+
+volatile Serial_rgblight_t serial_rgblight = {};
+uint8_t volatile status_rgblight = 0;
+#endif
+
volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
uint8_t volatile status0 = 0;
+enum serial_transaction_id {
+ GET_SLAVE_MATRIX = 0,
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ PUT_RGBLIGHT,
+#endif
+};
+
SSTD_t transactions[] = {
- {
+ [GET_SLAVE_MATRIX] = {
(uint8_t *)&status0,
sizeof(serial_m2s_buffer),
(uint8_t *)&serial_m2s_buffer,
sizeof(serial_s2m_buffer),
(uint8_t *)&serial_s2m_buffer,
},
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ [PUT_RGBLIGHT] = {
+ (uint8_t *)&status_rgblight,
+ sizeof(serial_rgblight),
+ (uint8_t *)&serial_rgblight,
+ 0, NULL // no slave to master transfer
+ },
+#endif
};
void transport_master_init(void) { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
void transport_slave_init(void) { soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+
+// rgblight synchronization information communication.
+
+void transport_rgblight_master(void) {
+ if (rgblight_get_change_flags()) {
+ rgblight_get_syncinfo((rgblight_syncinfo_t *)&serial_rgblight.rgblight_sync);
+ if (soft_serial_transaction(PUT_RGBLIGHT) == TRANSACTION_END) {
+ rgblight_clear_change_flags();
+ }
+ }
+}
+
+void transport_rgblight_slave(void) {
+ if (status_rgblight == TRANSACTION_ACCEPTED) {
+ rgblight_update_sync((rgblight_syncinfo_t *)&serial_rgblight.rgblight_sync,
+ false);
+ status_rgblight = TRANSACTION_END;
+ }
+}
+
+#else
+#define transport_rgblight_master()
+#define transport_rgblight_slave()
+#endif
+
bool transport_master(matrix_row_t matrix[]) {
- if (soft_serial_transaction()) {
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+ if (soft_serial_transaction() != TRANSACTION_END) {
return false;
}
+#else
+ transport_rgblight_master();
+ if (soft_serial_transaction(GET_SLAVE_MATRIX) != TRANSACTION_END) {
+ return false;
+ }
+#endif
// TODO: if MATRIX_COLS > 8 change to unpack()
for (int i = 0; i < ROWS_PER_HAND; ++i) {
@@ -179,23 +226,15 @@ bool transport_master(matrix_row_t matrix[]) {
serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
# endif
-# if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
- static rgblight_config_t prev_rgb = {~0};
- uint32_t rgb = rgblight_read_dword();
- if (rgb != prev_rgb.raw) {
- serial_m2s_buffer.rgblight_config.raw = rgb;
- prev_rgb.raw = rgb;
- }
-# endif
-
# ifdef ENCODER_ENABLE
- encoder_update_raw((uint8_t*)&serial_s2m_buffer.encoder_state);
+ encoder_update_raw((uint8_t *)serial_s2m_buffer.encoder_state);
# endif
return true;
}
void transport_slave(matrix_row_t matrix[]) {
+ transport_rgblight_slave();
// TODO: if MATRIX_COLS > 8 change to pack()
for (int i = 0; i < ROWS_PER_HAND; ++i) {
serial_s2m_buffer.smatrix[i] = matrix[i];
@@ -203,14 +242,11 @@ void transport_slave(matrix_row_t matrix[]) {
# ifdef BACKLIGHT_ENABLE
backlight_set(serial_m2s_buffer.backlight_level);
# endif
-# if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
- // Update RGB config with the new data
- rgblight_update_dword(serial_m2s_buffer.rgblight_config.raw);
-# endif
# ifdef ENCODER_ENABLE
- encoder_state_raw((uint8_t*)&serial_s2m_buffer.encoder_state);
+ encoder_state_raw((uint8_t *)serial_s2m_buffer.encoder_state);
# endif
+
}
#endif