drashna/qmk_firmware
1
0
Fork 0
Code Activity

[MERGE][Core] Add dirty chunk checking for all RGB and LED drivers (24872)

Browse source
This commit is contained in:
Drashna Jael're 2025-01-26 04:52:39 -08:00
parent 0324612c37
commit 4a138dd93c
Signed by: drashna
GPG key ID: DBA1FD3A860D1B11
28 changed files with 690 additions and 286 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
drivers/led/apa102.c
View file

@ -55,6 +55,7 @@
rgb_t apa102_leds[APA102_LED_COUNT]; rgb_t apa102_leds[APA102_LED_COUNT];
uint8_t apa102_led_brightness = APA102_DEFAULT_BRIGHTNESS; uint8_t apa102_led_brightness = APA102_DEFAULT_BRIGHTNESS;
bool apa102_dirty = false;
static void apa102_send_byte(uint8_t byte) { static void apa102_send_byte(uint8_t byte) {
APA102_SEND_BIT(byte, 7); APA102_SEND_BIT(byte, 7);
@ -126,6 +127,7 @@ void apa102_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
apa102_leds[index].r = red; apa102_leds[index].r = red;
apa102_leds[index].g = green; apa102_leds[index].g = green;
apa102_leds[index].b = blue; apa102_leds[index].b = blue;
apa102_dirty = true;
} }
void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
@ -135,6 +137,7 @@ void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
} }
void apa102_flush(void) { void apa102_flush(void) {
if (!apa102_dirty) return;
apa102_start_frame(); apa102_start_frame();
for (uint8_t i = 0; i < APA102_LED_COUNT; i++) { for (uint8_t i = 0; i < APA102_LED_COUNT; i++) {
apa102_send_frame(apa102_leds[i].r, apa102_leds[i].g, apa102_leds[i].b, apa102_led_brightness); apa102_send_frame(apa102_leds[i].r, apa102_leds[i].g, apa102_leds[i].b, apa102_led_brightness);

32
drivers/led/issi/is31fl3729-mono.c
View file

@ -64,6 +64,9 @@
# define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ # define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ
#endif #endif
#define IS31FL3729_PWM_REGISTERS_PER_CHUNK 13
#define IS31FL3729_CHUNK_COUNT (IS31FL3729_PWM_REGISTER_COUNT / IS31FL3729_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = {
IS31FL3729_I2C_ADDRESS_1, IS31FL3729_I2C_ADDRESS_1,
#ifdef IS31FL3729_I2C_ADDRESS_2 #ifdef IS31FL3729_I2C_ADDRESS_2
@ -81,14 +84,14 @@ const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = {
// Storing them like this is optimal for I2C transfers to the registers. // Storing them like this is optimal for I2C transfers to the registers.
typedef struct is31fl3729_driver_t { typedef struct is31fl3729_driver_t {
uint8_t pwm_buffer[IS31FL3729_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3729_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3729_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3729_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3729_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3729_driver_t; } PACKED is31fl3729_driver_t;
is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{ is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -107,13 +110,21 @@ void is31fl3729_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 11 transfers of 13 bytes. // Transmit PWM registers in 11 transfers of 13 bytes.
// Iterate over the pwm_buffer contents at 13 byte intervals. // Iterate over the pwm_buffer contents at 13 byte intervals.
for (uint8_t i = 0; i <= IS31FL3729_PWM_REGISTER_COUNT; i += 13) { for (uint8_t i = 0; i <= IS31FL3729_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3729_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3729_I2C_PERSISTENCE > 0 #if IS31FL3729_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -165,7 +176,7 @@ void is31fl3729_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -189,10 +200,13 @@ void is31fl3729_set_scaling_register(uint8_t index, uint8_t value) {
} }
void is31fl3729_update_pwm_buffers(uint8_t index) { void is31fl3729_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3729_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3729_write_pwm_buffer(index); is31fl3729_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

35
drivers/led/issi/is31fl3729.c
View file

@ -64,6 +64,9 @@
# define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ # define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ
#endif #endif
#define IS31FL3729_PWM_REGISTERS_PER_CHUNK 13
#define IS31FL3729_CHUNK_COUNT (IS31FL3729_PWM_REGISTER_COUNT / IS31FL3729_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = {
IS31FL3729_I2C_ADDRESS_1, IS31FL3729_I2C_ADDRESS_1,
#ifdef IS31FL3729_I2C_ADDRESS_2 #ifdef IS31FL3729_I2C_ADDRESS_2
@ -81,14 +84,14 @@ const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = {
// Storing them like this is optimal for I2C transfers to the registers. // Storing them like this is optimal for I2C transfers to the registers.
typedef struct is31fl3729_driver_t { typedef struct is31fl3729_driver_t {
uint8_t pwm_buffer[IS31FL3729_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3729_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3729_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3729_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3729_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3729_driver_t; } PACKED is31fl3729_driver_t;
is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{ is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -107,13 +110,21 @@ void is31fl3729_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 11 transfers of 13 bytes. // Transmit PWM registers in 11 transfers of 13 bytes.
// Iterate over the pwm_buffer contents at 13 byte intervals. // Iterate over the pwm_buffer contents at 13 byte intervals.
for (uint8_t i = 0; i <= IS31FL3729_PWM_REGISTER_COUNT; i += 13) { for (uint8_t i = 0; i <= IS31FL3729_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3729_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3729_I2C_PERSISTENCE > 0 #if IS31FL3729_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -167,7 +178,10 @@ void is31fl3729_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -195,10 +209,13 @@ void is31fl3729_set_scaling_register(uint8_t index, uint8_t red, uint8_t green,
} }
void is31fl3729_update_pwm_buffers(uint8_t index) { void is31fl3729_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3729_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3729_write_pwm_buffer(index); is31fl3729_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

32
drivers/led/issi/is31fl3731-mono.c
View file

@ -33,6 +33,9 @@
# define IS31FL3731_I2C_PERSISTENCE 0 # define IS31FL3731_I2C_PERSISTENCE 0
#endif #endif
#define IS31FL3731_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3731_CHUNK_COUNT (IS31FL3731_PWM_REGISTER_COUNT / IS31FL3731_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = {
IS31FL3731_I2C_ADDRESS_1, IS31FL3731_I2C_ADDRESS_1,
#ifdef IS31FL3731_I2C_ADDRESS_2 #ifdef IS31FL3731_I2C_ADDRESS_2
@ -53,14 +56,14 @@ const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3731_driver_t { typedef struct is31fl3731_driver_t {
uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3731_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3731_driver_t; } PACKED is31fl3731_driver_t;
is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{ is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -84,13 +87,21 @@ void is31fl3731_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 9 transfers of 16 bytes. // Transmit PWM registers in 9 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3731_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3731_PWM_REGISTER_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3731_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3731_I2C_PERSISTENCE > 0 #if IS31FL3731_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -179,7 +190,7 @@ void is31fl3731_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -206,10 +217,13 @@ void is31fl3731_set_led_control_register(uint8_t index, bool value) {
} }
void is31fl3731_update_pwm_buffers(uint8_t index) { void is31fl3731_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3731_write_pwm_buffer(index); is31fl3731_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

36
drivers/led/issi/is31fl3731.c
View file

@ -32,6 +32,9 @@
# define IS31FL3731_I2C_PERSISTENCE 0 # define IS31FL3731_I2C_PERSISTENCE 0
#endif #endif
#define IS31FL3731_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3731_CHUNK_COUNT (IS31FL3731_PWM_REGISTER_COUNT / IS31FL3731_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = {
IS31FL3731_I2C_ADDRESS_1, IS31FL3731_I2C_ADDRESS_1,
#ifdef IS31FL3731_I2C_ADDRESS_2 #ifdef IS31FL3731_I2C_ADDRESS_2
@ -52,14 +55,14 @@ const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3731_driver_t { typedef struct is31fl3731_driver_t {
uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3731_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3731_driver_t; } PACKED is31fl3731_driver_t;
is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{ is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -83,13 +86,21 @@ void is31fl3731_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 9 transfers of 16 bytes. // Transmit PWM registers in 9 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3731_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3731_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3731_I2C_PERSISTENCE > 0 #if IS31FL3731_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -180,7 +191,11 @@ void is31fl3731_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true;
// update the dirty bitfield for the PWM registers
driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -221,10 +236,13 @@ void is31fl3731_set_led_control_register(uint8_t index, bool red, bool green, bo
} }
void is31fl3731_update_pwm_buffers(uint8_t index) { void is31fl3731_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3731_write_pwm_buffer(index); is31fl3731_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

33
drivers/led/issi/is31fl3733-mono.c
View file

@ -63,6 +63,9 @@
# define IS31FL3733_SYNC_4 IS31FL3733_SYNC_NONE # define IS31FL3733_SYNC_4 IS31FL3733_SYNC_NONE
#endif #endif
#define IS31FL3733_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3733_CHUNK_COUNT (IS31FL3733_PWM_REGISTER_COUNT / IS31FL3733_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = {
IS31FL3733_I2C_ADDRESS_1, IS31FL3733_I2C_ADDRESS_1,
#ifdef IS31FL3733_I2C_ADDRESS_2 #ifdef IS31FL3733_I2C_ADDRESS_2
@ -97,14 +100,14 @@ const uint8_t driver_sync[IS31FL3733_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3733_driver_t { typedef struct is31fl3733_driver_t {
uint8_t pwm_buffer[IS31FL3733_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3733_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3733_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3733_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3733_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3733_driver_t; } PACKED is31fl3733_driver_t;
is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{ is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -129,13 +132,21 @@ void is31fl3733_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3733_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3733_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3733_I2C_PERSISTENCE > 0 #if IS31FL3733_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3733_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3733_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -210,7 +221,7 @@ void is31fl3733_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -237,12 +248,14 @@ void is31fl3733_set_led_control_register(uint8_t index, bool value) {
} }
void is31fl3733_update_pwm_buffers(uint8_t index) { void is31fl3733_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM); is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM);
is31fl3733_write_pwm_buffer(index); is31fl3733_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

37
drivers/led/issi/is31fl3733.c
View file

@ -62,6 +62,9 @@
# define IS31FL3733_SYNC_4 IS31FL3733_SYNC_NONE # define IS31FL3733_SYNC_4 IS31FL3733_SYNC_NONE
#endif #endif
#define IS31FL3733_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3733_CHUNK_COUNT (IS31FL3733_PWM_REGISTER_COUNT / IS31FL3733_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = {
IS31FL3733_I2C_ADDRESS_1, IS31FL3733_I2C_ADDRESS_1,
#ifdef IS31FL3733_I2C_ADDRESS_2 #ifdef IS31FL3733_I2C_ADDRESS_2
@ -96,16 +99,17 @@ const uint8_t driver_sync[IS31FL3733_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3733_driver_t { typedef struct is31fl3733_driver_t {
uint8_t pwm_buffer[IS31FL3733_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3733_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3733_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3733_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3733_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3733_driver_t; } PACKED is31fl3733_driver_t;
is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{ is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
.led_control_bitfield = {0},
}}; }};
void is31fl3733_write_register(uint8_t index, uint8_t reg, uint8_t data) { void is31fl3733_write_register(uint8_t index, uint8_t reg, uint8_t data) {
@ -128,13 +132,21 @@ void is31fl3733_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3733_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3733_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3733_I2C_PERSISTENCE > 0 #if IS31FL3733_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3733_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3733_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -211,7 +223,10 @@ void is31fl3733_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -252,12 +267,14 @@ void is31fl3733_set_led_control_register(uint8_t index, bool red, bool green, bo
} }
void is31fl3733_update_pwm_buffers(uint8_t index) { void is31fl3733_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM); is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM);
is31fl3733_write_pwm_buffer(index); is31fl3733_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

33
drivers/led/issi/is31fl3736-mono.c
View file

@ -47,6 +47,9 @@
# define IS31FL3736_GLOBAL_CURRENT 0xFF # define IS31FL3736_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3736_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3736_CHUNK_COUNT (IS31FL3736_PWM_REGISTER_COUNT / IS31FL3736_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = {
IS31FL3736_I2C_ADDRESS_1, IS31FL3736_I2C_ADDRESS_1,
#ifdef IS31FL3736_I2C_ADDRESS_2 #ifdef IS31FL3736_I2C_ADDRESS_2
@ -68,14 +71,14 @@ const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3736_driver_t { typedef struct is31fl3736_driver_t {
uint8_t pwm_buffer[IS31FL3736_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3736_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3736_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3736_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3736_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3736_driver_t; } PACKED is31fl3736_driver_t;
is31fl3736_driver_t driver_buffers[IS31FL3736_DRIVER_COUNT] = {{ is31fl3736_driver_t driver_buffers[IS31FL3736_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -100,13 +103,21 @@ void is31fl3736_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3736_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3736_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3736_I2C_PERSISTENCE > 0 #if IS31FL3736_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3736_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3736_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -179,7 +190,7 @@ void is31fl3736_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -212,12 +223,14 @@ void is31fl3736_set_led_control_register(uint8_t index, bool value) {
} }
void is31fl3736_update_pwm_buffers(uint8_t index) { void is31fl3736_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM); is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM);
is31fl3736_write_pwm_buffer(index); is31fl3736_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

35
drivers/led/issi/is31fl3736.c
View file

@ -47,6 +47,9 @@
# define IS31FL3736_GLOBAL_CURRENT 0xFF # define IS31FL3736_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3736_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3736_CHUNK_COUNT (IS31FL3736_PWM_REGISTER_COUNT / IS31FL3736_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = {
IS31FL3736_I2C_ADDRESS_1, IS31FL3736_I2C_ADDRESS_1,
#ifdef IS31FL3736_I2C_ADDRESS_2 #ifdef IS31FL3736_I2C_ADDRESS_2
@ -68,14 +71,14 @@ const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3736_driver_t { typedef struct is31fl3736_driver_t {
uint8_t pwm_buffer[IS31FL3736_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3736_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3736_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3736_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3736_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3736_driver_t; } PACKED is31fl3736_driver_t;
is31fl3736_driver_t driver_buffers[IS31FL3736_DRIVER_COUNT] = {{ is31fl3736_driver_t driver_buffers[IS31FL3736_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -100,13 +103,21 @@ void is31fl3736_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3736_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3736_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3736_I2C_PERSISTENCE > 0 #if IS31FL3736_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3736_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3736_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -181,7 +192,9 @@ void is31fl3736_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -229,12 +242,14 @@ void is31fl3736_set_led_control_register(uint8_t index, bool red, bool green, bo
} }
void is31fl3736_update_pwm_buffers(uint8_t index) { void is31fl3736_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM); is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM);
is31fl3736_write_pwm_buffer(index); is31fl3736_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

31
drivers/led/issi/is31fl3737-mono.c
View file

@ -49,6 +49,9 @@
# define IS31FL3737_GLOBAL_CURRENT 0xFF # define IS31FL3737_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3737_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3737_CHUNK_COUNT (IS31FL3737_PWM_REGISTER_COUNT / IS31FL3737_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = {
IS31FL3737_I2C_ADDRESS_1, IS31FL3737_I2C_ADDRESS_1,
#ifdef IS31FL3737_I2C_ADDRESS_2 #ifdef IS31FL3737_I2C_ADDRESS_2
@ -70,7 +73,7 @@ const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3737_driver_t { typedef struct is31fl3737_driver_t {
uint8_t pwm_buffer[IS31FL3737_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3737_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3737_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3737_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3737_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3737_driver_t; } PACKED is31fl3737_driver_t;
@ -102,13 +105,21 @@ void is31fl3737_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3737_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i += 16) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3737_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3737_I2C_PERSISTENCE > 0 #if IS31FL3737_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3737_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3737_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -181,7 +192,7 @@ void is31fl3737_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -208,12 +219,14 @@ void is31fl3737_set_led_control_register(uint8_t index, bool value) {
} }
void is31fl3737_update_pwm_buffers(uint8_t index) { void is31fl3737_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM); is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM);
is31fl3737_write_pwm_buffer(index); is31fl3737_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

36
drivers/led/issi/is31fl3737.c
View file

@ -49,6 +49,9 @@
# define IS31FL3737_GLOBAL_CURRENT 0xFF # define IS31FL3737_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3737_PWM_REGISTERS_PER_CHUNK 16
#define IS31FL3737_CHUNK_COUNT (IS31FL3737_PWM_REGISTER_COUNT / IS31FL3737_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = {
IS31FL3737_I2C_ADDRESS_1, IS31FL3737_I2C_ADDRESS_1,
#ifdef IS31FL3737_I2C_ADDRESS_2 #ifdef IS31FL3737_I2C_ADDRESS_2
@ -70,14 +73,14 @@ const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct is31fl3737_driver_t { typedef struct is31fl3737_driver_t {
uint8_t pwm_buffer[IS31FL3737_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3737_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3737_CHUNK_COUNT];
uint8_t led_control_buffer[IS31FL3737_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[IS31FL3737_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED is31fl3737_driver_t; } PACKED is31fl3737_driver_t;
is31fl3737_driver_t driver_buffers[IS31FL3737_DRIVER_COUNT] = {{ is31fl3737_driver_t driver_buffers[IS31FL3737_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -102,13 +105,21 @@ void is31fl3737_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < IS31FL3737_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i += 16) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3737_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3737_I2C_PERSISTENCE > 0 #if IS31FL3737_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3737_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3737_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -183,7 +194,10 @@ void is31fl3737_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -224,12 +238,14 @@ void is31fl3737_set_led_control_register(uint8_t index, bool red, bool green, bo
} }
void is31fl3737_update_pwm_buffers(uint8_t index) { void is31fl3737_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM); is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM);
is31fl3737_write_pwm_buffer(index); is31fl3737_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

63
drivers/led/issi/is31fl3741-mono.c
View file

@ -55,6 +55,11 @@
# define IS31FL3741_GLOBAL_CURRENT 0xFF # define IS31FL3741_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3741_PWM_0_REGISTERS_PER_CHUNK 30
#define IS31FL3741_PWM_1_REGISTERS_PER_CHUNK 19
#define IS31FL3741_PAGE_0_CHUNK_COUNT (IS31FL3741_PWM_0_REGISTER_COUNT / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK)
#define IS31FL3741_PAGE_1_CHUNK_COUNT (IS31FL3741_PWM_1_REGISTER_COUNT / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = {
IS31FL3741_I2C_ADDRESS_1, IS31FL3741_I2C_ADDRESS_1,
#ifdef IS31FL3741_I2C_ADDRESS_2 #ifdef IS31FL3741_I2C_ADDRESS_2
@ -77,19 +82,21 @@ const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = {
typedef struct is31fl3741_driver_t { typedef struct is31fl3741_driver_t {
uint8_t pwm_buffer_0[IS31FL3741_PWM_0_REGISTER_COUNT]; uint8_t pwm_buffer_0[IS31FL3741_PWM_0_REGISTER_COUNT];
uint8_t pwm_buffer_1[IS31FL3741_PWM_1_REGISTER_COUNT]; uint8_t pwm_buffer_1[IS31FL3741_PWM_1_REGISTER_COUNT];
bool pwm_buffer_dirty;
uint8_t scaling_buffer_0[IS31FL3741_SCALING_0_REGISTER_COUNT]; uint8_t scaling_buffer_0[IS31FL3741_SCALING_0_REGISTER_COUNT];
uint8_t scaling_buffer_1[IS31FL3741_SCALING_1_REGISTER_COUNT]; uint8_t scaling_buffer_1[IS31FL3741_SCALING_1_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
bool pwm_buffer_0_dirty[IS31FL3741_PAGE_0_CHUNK_COUNT];
bool pwm_buffer_1_dirty[IS31FL3741_PAGE_1_CHUNK_COUNT];
} PACKED is31fl3741_driver_t; } PACKED is31fl3741_driver_t;
is31fl3741_driver_t driver_buffers[IS31FL3741_DRIVER_COUNT] = {{ is31fl3741_driver_t driver_buffers[IS31FL3741_DRIVER_COUNT] = {{
.pwm_buffer_0 = {0}, .pwm_buffer_0 = {0},
.pwm_buffer_1 = {0}, .pwm_buffer_1 = {0},
.pwm_buffer_dirty = false,
.scaling_buffer_0 = {0}, .scaling_buffer_0 = {0},
.scaling_buffer_1 = {0}, .scaling_buffer_1 = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
.pwm_buffer_0_dirty = {0},
.pwm_buffer_1_dirty = {0},
}}; }};
void is31fl3741_write_register(uint8_t index, uint8_t reg, uint8_t data) { void is31fl3741_write_register(uint8_t index, uint8_t reg, uint8_t data) {
@ -113,13 +120,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) {
// Transmit PWM0 registers in 6 transfers of 30 bytes. // Transmit PWM0 registers in 6 transfers of 30 bytes.
// Iterate over the pwm_buffer_0 contents at 30 byte intervals. // Iterate over the pwm_buffer_0 contents at 30 byte intervals.
for (uint8_t i = 0; i < IS31FL3741_PWM_0_REGISTER_COUNT; i += 30) { for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_0_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_0_dirty[i] = false;
uint8_t offset = i * IS31FL3741_PWM_0_REGISTERS_PER_CHUNK;
#if IS31FL3741_I2C_PERSISTENCE > 0 #if IS31FL3741_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3741_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3741_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT);
#endif #endif
} }
@ -128,13 +143,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) {
// Transmit PWM1 registers in 9 transfers of 19 bytes. // Transmit PWM1 registers in 9 transfers of 19 bytes.
// Iterate over the pwm_buffer_1 contents at 19 byte intervals. // Iterate over the pwm_buffer_1 contents at 19 byte intervals.
for (uint8_t i = 0; i < IS31FL3741_PWM_1_REGISTER_COUNT; i += 19) { for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_1_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_1_dirty[i] = false;
uint8_t offset = i * IS31FL3741_PWM_1_REGISTERS_PER_CHUNK;
#if IS31FL3741_I2C_PERSISTENCE > 0 #if IS31FL3741_I2C_PERSISTENCE > 0
for (uint8_t i = 0; i < IS31FL3741_I2C_PERSISTENCE; i++) { for (uint8_t i = 0; i < IS31FL3741_I2C_PERSISTENCE; i++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -201,6 +224,14 @@ void set_pwm_value(uint8_t driver, uint16_t reg, uint8_t value) {
} }
} }
void dirty_bitfield_set(uint8_t driver, uint16_t reg) {
if (reg & 0x100) {
driver_buffers[driver].pwm_buffer_1_dirty[(reg & 0xFF) / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK] = true;
} else {
driver_buffers[driver].pwm_buffer_0_dirty[reg / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK] = true;
}
}
void is31fl3741_set_value(int index, uint8_t value) { void is31fl3741_set_value(int index, uint8_t value) {
is31fl3741_led_t led; is31fl3741_led_t led;
@ -212,7 +243,7 @@ void is31fl3741_set_value(int index, uint8_t value) {
} }
set_pwm_value(led.driver, led.v, value); set_pwm_value(led.driver, led.v, value);
driver_buffers[led.driver].pwm_buffer_dirty = true; dirty_bitfield_set(led.driver, led.v);
} }
} }
@ -240,10 +271,20 @@ void is31fl3741_set_led_control_register(uint8_t index, bool value) {
} }
void is31fl3741_update_pwm_buffers(uint8_t index) { void is31fl3741_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { // Check if any of the PWM buffers are dirty.
for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_0_dirty[i]) {
is31fl3741_write_pwm_buffer(index); is31fl3741_write_pwm_buffer(index);
// return since we update both pages at the same time
return;
}
}
driver_buffers[index].pwm_buffer_dirty = false; for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_1_dirty[i]) {
is31fl3741_write_pwm_buffer(index);
return;
}
} }
} }

71
drivers/led/issi/is31fl3741.c
View file

@ -55,6 +55,11 @@
# define IS31FL3741_GLOBAL_CURRENT 0xFF # define IS31FL3741_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3741_PWM_0_REGISTERS_PER_CHUNK 30
#define IS31FL3741_PWM_1_REGISTERS_PER_CHUNK 19
#define IS31FL3741_PAGE_0_CHUNK_COUNT (IS31FL3741_PWM_0_REGISTER_COUNT / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK)
#define IS31FL3741_PAGE_1_CHUNK_COUNT (IS31FL3741_PWM_1_REGISTER_COUNT / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = {
IS31FL3741_I2C_ADDRESS_1, IS31FL3741_I2C_ADDRESS_1,
#ifdef IS31FL3741_I2C_ADDRESS_2 #ifdef IS31FL3741_I2C_ADDRESS_2
@ -77,19 +82,21 @@ const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = {
typedef struct is31fl3741_driver_t { typedef struct is31fl3741_driver_t {
uint8_t pwm_buffer_0[IS31FL3741_PWM_0_REGISTER_COUNT]; uint8_t pwm_buffer_0[IS31FL3741_PWM_0_REGISTER_COUNT];
uint8_t pwm_buffer_1[IS31FL3741_PWM_1_REGISTER_COUNT]; uint8_t pwm_buffer_1[IS31FL3741_PWM_1_REGISTER_COUNT];
bool pwm_buffer_dirty;
uint8_t scaling_buffer_0[IS31FL3741_SCALING_0_REGISTER_COUNT]; uint8_t scaling_buffer_0[IS31FL3741_SCALING_0_REGISTER_COUNT];
uint8_t scaling_buffer_1[IS31FL3741_SCALING_1_REGISTER_COUNT]; uint8_t scaling_buffer_1[IS31FL3741_SCALING_1_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
bool pwm_buffer_0_dirty[IS31FL3741_PAGE_0_CHUNK_COUNT];
bool pwm_buffer_1_dirty[IS31FL3741_PAGE_1_CHUNK_COUNT];
} PACKED is31fl3741_driver_t; } PACKED is31fl3741_driver_t;
is31fl3741_driver_t driver_buffers[IS31FL3741_DRIVER_COUNT] = {{ is31fl3741_driver_t driver_buffers[IS31FL3741_DRIVER_COUNT] = {{
.pwm_buffer_0 = {0}, .pwm_buffer_0 = {0},
.pwm_buffer_1 = {0}, .pwm_buffer_1 = {0},
.pwm_buffer_dirty = false,
.scaling_buffer_0 = {0}, .scaling_buffer_0 = {0},
.scaling_buffer_1 = {0}, .scaling_buffer_1 = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
.pwm_buffer_0_dirty = {0},
.pwm_buffer_1_dirty = {0},
}}; }};
void is31fl3741_write_register(uint8_t index, uint8_t reg, uint8_t data) { void is31fl3741_write_register(uint8_t index, uint8_t reg, uint8_t data) {
@ -113,13 +120,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) {
// Transmit PWM0 registers in 6 transfers of 30 bytes. // Transmit PWM0 registers in 6 transfers of 30 bytes.
// Iterate over the pwm_buffer_0 contents at 30 byte intervals. // Iterate over the pwm_buffer_0 contents at 30 byte intervals.
for (uint8_t i = 0; i < IS31FL3741_PWM_0_REGISTER_COUNT; i += 30) { for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_0_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_0_dirty[i] = false;
uint8_t offset = i * IS31FL3741_PWM_0_REGISTERS_PER_CHUNK;
#if IS31FL3741_I2C_PERSISTENCE > 0 #if IS31FL3741_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3741_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3741_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT);
#endif #endif
} }
@ -128,13 +143,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) {
// Transmit PWM1 registers in 9 transfers of 19 bytes. // Transmit PWM1 registers in 9 transfers of 19 bytes.
// Iterate over the pwm_buffer_1 contents at 19 byte intervals. // Iterate over the pwm_buffer_1 contents at 19 byte intervals.
for (uint8_t i = 0; i < IS31FL3741_PWM_1_REGISTER_COUNT; i += 19) { for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_1_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_1_dirty[i] = false;
uint8_t offset = i * IS31FL3741_PWM_1_REGISTERS_PER_CHUNK;
#if IS31FL3741_I2C_PERSISTENCE > 0 #if IS31FL3741_I2C_PERSISTENCE > 0
for (uint8_t i = 0; i < IS31FL3741_I2C_PERSISTENCE; i++) { for (uint8_t i = 0; i < IS31FL3741_I2C_PERSISTENCE; i++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -201,6 +224,14 @@ void set_pwm_value(uint8_t driver, uint16_t reg, uint8_t value) {
} }
} }
void dirty_bitfield_set(uint8_t driver, uint16_t reg) {
if (reg & 0x100) {
driver_buffers[driver].pwm_buffer_1_dirty[(reg & 0xFF) / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK] = true;
} else {
driver_buffers[driver].pwm_buffer_0_dirty[reg / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK] = true;
}
}
void is31fl3741_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { void is31fl3741_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
is31fl3741_led_t led; is31fl3741_led_t led;
@ -214,7 +245,10 @@ void is31fl3741_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
set_pwm_value(led.driver, led.r, red); set_pwm_value(led.driver, led.r, red);
set_pwm_value(led.driver, led.g, green); set_pwm_value(led.driver, led.g, green);
set_pwm_value(led.driver, led.b, blue); set_pwm_value(led.driver, led.b, blue);
driver_buffers[led.driver].pwm_buffer_dirty = true;
dirty_bitfield_set(led.driver, led.r);
dirty_bitfield_set(led.driver, led.g);
dirty_bitfield_set(led.driver, led.b);
} }
} }
@ -244,10 +278,20 @@ void is31fl3741_set_led_control_register(uint8_t index, bool red, bool green, bo
} }
void is31fl3741_update_pwm_buffers(uint8_t index) { void is31fl3741_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { // Check if any of the PWM buffers are dirty.
for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_0_dirty[i]) {
is31fl3741_write_pwm_buffer(index); is31fl3741_write_pwm_buffer(index);
// return since we update both pages at the same time
return;
}
}
driver_buffers[index].pwm_buffer_dirty = false; for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_1_dirty[i]) {
is31fl3741_write_pwm_buffer(index);
return;
}
} }
} }
@ -255,7 +299,10 @@ void is31fl3741_set_pwm_buffer(const is31fl3741_led_t *pled, uint8_t red, uint8_
set_pwm_value(pled->driver, pled->r, red); set_pwm_value(pled->driver, pled->r, red);
set_pwm_value(pled->driver, pled->g, green); set_pwm_value(pled->driver, pled->g, green);
set_pwm_value(pled->driver, pled->b, blue); set_pwm_value(pled->driver, pled->b, blue);
driver_buffers[pled->driver].pwm_buffer_dirty = true;
dirty_bitfield_set(pled->driver, pled->r);
dirty_bitfield_set(pled->driver, pled->g);
dirty_bitfield_set(pled->driver, pled->b);
} }
void is31fl3741_update_led_control_registers(uint8_t index) { void is31fl3741_update_led_control_registers(uint8_t index) {

33
drivers/led/issi/is31fl3742a-mono.c
View file

@ -54,6 +54,9 @@
# define IS31FL3742A_GLOBAL_CURRENT 0xFF # define IS31FL3742A_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3742A_PWM_REGISTERS_PER_CHUNK 30
#define IS31FL3742A_CHUNK_COUNT (IS31FL3742A_PWM_REGISTER_COUNT / IS31FL3742A_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = {
IS31FL3742A_I2C_ADDRESS_1, IS31FL3742A_I2C_ADDRESS_1,
#ifdef IS31FL3742A_I2C_ADDRESS_2 #ifdef IS31FL3742A_I2C_ADDRESS_2
@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = {
typedef struct is31fl3742a_driver_t { typedef struct is31fl3742a_driver_t {
uint8_t pwm_buffer[IS31FL3742A_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3742A_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3742A_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3742A_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3742A_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3742a_driver_t; } PACKED is31fl3742a_driver_t;
is31fl3742a_driver_t driver_buffers[IS31FL3742A_DRIVER_COUNT] = {{ is31fl3742a_driver_t driver_buffers[IS31FL3742A_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -101,13 +104,21 @@ void is31fl3742a_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 6 transfers of 30 bytes. // Transmit PWM registers in 6 transfers of 30 bytes.
// Iterate over the pwm_buffer contents at 30 byte intervals. // Iterate over the pwm_buffer contents at 30 byte intervals.
for (uint8_t i = 0; i < IS31FL3742A_PWM_REGISTER_COUNT; i += 30) { for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3742A_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3742A_I2C_PERSISTENCE > 0 #if IS31FL3742A_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3742A_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3742A_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -174,7 +185,7 @@ void is31fl3742a_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -193,12 +204,14 @@ void is31fl3742a_set_scaling_register(uint8_t index, uint8_t value) {
} }
void is31fl3742a_update_pwm_buffers(uint8_t index) { void is31fl3742a_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM); is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM);
is31fl3742a_write_pwm_buffer(index); is31fl3742a_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

35
drivers/led/issi/is31fl3742a.c
View file

@ -54,6 +54,9 @@
# define IS31FL3742A_GLOBAL_CURRENT 0xFF # define IS31FL3742A_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3742A_PWM_REGISTERS_PER_CHUNK 30
#define IS31FL3742A_CHUNK_COUNT (IS31FL3742A_PWM_REGISTER_COUNT / IS31FL3742A_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = {
IS31FL3742A_I2C_ADDRESS_1, IS31FL3742A_I2C_ADDRESS_1,
#ifdef IS31FL3742A_I2C_ADDRESS_2 #ifdef IS31FL3742A_I2C_ADDRESS_2
@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = {
typedef struct is31fl3742a_driver_t { typedef struct is31fl3742a_driver_t {
uint8_t pwm_buffer[IS31FL3742A_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3742A_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3742A_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3742A_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3742A_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3742a_driver_t; } PACKED is31fl3742a_driver_t;
is31fl3742a_driver_t driver_buffers[IS31FL3742A_DRIVER_COUNT] = {{ is31fl3742a_driver_t driver_buffers[IS31FL3742A_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -101,13 +104,21 @@ void is31fl3742a_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 6 transfers of 30 bytes. // Transmit PWM registers in 6 transfers of 30 bytes.
// Iterate over the pwm_buffer contents at 30 byte intervals. // Iterate over the pwm_buffer contents at 30 byte intervals.
for (uint8_t i = 0; i < IS31FL3742A_PWM_REGISTER_COUNT; i += 30) { for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3742A_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3742A_I2C_PERSISTENCE > 0 #if IS31FL3742A_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3742A_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3742A_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -176,7 +187,9 @@ void is31fl3742a_set_color(int index, uint8_t red, uint8_t green, uint8_t blue)
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -197,12 +210,14 @@ void is31fl3742a_set_scaling_register(uint8_t index, uint8_t red, uint8_t green,
} }
void is31fl3742a_update_pwm_buffers(uint8_t index) { void is31fl3742a_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM); is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM);
is31fl3742a_write_pwm_buffer(index); is31fl3742a_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

33
drivers/led/issi/is31fl3743a-mono.c
View file

@ -63,6 +63,9 @@
# define IS31FL3743A_SYNC_4 IS31FL3743A_SYNC_NONE # define IS31FL3743A_SYNC_4 IS31FL3743A_SYNC_NONE
#endif #endif
#define IS31FL3743A_PWM_REGISTERS_PER_CHUNK 18
#define IS31FL3743A_CHUNK_COUNT (IS31FL3743A_PWM_REGISTER_COUNT / IS31FL3743A_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = {
IS31FL3743A_I2C_ADDRESS_1, IS31FL3743A_I2C_ADDRESS_1,
#ifdef IS31FL3743A_I2C_ADDRESS_2 #ifdef IS31FL3743A_I2C_ADDRESS_2
@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3743A_DRIVER_COUNT] = {
typedef struct is31fl3743a_driver_t { typedef struct is31fl3743a_driver_t {
uint8_t pwm_buffer[IS31FL3743A_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3743A_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3743A_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3743A_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3743A_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3743a_driver_t; } PACKED is31fl3743a_driver_t;
is31fl3743a_driver_t driver_buffers[IS31FL3743A_DRIVER_COUNT] = {{ is31fl3743a_driver_t driver_buffers[IS31FL3743A_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -123,13 +126,21 @@ void is31fl3743a_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 11 transfers of 18 bytes. // Transmit PWM registers in 11 transfers of 18 bytes.
// Iterate over the pwm_buffer contents at 18 byte intervals. // Iterate over the pwm_buffer contents at 18 byte intervals.
for (uint8_t i = 0; i < IS31FL3743A_PWM_REGISTER_COUNT; i += 18) { for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3743A_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3743A_I2C_PERSISTENCE > 0 #if IS31FL3743A_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3743A_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3743A_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -198,7 +209,7 @@ void is31fl3743a_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -217,12 +228,14 @@ void is31fl3743a_set_scaling_register(uint8_t index, uint8_t value) {
} }
void is31fl3743a_update_pwm_buffers(uint8_t index) { void is31fl3743a_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM); is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM);
is31fl3743a_write_pwm_buffer(index); is31fl3743a_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

35
drivers/led/issi/is31fl3743a.c
View file

@ -63,6 +63,9 @@
# define IS31FL3743A_SYNC_4 IS31FL3743A_SYNC_NONE # define IS31FL3743A_SYNC_4 IS31FL3743A_SYNC_NONE
#endif #endif
#define IS31FL3743A_PWM_REGISTERS_PER_CHUNK 18
#define IS31FL3743A_CHUNK_COUNT (IS31FL3743A_PWM_REGISTER_COUNT / IS31FL3743A_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = {
IS31FL3743A_I2C_ADDRESS_1, IS31FL3743A_I2C_ADDRESS_1,
#ifdef IS31FL3743A_I2C_ADDRESS_2 #ifdef IS31FL3743A_I2C_ADDRESS_2
@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3743A_DRIVER_COUNT] = {
typedef struct is31fl3743a_driver_t { typedef struct is31fl3743a_driver_t {
uint8_t pwm_buffer[IS31FL3743A_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3743A_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3743A_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3743A_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3743A_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3743a_driver_t; } PACKED is31fl3743a_driver_t;
is31fl3743a_driver_t driver_buffers[IS31FL3743A_DRIVER_COUNT] = {{ is31fl3743a_driver_t driver_buffers[IS31FL3743A_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -123,13 +126,21 @@ void is31fl3743a_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 11 transfers of 18 bytes. // Transmit PWM registers in 11 transfers of 18 bytes.
// Iterate over the pwm_buffer contents at 18 byte intervals. // Iterate over the pwm_buffer contents at 18 byte intervals.
for (uint8_t i = 0; i < IS31FL3743A_PWM_REGISTER_COUNT; i += 18) { for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3743A_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3743A_I2C_PERSISTENCE > 0 #if IS31FL3743A_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3743A_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3743A_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -200,7 +211,9 @@ void is31fl3743a_set_color(int index, uint8_t red, uint8_t green, uint8_t blue)
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -221,12 +234,14 @@ void is31fl3743a_set_scaling_register(uint8_t index, uint8_t red, uint8_t green,
} }
void is31fl3743a_update_pwm_buffers(uint8_t index) { void is31fl3743a_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM); is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM);
is31fl3743a_write_pwm_buffer(index); is31fl3743a_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

37
drivers/led/issi/is31fl3745-mono.c
View file

@ -63,6 +63,9 @@
# define IS31FL3745_SYNC_4 IS31FL3745_SYNC_NONE # define IS31FL3745_SYNC_4 IS31FL3745_SYNC_NONE
#endif #endif
#define IS31FL3745_PWM_REGISTERS_PER_CHUNK 18
#define IS31FL3745_CHUNK_COUNT (IS31FL3745_PWM_REGISTER_COUNT / IS31FL3745_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = {
IS31FL3745_I2C_ADDRESS_1, IS31FL3745_I2C_ADDRESS_1,
#ifdef IS31FL3745_I2C_ADDRESS_2 #ifdef IS31FL3745_I2C_ADDRESS_2
@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3745_DRIVER_COUNT] = {
typedef struct is31fl3745_driver_t { typedef struct is31fl3745_driver_t {
uint8_t pwm_buffer[IS31FL3745_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3745_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3745_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3745_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3745_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3745_driver_t; } PACKED is31fl3745_driver_t;
is31fl3745_driver_t driver_buffers[IS31FL3745_DRIVER_COUNT] = {{ is31fl3745_driver_t driver_buffers[IS31FL3745_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -123,13 +126,21 @@ void is31fl3745_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 8 transfers of 18 bytes. // Transmit PWM registers in 8 transfers of 18 bytes.
// Iterate over the pwm_buffer contents at 18 byte intervals. // Iterate over the pwm_buffer contents at 18 byte intervals.
for (uint8_t i = 0; i < IS31FL3745_PWM_REGISTER_COUNT; i += 18) { for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3745_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3745_I2C_PERSISTENCE > 0 #if IS31FL3745_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3745_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3745_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -198,7 +209,7 @@ void is31fl3745_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -217,12 +228,14 @@ void is31fl3745_set_scaling_register(uint8_t index, uint8_t value) {
} }
void is31fl3745_update_pwm_buffers(uint8_t index) { void is31fl3745_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) {
is31fl3745_select_page(index, IS31FL3745_COMMAND_PWM); if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
is31fl3745_write_pwm_buffer(index); // then exit the loop
is31fl3745a_select_page(index, IS31FL3745_COMMAND_PWM);
driver_buffers[index].pwm_buffer_dirty = false; is31fl3745a_write_pwm_buffer(index);
return;
}
} }
} }

35
drivers/led/issi/is31fl3745.c
View file

@ -63,6 +63,9 @@
# define IS31FL3745_SYNC_4 IS31FL3745_SYNC_NONE # define IS31FL3745_SYNC_4 IS31FL3745_SYNC_NONE
#endif #endif
#define IS31FL3745_PWM_REGISTERS_PER_CHUNK 18
#define IS31FL3745_CHUNK_COUNT (IS31FL3745_PWM_REGISTER_COUNT / IS31FL3745_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = {
IS31FL3745_I2C_ADDRESS_1, IS31FL3745_I2C_ADDRESS_1,
#ifdef IS31FL3745_I2C_ADDRESS_2 #ifdef IS31FL3745_I2C_ADDRESS_2
@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3745_DRIVER_COUNT] = {
typedef struct is31fl3745_driver_t { typedef struct is31fl3745_driver_t {
uint8_t pwm_buffer[IS31FL3745_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3745_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3745_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3745_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3745_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3745_driver_t; } PACKED is31fl3745_driver_t;
is31fl3745_driver_t driver_buffers[IS31FL3745_DRIVER_COUNT] = {{ is31fl3745_driver_t driver_buffers[IS31FL3745_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -123,13 +126,21 @@ void is31fl3745_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 8 transfers of 18 bytes. // Transmit PWM registers in 8 transfers of 18 bytes.
// Iterate over the pwm_buffer contents at 18 byte intervals. // Iterate over the pwm_buffer contents at 18 byte intervals.
for (uint8_t i = 0; i < IS31FL3745_PWM_REGISTER_COUNT; i += 18) { for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3745_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3745_I2C_PERSISTENCE > 0 #if IS31FL3745_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3745_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3745_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -200,7 +211,9 @@ void is31fl3745_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -221,12 +234,14 @@ void is31fl3745_set_scaling_register(uint8_t index, uint8_t red, uint8_t green,
} }
void is31fl3745_update_pwm_buffers(uint8_t index) { void is31fl3745_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3745_select_page(index, IS31FL3745_COMMAND_PWM); is31fl3745_select_page(index, IS31FL3745_COMMAND_PWM);
is31fl3745_write_pwm_buffer(index); is31fl3745_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

33
drivers/led/issi/is31fl3746a-mono.c
View file

@ -54,6 +54,9 @@
# define IS31FL3746A_GLOBAL_CURRENT 0xFF # define IS31FL3746A_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3746A_PWM_REGISTERS_PER_CHUNK 18
#define IS31FL3746A_CHUNK_COUNT (IS31FL3746A_PWM_REGISTER_COUNT / IS31FL3746A_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = {
IS31FL3746A_I2C_ADDRESS_1, IS31FL3746A_I2C_ADDRESS_1,
#ifdef IS31FL3746A_I2C_ADDRESS_2 #ifdef IS31FL3746A_I2C_ADDRESS_2
@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = {
typedef struct is31fl3746a_driver_t { typedef struct is31fl3746a_driver_t {
uint8_t pwm_buffer[IS31FL3746A_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3746A_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3746A_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3746A_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3746A_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3746a_driver_t; } PACKED is31fl3746a_driver_t;
is31fl3746a_driver_t driver_buffers[IS31FL3746A_DRIVER_COUNT] = {{ is31fl3746a_driver_t driver_buffers[IS31FL3746A_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -101,13 +104,21 @@ void is31fl3746a_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 4 transfers of 18 bytes. // Transmit PWM registers in 4 transfers of 18 bytes.
// Iterate over the pwm_buffer contents at 18 byte intervals. // Iterate over the pwm_buffer contents at 18 byte intervals.
for (uint8_t i = 0; i < IS31FL3746A_PWM_REGISTER_COUNT; i += 18) { for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3746A_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3746A_I2C_PERSISTENCE > 0 #if IS31FL3746A_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3746A_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3746A_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -175,7 +186,7 @@ void is31fl3746a_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -194,12 +205,14 @@ void is31fl3746a_set_scaling_register(uint8_t index, uint8_t value) {
} }
void is31fl3746a_update_pwm_buffers(uint8_t index) { void is31fl3746a_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM); is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM);
is31fl3746a_write_pwm_buffer(index); is31fl3746a_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

35
drivers/led/issi/is31fl3746a.c
View file

@ -54,6 +54,9 @@
# define IS31FL3746A_GLOBAL_CURRENT 0xFF # define IS31FL3746A_GLOBAL_CURRENT 0xFF
#endif #endif
#define IS31FL3746A_PWM_REGISTERS_PER_CHUNK 18
#define IS31FL3746A_CHUNK_COUNT (IS31FL3746A_PWM_REGISTER_COUNT / IS31FL3746A_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = {
IS31FL3746A_I2C_ADDRESS_1, IS31FL3746A_I2C_ADDRESS_1,
#ifdef IS31FL3746A_I2C_ADDRESS_2 #ifdef IS31FL3746A_I2C_ADDRESS_2
@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = {
typedef struct is31fl3746a_driver_t { typedef struct is31fl3746a_driver_t {
uint8_t pwm_buffer[IS31FL3746A_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[IS31FL3746A_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[IS31FL3746A_CHUNK_COUNT];
uint8_t scaling_buffer[IS31FL3746A_SCALING_REGISTER_COUNT]; uint8_t scaling_buffer[IS31FL3746A_SCALING_REGISTER_COUNT];
bool scaling_buffer_dirty; bool scaling_buffer_dirty;
} PACKED is31fl3746a_driver_t; } PACKED is31fl3746a_driver_t;
is31fl3746a_driver_t driver_buffers[IS31FL3746A_DRIVER_COUNT] = {{ is31fl3746a_driver_t driver_buffers[IS31FL3746A_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.scaling_buffer = {0}, .scaling_buffer = {0},
.scaling_buffer_dirty = false, .scaling_buffer_dirty = false,
}}; }};
@ -101,13 +104,21 @@ void is31fl3746a_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 4 transfers of 18 bytes. // Transmit PWM registers in 4 transfers of 18 bytes.
// Iterate over the pwm_buffer contents at 18 byte intervals. // Iterate over the pwm_buffer contents at 18 byte intervals.
for (uint8_t i = 0; i < IS31FL3746A_PWM_REGISTER_COUNT; i += 18) { for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * IS31FL3746A_PWM_REGISTERS_PER_CHUNK;
#if IS31FL3746A_I2C_PERSISTENCE > 0 #if IS31FL3746A_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < IS31FL3746A_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < IS31FL3746A_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -177,7 +188,9 @@ void is31fl3746a_set_color(int index, uint8_t red, uint8_t green, uint8_t blue)
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -198,12 +211,14 @@ void is31fl3746a_set_scaling_register(uint8_t index, uint8_t red, uint8_t green,
} }
void is31fl3746a_update_pwm_buffers(uint8_t index) { void is31fl3746a_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM); is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM);
is31fl3746a_write_pwm_buffer(index); is31fl3746a_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

33
drivers/led/snled27351-mono.c
View file

@ -38,6 +38,9 @@
{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }
#endif #endif
#define SNLED27351_PWM_REGISTERS_PER_CHUNK 16
#define SNLED27351_CHUNK_COUNT (SNLED27351_PWM_REGISTER_COUNT / SNLED27351_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = {
SNLED27351_I2C_ADDRESS_1, SNLED27351_I2C_ADDRESS_1,
#ifdef SNLED27351_I2C_ADDRESS_2 #ifdef SNLED27351_I2C_ADDRESS_2
@ -59,14 +62,14 @@ const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct snled27351_driver_t { typedef struct snled27351_driver_t {
uint8_t pwm_buffer[SNLED27351_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[SNLED27351_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[SNLED27351_CHUNK_COUNT];
uint8_t led_control_buffer[SNLED27351_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[SNLED27351_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED snled27351_driver_t; } PACKED snled27351_driver_t;
snled27351_driver_t driver_buffers[SNLED27351_DRIVER_COUNT] = {{ snled27351_driver_t driver_buffers[SNLED27351_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -90,13 +93,21 @@ void snled27351_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < SNLED27351_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * SNLED27351_PWM_REGISTERS_PER_CHUNK;
#if SNLED27351_I2C_PERSISTENCE > 0 #if SNLED27351_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < SNLED27351_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < SNLED27351_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -179,7 +190,7 @@ void snled27351_set_value(int index, uint8_t value) {
} }
driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer[led.v] = value;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.v / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -206,12 +217,14 @@ void snled27351_set_led_control_register(uint8_t index, bool value) {
} }
void snled27351_update_pwm_buffers(uint8_t index) { void snled27351_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
snled27351_select_page(index, SNLED27351_COMMAND_PWM); snled27351_select_page(index, SNLED27351_COMMAND_PWM);
snled27351_write_pwm_buffer(index); snled27351_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

35
drivers/led/snled27351.c
View file

@ -38,6 +38,9 @@
{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }
#endif #endif
#define SNLED27351_PWM_REGISTERS_PER_CHUNK 16
#define SNLED27351_CHUNK_COUNT (SNLED27351_PWM_REGISTER_COUNT / SNLED27351_PWM_REGISTERS_PER_CHUNK)
const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = {
SNLED27351_I2C_ADDRESS_1, SNLED27351_I2C_ADDRESS_1,
#ifdef SNLED27351_I2C_ADDRESS_2 #ifdef SNLED27351_I2C_ADDRESS_2
@ -59,14 +62,14 @@ const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = {
// probably not worth the extra complexity. // probably not worth the extra complexity.
typedef struct snled27351_driver_t { typedef struct snled27351_driver_t {
uint8_t pwm_buffer[SNLED27351_PWM_REGISTER_COUNT]; uint8_t pwm_buffer[SNLED27351_PWM_REGISTER_COUNT];
bool pwm_buffer_dirty; bool pwm_buffer_dirty[SNLED27351_CHUNK_COUNT];
uint8_t led_control_buffer[SNLED27351_LED_CONTROL_REGISTER_COUNT]; uint8_t led_control_buffer[SNLED27351_LED_CONTROL_REGISTER_COUNT];
bool led_control_buffer_dirty; bool led_control_buffer_dirty;
} PACKED snled27351_driver_t; } PACKED snled27351_driver_t;
snled27351_driver_t driver_buffers[SNLED27351_DRIVER_COUNT] = {{ snled27351_driver_t driver_buffers[SNLED27351_DRIVER_COUNT] = {{
.pwm_buffer = {0}, .pwm_buffer = {0},
.pwm_buffer_dirty = false, .pwm_buffer_dirty = {0},
.led_control_buffer = {0}, .led_control_buffer = {0},
.led_control_buffer_dirty = false, .led_control_buffer_dirty = false,
}}; }};
@ -90,13 +93,21 @@ void snled27351_write_pwm_buffer(uint8_t index) {
// Transmit PWM registers in 12 transfers of 16 bytes. // Transmit PWM registers in 12 transfers of 16 bytes.
// Iterate over the pwm_buffer contents at 16 byte intervals. // Iterate over the pwm_buffer contents at 16 byte intervals.
for (uint8_t i = 0; i < SNLED27351_PWM_REGISTER_COUNT; i += 16) { for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) {
if (!driver_buffers[index].pwm_buffer_dirty[i]) {
continue;
}
driver_buffers[index].pwm_buffer_dirty[i] = false;
uint8_t offset = i * SNLED27351_PWM_REGISTERS_PER_CHUNK;
#if SNLED27351_I2C_PERSISTENCE > 0 #if SNLED27351_I2C_PERSISTENCE > 0
for (uint8_t j = 0; j < SNLED27351_I2C_PERSISTENCE; j++) { for (uint8_t j = 0; j < SNLED27351_I2C_PERSISTENCE; j++) {
if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
} }
#else #else
i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT); i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT);
#endif #endif
} }
} }
@ -181,7 +192,9 @@ void snled27351_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.r] = red;
driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.g] = green;
driver_buffers[led.driver].pwm_buffer[led.b] = blue; driver_buffers[led.driver].pwm_buffer[led.b] = blue;
driver_buffers[led.driver].pwm_buffer_dirty = true; driver_buffers[led.driver].pwm_buffer_dirty[led.r / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.g / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true;
driver_buffers[led.driver].pwm_buffer_dirty[led.b / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true;
} }
} }
@ -222,12 +235,14 @@ void snled27351_set_led_control_register(uint8_t index, bool red, bool green, bo
} }
void snled27351_update_pwm_buffers(uint8_t index) { void snled27351_update_pwm_buffers(uint8_t index) {
if (driver_buffers[index].pwm_buffer_dirty) { for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) {
if (driver_buffers[index].pwm_buffer_dirty[i]) {
// if any of these are true then write PWM buffer
// then exit the loop
snled27351_select_page(index, SNLED27351_COMMAND_PWM); snled27351_select_page(index, SNLED27351_COMMAND_PWM);
snled27351_write_pwm_buffer(index); snled27351_write_pwm_buffer(index);
return;
driver_buffers[index].pwm_buffer_dirty = false; }
} }
} }

5
platforms/avr/drivers/ws2812_bitbang.c
View file

@ -25,6 +25,7 @@
#include <util/delay.h> #include <util/delay.h>
#include "ws2812.h" #include "ws2812.h"
#include "pin_defs.h" #include "pin_defs.h"
#include <stdbool.h>
#define pinmask(pin) (_BV((pin)&0xF)) #define pinmask(pin) (_BV((pin)&0xF))
@ -152,6 +153,7 @@ static inline void ws2812_sendarray_mask(uint8_t *data, uint16_t datlen, uint8_t
} }
ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; ws2812_led_t ws2812_leds[WS2812_LED_COUNT];
bool ws2812_dirty = false;
void ws2812_init(void) { void ws2812_init(void) {
DDRx_ADDRESS(WS2812_DI_PIN) |= pinmask(WS2812_DI_PIN); DDRx_ADDRESS(WS2812_DI_PIN) |= pinmask(WS2812_DI_PIN);
@ -161,6 +163,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
ws2812_leds[index].r = red; ws2812_leds[index].r = red;
ws2812_leds[index].g = green; ws2812_leds[index].g = green;
ws2812_leds[index].b = blue; ws2812_leds[index].b = blue;
ws2812_dirty = true;
#if defined(WS2812_RGBW) #if defined(WS2812_RGBW)
ws2812_rgb_to_rgbw(&ws2812_leds[index]); ws2812_rgb_to_rgbw(&ws2812_leds[index]);
#endif #endif
@ -173,6 +176,8 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
} }
void ws2812_flush(void) { void ws2812_flush(void) {
if (!ws2812_dirty) return;
ws2812_dirty = false;
uint8_t masklo = ~(pinmask(WS2812_DI_PIN)) & PORTx_ADDRESS(WS2812_DI_PIN); uint8_t masklo = ~(pinmask(WS2812_DI_PIN)) & PORTx_ADDRESS(WS2812_DI_PIN);
uint8_t maskhi = pinmask(WS2812_DI_PIN) | PORTx_ADDRESS(WS2812_DI_PIN); uint8_t maskhi = pinmask(WS2812_DI_PIN) | PORTx_ADDRESS(WS2812_DI_PIN);

5
platforms/avr/drivers/ws2812_i2c.c
View file

@ -1,6 +1,7 @@
// Copyright 2024 QMK // Copyright 2024 QMK
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include <stdbool.h>
#include "ws2812.h" #include "ws2812.h"
#include "i2c_master.h" #include "i2c_master.h"
@ -17,6 +18,7 @@
#endif #endif
ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; ws2812_led_t ws2812_leds[WS2812_LED_COUNT];
bool ws2812_dirty = false;
void ws2812_init(void) { void ws2812_init(void) {
i2c_init(); i2c_init();
@ -26,6 +28,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
ws2812_leds[index].r = red; ws2812_leds[index].r = red;
ws2812_leds[index].g = green; ws2812_leds[index].g = green;
ws2812_leds[index].b = blue; ws2812_leds[index].b = blue;
ws2812_dirty = true;
} }
void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
@ -35,5 +38,7 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
} }
void ws2812_flush(void) { void ws2812_flush(void) {
if (!ws2812_dirty) return;
ws2812_dirty = false;
i2c_transmit(WS2812_I2C_ADDRESS, (uint8_t *)ws2812_leds, WS2812_LED_COUNT * sizeof(ws2812_led_t), WS2812_I2C_TIMEOUT); i2c_transmit(WS2812_I2C_ADDRESS, (uint8_t *)ws2812_leds, WS2812_LED_COUNT * sizeof(ws2812_led_t), WS2812_I2C_TIMEOUT);
} }

4
platforms/chibios/drivers/ws2812_bitbang.c
View file

@ -77,6 +77,7 @@ void sendByte(uint8_t byte) {
} }
ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; ws2812_led_t ws2812_leds[WS2812_LED_COUNT];
bool ws2812_dirty = false;
void ws2812_init(void) { void ws2812_init(void) {
palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE); palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE);
@ -86,6 +87,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
ws2812_leds[index].r = red; ws2812_leds[index].r = red;
ws2812_leds[index].g = green; ws2812_leds[index].g = green;
ws2812_leds[index].b = blue; ws2812_leds[index].b = blue;
ws2812_dirty = true;
#if defined(WS2812_RGBW) #if defined(WS2812_RGBW)
ws2812_rgb_to_rgbw(&ws2812_leds[index]); ws2812_rgb_to_rgbw(&ws2812_leds[index]);
#endif #endif
@ -98,6 +100,8 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
} }
void ws2812_flush(void) { void ws2812_flush(void) {
if (!ws2812_dirty) return;
ws2812_dirty = false;
// this code is very time dependent, so we need to disable interrupts // this code is very time dependent, so we need to disable interrupts
chSysLock(); chSysLock();

8
platforms/chibios/drivers/ws2812_pwm.c
View file

@ -291,6 +291,7 @@ typedef uint8_t ws2812_buffer_t;
#endif #endif
static ws2812_buffer_t ws2812_frame_buffer[WS2812_BIT_N + 1]; /**< Buffer for a frame */ static ws2812_buffer_t ws2812_frame_buffer[WS2812_BIT_N + 1]; /**< Buffer for a frame */
bool ws2812_dirty = false;
/* --- PUBLIC FUNCTIONS ----------------------------------------------------- */ /* --- PUBLIC FUNCTIONS ----------------------------------------------------- */
/* /*
@ -310,7 +311,7 @@ void ws2812_init(void) {
palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE); palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE);
// PWM Configuration // PWM Configuration
//#pragma GCC diagnostic ignored "-Woverride-init" // Turn off override-init warning for this struct. We use the overriding ability to set a "default" channel config // #pragma GCC diagnostic ignored "-Woverride-init" // Turn off override-init warning for this struct. We use the overriding ability to set a "default" channel config
static const PWMConfig ws2812_pwm_config = { static const PWMConfig ws2812_pwm_config = {
.frequency = WS2812_PWM_TICK_FREQUENCY, .frequency = WS2812_PWM_TICK_FREQUENCY,
.period = WS2812_PWM_PERIOD, // Mit dieser Periode wird UDE-Event erzeugt und ein neuer Wert (Länge WS2812_BIT_N) vom DMA ins CCR geschrieben .period = WS2812_PWM_PERIOD, // Mit dieser Periode wird UDE-Event erzeugt und ein neuer Wert (Länge WS2812_BIT_N) vom DMA ins CCR geschrieben
@ -328,7 +329,7 @@ void ws2812_init(void) {
.dier = TIM_DIER_UDE, // DMA on update event for next period .dier = TIM_DIER_UDE, // DMA on update event for next period
#endif #endif
}; };
//#pragma GCC diagnostic pop // Restore command-line warning options // #pragma GCC diagnostic pop // Restore command-line warning options
// Configure DMA // Configure DMA
// dmaInit(); // Joe added this // dmaInit(); // Joe added this
@ -398,6 +399,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
ws2812_leds[index].r = red; ws2812_leds[index].r = red;
ws2812_leds[index].g = green; ws2812_leds[index].g = green;
ws2812_leds[index].b = blue; ws2812_leds[index].b = blue;
ws2812_dirty = true;
#if defined(WS2812_RGBW) #if defined(WS2812_RGBW)
ws2812_rgb_to_rgbw(&ws2812_leds[index]); ws2812_rgb_to_rgbw(&ws2812_leds[index]);
#endif #endif
@ -410,6 +412,8 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
} }
void ws2812_flush(void) { void ws2812_flush(void) {
if (!ws2812_dirty) return;
ws2812_dirty = false;
for (int i = 0; i < WS2812_LED_COUNT; i++) { for (int i = 0; i < WS2812_LED_COUNT; i++) {
#if defined(WS2812_RGBW) #if defined(WS2812_RGBW)
ws2812_write_led_rgbw(i, ws2812_leds[i].r, ws2812_leds[i].g, ws2812_leds[i].b, ws2812_leds[i].w); ws2812_write_led_rgbw(i, ws2812_leds[i].r, ws2812_leds[i].g, ws2812_leds[i].b, ws2812_leds[i].w);

5
platforms/chibios/drivers/ws2812_spi.c
View file

@ -165,6 +165,7 @@ static void set_led_color_rgb(ws2812_led_t color, int pos) {
} }
ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; ws2812_led_t ws2812_leds[WS2812_LED_COUNT];
bool ws2812_dirty = false;
void ws2812_init(void) { void ws2812_init(void) {
palSetLineMode(WS2812_DI_PIN, WS2812_MOSI_OUTPUT_MODE); palSetLineMode(WS2812_DI_PIN, WS2812_MOSI_OUTPUT_MODE);
@ -228,6 +229,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
ws2812_leds[index].r = red; ws2812_leds[index].r = red;
ws2812_leds[index].g = green; ws2812_leds[index].g = green;
ws2812_leds[index].b = blue; ws2812_leds[index].b = blue;
ws2812_dirty = true;
#if defined(WS2812_RGBW) #if defined(WS2812_RGBW)
ws2812_rgb_to_rgbw(&ws2812_leds[index]); ws2812_rgb_to_rgbw(&ws2812_leds[index]);
#endif #endif
@ -240,6 +242,9 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
} }
void ws2812_flush(void) { void ws2812_flush(void) {
if (!ws2812_dirty) return;
ws2812_dirty = false;
for (int i = 0; i < WS2812_LED_COUNT; i++) { for (int i = 0; i < WS2812_LED_COUNT; i++) {
set_led_color_rgb(ws2812_leds[i], i); set_led_color_rgb(ws2812_leds[i], i);
} }