From 1d091c317c1a4133e4473308729ca3dc5824b53d Mon Sep 17 00:00:00 2001 From: DrClaes Date: Sat, 27 May 2017 00:00:20 +0200 Subject: [PATCH] Adjusted throttle led behavior --- src/main/io/ledstrip.c | 244 +++++++++++++++++------------------------ 1 file changed, 99 insertions(+), 145 deletions(-) diff --git a/src/main/io/ledstrip.c b/src/main/io/ledstrip.c index 7f8494a6c..c07bd2a42 100644 --- a/src/main/io/ledstrip.c +++ b/src/main/io/ledstrip.c @@ -27,66 +27,52 @@ #include "build/build_config.h" +#include "common/axis.h" #include "common/color.h" #include "common/maths.h" +#include "common/printf.h" #include "common/typeconversion.h" +#include "common/utils.h" + +#include "config/feature.h" +#include "config/parameter_group.h" +#include "config/parameter_group_ids.h" #include "drivers/light_ws2811strip.h" -#include "drivers/system.h" #include "drivers/serial.h" -#include "drivers/sensor.h" -#include "drivers/accgyro.h" -#include "drivers/gpio.h" -#include "drivers/timer.h" -#include "drivers/rx_pwm.h" - -#include "common/printf.h" -#include "common/axis.h" -#include "common/utils.h" #include "fc/config.h" #include "fc/rc_controls.h" #include "fc/runtime_config.h" -#include "sensors/battery.h" -#include "sensors/sensors.h" -#include "sensors/boardalignment.h" -#include "sensors/gyro.h" -#include "sensors/acceleration.h" -#include "sensors/barometer.h" - -#include "io/ledstrip.h" -#include "io/beeper.h" -#include "io/motors.h" -#include "io/servos.h" -#include "io/gimbal.h" -#include "io/serial.h" -#include "io/gps.h" - #include "flight/failsafe.h" -#include "flight/mixer.h" -#include "flight/pid.h" #include "flight/imu.h" +#include "flight/mixer.h" #include "flight/navigation.h" +#include "flight/pid.h" +#include "flight/servos.h" + +#include "io/beeper.h" +#include "io/gimbal.h" +#include "io/gps.h" +#include "io/ledstrip.h" +#include "io/serial.h" #include "rx/rx.h" +#include "sensors/acceleration.h" +#include "sensors/barometer.h" +#include "sensors/battery.h" +#include "sensors/boardalignment.h" +#include "sensors/gyro.h" +#include "sensors/sensors.h" + #include "telemetry/telemetry.h" -#include "config/config_profile.h" -#include "config/config_master.h" -#include "config/feature.h" - -/* -PG_REGISTER_ARR_WITH_RESET_FN(ledConfig_t, LED_MAX_STRIP_LENGTH, ledConfigs, PG_LED_STRIP_CONFIG, 0); -PG_REGISTER_ARR_WITH_RESET_FN(hsvColor_t, LED_CONFIGURABLE_COLOR_COUNT, colors, PG_COLOR_CONFIG, 0); -PG_REGISTER_ARR_WITH_RESET_FN(modeColorIndexes_t, LED_MODE_COUNT, modeColors, PG_MODE_COLOR_CONFIG, 0); -PG_REGISTER_WITH_RESET_FN(specialColorIndexes_t, specialColors, PG_SPECIAL_COLOR_CONFIG, 0); -*/ +PG_REGISTER_WITH_RESET_FN(ledStripConfig_t, ledStripConfig, PG_LED_STRIP_CONFIG, 0); static bool ledStripInitialised = false; static bool ledStripEnabled = true; -static ledStripConfig_t * currentLedStripConfig; static void ledStripDisable(void); @@ -168,8 +154,32 @@ static const specialColorIndexes_t defaultSpecialColors[] = { }} }; +void pgResetFn_ledStripConfig(ledStripConfig_t *ledStripConfig) +{ + memset(ledStripConfig->ledConfigs, 0, LED_MAX_STRIP_LENGTH * sizeof(ledConfig_t)); + // copy hsv colors as default + memset(ledStripConfig->colors, 0, ARRAYLEN(hsv) * sizeof(hsvColor_t)); + BUILD_BUG_ON(LED_CONFIGURABLE_COLOR_COUNT < ARRAYLEN(hsv)); + for (unsigned colorIndex = 0; colorIndex < ARRAYLEN(hsv); colorIndex++) { + ledStripConfig->colors[colorIndex] = hsv[colorIndex]; + } + memcpy_fn(&ledStripConfig->modeColors, &defaultModeColors, sizeof(defaultModeColors)); + memcpy_fn(&ledStripConfig->specialColors, &defaultSpecialColors, sizeof(defaultSpecialColors)); + ledStripConfig->ledstrip_visual_beeper = 0; + ledStripConfig->ledstrip_aux_channel = THROTTLE; + + for (int i = 0; i < USABLE_TIMER_CHANNEL_COUNT; i++) { + if (timerHardware[i].usageFlags & TIM_USE_LED) { + ledStripConfig->ioTag = timerHardware[i].tag; + return; + } + } + ledStripConfig->ioTag = IO_TAG_NONE; +} + static int scaledThrottle; -static int scaledAux; +//static int scaledAux; +static int auxInput; static void updateLedRingCounts(void); @@ -181,7 +191,7 @@ STATIC_UNIT_TESTED void updateDimensions(void) int minY = LED_XY_MASK; for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; int ledX = ledGetX(ledConfig); maxX = MAX(ledX, maxX); @@ -215,7 +225,7 @@ STATIC_UNIT_TESTED void updateLedCount(void) int count = 0, countRing = 0, countScanner= 0; for (int ledIndex = 0; ledIndex < LED_MAX_STRIP_LENGTH; ledIndex++) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; if (!(*ledConfig)) break; @@ -242,9 +252,9 @@ void reevaluateLedConfig(void) } // get specialColor by index -static hsvColor_t* getSC(ledSpecialColorIds_e index) +static const hsvColor_t* getSC(ledSpecialColorIds_e index) { - return ¤tLedStripConfig->colors[currentLedStripConfig->specialColors.color[index]]; + return &ledStripConfig()->colors[ledStripConfig()->specialColors.color[index]]; } static const char directionCodes[LED_DIRECTION_COUNT] = { 'N', 'E', 'S', 'W', 'U', 'D' }; @@ -268,7 +278,7 @@ bool parseLedStripConfig(int ledIndex, const char *config) }; static const char chunkSeparators[PARSE_STATE_COUNT] = {',', ':', ':', ':', '\0'}; - ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + ledConfig_t *ledConfig = &ledStripConfigMutable()->ledConfigs[ledIndex]; memset(ledConfig, 0, sizeof(ledConfig_t)); int x = 0, y = 0, color = 0; // initialize to prevent warnings @@ -366,7 +376,7 @@ void generateLedConfig(ledConfig_t *ledConfig, char *ledConfigBuffer, size_t buf *fptr = 0; // TODO - check buffer length - sprintf(ledConfigBuffer, "%u,%u:%s:%s:%u", ledGetX(ledConfig), ledGetY(ledConfig), directions, baseFunctionOverlays, ledGetColor(ledConfig)); + tfp_sprintf(ledConfigBuffer, "%u,%u:%s:%s:%u", ledGetX(ledConfig), ledGetY(ledConfig), directions, baseFunctionOverlays, ledGetColor(ledConfig)); } typedef enum { @@ -379,7 +389,7 @@ typedef enum { static quadrant_e getLedQuadrant(const int ledIndex) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; int x = ledGetX(ledConfig); int y = ledGetY(ledConfig); @@ -399,12 +409,12 @@ static quadrant_e getLedQuadrant(const int ledIndex) static hsvColor_t* getDirectionalModeColor(const int ledIndex, const modeColorIndexes_t *modeColors) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; const int ledDirection = ledGetDirection(ledConfig); for (unsigned i = 0; i < LED_DIRECTION_COUNT; i++) { if (ledDirection & (1 << i)) { - return ¤tLedStripConfig->colors[modeColors->color[i]]; + return &ledStripConfigMutable()->colors[modeColors->color[i]]; } } @@ -432,25 +442,25 @@ static const struct { static void applyLedFixedLayers() { for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; hsvColor_t color = *getSC(LED_SCOLOR_BACKGROUND); - hsvColor_t color2 = *getSC(LED_SCOLOR_BACKGROUND); //next color above the one selected, or color 0 if your are at the maximum - hsvColor_t color0 = *getSC(LED_SCOLOR_BACKGROUND); //Previous color to the one selected, modulo color count - + hsvColor_t color2 = *getSC(LED_SCOLOR_BACKGROUND); //next color above the one selected, or color 0 if your are at the maximum + hsvColor_t color0 = *getSC(LED_SCOLOR_BACKGROUND); //Previous color to the one selected, modulo color count + int fn = ledGetFunction(ledConfig); int hOffset = HSV_HUE_MAX; switch (fn) { case LED_FUNCTION_COLOR: - color = currentLedStripConfig->colors[ledGetColor(ledConfig)]; - color2 = currentLedStripConfig->colors[(ledGetColor(ledConfig)+1) % LED_CONFIGURABLE_COLOR_COUNT]; - color0 = currentLedStripConfig->colors[(ledGetColor(ledConfig)-1) % LED_CONFIGURABLE_COLOR_COUNT]; + color = ledStripConfig()->colors[ledGetColor(ledConfig)]; + color2 = ledStripConfig()->colors[(ledGetColor(ledConfig)+1) % LED_CONFIGURABLE_COLOR_COUNT]; + color0 = ledStripConfig()->colors[(ledGetColor(ledConfig)-1) % LED_CONFIGURABLE_COLOR_COUNT]; break; case LED_FUNCTION_FLIGHT_MODE: for (unsigned i = 0; i < ARRAYLEN(flightModeToLed); i++) if (!flightModeToLed[i].flightMode || FLIGHT_MODE(flightModeToLed[i].flightMode)) { - hsvColor_t *directionalColor = getDirectionalModeColor(ledIndex, ¤tLedStripConfig->modeColors[flightModeToLed[i].ledMode]); + const hsvColor_t *directionalColor = getDirectionalModeColor(ledIndex, &ledStripConfig()->modeColors[flightModeToLed[i].ledMode]); if (directionalColor) { color = *directionalColor; } @@ -465,7 +475,7 @@ static void applyLedFixedLayers() case LED_FUNCTION_BATTERY: color = HSV(RED); - hOffset += scaleRange(calculateBatteryPercentage(), 0, 100, -30, 120); + hOffset += scaleRange(calculateBatteryPercentageRemaining(), 0, 100, -30, 120); break; case LED_FUNCTION_RSSI: @@ -478,24 +488,24 @@ static void applyLedFixedLayers() } if (ledGetOverlayBit(ledConfig, LED_OVERLAY_THROTTLE)) { - if (rcData[THROTTLE] < (PWM_RANGE_MIN + PWM_RANGE_MAX)/2) //if below average + if (auxInput < (PWM_RANGE_MIN + PWM_RANGE_MAX)/2) //if below average { - color.h = scaleRange(rcData[THROTTLE], PWM_RANGE_MIN, (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2, color0.h, color.h); //Fade the color smoothly from color to the next color from min to max throttle - color.s = scaleRange(rcData[THROTTLE], PWM_RANGE_MIN, (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2, color0.s, color.s); - color.v = scaleRange(rcData[THROTTLE], PWM_RANGE_MIN, (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2, color0.v, color.v); + color.h = scaleRange(auxInput, PWM_RANGE_MIN, (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2, color0.h, color.h); //Fade the color smoothly from color to the next color from min to max throttle + color.s = scaleRange(auxInput, PWM_RANGE_MIN, (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2, color0.s, color.s); + color.v = scaleRange(auxInput, PWM_RANGE_MIN, (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2, color0.v, color.v); } else { - color.h = scaleRange(rcData[THROTTLE], (PWM_RANGE_MAX + PWM_RANGE_MIN) / 2, PWM_RANGE_MAX, color.h, color2.h); //Fade the color smoothly from color to the next color from min to max throttle - color.s = scaleRange(rcData[THROTTLE], (PWM_RANGE_MAX + PWM_RANGE_MIN) / 2, PWM_RANGE_MAX, color.s, color2.s); - color.v = scaleRange(rcData[THROTTLE], (PWM_RANGE_MAX + PWM_RANGE_MIN) / 2, PWM_RANGE_MAX, color.v, color2.v); + color.h = scaleRange(auxInput, (PWM_RANGE_MAX + PWM_RANGE_MIN) / 2, PWM_RANGE_MAX, color.h, color2.h); //Fade the color smoothly from color to the next color from min to max throttle + color.s = scaleRange(auxInput, (PWM_RANGE_MAX + PWM_RANGE_MIN) / 2, PWM_RANGE_MAX, color.s, color2.s); + color.v = scaleRange(auxInput, (PWM_RANGE_MAX + PWM_RANGE_MIN) / 2, PWM_RANGE_MAX, color.v, color2.v); } - hOffset = 0; + hOffset = 0; //this makes throttle function override others, not sure which is best } - color.h = (color.h + hOffset) % (HSV_HUE_MAX + 1); - setLedHsv(ledIndex, &color); + + setLedHsv(ledIndex, &color); } } @@ -503,7 +513,7 @@ static void applyLedFixedLayers() static void applyLedHsv(uint32_t mask, const hsvColor_t *color) { for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; if ((*ledConfig & mask) == mask) setLedHsv(ledIndex, color); } @@ -527,7 +537,7 @@ static void applyLedWarningLayer(bool updateNow, timeUs_t *timer) if (warningFlashCounter == 0) { // update when old flags was processed warningFlags = 0; - if (feature(FEATURE_VBAT) && getBatteryState() != BATTERY_OK) + if (batteryConfig()->voltageMeterSource != VOLTAGE_METER_NONE && getBatteryState() != BATTERY_OK) warningFlags |= 1 << WARNING_LOW_BATTERY; if (feature(FEATURE_FAILSAFE) && failsafeIsActive()) warningFlags |= 1 << WARNING_FAILSAFE; @@ -591,7 +601,7 @@ static void applyLedBatteryLayer(bool updateNow, timeUs_t *timer) *timer += timerDelayUs; if (!flash) { - hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); + const hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); applyLedHsv(LED_MOV_FUNCTION(LED_FUNCTION_BATTERY), bgc); } } @@ -620,7 +630,7 @@ static void applyLedRssiLayer(bool updateNow, timeUs_t *timer) *timer += timerDelay; if (!flash) { - hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); + const hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); applyLedHsv(LED_MOV_FUNCTION(LED_FUNCTION_RSSI), bgc); } } @@ -701,7 +711,7 @@ static void applyLedIndicatorLayer(bool updateNow, timeUs_t *timer) } for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; if (ledGetOverlayBit(ledConfig, LED_OVERLAY_INDICATOR)) { if (getLedQuadrant(ledIndex) & quadrants) setLedHsv(ledIndex, flashColor); @@ -741,7 +751,7 @@ static void applyLedThrustRingLayer(bool updateNow, timeUs_t *timer) } for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; if (ledGetFunction(ledConfig) == LED_FUNCTION_THRUST_RING) { bool applyColor; @@ -752,7 +762,7 @@ static void applyLedThrustRingLayer(bool updateNow, timeUs_t *timer) } if (applyColor) { - const hsvColor_t *ringColor = ¤tLedStripConfig->colors[ledGetColor(ledConfig)]; + const hsvColor_t *ringColor = &ledStripConfig()->colors[ledGetColor(ledConfig)]; setLedHsv(ledIndex, ringColor); } @@ -811,7 +821,7 @@ static void applyLarsonScannerLayer(bool updateNow, timeUs_t *timer) int scannerLedIndex = 0; for (unsigned i = 0; i < ledCounts.count; i++) { - const ledConfig_t *ledConfig = &ledConfigs[i]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[i]; if (ledGetOverlayBit(ledConfig, LED_OVERLAY_LARSON_SCANNER)) { hsvColor_t ledColor; @@ -840,7 +850,7 @@ static void applyLedBlinkLayer(bool updateNow, timeUs_t *timer) bool ledOn = (blinkMask & 1); // b_b_____... if (!ledOn) { for (int i = 0; i < ledCounts.count; ++i) { - const ledConfig_t *ledConfig = &ledConfigs[i]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[i]; if (ledGetOverlayBit(ledConfig, LED_OVERLAY_BLINK) || (ledGetOverlayBit(ledConfig, LED_OVERLAY_LANDING_FLASH) && scaledThrottle < 50)) { @@ -868,7 +878,7 @@ static void applyLedAnimationLayer(bool updateNow, timeUs_t *timer) int nextRow = (frameCounter + 1 < animationFrames) ? frameCounter + 1 : 0; for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; if (ledGetY(ledConfig) == previousRow) { setLedHsv(ledIndex, getSC(LED_SCOLOR_ANIMATION)); @@ -930,7 +940,7 @@ void ledStripUpdate(timeUs_t currentTimeUs) return; } - if (IS_RC_MODE_ACTIVE(BOXLEDLOW) && !(currentLedStripConfig->ledstrip_visual_beeper && isBeeperOn())) { + if (IS_RC_MODE_ACTIVE(BOXLEDLOW) && !(ledStripConfig()->ledstrip_visual_beeper && isBeeperOn())) { if (ledStripEnabled) { ledStripDisable(); ledStripEnabled = false; @@ -961,7 +971,8 @@ void ledStripUpdate(timeUs_t currentTimeUs) // apply all layers; triggered timed functions has to update timers scaledThrottle = ARMING_FLAG(ARMED) ? scaleRange(rcData[THROTTLE], PWM_RANGE_MIN, PWM_RANGE_MAX, 0, 100) : 0; - scaledAux = scaleRange(rcData[currentLedStripConfig->ledstrip_aux_channel], PWM_RANGE_MIN, PWM_RANGE_MAX, 0, HSV_HUE_MAX + 1); + // scaledAux = scaleRange(rcData[ledStripConfig()->ledstrip_aux_channel], PWM_RANGE_MIN, PWM_RANGE_MAX, 0, HSV_HUE_MAX + 1); + auxInput = rcData[ledStripConfig()->ledstrip_aux_channel]; applyLedFixedLayers(); @@ -977,7 +988,7 @@ bool parseColor(int index, const char *colorConfig) { const char *remainingCharacters = colorConfig; - hsvColor_t *color = ¤tLedStripConfig->colors[index]; + hsvColor_t *color = &ledStripConfigMutable()->colors[index]; bool result = true; static const uint16_t hsv_limit[HSV_COLOR_COMPONENT_COUNT] = { @@ -1030,92 +1041,35 @@ bool setModeColor(ledModeIndex_e modeIndex, int modeColorIndex, int colorIndex) if (modeIndex < LED_MODE_COUNT) { // modeIndex_e is unsigned, so one-sided test is enough if(modeColorIndex < 0 || modeColorIndex >= LED_DIRECTION_COUNT) return false; - currentLedStripConfig->modeColors[modeIndex].color[modeColorIndex] = colorIndex; + ledStripConfigMutable()->modeColors[modeIndex].color[modeColorIndex] = colorIndex; } else if (modeIndex == LED_SPECIAL) { if (modeColorIndex < 0 || modeColorIndex >= LED_SPECIAL_COLOR_COUNT) return false; - currentLedStripConfig->specialColors.color[modeColorIndex] = colorIndex; + ledStripConfigMutable()->specialColors.color[modeColorIndex] = colorIndex; } else if (modeIndex == LED_AUX_CHANNEL) { if (modeColorIndex < 0 || modeColorIndex >= 1) return false; - currentLedStripConfig->ledstrip_aux_channel = colorIndex; + ledStripConfigMutable()->ledstrip_aux_channel = colorIndex; } else { return false; } return true; } -/* -void pgResetFn_ledConfigs(ledConfig_t *instance) +void ledStripInit() { - memcpy_fn(instance, &defaultLedStripConfig, sizeof(defaultLedStripConfig)); -} - -void pgResetFn_colors(hsvColor_t *instance) -{ - // copy hsv colors as default - BUILD_BUG_ON(ARRAYLEN(*colors_arr()) < ARRAYLEN(hsv)); - - for (unsigned colorIndex = 0; colorIndex < ARRAYLEN(hsv); colorIndex++) { - *instance++ = hsv[colorIndex]; - } -} - -void pgResetFn_modeColors(modeColorIndexes_t *instance) -{ - memcpy_fn(instance, &defaultModeColors, sizeof(defaultModeColors)); -} - -void pgResetFn_specialColors(specialColorIndexes_t *instance) -{ - memcpy_fn(instance, &defaultSpecialColors, sizeof(defaultSpecialColors)); -} -*/ - -void applyDefaultLedStripConfig(ledConfig_t *ledConfigs) -{ - memset(ledConfigs, 0, LED_MAX_STRIP_LENGTH * sizeof(ledConfig_t)); -} - -void applyDefaultColors(hsvColor_t *colors) -{ - // copy hsv colors as default - memset(colors, 0, ARRAYLEN(hsv) * sizeof(hsvColor_t)); - for (unsigned colorIndex = 0; colorIndex < ARRAYLEN(hsv); colorIndex++) { - *colors++ = hsv[colorIndex]; - } -} - -void applyDefaultModeColors(modeColorIndexes_t *modeColors) -{ - memcpy_fn(modeColors, &defaultModeColors, sizeof(defaultModeColors)); -} - -void applyDefaultSpecialColors(specialColorIndexes_t *specialColors) -{ - memcpy_fn(specialColors, &defaultSpecialColors, sizeof(defaultSpecialColors)); -} - -void ledStripInit(ledStripConfig_t *ledStripConfig) -{ - currentLedStripConfig = ledStripConfig; - - ledConfigs = currentLedStripConfig->ledConfigs; - colors = currentLedStripConfig->colors; - modeColors = currentLedStripConfig->modeColors; - specialColors = currentLedStripConfig->specialColors; + colors = ledStripConfigMutable()->colors; + modeColors = ledStripConfig()->modeColors; + specialColors = ledStripConfig()->specialColors; ledStripInitialised = false; } void ledStripEnable(void) { - if (currentLedStripConfig == NULL) { - return; - } reevaluateLedConfig(); ledStripInitialised = true; - ws2811LedStripInit(currentLedStripConfig->ioTag); + ws2811LedStripInit(ledStripConfig()->ioTag); } static void ledStripDisable(void)