uhk/firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Extract LedDriverValues from LedDriverStates to make them public, and make LedDriverStates values private.

Browse Source
This commit is contained in:
László Monda
2017-09-29 15:18:01 +02:00
parent fad17aeb32
commit 877cb78b0a
3 changed files with 21 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
right/src/led_display.c
View File

@@ -66,13 +66,13 @@ void LedDisplay_SetText(uint8_t length, const char* text) {
allSegmentSets |= characterToSegmentSet(text[0]); allSegmentSets |= characterToSegmentSet(text[0]);
} }
LedDriverStates[LedDriverId_Left].sourceLedValues[11] = allSegmentSets & 0b00000001 ? LED_BRIGHTNESS_LEVEL : 0; LedDriverValues[LedDriverId_Left][11] = allSegmentSets & 0b00000001 ? LED_BRIGHTNESS_LEVEL : 0;
LedDriverStates[LedDriverId_Left].sourceLedValues[12] = allSegmentSets & 0b00000010 ? LED_BRIGHTNESS_LEVEL : 0; LedDriverValues[LedDriverId_Left][12] = allSegmentSets & 0b00000010 ? LED_BRIGHTNESS_LEVEL : 0;
allSegmentSets >>= 2; allSegmentSets >>= 2;
for (uint8_t i = 24; i <= 136; i += 16) { for (uint8_t i = 24; i <= 136; i += 16) {
for (uint8_t j = 0; j < 5; j++) { for (uint8_t j = 0; j < 5; j++) {
LedDriverStates[LedDriverId_Left].sourceLedValues[i + j] = allSegmentSets & 1 << j ? LED_BRIGHTNESS_LEVEL : 0; LedDriverValues[LedDriverId_Left][i + j] = allSegmentSets & 1 << j ? LED_BRIGHTNESS_LEVEL : 0;
} }
allSegmentSets >>= 5; allSegmentSets >>= 5;
} }
@@ -80,14 +80,14 @@ void LedDisplay_SetText(uint8_t length, const char* text) {
void LedDisplay_SetLayer(uint8_t layerId) { void LedDisplay_SetLayer(uint8_t layerId) {
for (uint8_t i = 13; i <= 45; i += 16) { for (uint8_t i = 13; i <= 45; i += 16) {
LedDriverStates[LedDriverId_Left].sourceLedValues[i] = 0; LedDriverValues[LedDriverId_Left][i] = 0;
} }
if (layerId >= LAYER_ID_MOD && layerId <= LAYER_ID_MOUSE) { if (layerId >= LAYER_ID_MOD && layerId <= LAYER_ID_MOUSE) {
LedDriverStates[LedDriverId_Left].sourceLedValues[16 * layerId - 3] = LED_BRIGHTNESS_LEVEL; LedDriverValues[LedDriverId_Left][16 * layerId - 3] = LED_BRIGHTNESS_LEVEL;
} }
} }
void LedDisplay_SetIcon(led_display_icon_t icon, bool isEnabled) { void LedDisplay_SetIcon(led_display_icon_t icon, bool isEnabled) {
LedDriverStates[LedDriverId_Left].sourceLedValues[8 + icon] = isEnabled ? LED_BRIGHTNESS_LEVEL : 0; LedDriverValues[LedDriverId_Left][8 + icon] = isEnabled ? LED_BRIGHTNESS_LEVEL : 0;
} }

26
right/src/slave_drivers/is31fl3731_driver.c
View File

@@ -3,7 +3,9 @@
#include "slave_scheduler.h" #include "slave_scheduler.h"
#include "led_display.h" #include "led_display.h"
led_driver_state_t LedDriverStates[LED_DRIVER_MAX_COUNT] = { uint8_t LedDriverValues[LED_DRIVER_MAX_COUNT][LED_DRIVER_LED_COUNT];
static led_driver_state_t ledDriverStates[LED_DRIVER_MAX_COUNT] = {
{ {
.i2cAddress = I2C_ADDRESS_IS31FL3731_RIGHT, .i2cAddress = I2C_ADDRESS_IS31FL3731_RIGHT,
.setupLedControlRegistersCommand = { .setupLedControlRegistersCommand = {
@@ -61,19 +63,20 @@ uint8_t updatePwmRegistersBuffer[PWM_REGISTER_BUFFER_LENGTH];
void LedSlaveDriver_Init(uint8_t ledDriverId) { void LedSlaveDriver_Init(uint8_t ledDriverId) {
if (ledDriverId == ISO_KEY_LED_DRIVER_ID && IS_ISO) { if (ledDriverId == ISO_KEY_LED_DRIVER_ID && IS_ISO) {
LedDriverStates[LedDriverId_Left].setupLedControlRegistersCommand[ISO_KEY_CONTROL_REGISTER_POS] |= 1 << ISO_KEY_CONTROL_REGISTER_BIT; ledDriverStates[LedDriverId_Left].setupLedControlRegistersCommand[ISO_KEY_CONTROL_REGISTER_POS] |= 1 << ISO_KEY_CONTROL_REGISTER_BIT;
} }
led_driver_state_t *currentLedDriverState = LedDriverStates + ledDriverId; led_driver_state_t *currentLedDriverState = ledDriverStates + ledDriverId;
currentLedDriverState->phase = LedDriverPhase_SetFunctionFrame; currentLedDriverState->phase = LedDriverPhase_SetFunctionFrame;
currentLedDriverState->ledIndex = 0; currentLedDriverState->ledIndex = 0;
memset(LedDriverStates[ledDriverId].sourceLedValues, LED_BRIGHTNESS_LEVEL, LED_DRIVER_LED_COUNT); memset(LedDriverValues[ledDriverId], LED_BRIGHTNESS_LEVEL, LED_DRIVER_LED_COUNT);
LedDisplay_SetText(3, "ABC"); LedDisplay_SetText(3, "ABC");
} }
status_t LedSlaveDriver_Update(uint8_t ledDriverId) { status_t LedSlaveDriver_Update(uint8_t ledDriverId) {
status_t status = kStatus_Uhk_IdleSlave; status_t status = kStatus_Uhk_IdleSlave;
led_driver_state_t *currentLedDriverState = LedDriverStates + ledDriverId; uint8_t *ledValues = LedDriverValues[ledDriverId];
led_driver_state_t *currentLedDriverState = ledDriverStates + ledDriverId;
uint8_t *ledDriverPhase = &currentLedDriverState->phase; uint8_t *ledDriverPhase = &currentLedDriverState->phase;
uint8_t ledDriverAddress = currentLedDriverState->i2cAddress; uint8_t ledDriverAddress = currentLedDriverState->i2cAddress;
uint8_t *ledIndex = &currentLedDriverState->ledIndex; uint8_t *ledIndex = &currentLedDriverState->ledIndex;
@@ -101,19 +104,18 @@ status_t LedSlaveDriver_Update(uint8_t ledDriverId) {
case LedDriverPhase_InitLedValues: case LedDriverPhase_InitLedValues:
updatePwmRegistersBuffer[0] = FRAME_REGISTER_PWM_FIRST + *ledIndex; updatePwmRegistersBuffer[0] = FRAME_REGISTER_PWM_FIRST + *ledIndex;
uint8_t chunkSize = MIN(LED_DRIVER_LED_COUNT - *ledIndex, PMW_REGISTER_UPDATE_CHUNK_SIZE); uint8_t chunkSize = MIN(LED_DRIVER_LED_COUNT - *ledIndex, PMW_REGISTER_UPDATE_CHUNK_SIZE);
memcpy(updatePwmRegistersBuffer+1, currentLedDriverState->sourceLedValues + *ledIndex, chunkSize); memcpy(updatePwmRegistersBuffer+1, ledValues + *ledIndex, chunkSize);
status = I2cAsyncWrite(ledDriverAddress, updatePwmRegistersBuffer, chunkSize + 1); status = I2cAsyncWrite(ledDriverAddress, updatePwmRegistersBuffer, chunkSize + 1);
*ledIndex += chunkSize; *ledIndex += chunkSize;
if (*ledIndex >= LED_DRIVER_LED_COUNT) { if (*ledIndex >= LED_DRIVER_LED_COUNT) {
*ledIndex = 0; *ledIndex = 0;
#ifndef LED_DRIVER_FORCE_UPDATE #ifndef LED_DRIVER_FORCE_UPDATE
memcpy(currentLedDriverState->targetLedValues, currentLedDriverState->sourceLedValues, LED_DRIVER_LED_COUNT); memcpy(currentLedDriverState->targetLedValues, ledValues, LED_DRIVER_LED_COUNT);
*ledDriverPhase = LedDriverPhase_UpdateChangedLedValues; *ledDriverPhase = LedDriverPhase_UpdateChangedLedValues;
#endif #endif
} }
break; break;
case LedDriverPhase_UpdateChangedLedValues: { case LedDriverPhase_UpdateChangedLedValues: {
uint8_t *sourceLedValues = currentLedDriverState->sourceLedValues;
uint8_t *targetLedValues = currentLedDriverState->targetLedValues; uint8_t *targetLedValues = currentLedDriverState->targetLedValues;
uint8_t lastLedChunkStartIndex = LED_DRIVER_LED_COUNT - PMW_REGISTER_UPDATE_CHUNK_SIZE; uint8_t lastLedChunkStartIndex = LED_DRIVER_LED_COUNT - PMW_REGISTER_UPDATE_CHUNK_SIZE;
@@ -121,7 +123,7 @@ status_t LedSlaveDriver_Update(uint8_t ledDriverId) {
uint8_t count; uint8_t count;
for (count=0; count<LED_DRIVER_LED_COUNT; count++) { for (count=0; count<LED_DRIVER_LED_COUNT; count++) {
if (sourceLedValues[startLedIndex] != targetLedValues[startLedIndex]) { if (ledValues[startLedIndex] != targetLedValues[startLedIndex]) {
break; break;
} }
@@ -140,15 +142,15 @@ status_t LedSlaveDriver_Update(uint8_t ledDriverId) {
uint8_t maxEndLedIndex = startLedIndex + maxChunkSize - 1; uint8_t maxEndLedIndex = startLedIndex + maxChunkSize - 1;
uint8_t endLedIndex = startLedIndex; uint8_t endLedIndex = startLedIndex;
for (uint8_t index=startLedIndex; index<=maxEndLedIndex; index++) { for (uint8_t index=startLedIndex; index<=maxEndLedIndex; index++) {
if (sourceLedValues[index] != targetLedValues[index]) { if (ledValues[index] != targetLedValues[index]) {
endLedIndex = index; endLedIndex = index;
} }
} }
updatePwmRegistersBuffer[0] = FRAME_REGISTER_PWM_FIRST + startLedIndex; updatePwmRegistersBuffer[0] = FRAME_REGISTER_PWM_FIRST + startLedIndex;
uint8_t length = endLedIndex - startLedIndex + 1; uint8_t length = endLedIndex - startLedIndex + 1;
memcpy(updatePwmRegistersBuffer+1, currentLedDriverState->sourceLedValues + startLedIndex, length); memcpy(updatePwmRegistersBuffer+1, ledValues + startLedIndex, length);
memcpy(currentLedDriverState->targetLedValues + startLedIndex, currentLedDriverState->sourceLedValues + startLedIndex, length); memcpy(currentLedDriverState->targetLedValues + startLedIndex, ledValues + startLedIndex, length);
status = I2cAsyncWrite(ledDriverAddress, updatePwmRegistersBuffer, length+1); status = I2cAsyncWrite(ledDriverAddress, updatePwmRegistersBuffer, length+1);
*ledIndex += length; *ledIndex += length;
if (*ledIndex >= LED_DRIVER_LED_COUNT) { if (*ledIndex >= LED_DRIVER_LED_COUNT) {

3
right/src/slave_drivers/is31fl3731_driver.h
View File

@@ -37,7 +37,6 @@
typedef struct { typedef struct {
led_driver_phase_t phase; led_driver_phase_t phase;
uint8_t sourceLedValues[LED_DRIVER_LED_COUNT];
uint8_t targetLedValues[LED_DRIVER_LED_COUNT]; uint8_t targetLedValues[LED_DRIVER_LED_COUNT];
uint8_t ledIndex; uint8_t ledIndex;
uint8_t i2cAddress; uint8_t i2cAddress;
@@ -46,7 +45,7 @@
// Variables: // Variables:
extern led_driver_state_t LedDriverStates[LED_DRIVER_MAX_COUNT]; extern uint8_t LedDriverValues[LED_DRIVER_MAX_COUNT][LED_DRIVER_LED_COUNT];
// Functions: // Functions: