diff --git a/drivers/led/issi/is31fl3729.c b/drivers/led/issi/is31fl3729.c index 80acb22fa28..79005686ddc 100644 --- a/drivers/led/issi/is31fl3729.c +++ b/drivers/led/issi/is31fl3729.c @@ -64,6 +64,9 @@ # define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ #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] = { IS31FL3729_I2C_ADDRESS_1, #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. typedef struct is31fl3729_driver_t { 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]; bool scaling_buffer_dirty; } PACKED is31fl3729_driver_t; is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .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. // 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 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; } #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 } } @@ -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.g] = green; 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) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3729_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + 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); + return; + } } } diff --git a/drivers/led/issi/is31fl3731-mono.c b/drivers/led/issi/is31fl3731-mono.c index 33a863b982f..077fc16ce87 100644 --- a/drivers/led/issi/is31fl3731-mono.c +++ b/drivers/led/issi/is31fl3731-mono.c @@ -33,6 +33,9 @@ # define IS31FL3731_I2C_PERSISTENCE 0 #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] = { IS31FL3731_I2C_ADDRESS_1, #ifdef IS31FL3731_I2C_ADDRESS_2 @@ -53,14 +56,14 @@ const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3731_driver_t { 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]; bool led_control_buffer_dirty; } PACKED is31fl3731_driver_t; is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .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. // 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 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; } #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 } } @@ -178,8 +189,8 @@ void is31fl3731_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + 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) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3731_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + 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); + return; + } } } diff --git a/drivers/led/issi/is31fl3731.c b/drivers/led/issi/is31fl3731.c index 86d953ef25d..6ea50cac74a 100644 --- a/drivers/led/issi/is31fl3731.c +++ b/drivers/led/issi/is31fl3731.c @@ -32,6 +32,9 @@ # define IS31FL3731_I2C_PERSISTENCE 0 #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] = { IS31FL3731_I2C_ADDRESS_1, #ifdef IS31FL3731_I2C_ADDRESS_2 @@ -51,15 +54,15 @@ const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { // buffers and the transfers in is31fl3731_write_pwm_buffer() but it's // probably not worth the extra complexity. typedef struct is31fl3731_driver_t { - uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; - uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; - bool led_control_buffer_dirty; + uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; + bool pwm_buffer_dirty[IS31FL3731_CHUNK_COUNT]; + uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; + bool led_control_buffer_dirty; } PACKED is31fl3731_driver_t; is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .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. // 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 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; } #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 } } @@ -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.g] = green; 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) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3731_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + 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); + return; + } } } diff --git a/drivers/led/issi/is31fl3733.c b/drivers/led/issi/is31fl3733.c index a1d68991149..339a310a1f1 100644 --- a/drivers/led/issi/is31fl3733.c +++ b/drivers/led/issi/is31fl3733.c @@ -21,6 +21,7 @@ #include "i2c_master.h" #include "gpio.h" #include "wait.h" +#include "bit_array.h" #define IS31FL3733_PWM_REGISTER_COUNT 192 #define IS31FL3733_LED_CONTROL_REGISTER_COUNT 24 @@ -62,6 +63,9 @@ # define IS31FL3733_SYNC_4 IS31FL3733_SYNC_NONE #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] = { IS31FL3733_I2C_ADDRESS_1, #ifdef IS31FL3733_I2C_ADDRESS_2 @@ -96,16 +100,17 @@ const uint8_t driver_sync[IS31FL3733_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3733_driver_t { 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]; bool led_control_buffer_dirty; } PACKED is31fl3733_driver_t; is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, + .led_control_bitfield = {0}, }}; void is31fl3733_write_register(uint8_t index, uint8_t reg, uint8_t data) { @@ -128,13 +133,21 @@ void is31fl3733_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // 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 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 - 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 } } @@ -211,7 +224,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.g] = green; 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 +268,14 @@ void is31fl3733_set_led_control_register(uint8_t index, bool red, bool green, bo } void is31fl3733_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM); - - is31fl3733_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + 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_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3741.c b/drivers/led/issi/is31fl3741.c index 3614d1c104c..ed51d9d442b 100644 --- a/drivers/led/issi/is31fl3741.c +++ b/drivers/led/issi/is31fl3741.c @@ -55,6 +55,11 @@ # define IS31FL3741_GLOBAL_CURRENT 0xFF #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] = { IS31FL3741_I2C_ADDRESS_1, #ifdef IS31FL3741_I2C_ADDRESS_2 @@ -77,19 +82,21 @@ const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { typedef struct is31fl3741_driver_t { uint8_t pwm_buffer_0[IS31FL3741_PWM_0_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_1[IS31FL3741_SCALING_1_REGISTER_COUNT]; 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; is31fl3741_driver_t driver_buffers[IS31FL3741_DRIVER_COUNT] = {{ .pwm_buffer_0 = {0}, .pwm_buffer_1 = {0}, - .pwm_buffer_dirty = false, .scaling_buffer_0 = {0}, .scaling_buffer_1 = {0}, .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) { @@ -113,13 +120,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) { // Transmit PWM0 registers in 6 transfers of 30 bytes. // 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 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 - 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 } @@ -128,13 +143,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) { // Transmit PWM1 registers in 9 transfers of 19 bytes. // 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 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 - 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 } } @@ -201,6 +224,14 @@ void set_pwm_value(uint8_t driver, uint16_t reg, uint8_t value) { } } +void dirty_bitfield_set_bit(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) { 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.g, green); set_pwm_value(led.driver, led.b, blue); - driver_buffers[led.driver].pwm_buffer_dirty = true; + + dirty_bitfield_set_bit(led.driver, led.r); + dirty_bitfield_set_bit(led.driver, led.g); + dirty_bitfield_set_bit(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) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3741_write_pwm_buffer(index); + // 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); + // 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->g, green); set_pwm_value(pled->driver, pled->b, blue); - driver_buffers[pled->driver].pwm_buffer_dirty = true; + + dirty_bitfield_set_bit(pled->driver, pled->r); + dirty_bitfield_set_bit(pled->driver, pled->g); + dirty_bitfield_set_bit(pled->driver, pled->b); } void is31fl3741_update_led_control_registers(uint8_t index) {