8 #define ROWS_PER_HAND (MATRIX_ROWS / 2)
10 #ifdef RGBLIGHT_ENABLE
11 # include "rgblight.h"
14 #ifdef BACKLIGHT_ENABLE
15 # include "backlight.h"
16 extern backlight_config_t backlight_config;
23 #if defined(USE_I2C) || defined(EH)
25 # include "i2c_master.h"
26 # include "i2c_slave.h"
28 typedef struct __attribute__ ((__packed__)) {
29 #ifdef BACKLIGHT_ENABLE
30 uint8_t backlight_level;
32 #ifdef RGBLIGHT_ENABLE
33 uint32_t rgb_settings;
36 uint8_t encoder_state[NUMBER_OF_ENCODERS];
38 // Keep matrix last, we are only using this for it's offset
39 uint8_t matrix_start[0];
42 __attribute__ ((unused))
43 static transport_values_t transport_values;
45 #ifdef BACKLIGHT_ENABLE
46 # define I2C_BACKLIT_START (uint8_t)offsetof(transport_values_t, backlight_level)
49 #ifdef RGBLIGHT_ENABLE
50 # define I2C_RGB_START (uint8_t)offsetof(transport_values_t, rgb_settings)
54 # define I2C_ENCODER_START (uint8_t)offsetof(transport_values_t, encoder_state)
57 #define I2C_KEYMAP_START (uint8_t)offsetof(transport_values_t, matrix_start)
61 # ifndef SLAVE_I2C_ADDRESS
62 # define SLAVE_I2C_ADDRESS 0x32
65 // Get rows from other half over i2c
66 bool transport_master(matrix_row_t matrix[]) {
67 i2c_readReg(SLAVE_I2C_ADDRESS, I2C_KEYMAP_START, (void *)matrix, ROWS_PER_HAND * sizeof(matrix_row_t), TIMEOUT);
69 // write backlight info
70 # ifdef BACKLIGHT_ENABLE
71 uint8_t level = get_backlight_level();
72 if (level != transport_values.backlight_level) {
73 if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_BACKLIT_START, (void *)&level, sizeof(level), TIMEOUT) >= 0) {
74 transport_values.backlight_level = level;
79 # ifdef RGBLIGHT_ENABLE
80 uint32_t rgb = rgblight_read_dword();
81 if (rgb != transport_values.rgb_settings) {
82 if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_START, (void *)&rgb, sizeof(rgb), TIMEOUT) >= 0) {
83 transport_values.rgb_settings = rgb;
88 # ifdef ENCODER_ENABLE
89 i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)transport_values.encoder_state, sizeof(transport_values.encoder_state), TIMEOUT);
90 encoder_update_raw(&transport_values.encoder_state[0]);
96 void transport_slave(matrix_row_t matrix[]) {
97 // Copy matrix to I2C buffer
98 memcpy((void*)(i2c_slave_reg + I2C_KEYMAP_START), (void *)matrix, ROWS_PER_HAND * sizeof(matrix_row_t) );
100 // Read Backlight Info
101 # ifdef BACKLIGHT_ENABLE
102 backlight_set(i2c_slave_reg[I2C_BACKLIT_START]);
105 # ifdef RGBLIGHT_ENABLE
106 uint32_t rgb = *(uint32_t *)(i2c_slave_reg + I2C_RGB_START);
107 // Update the RGB with the new data
108 rgblight_update_dword(rgb);
111 # ifdef ENCODER_ENABLE
112 encoder_state_raw((uint8_t*)(i2c_slave_reg + I2C_ENCODER_START));
116 void transport_master_init(void) { i2c_init(); }
118 void transport_slave_init(void) { i2c_slave_init(SLAVE_I2C_ADDRESS); }
124 typedef struct __attribute__ ((__packed__)) {
125 # ifdef ENCODER_ENABLE
126 uint8_t encoder_state[NUMBER_OF_ENCODERS];
128 // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
129 matrix_row_t smatrix[ROWS_PER_HAND];
130 } Serial_s2m_buffer_t;
132 typedef struct __attribute__ ((__packed__)) {
133 # ifdef BACKLIGHT_ENABLE
134 uint8_t backlight_level;
136 # if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
137 rgblight_config_t rgblight_config; // not yet use
139 // When MCUs on both sides drive their respective RGB LED chains,
140 // it is necessary to synchronize, so it is necessary to communicate RGB
141 // information. In that case, define RGBLED_SPLIT with info on the number
142 // of LEDs on each half.
144 // Otherwise, if the master side MCU drives both sides RGB LED chains,
145 // there is no need to communicate.
147 } Serial_m2s_buffer_t;
149 volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
150 volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
151 uint8_t volatile status0 = 0;
153 SSTD_t transactions[] = {
156 sizeof(serial_m2s_buffer),
157 (uint8_t *)&serial_m2s_buffer,
158 sizeof(serial_s2m_buffer),
159 (uint8_t *)&serial_s2m_buffer,
163 void transport_master_init(void) { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
165 void transport_slave_init(void) { soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
167 bool transport_master(matrix_row_t matrix[]) {
168 if (soft_serial_transaction()) {
172 // TODO: if MATRIX_COLS > 8 change to unpack()
173 for (int i = 0; i < ROWS_PER_HAND; ++i) {
174 matrix[i] = serial_s2m_buffer.smatrix[i];
177 # ifdef BACKLIGHT_ENABLE
178 // Write backlight level for slave to read
179 serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
182 # if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
183 static rgblight_config_t prev_rgb = {~0};
184 uint32_t rgb = rgblight_read_dword();
185 if (rgb != prev_rgb.raw) {
186 serial_m2s_buffer.rgblight_config.raw = rgb;
191 # ifdef ENCODER_ENABLE
192 encoder_update_raw((uint8_t*)&serial_s2m_buffer.encoder_state);
198 void transport_slave(matrix_row_t matrix[]) {
199 // TODO: if MATRIX_COLS > 8 change to pack()
200 for (int i = 0; i < ROWS_PER_HAND; ++i) {
201 serial_s2m_buffer.smatrix[i] = matrix[i];
203 # ifdef BACKLIGHT_ENABLE
204 backlight_set(serial_m2s_buffer.backlight_level);
206 # if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
207 // Update RGB config with the new data
208 rgblight_update_dword(serial_m2s_buffer.rgblight_config.raw);
211 # ifdef ENCODER_ENABLE
212 encoder_state_raw((uint8_t*)&serial_s2m_buffer.encoder_state);