From 255d781305f316940ae7c8830b178940109add5d Mon Sep 17 00:00:00 2001 From: DrClaes Date: Thu, 25 May 2017 22:36:42 +0200 Subject: [PATCH 1/5] Improved Throttle LED functionality Fades the LED smoothly from the previous color through the chosen color to the next color as throttle is advanced. --- src/main/io/ledstrip.c | 237 ++++++++++++++++++++++++++--------------- 1 file changed, 150 insertions(+), 87 deletions(-) diff --git a/src/main/io/ledstrip.c b/src/main/io/ledstrip.c index 9740daa504..7f8494a6c5 100644 --- a/src/main/io/ledstrip.c +++ b/src/main/io/ledstrip.c @@ -27,53 +27,66 @@ #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/serial.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 "flight/failsafe.h" -#include "flight/imu.h" -#include "flight/mixer.h" -#include "flight/navigation.h" -#include "flight/pid.h" -#include "flight/servos.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/beeper.h" -#include "io/gimbal.h" -#include "io/gps.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/navigation.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" -PG_REGISTER_WITH_RESET_FN(ledStripConfig_t, ledStripConfig, PG_LED_STRIP_CONFIG, 0); +#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); +*/ static bool ledStripInitialised = false; static bool ledStripEnabled = true; +static ledStripConfig_t * currentLedStripConfig; static void ledStripDisable(void); @@ -155,29 +168,6 @@ 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; @@ -191,7 +181,7 @@ STATIC_UNIT_TESTED void updateDimensions(void) int minY = LED_XY_MASK; for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; int ledX = ledGetX(ledConfig); maxX = MAX(ledX, maxX); @@ -225,7 +215,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 = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; if (!(*ledConfig)) break; @@ -252,9 +242,9 @@ void reevaluateLedConfig(void) } // get specialColor by index -static const hsvColor_t* getSC(ledSpecialColorIds_e index) +static hsvColor_t* getSC(ledSpecialColorIds_e index) { - return &ledStripConfig()->colors[ledStripConfig()->specialColors.color[index]]; + return ¤tLedStripConfig->colors[currentLedStripConfig->specialColors.color[index]]; } static const char directionCodes[LED_DIRECTION_COUNT] = { 'N', 'E', 'S', 'W', 'U', 'D' }; @@ -278,7 +268,7 @@ bool parseLedStripConfig(int ledIndex, const char *config) }; static const char chunkSeparators[PARSE_STATE_COUNT] = {',', ':', ':', ':', '\0'}; - ledConfig_t *ledConfig = &ledStripConfigMutable()->ledConfigs[ledIndex]; + ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; memset(ledConfig, 0, sizeof(ledConfig_t)); int x = 0, y = 0, color = 0; // initialize to prevent warnings @@ -376,7 +366,7 @@ void generateLedConfig(ledConfig_t *ledConfig, char *ledConfigBuffer, size_t buf *fptr = 0; // TODO - check buffer length - tfp_sprintf(ledConfigBuffer, "%u,%u:%s:%s:%u", ledGetX(ledConfig), ledGetY(ledConfig), directions, baseFunctionOverlays, ledGetColor(ledConfig)); + sprintf(ledConfigBuffer, "%u,%u:%s:%s:%u", ledGetX(ledConfig), ledGetY(ledConfig), directions, baseFunctionOverlays, ledGetColor(ledConfig)); } typedef enum { @@ -389,7 +379,7 @@ typedef enum { static quadrant_e getLedQuadrant(const int ledIndex) { - const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; int x = ledGetX(ledConfig); int y = ledGetY(ledConfig); @@ -409,12 +399,12 @@ static quadrant_e getLedQuadrant(const int ledIndex) static hsvColor_t* getDirectionalModeColor(const int ledIndex, const modeColorIndexes_t *modeColors) { - const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; const int ledDirection = ledGetDirection(ledConfig); for (unsigned i = 0; i < LED_DIRECTION_COUNT; i++) { if (ledDirection & (1 << i)) { - return &ledStripConfigMutable()->colors[modeColors->color[i]]; + return ¤tLedStripConfig->colors[modeColors->color[i]]; } } @@ -442,21 +432,25 @@ static const struct { static void applyLedFixedLayers() { for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->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 + int fn = ledGetFunction(ledConfig); int hOffset = HSV_HUE_MAX; switch (fn) { case LED_FUNCTION_COLOR: - color = ledStripConfig()->colors[ledGetColor(ledConfig)]; - break; + 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]; + break; case LED_FUNCTION_FLIGHT_MODE: for (unsigned i = 0; i < ARRAYLEN(flightModeToLed); i++) if (!flightModeToLed[i].flightMode || FLIGHT_MODE(flightModeToLed[i].flightMode)) { - const hsvColor_t *directionalColor = getDirectionalModeColor(ledIndex, &ledStripConfig()->modeColors[flightModeToLed[i].ledMode]); + hsvColor_t *directionalColor = getDirectionalModeColor(ledIndex, ¤tLedStripConfig->modeColors[flightModeToLed[i].ledMode]); if (directionalColor) { color = *directionalColor; } @@ -471,7 +465,7 @@ static void applyLedFixedLayers() case LED_FUNCTION_BATTERY: color = HSV(RED); - hOffset += scaleRange(calculateBatteryPercentageRemaining(), 0, 100, -30, 120); + hOffset += scaleRange(calculateBatteryPercentage(), 0, 100, -30, 120); break; case LED_FUNCTION_RSSI: @@ -484,12 +478,24 @@ static void applyLedFixedLayers() } if (ledGetOverlayBit(ledConfig, LED_OVERLAY_THROTTLE)) { - hOffset += scaledAux; + if (rcData[THROTTLE] < (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); + } + 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); + } + hOffset = 0; } + color.h = (color.h + hOffset) % (HSV_HUE_MAX + 1); - - setLedHsv(ledIndex, &color); + setLedHsv(ledIndex, &color); } } @@ -497,7 +503,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 = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; if ((*ledConfig & mask) == mask) setLedHsv(ledIndex, color); } @@ -521,7 +527,7 @@ static void applyLedWarningLayer(bool updateNow, timeUs_t *timer) if (warningFlashCounter == 0) { // update when old flags was processed warningFlags = 0; - if (batteryConfig()->voltageMeterSource != VOLTAGE_METER_NONE && getBatteryState() != BATTERY_OK) + if (feature(FEATURE_VBAT) && getBatteryState() != BATTERY_OK) warningFlags |= 1 << WARNING_LOW_BATTERY; if (feature(FEATURE_FAILSAFE) && failsafeIsActive()) warningFlags |= 1 << WARNING_FAILSAFE; @@ -585,7 +591,7 @@ static void applyLedBatteryLayer(bool updateNow, timeUs_t *timer) *timer += timerDelayUs; if (!flash) { - const hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); + hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); applyLedHsv(LED_MOV_FUNCTION(LED_FUNCTION_BATTERY), bgc); } } @@ -614,7 +620,7 @@ static void applyLedRssiLayer(bool updateNow, timeUs_t *timer) *timer += timerDelay; if (!flash) { - const hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); + hsvColor_t *bgc = getSC(LED_SCOLOR_BACKGROUND); applyLedHsv(LED_MOV_FUNCTION(LED_FUNCTION_RSSI), bgc); } } @@ -695,7 +701,7 @@ static void applyLedIndicatorLayer(bool updateNow, timeUs_t *timer) } for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; if (ledGetOverlayBit(ledConfig, LED_OVERLAY_INDICATOR)) { if (getLedQuadrant(ledIndex) & quadrants) setLedHsv(ledIndex, flashColor); @@ -735,7 +741,7 @@ static void applyLedThrustRingLayer(bool updateNow, timeUs_t *timer) } for (int ledIndex = 0; ledIndex < ledCounts.count; ledIndex++) { - const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; if (ledGetFunction(ledConfig) == LED_FUNCTION_THRUST_RING) { bool applyColor; @@ -746,7 +752,7 @@ static void applyLedThrustRingLayer(bool updateNow, timeUs_t *timer) } if (applyColor) { - const hsvColor_t *ringColor = &ledStripConfig()->colors[ledGetColor(ledConfig)]; + const hsvColor_t *ringColor = ¤tLedStripConfig->colors[ledGetColor(ledConfig)]; setLedHsv(ledIndex, ringColor); } @@ -805,7 +811,7 @@ static void applyLarsonScannerLayer(bool updateNow, timeUs_t *timer) int scannerLedIndex = 0; for (unsigned i = 0; i < ledCounts.count; i++) { - const ledConfig_t *ledConfig = &ledStripConfig()->ledConfigs[i]; + const ledConfig_t *ledConfig = &ledConfigs[i]; if (ledGetOverlayBit(ledConfig, LED_OVERLAY_LARSON_SCANNER)) { hsvColor_t ledColor; @@ -834,7 +840,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 = &ledStripConfig()->ledConfigs[i]; + const ledConfig_t *ledConfig = &ledConfigs[i]; if (ledGetOverlayBit(ledConfig, LED_OVERLAY_BLINK) || (ledGetOverlayBit(ledConfig, LED_OVERLAY_LANDING_FLASH) && scaledThrottle < 50)) { @@ -862,7 +868,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 = &ledStripConfig()->ledConfigs[ledIndex]; + const ledConfig_t *ledConfig = ¤tLedStripConfig->ledConfigs[ledIndex]; if (ledGetY(ledConfig) == previousRow) { setLedHsv(ledIndex, getSC(LED_SCOLOR_ANIMATION)); @@ -924,7 +930,7 @@ void ledStripUpdate(timeUs_t currentTimeUs) return; } - if (IS_RC_MODE_ACTIVE(BOXLEDLOW) && !(ledStripConfig()->ledstrip_visual_beeper && isBeeperOn())) { + if (IS_RC_MODE_ACTIVE(BOXLEDLOW) && !(currentLedStripConfig->ledstrip_visual_beeper && isBeeperOn())) { if (ledStripEnabled) { ledStripDisable(); ledStripEnabled = false; @@ -955,7 +961,7 @@ 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[ledStripConfig()->ledstrip_aux_channel], PWM_RANGE_MIN, PWM_RANGE_MAX, 0, HSV_HUE_MAX + 1); + scaledAux = scaleRange(rcData[currentLedStripConfig->ledstrip_aux_channel], PWM_RANGE_MIN, PWM_RANGE_MAX, 0, HSV_HUE_MAX + 1); applyLedFixedLayers(); @@ -971,7 +977,7 @@ bool parseColor(int index, const char *colorConfig) { const char *remainingCharacters = colorConfig; - hsvColor_t *color = &ledStripConfigMutable()->colors[index]; + hsvColor_t *color = ¤tLedStripConfig->colors[index]; bool result = true; static const uint16_t hsv_limit[HSV_COLOR_COMPONENT_COUNT] = { @@ -1024,35 +1030,92 @@ 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; - ledStripConfigMutable()->modeColors[modeIndex].color[modeColorIndex] = colorIndex; + currentLedStripConfig->modeColors[modeIndex].color[modeColorIndex] = colorIndex; } else if (modeIndex == LED_SPECIAL) { if (modeColorIndex < 0 || modeColorIndex >= LED_SPECIAL_COLOR_COUNT) return false; - ledStripConfigMutable()->specialColors.color[modeColorIndex] = colorIndex; + currentLedStripConfig->specialColors.color[modeColorIndex] = colorIndex; } else if (modeIndex == LED_AUX_CHANNEL) { if (modeColorIndex < 0 || modeColorIndex >= 1) return false; - ledStripConfigMutable()->ledstrip_aux_channel = colorIndex; + currentLedStripConfig->ledstrip_aux_channel = colorIndex; } else { return false; } return true; } -void ledStripInit() +/* +void pgResetFn_ledConfigs(ledConfig_t *instance) { - colors = ledStripConfigMutable()->colors; - modeColors = ledStripConfig()->modeColors; - specialColors = ledStripConfig()->specialColors; + 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; ledStripInitialised = false; } void ledStripEnable(void) { + if (currentLedStripConfig == NULL) { + return; + } reevaluateLedConfig(); ledStripInitialised = true; - ws2811LedStripInit(ledStripConfig()->ioTag); + ws2811LedStripInit(currentLedStripConfig->ioTag); } static void ledStripDisable(void) From 1d091c317c1a4133e4473308729ca3dc5824b53d Mon Sep 17 00:00:00 2001 From: DrClaes Date: Sat, 27 May 2017 00:00:20 +0200 Subject: [PATCH 2/5] 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 7f8494a6c5..c07bd2a425 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) From be91983bb40a802c5a041054d608202dd98c619b Mon Sep 17 00:00:00 2001 From: DrClaes Date: Sat, 27 May 2017 08:05:21 +0200 Subject: [PATCH 3/5] Made suggested changes to style and function Style suggestions adopted. Use centerPWM (average of max and min PWM) for readability. No longer resets hOffset, means that other functions (battery and rssi, currently) which use this still add to the hue --- src/main/io/ledstrip.c | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/src/main/io/ledstrip.c b/src/main/io/ledstrip.c index c07bd2a425..21d82f7822 100644 --- a/src/main/io/ledstrip.c +++ b/src/main/io/ledstrip.c @@ -444,8 +444,8 @@ static void applyLedFixedLayers() for (int ledIndex = 0; ledIndex < ledCounts.count; 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 nextColor = *getSC(LED_SCOLOR_BACKGROUND); //next color above the one selected, or color 0 if your are at the maximum + hsvColor_t previousColor = *getSC(LED_SCOLOR_BACKGROUND); //Previous color to the one selected, modulo color count int fn = ledGetFunction(ledConfig); int hOffset = HSV_HUE_MAX; @@ -453,8 +453,8 @@ static void applyLedFixedLayers() switch (fn) { case LED_FUNCTION_COLOR: 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]; + nextColor = ledStripConfig()->colors[(ledGetColor(ledConfig)+1) % LED_CONFIGURABLE_COLOR_COUNT]; + previousColor = ledStripConfig()->colors[(ledGetColor(ledConfig)-1) % LED_CONFIGURABLE_COLOR_COUNT]; break; case LED_FUNCTION_FLIGHT_MODE: @@ -487,20 +487,20 @@ static void applyLedFixedLayers() break; } - if (ledGetOverlayBit(ledConfig, LED_OVERLAY_THROTTLE)) { - if (auxInput < (PWM_RANGE_MIN + PWM_RANGE_MAX)/2) //if below average - { - 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(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; //this makes throttle function override others, not sure which is best + if (ledGetOverlayBit(ledConfig, LED_OVERLAY_THROTTLE)) { //smooth fade with selected Aux channel of all HSV values from previousColor through color to nextColor + int centerPWM = (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2; + if (auxInput < centerPWM) //if below average + { + color.h = scaleRange(auxInput, PWM_RANGE_MIN, centerPWM, previousColor.h, color.h); + color.s = scaleRange(auxInput, PWM_RANGE_MIN, centerPWM, previousColor.s, color.s); + color.v = scaleRange(auxInput, PWM_RANGE_MIN, centerPWM, previousColor.v, color.v); + } + else + { + color.h = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.h, nextColor.h); + color.s = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.s, nextColor.s); + color.v = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.v, nextColor.v); + } } color.h = (color.h + hOffset) % (HSV_HUE_MAX + 1); @@ -971,8 +971,7 @@ 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[ledStripConfig()->ledstrip_aux_channel], PWM_RANGE_MIN, PWM_RANGE_MAX, 0, HSV_HUE_MAX + 1); - auxInput = rcData[ledStripConfig()->ledstrip_aux_channel]; + auxInput = rcData[ledStripConfig()->ledstrip_aux_channel]; applyLedFixedLayers(); From 7566e4155059f9ee74832369dfc5aefbe6365b26 Mon Sep 17 00:00:00 2001 From: DrClaes Date: Sat, 27 May 2017 08:18:05 +0200 Subject: [PATCH 4/5] Fixed modulo math --- src/main/io/ledstrip.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/io/ledstrip.c b/src/main/io/ledstrip.c index 21d82f7822..ea315445eb 100644 --- a/src/main/io/ledstrip.c +++ b/src/main/io/ledstrip.c @@ -453,8 +453,8 @@ static void applyLedFixedLayers() switch (fn) { case LED_FUNCTION_COLOR: color = ledStripConfig()->colors[ledGetColor(ledConfig)]; - nextColor = ledStripConfig()->colors[(ledGetColor(ledConfig)+1) % LED_CONFIGURABLE_COLOR_COUNT]; - previousColor = ledStripConfig()->colors[(ledGetColor(ledConfig)-1) % LED_CONFIGURABLE_COLOR_COUNT]; + nextColor = ledStripConfig()->colors[(ledGetColor(ledConfig) + 1 + LED_CONFIGURABLE_COLOR_COUNT) % LED_CONFIGURABLE_COLOR_COUNT]; + previousColor = ledStripConfig()->colors[(ledGetColor(ledConfig) - 1 + LED_CONFIGURABLE_COLOR_COUNT) % LED_CONFIGURABLE_COLOR_COUNT]; break; case LED_FUNCTION_FLIGHT_MODE: @@ -500,7 +500,7 @@ static void applyLedFixedLayers() color.h = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.h, nextColor.h); color.s = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.s, nextColor.s); color.v = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.v, nextColor.v); - } + } } color.h = (color.h + hOffset) % (HSV_HUE_MAX + 1); From d22b32d969f903169e7b8b27f0549e191ba30472 Mon Sep 17 00:00:00 2001 From: DrClaes Date: Sat, 27 May 2017 10:38:57 +0200 Subject: [PATCH 5/5] Fixed whitespace --- src/main/io/ledstrip.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/main/io/ledstrip.c b/src/main/io/ledstrip.c index ea315445eb..c93283c1f5 100644 --- a/src/main/io/ledstrip.c +++ b/src/main/io/ledstrip.c @@ -178,7 +178,6 @@ void pgResetFn_ledStripConfig(ledStripConfig_t *ledStripConfig) } static int scaledThrottle; -//static int scaledAux; static int auxInput; static void updateLedRingCounts(void); @@ -487,9 +486,10 @@ static void applyLedFixedLayers() break; } - if (ledGetOverlayBit(ledConfig, LED_OVERLAY_THROTTLE)) { //smooth fade with selected Aux channel of all HSV values from previousColor through color to nextColor - int centerPWM = (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2; - if (auxInput < centerPWM) //if below average + if (ledGetOverlayBit(ledConfig, LED_OVERLAY_THROTTLE)) //smooth fade with selected Aux channel of all HSV values from previousColor through color to nextColor + { + int centerPWM = (PWM_RANGE_MIN + PWM_RANGE_MAX) / 2; + if (auxInput < centerPWM) { color.h = scaleRange(auxInput, PWM_RANGE_MIN, centerPWM, previousColor.h, color.h); color.s = scaleRange(auxInput, PWM_RANGE_MIN, centerPWM, previousColor.s, color.s); @@ -500,13 +500,10 @@ static void applyLedFixedLayers() color.h = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.h, nextColor.h); color.s = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.s, nextColor.s); color.v = scaleRange(auxInput, centerPWM, PWM_RANGE_MAX, color.v, nextColor.v); - } - } - + } + } color.h = (color.h + hOffset) % (HSV_HUE_MAX + 1); - setLedHsv(ledIndex, &color); - } }