# include "i2c_master.h"
# include "i2c_slave.h"
-typedef struct __attribute__ ((__packed__)) {
-#ifdef BACKLIGHT_ENABLE
- uint8_t backlight_level;
-#endif
-#ifdef RGBLIGHT_ENABLE
- uint32_t rgb_settings;
+typedef struct _I2C_slave_buffer_t {
+ matrix_row_t smatrix[ROWS_PER_HAND];
+ uint8_t backlight_level;
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ rgblight_syncinfo_t rgblight_sync;
#endif
#ifdef ENCODER_ENABLE
- uint8_t encoder_state[NUMBER_OF_ENCODERS];
-#endif
- // Keep matrix last, we are only using this for it's offset
- uint8_t matrix_start[0];
-} transport_values_t;
-
-__attribute__ ((unused))
-static transport_values_t transport_values;
-
-#ifdef BACKLIGHT_ENABLE
-# define I2C_BACKLIT_START (uint8_t)offsetof(transport_values_t, backlight_level)
-#endif
-
-#ifdef RGBLIGHT_ENABLE
-# define I2C_RGB_START (uint8_t)offsetof(transport_values_t, rgb_settings)
+ uint8_t encoder_state[NUMBER_OF_ENCODERS];
#endif
+} I2C_slave_buffer_t;
-#ifdef ENCODER_ENABLE
-# define I2C_ENCODER_START (uint8_t)offsetof(transport_values_t, encoder_state)
-#endif
+static I2C_slave_buffer_t * const i2c_buffer = (I2C_slave_buffer_t *)i2c_slave_reg;
-#define I2C_KEYMAP_START (uint8_t)offsetof(transport_values_t, matrix_start)
+# define I2C_BACKLIGHT_START offsetof(I2C_slave_buffer_t, backlight_level)
+# define I2C_RGB_START offsetof(I2C_slave_buffer_t, rgblight_sync)
+# define I2C_KEYMAP_START offsetof(I2C_slave_buffer_t, smatrix)
+# define I2C_ENCODER_START offsetof(I2C_slave_buffer_t, encoder_state)
# define TIMEOUT 100
// Get rows from other half over i2c
bool transport_master(matrix_row_t matrix[]) {
- i2c_readReg(SLAVE_I2C_ADDRESS, I2C_KEYMAP_START, (void *)matrix, ROWS_PER_HAND * sizeof(matrix_row_t), TIMEOUT);
+ i2c_readReg(SLAVE_I2C_ADDRESS, I2C_KEYMAP_START, (void *)matrix, sizeof(i2c_buffer->smatrix), TIMEOUT);
// write backlight info
# ifdef BACKLIGHT_ENABLE
uint8_t level = get_backlight_level();
- if (level != transport_values.backlight_level) {
- if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_BACKLIT_START, (void *)&level, sizeof(level), TIMEOUT) >= 0) {
- transport_values.backlight_level = level;
+ if (level != i2c_buffer->backlight_level) {
+ if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_BACKLIGHT_START, (void *)&level, sizeof(level), TIMEOUT) >= 0) {
+ i2c_buffer->backlight_level = level;
}
}
# endif
-# ifdef RGBLIGHT_ENABLE
- uint32_t rgb = rgblight_read_dword();
- if (rgb != transport_values.rgb_settings) {
- if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_START, (void *)&rgb, sizeof(rgb), TIMEOUT) >= 0) {
- transport_values.rgb_settings = rgb;
+# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ if (rgblight_get_change_flags()) {
+ rgblight_syncinfo_t rgblight_sync;
+ rgblight_get_syncinfo(&rgblight_sync);
+ if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_START,
+ (void *)&rgblight_sync, sizeof(rgblight_sync), TIMEOUT) >= 0) {
+ rgblight_clear_change_flags();
}
}
# endif
# ifdef ENCODER_ENABLE
- i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)transport_values.encoder_state, sizeof(transport_values.encoder_state), TIMEOUT);
- encoder_update_raw(&transport_values.encoder_state[0]);
+ i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)i2c_buffer->encoder_state, sizeof(I2C_slave_buffer_t.encoder_state), TIMEOUT);
+ encoder_update_raw(i2c_buffer->encoder_state);
# endif
return true;
void transport_slave(matrix_row_t matrix[]) {
// Copy matrix to I2C buffer
- memcpy((void*)(i2c_slave_reg + I2C_KEYMAP_START), (void *)matrix, ROWS_PER_HAND * sizeof(matrix_row_t) );
+ memcpy((void*)i2c_buffer->smatrix, (void *)matrix, sizeof(i2c_buffer->smatrix));
// Read Backlight Info
# ifdef BACKLIGHT_ENABLE
- backlight_set(i2c_slave_reg[I2C_BACKLIT_START]);
+ backlight_set(i2c_buffer->backlight_level);
# endif
-# ifdef RGBLIGHT_ENABLE
- uint32_t rgb = *(uint32_t *)(i2c_slave_reg + I2C_RGB_START);
+# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
// Update the RGB with the new data
- rgblight_update_dword(rgb);
+ if (i2c_buffer->rgblight_sync.status.change_flags != 0) {
+ rgblight_update_sync(&i2c_buffer->rgblight_sync, false);
+ i2c_buffer->rgblight_sync.status.change_flags = 0;
+ }
# endif
# ifdef ENCODER_ENABLE
- encoder_state_raw((uint8_t*)(i2c_slave_reg + I2C_ENCODER_START));
+ encoder_state_raw(i2c_buffer->encoder_state);
# endif
}
# include "serial.h"
-typedef struct __attribute__ ((__packed__)) {
+typedef struct _Serial_s2m_buffer_t {
+ // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
+ matrix_row_t smatrix[ROWS_PER_HAND];
+
# ifdef ENCODER_ENABLE
uint8_t encoder_state[NUMBER_OF_ENCODERS];
# endif
- // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
- matrix_row_t smatrix[ROWS_PER_HAND];
+
} Serial_s2m_buffer_t;
-typedef struct __attribute__ ((__packed__)) {
+typedef struct _Serial_m2s_buffer_t {
# ifdef BACKLIGHT_ENABLE
uint8_t backlight_level;
# endif
-# if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
- rgblight_config_t rgblight_config; // not yet use
- //
- // When MCUs on both sides drive their respective RGB LED chains,
- // it is necessary to synchronize, so it is necessary to communicate RGB
- // information. In that case, define RGBLED_SPLIT with info on the number
- // of LEDs on each half.
- //
- // Otherwise, if the master side MCU drives both sides RGB LED chains,
- // there is no need to communicate.
-# endif
} Serial_m2s_buffer_t;
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+// When MCUs on both sides drive their respective RGB LED chains,
+// it is necessary to synchronize, so it is necessary to communicate RGB
+// information. In that case, define RGBLIGHT_SPLIT with info on the number
+// of LEDs on each half.
+//
+// Otherwise, if the master side MCU drives both sides RGB LED chains,
+// there is no need to communicate.
+
+typedef struct _Serial_rgblight_t {
+ rgblight_syncinfo_t rgblight_sync;
+} Serial_rgblight_t;
+
+volatile Serial_rgblight_t serial_rgblight = {};
+uint8_t volatile status_rgblight = 0;
+#endif
+
volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
uint8_t volatile status0 = 0;
+enum serial_transaction_id {
+ GET_SLAVE_MATRIX = 0,
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ PUT_RGBLIGHT,
+#endif
+};
+
SSTD_t transactions[] = {
- {
+ [GET_SLAVE_MATRIX] = {
(uint8_t *)&status0,
sizeof(serial_m2s_buffer),
(uint8_t *)&serial_m2s_buffer,
sizeof(serial_s2m_buffer),
(uint8_t *)&serial_s2m_buffer,
},
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+ [PUT_RGBLIGHT] = {
+ (uint8_t *)&status_rgblight,
+ sizeof(serial_rgblight),
+ (uint8_t *)&serial_rgblight,
+ 0, NULL // no slave to master transfer
+ },
+#endif
};
void transport_master_init(void) { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
void transport_slave_init(void) { soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+
+// rgblight synchronization information communication.
+
+void transport_rgblight_master(void) {
+ if (rgblight_get_change_flags()) {
+ rgblight_get_syncinfo((rgblight_syncinfo_t *)&serial_rgblight.rgblight_sync);
+ if (soft_serial_transaction(PUT_RGBLIGHT) == TRANSACTION_END) {
+ rgblight_clear_change_flags();
+ }
+ }
+}
+
+void transport_rgblight_slave(void) {
+ if (status_rgblight == TRANSACTION_ACCEPTED) {
+ rgblight_update_sync((rgblight_syncinfo_t *)&serial_rgblight.rgblight_sync,
+ false);
+ status_rgblight = TRANSACTION_END;
+ }
+}
+
+#else
+#define transport_rgblight_master()
+#define transport_rgblight_slave()
+#endif
+
bool transport_master(matrix_row_t matrix[]) {
- if (soft_serial_transaction()) {
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+ if (soft_serial_transaction() != TRANSACTION_END) {
return false;
}
+#else
+ transport_rgblight_master();
+ if (soft_serial_transaction(GET_SLAVE_MATRIX) != TRANSACTION_END) {
+ return false;
+ }
+#endif
// TODO: if MATRIX_COLS > 8 change to unpack()
for (int i = 0; i < ROWS_PER_HAND; ++i) {
serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
# endif
-# if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
- static rgblight_config_t prev_rgb = {~0};
- uint32_t rgb = rgblight_read_dword();
- if (rgb != prev_rgb.raw) {
- serial_m2s_buffer.rgblight_config.raw = rgb;
- prev_rgb.raw = rgb;
- }
-# endif
-
# ifdef ENCODER_ENABLE
- encoder_update_raw((uint8_t*)&serial_s2m_buffer.encoder_state);
+ encoder_update_raw((uint8_t *)serial_s2m_buffer.encoder_state);
# endif
return true;
}
void transport_slave(matrix_row_t matrix[]) {
+ transport_rgblight_slave();
// TODO: if MATRIX_COLS > 8 change to pack()
for (int i = 0; i < ROWS_PER_HAND; ++i) {
serial_s2m_buffer.smatrix[i] = matrix[i];
# ifdef BACKLIGHT_ENABLE
backlight_set(serial_m2s_buffer.backlight_level);
# endif
-# if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
- // Update RGB config with the new data
- rgblight_update_dword(serial_m2s_buffer.rgblight_config.raw);
-# endif
# ifdef ENCODER_ENABLE
- encoder_state_raw((uint8_t*)&serial_s2m_buffer.encoder_state);
+ encoder_state_raw((uint8_t *)serial_s2m_buffer.encoder_state);
# endif
+
}
#endif
projects / qmk_firmware.git / blobdiff