/* WS2812FX_fcn.cpp contains all utility functions Harm Aldick - 2016 www.aldick.org LICENSE The MIT License (MIT) Copyright (c) 2016 Harm Aldick Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Modified heavily for WLED */ #include "wled.h" #include "FX.h" #include "palettes.h" #ifdef ARDUINO_ARCH_ESP32 #include // WLEDMM to get esp_timer_get_time() #endif /* Custom per-LED mapping has moved! Create a file "ledmap.json" using the edit page. this is just an example (30 LEDs). It will first set all even, then all uneven LEDs. {"map":[ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]} another example. Switches direction every 5 LEDs. {"map":[ 0, 1, 2, 3, 4, 9, 8, 7, 6, 5, 10, 11, 12, 13, 14, 19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 29, 28, 27, 26, 25]} */ //factory defaults LED setup //#define PIXEL_COUNTS 30, 30, 30, 30 //#define DATA_PINS 16, 1, 3, 4 //#define DEFAULT_LED_TYPE TYPE_WS2812_RGB #ifndef PIXEL_COUNTS #define PIXEL_COUNTS DEFAULT_LED_COUNT #endif #ifndef DATA_PINS #define DATA_PINS LEDPIN #endif #ifndef DEFAULT_LED_TYPE #define DEFAULT_LED_TYPE TYPE_WS2812_RGB #endif #ifndef DEFAULT_LED_COLOR_ORDER #define DEFAULT_LED_COLOR_ORDER COL_ORDER_GRB //default to GRB #endif #if MAX_NUM_SEGMENTS < WLED_MAX_BUSSES #error "Max segments must be at least max number of busses!" #endif // WLEDMM experimental . this is a "C style" wrapper for strip.waitUntilIdle() // This workaround is just needed for the segment class, that does't know about "strip" void strip_wait_until_idle(String whoCalledMe) { #if defined(ARDUINO_ARCH_ESP32) && defined(WLEDMM_PROTECT_SERVICE) // WLEDMM experimental if (strip.isServicing() && (strncmp(pcTaskGetTaskName(NULL), "loopTask", 8) != 0)) { // if we are in looptask (arduino loop), its safe to proceed without waiting USER_PRINTLN(whoCalledMe + String(": strip is still drawing effects.")); strip.waitUntilIdle(); } #endif } /////////////////////////////////////////////////////////////////////////////// // Segment class implementation /////////////////////////////////////////////////////////////////////////////// uint16_t Segment::_usedSegmentData = 0U; // amount of RAM all segments use for their data[] CRGB *Segment::_globalLeds = nullptr; uint16_t Segment::maxWidth = DEFAULT_LED_COUNT; uint16_t Segment::maxHeight = 1; // copy constructor Segment::Segment(const Segment &orig) { USER_PRINTLN(F("-- Copy segment constructor --")); memcpy((void*)this, (void*)&orig, sizeof(Segment)); //WLEDMM copy to this name = nullptr; data = nullptr; _dataLen = 0; _t = nullptr; if (ledsrgb && !Segment::_globalLeds) ledsrgb = nullptr; //WLEDMM constructor so there was nothing. ledsrgb not freed as still used by orig! if (orig.name) { name = new char[strlen(orig.name)+1]; if (name) strcpy(name, orig.name); } if (orig.data) { if (allocateData(orig._dataLen)) memcpy(data, orig.data, orig._dataLen); } if (orig._t) { _t = new Transition(orig._t->_dur, orig._t->_briT, orig._t->_cctT, orig._t->_colorT); } if (orig.ledsrgb && !Segment::_globalLeds) { allocLeds(); if (ledsrgb) memcpy(ledsrgb, orig.ledsrgb, sizeof(CRGB)*length()); } jMap = nullptr; //WLEDMM jMap } //WLEDMM: recreate ledsrgb if more space needed (will not free ledsrgb!) void Segment::allocLeds() { if (!ledsrgb || sizeof(CRGB)*length() > ledsrgbSize) { USER_PRINTF("allocLeds %d from %d\n", sizeof(CRGB)*length(), ledsrgb?ledsrgbSize:0); ledsrgb = (CRGB*)malloc(sizeof(CRGB)*length()); ledsrgbSize = ledsrgb?sizeof(CRGB)*length():0; } else { USER_PRINTF("reuse Leds %d from %d\n", sizeof(CRGB)*length(), ledsrgb?ledsrgbSize:0); } } // move constructor Segment::Segment(Segment &&orig) noexcept { USER_PRINTLN(F("-- Move segment constructor --")); memcpy((void*)this, (void*)&orig, sizeof(Segment)); orig.name = nullptr; orig.data = nullptr; orig._dataLen = 0; orig._t = nullptr; orig.ledsrgb = nullptr; //WLEDMM: do not free as moved to here (constructor so there where no leds) orig.jMap = nullptr; //WLEDMM jMap } // copy assignment Segment& Segment::operator= (const Segment &orig) { USER_PRINTLN(F("-- Copying segment --")); if (this != &orig) { // clean destination if (name) delete[] name; if (_t) delete _t; // WLEDMM reuse leds instead of removing themn // if (ledsrgb && !Segment::_globalLeds) free(ledsrgb); //WLEDMM: nullify below! CRGB* oldLeds = ledsrgb; uint16_t oldLedsSize = ledsrgbSize; deallocateData(); // copy source memcpy((void*)this, (void*)&orig, sizeof(Segment)); // erase pointers to allocated data name = nullptr; data = nullptr; _dataLen = 0; _t = nullptr; if (!Segment::_globalLeds) {ledsrgb = oldLeds; ledsrgbSize = oldLedsSize;};// WLEDMM reuse leds instead of ledsrgb = nullptr; // copy source data if (orig.name) { name = new char[strlen(orig.name)+1]; if (name) strcpy(name, orig.name); } if (orig.data) { if (allocateData(orig._dataLen)) memcpy(data, orig.data, orig._dataLen); } if (orig._t) { _t = new Transition(orig._t->_dur, orig._t->_briT, orig._t->_cctT, orig._t->_colorT); } if (orig.ledsrgb && !Segment::_globalLeds) { allocLeds(); if (ledsrgb) memcpy(ledsrgb, orig.ledsrgb, sizeof(CRGB)*length()); } jMap = nullptr; //WLEDMM jMap } return *this; } // move assignment Segment& Segment::operator= (Segment &&orig) noexcept { USER_PRINTLN(F("-- Moving segment --")); if (this != &orig) { if (name) delete[] name; // free old name deallocateData(); // free old runtime data if (_t) delete _t; if (ledsrgb && !Segment::_globalLeds) free(ledsrgb); //WLEDMM: not needed anymore as we will use leds from copy. no need to nullify ledsrgb as it gets new value in memcpy memcpy((void*)this, (void*)&orig, sizeof(Segment)); orig.name = nullptr; orig.data = nullptr; orig._dataLen = 0; orig._t = nullptr; orig.ledsrgb = nullptr; //WLEDMM: do not free as moved to here orig.jMap = nullptr; //WLEDMM jMap } return *this; } bool Segment::allocateData(size_t len) { if (data && _dataLen == len) return true; //already allocated deallocateData(); if (Segment::getUsedSegmentData() + len > MAX_SEGMENT_DATA) return false; //not enough memory // if possible use SPI RAM on ESP32 #if defined(ARDUINO_ARCH_ESP32) && defined(BOARD_HAS_PSRAM) && defined(WLED_USE_PSRAM) if (psramFound()) data = (byte*) ps_malloc(len); else #endif data = (byte*) malloc(len); if (!data) return false; //allocation failed Segment::addUsedSegmentData(len); _dataLen = len; memset(data, 0, len); return true; } void Segment::deallocateData() { if (!data) return; free(data); data = nullptr; Segment::addUsedSegmentData(-_dataLen); _dataLen = 0; } /** * If reset of this segment was requested, clears runtime * settings of this segment. * Must not be called while an effect mode function is running * because it could access the data buffer and this method * may free that data buffer. */ void Segment::resetIfRequired() { if (reset) { //WLEDMM no need to free leds as we will reuse them // if (ledsrgb && !Segment::_globalLeds) { free(ledsrgb); ledsrgb = nullptr; } if (transitional && _t) { transitional = false; delete _t; _t = nullptr; } deallocateData(); next_time = 0; step = 0; call = 0; aux0 = 0; aux1 = 0; reset = false; // setOption(SEG_OPTION_RESET, false); } } void Segment::setUpLeds() { // deallocation happens in resetIfRequired() as it is called when segment changes or in destructor if (Segment::_globalLeds) #ifndef WLED_DISABLE_2D ledsrgb = &Segment::_globalLeds[start + startY*Segment::maxWidth]; #else leds = &Segment::_globalLeds[start]; #endif else if ((ledsrgb == nullptr) && (length() > 0)) { //softhack007 quickfix - avoid malloc(0) which is undefined behaviour (should not happen, but i've seen it) //#if defined(ARDUINO_ARCH_ESP32) && defined(BOARD_HAS_PSRAM) && defined(WLED_USE_PSRAM) //if (psramFound()) // ledsrgb = (CRGB*)ps_malloc(sizeof(CRGB)*length()); // softhack007 disabled; putting leds into psram leads to horrible slowdown on WROVER boards //else //#endif allocLeds(); //WLEDMM } } CRGBPalette16 &Segment::loadPalette(CRGBPalette16 &targetPalette, uint8_t pal) { static unsigned long _lastPaletteChange = 0; // perhaps it should be per segment static CRGBPalette16 randomPalette = CRGBPalette16(DEFAULT_COLOR); static CRGBPalette16 prevRandomPalette = CRGBPalette16(CRGB(BLACK)); byte tcp[76] = { 255 }; //WLEDMM: prevent out-of-range access in loadDynamicGradientPalette() if (pal < 245 && pal > GRADIENT_PALETTE_COUNT+13) pal = 0; if (pal > 245 && (strip.customPalettes.size() == 0 || 255U-pal > strip.customPalettes.size()-1)) pal = 0; //default palette. Differs depending on effect if (pal == 0) switch (mode) { case FX_MODE_FIRE_2012 : pal = 35; break; // heat palette case FX_MODE_COLORWAVES : pal = 26; break; // landscape 33 case FX_MODE_FILLNOISE8 : pal = 9; break; // ocean colors case FX_MODE_NOISE16_1 : pal = 20; break; // Drywet case FX_MODE_NOISE16_2 : pal = 43; break; // Blue cyan yellow case FX_MODE_NOISE16_3 : pal = 35; break; // heat palette case FX_MODE_NOISE16_4 : pal = 26; break; // landscape 33 case FX_MODE_GLITTER : pal = 11; break; // rainbow colors case FX_MODE_SUNRISE : pal = 35; break; // heat palette case FX_MODE_RAILWAY : pal = 3; break; // prim + sec case FX_MODE_2DSOAP : pal = 11; break; // rainbow colors } switch (pal) { case 0: //default palette. Exceptions for specific effects above targetPalette = PartyColors_p; break; case 1: {//periodically replace palette with a random one. Transition palette change in 500ms uint32_t timeSinceLastChange = millis() - _lastPaletteChange; if (timeSinceLastChange > randomPaletteChangeTime * 1000U) { prevRandomPalette = randomPalette; randomPalette = CRGBPalette16( CHSV(random8(), random8(160, 255), random8(128, 255)), CHSV(random8(), random8(160, 255), random8(128, 255)), CHSV(random8(), random8(160, 255), random8(128, 255)), CHSV(random8(), random8(160, 255), random8(128, 255))); _lastPaletteChange = millis(); timeSinceLastChange = 0; } //WLEDMM: smooth transitions of palettes instead of every 5 sec with short transition for (int i=0; i< 16; i++) { targetPalette[i].r = prevRandomPalette[i].r*(5000-timeSinceLastChange)/5000 + randomPalette[i].r*timeSinceLastChange/5000; targetPalette[i].g = prevRandomPalette[i].g*(5000-timeSinceLastChange)/5000 + randomPalette[i].g*timeSinceLastChange/5000; targetPalette[i].b = prevRandomPalette[i].b*(5000-timeSinceLastChange)/5000 + randomPalette[i].b*timeSinceLastChange/5000; } break;} case 74: {//periodically replace palette with a random one. Transition palette change in 500ms uint32_t timeSinceLastChange = millis() - _lastPaletteChange; if (timeSinceLastChange > randomPaletteChangeTime * 1000U) { prevRandomPalette = randomPalette; randomPalette = CRGBPalette16( CHSV(random8(), random8(160, 255), random8(128, 255)), CHSV(random8(), random8(160, 255), random8(128, 255)), CHSV(random8(), random8(160, 255), random8(128, 255)), CHSV(random8(), random8(160, 255), random8(128, 255))); _lastPaletteChange = millis(); timeSinceLastChange = 0; } if (timeSinceLastChange <= 250) { targetPalette = prevRandomPalette; // there needs to be 255 palette blends (48) for full blend but that is too resource intensive // so 128 is a compromise (we need to perform full blend of the two palettes as each segment can have random // palette selected but only 2 static palettes are used) size_t noOfBlends = ((128U * timeSinceLastChange) / 250U); for (size_t i=0; i245) { targetPalette = strip.customPalettes[255-pal]; // we checked bounds above } else { memcpy_P(tcp, (byte*)pgm_read_dword(&(gGradientPalettes[pal-13])), 72); targetPalette.loadDynamicGradientPalette(tcp); } break; } return targetPalette; } void Segment::startTransition(uint16_t dur) { if (transitional || _t) return; // already in transition no need to store anything // starting a transition has to occur before change so we get current values 1st uint8_t _briT = currentBri(on ? opacity : 0); uint8_t _cctT = currentBri(cct, true); CRGBPalette16 _palT = CRGBPalette16(DEFAULT_COLOR); loadPalette(_palT, palette); uint8_t _modeP = mode; uint32_t _colorT[NUM_COLORS]; for (size_t i=0; i_briT = _briT; _t->_cctT = _cctT; _t->_palT = _palT; _t->_modeP = _modeP; for (size_t i=0; i_colorT[i] = _colorT[i]; transitional = true; // setOption(SEG_OPTION_TRANSITIONAL, true); } // transition progression between 0-65535 uint16_t Segment::progress() { if (!transitional || !_t) return 0xFFFFU; uint32_t timeNow = millis(); if (timeNow - _t->_start > _t->_dur || _t->_dur == 0) return 0xFFFFU; return (timeNow - _t->_start) * 0xFFFFU / _t->_dur; } uint8_t Segment::currentBri(uint8_t briNew, bool useCct) { if (transitional && _t) { uint32_t prog = progress() + 1; if (useCct) return ((briNew * prog) + _t->_cctT * (0x10000 - prog)) >> 16; else return ((briNew * prog) + _t->_briT * (0x10000 - prog)) >> 16; } else { return briNew; } } uint8_t Segment::currentMode(uint8_t newMode) { return (progress()>32767U) ? newMode : _t->_modeP; // change effect in the middle of transition } uint32_t Segment::currentColor(uint8_t slot, uint32_t colorNew) { return transitional && _t ? color_blend(_t->_colorT[slot], colorNew, progress(), true) : colorNew; } CRGBPalette16 &Segment::currentPalette(CRGBPalette16 &targetPalette, uint8_t pal) { loadPalette(targetPalette, pal); if (transitional && _t && progress() < 0xFFFFU) { // blend palettes // there are about 255 blend passes of 48 "blends" to completely blend two palettes (in _dur time) // minimum blend time is 100ms maximum is 65535ms uint32_t timeMS = millis() - _t->_start; uint16_t noOfBlends = (255U * timeMS / _t->_dur) - _t->_prevPaletteBlends; for (int i=0; i_prevPaletteBlends++) nblendPaletteTowardPalette(_t->_palT, targetPalette, 48); targetPalette = _t->_palT; // copy transitioning/temporary palette } return targetPalette; } void Segment::handleTransition() { if (!transitional) return; unsigned long maxWait = millis() + 20; if (mode == FX_MODE_STATIC && next_time > maxWait) next_time = maxWait; if (progress() == 0xFFFFU) { if (_t) { if (_t->_modeP != mode) markForReset(); delete _t; _t = nullptr; } transitional = false; // finish transitioning segment } } void Segment::set(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, uint16_t ofs, uint16_t i1Y, uint16_t i2Y) { //return if neither bounds nor grouping have changed bool boundsUnchanged = (start == i1 && stop == i2); #ifndef WLED_DISABLE_2D if (Segment::maxHeight>1) boundsUnchanged &= (startY == i1Y && stopY == i2Y); // 2D #endif if (boundsUnchanged && (!grp || (grouping == grp && spacing == spc)) && (ofs == UINT16_MAX || ofs == offset)) return; if (stop) fill(BLACK); //turn old segment range off if (i2 <= i1) { //disable segment stop = 0; markForReset(); return; } if (i1 < Segment::maxWidth || (i1 >= Segment::maxWidth*Segment::maxHeight && i1 < strip.getLengthTotal())) start = i1; // Segment::maxWidth equals strip.getLengthTotal() for 1D stop = i2 > Segment::maxWidth*Segment::maxHeight ? min(i2,strip.getLengthTotal()) : (i2 > Segment::maxWidth ? Segment::maxWidth : max((uint16_t)1,i2)); // WLEDMM: use native min/max startY = 0; stopY = 1; #ifndef WLED_DISABLE_2D if (Segment::maxHeight>1) { // 2D if (i1Y < Segment::maxHeight) startY = i1Y; stopY = i2Y > Segment::maxHeight ? Segment::maxHeight : max((uint16_t)1,i2Y); // WLEDMM: use native min/max } #endif if (grp) { grouping = grp; spacing = spc; } if (ofs < UINT16_MAX) offset = ofs; markForReset(); if (!boundsUnchanged) refreshLightCapabilities(); } bool Segment::setColor(uint8_t slot, uint32_t c) { //returns true if changed if (slot >= NUM_COLORS || c == colors[slot]) return false; if (!_isRGB && !_hasW) { if (slot == 0 && c == BLACK) return false; // on/off segment cannot have primary color black if (slot == 1 && c != BLACK) return false; // on/off segment cannot have secondary color non black } if (fadeTransition) startTransition(strip.getTransition()); // start transition prior to change colors[slot] = c; stateChanged = true; // send UDP/WS broadcast return true; } void Segment::setCCT(uint16_t k) { if (k > 255) { //kelvin value, convert to 0-255 if (k < 1900) k = 1900; if (k > 10091) k = 10091; k = (k - 1900) >> 5; } if (cct == k) return; if (fadeTransition) startTransition(strip.getTransition()); // start transition prior to change cct = k; stateChanged = true; // send UDP/WS broadcast } void Segment::setOpacity(uint8_t o) { if (opacity == o) return; if (fadeTransition) startTransition(strip.getTransition()); // start transition prior to change opacity = o; stateChanged = true; // send UDP/WS broadcast } void Segment::setOption(uint8_t n, bool val) { bool prevOn = on; if (fadeTransition && n == SEG_OPTION_ON && val != prevOn) startTransition(strip.getTransition()); // start transition prior to change if (val) options |= 0x01 << n; else options &= ~(0x01 << n); if (!(n == SEG_OPTION_SELECTED || n == SEG_OPTION_RESET || n == SEG_OPTION_TRANSITIONAL)) stateChanged = true; // send UDP/WS broadcast } void Segment::setMode(uint8_t fx, bool loadDefaults) { //WLEDMM: return to old setting if not explicitly set static int16_t oldMap = -1; static int16_t oldSim = -1; static int16_t oldPalette = -1; static byte oldReverse = -1; static byte oldMirror = -1; static byte oldReverse_y = -1; static byte oldMirror_y = -1; // if we have a valid mode & is not reserved if (fx < strip.getModeCount() && strncmp_P("RSVD", strip.getModeData(fx), 4)) { if (fx != mode) { startTransition(strip.getTransition()); // set effect transitions //markForReset(); // transition will handle this mode = fx; // load default values from effect string if (loadDefaults) { int16_t sOpt; sOpt = extractModeDefaults(fx, "sx"); speed = (sOpt >= 0) ? sOpt : DEFAULT_SPEED; sOpt = extractModeDefaults(fx, "ix"); intensity = (sOpt >= 0) ? sOpt : DEFAULT_INTENSITY; sOpt = extractModeDefaults(fx, "c1"); custom1 = (sOpt >= 0) ? sOpt : DEFAULT_C1; sOpt = extractModeDefaults(fx, "c2"); custom2 = (sOpt >= 0) ? sOpt : DEFAULT_C2; sOpt = extractModeDefaults(fx, "c3"); custom3 = (sOpt >= 0) ? sOpt : DEFAULT_C3; sOpt = extractModeDefaults(fx, "o1"); check1 = (sOpt >= 0) ? (bool)sOpt : false; sOpt = extractModeDefaults(fx, "o2"); check2 = (sOpt >= 0) ? (bool)sOpt : false; sOpt = extractModeDefaults(fx, "o3"); check3 = (sOpt >= 0) ? (bool)sOpt : false; //WLEDMM: return to old setting if not explicitly set sOpt = extractModeDefaults(fx, "m12"); if (sOpt >= 0) {if (oldMap==-1) oldMap = map1D2D; map1D2D = constrain(sOpt, 0, 7);} else {if (oldMap!=-1) map1D2D = oldMap; oldMap = -1;} sOpt = extractModeDefaults(fx, "si"); if (sOpt >= 0) {if (oldSim==-1) oldSim = soundSim; soundSim = constrain(sOpt, 0, 7);} else {if (oldSim!=-1) soundSim = oldSim; oldSim = -1;} sOpt = extractModeDefaults(fx, "rev"); if (sOpt >= 0) {if (oldReverse==-1) oldReverse = reverse; reverse = (bool)sOpt;} else {if (oldReverse!=-1) reverse = oldReverse==1; oldReverse = -1;} sOpt = extractModeDefaults(fx, "mi"); if (sOpt >= 0) {if (oldMirror==-1) oldMirror = mirror; mirror = (bool)sOpt;} else {if (oldMirror!=-1) mirror = oldMirror==1; oldMirror = -1;} // NOTE: setting this option is a risky business sOpt = extractModeDefaults(fx, "rY"); if (sOpt >= 0) {if (oldReverse_y==-1) oldReverse_y = reverse_y; reverse_y = (bool)sOpt;} else {if (oldReverse_y!=-1) reverse_y = oldReverse_y==1; oldReverse_y = -1;} sOpt = extractModeDefaults(fx, "mY"); if (sOpt >= 0) {if (oldMirror_y==-1) oldMirror_y = mirror_y; mirror_y = (bool)sOpt;} else {if (oldMirror_y!=-1) mirror_y = oldMirror_y==1; oldMirror_y = -1;} // NOTE: setting this option is a risky business sOpt = extractModeDefaults(fx, "pal"); if (sOpt >= 0) {if (oldPalette==-1) oldPalette = palette; setPalette(sOpt);} else {if (oldPalette!=-1) setPalette(oldPalette); oldPalette = -1;} } stateChanged = true; // send UDP/WS broadcast } } } void Segment::setPalette(uint8_t pal) { if (pal < 245 && pal > GRADIENT_PALETTE_COUNT+13) pal = 0; // built in palettes if (pal > 245 && (strip.customPalettes.size() == 0 || 255U-pal > strip.customPalettes.size()-1)) pal = 0; // custom palettes if (pal != palette) { if (strip.paletteFade) startTransition(strip.getTransition()); palette = pal; stateChanged = true; // send UDP/WS broadcast } } // 2D matrix // // WLEDMM Segment::virtualWidth() and Segment::virtualHeight() are declared inline, see FX.h // uint16_t Segment::nrOfVStrips() const { uint16_t vLen = 1; #ifndef WLED_DISABLE_2D if (is2D()) { switch (map1D2D) { case M12_pBar: vLen = virtualWidth(); break; case M12_sCircle: //WLEDMM vLen = (virtualWidth() + virtualHeight()) / 6; // take third of the average width break; case M12_sBlock: //WLEDMM vLen = (virtualWidth() + virtualHeight()) / 8; // take half of the average width break; } } #endif return vLen; } //WLEDMM jMap struct XandY { uint8_t x; uint8_t y; }; struct ArrayAndSize { uint8_t size; XandY *array; }; class JMapC { public: char previousSegmentName[50] = ""; ~JMapC() { USER_PRINTLN("~JMapC"); deletejVectorMap(); } void deletejVectorMap() { if (jVectorMap.size() > 0) { USER_PRINTLN("delete jVectorMap"); for (size_t i=0; i 0) return size; else return SEGMENT.virtualWidth() * SEGMENT.virtualHeight(); //pixels } void setPixelColor(uint16_t i, uint32_t col) { updatejMapDoc(); if (jVectorMap.size() > i) { if (i==0) { SEGMENT.fadeToBlackBy(10); //as not all pixels used } for (int j=0; j 0) return SEGMENT.getPixelColorXY(jVectorMap[i].array[0].x * scale, jVectorMap[i].array[0].y * scale); else return 0; } private: std::vector jVectorMap; StaticJsonDocument<4096> docChunk; //must fit forks with about 32 points each uint8_t scale; void updatejMapDoc() { if (SEGMENT.name == nullptr && jVectorMap.size() > 0) { deletejVectorMap(); } else if (SEGMENT.name != nullptr && strcmp(SEGMENT.name, previousSegmentName) != 0) { uint32_t dataSize = 0; deletejVectorMap(); USER_PRINT("New "); USER_PRINTLN(SEGMENT.name); char jMapFileName[50]; strcpy(jMapFileName, "/"); strcat(jMapFileName, SEGMENT.name); strcat(jMapFileName, ".json"); File jMapFile; jMapFile = WLED_FS.open(jMapFileName, "r"); uint_fast16_t maxWidth = 0; // WLEDMM fix uint8 overflow for large width/height uint_fast16_t maxHeight = 0; // WLEDMM //https://arduinojson.org/v6/how-to/deserialize-a-very-large-document/ jMapFile.find("["); do { //for each element in the array DeserializationError err = deserializeJson(docChunk, jMapFile); // serializeJson(docChunk, Serial); USER_PRINTLN(); // USER_PRINTF("docChunk %u / %u%% (%u %u %u) %u\n", (unsigned int)docChunk.memoryUsage(), 100 * docChunk.memoryUsage() / docChunk.capacity(), (unsigned int)docChunk.size(), docChunk.overflowed(), (unsigned int)docChunk.nesting(), jMapFile.size()); if (err) { USER_PRINTF("deserializeJson() of parseTree failed with code %s\n", err.c_str()); if (SEGMENT.name) delete[] SEGMENT.name; SEGMENT.name = nullptr; //need to clear the name as otherwise continuously loaded // softhack007 avoid deleting nullptr return; } if (docChunk.is()) { //each item is or an array of arrays (fork) or an array of x,y (no fork) //fill the vector with arrays and get the width and height of the jMap JsonArray arrayChunk = docChunk.as(); ArrayAndSize arrayAndSize; arrayAndSize.size = 0; if (arrayChunk[0].is()) { //if array of arrays arrayAndSize.array = new XandY[arrayChunk.size()]; for (JsonVariant arrayElement: arrayChunk) { maxWidth = max((uint16_t)maxWidth, arrayElement[0].as()); // WLEDMM use native min/max maxHeight = max((uint16_t)maxHeight, arrayElement[1].as()); // WLEDMM arrayAndSize.array[arrayAndSize.size].x = arrayElement[0].as(); arrayAndSize.array[arrayAndSize.size].y = arrayElement[1].as(); arrayAndSize.size++; dataSize += sizeof(XandY); } } else { // if array (of x and y) arrayAndSize.array = new XandY[1]; maxWidth = max((uint16_t)maxWidth, arrayChunk[0].as()); // WLEDMM use native min/max maxHeight = max((uint16_t)maxHeight, arrayChunk[1].as()); // WLEDMM arrayAndSize.array[arrayAndSize.size].x = arrayChunk[0].as(); arrayAndSize.array[arrayAndSize.size].y = arrayChunk[1].as(); arrayAndSize.size++; dataSize += sizeof(XandY); } jVectorMap.push_back(arrayAndSize); dataSize += sizeof(arrayAndSize); } } while (jMapFile.findUntil(",", "]")); jMapFile.close(); maxWidth++; maxHeight++; scale = min(SEGMENT.virtualWidth() / maxWidth, SEGMENT.virtualHeight() / maxHeight); // WLEDMM use native min/max dataSize += sizeof(jVectorMap); USER_PRINT("dataSize "); USER_PRINT(dataSize); USER_PRINT(" scale "); USER_PRINTLN(scale); strcpy(previousSegmentName, SEGMENT.name); } } //updatejMapDoc }; //class JMapC //WLEDMM jMap void Segment::createjMap() { if (!jMap) { USER_PRINTLN("createjMap"); jMap = new JMapC(); } } //WLEDMM jMap void Segment::deletejMap() { //Should be called from ~Segment but causes crash (and ~Segment is called quite often...) if (jMap) { USER_PRINTLN("deletejMap"); delete (JMapC *)jMap; jMap = nullptr; } } // 1D strip uint16_t Segment::virtualLength() const { #ifndef WLED_DISABLE_2D if (is2D()) { uint16_t vW = virtualWidth(); uint16_t vH = virtualHeight(); uint16_t vLen = vW * vH; // use all pixels from segment switch (map1D2D) { case M12_pBar: vLen = vH; break; case M12_pCorner: case M12_pArc: vLen = max(vW,vH); // get the longest dimension break; case M12_jMap: //WLEDMM jMap if (jMap) vLen = ((JMapC *)jMap)->length(); break; case M12_sCircle: //WLEDMM vLen = max(vW,vH); // get the longest dimension // vLen = (virtualWidth() + virtualHeight()) * 3; break; case M12_sBlock: //WLEDMM if (nrOfVStrips()>1) vLen = max(vW,vH) * 4;//0.5; // get the longest dimension else vLen = max(vW,vH) * 0.5; // get the longest dimension break; } return vLen; } #endif uint16_t groupLen = groupLength(); uint16_t vLength = (length() + groupLen - 1) / groupLen; if (mirror) vLength = (vLength + 1) /2; // divide by 2 if mirror, leave at least a single LED return vLength; } //WLEDMM used for M12_sBlock void xyFromBlock(uint16_t &x,uint16_t &y, uint16_t i, uint16_t vW, uint16_t vH, uint16_t vStrip) { float i2; if (i<=SEGLEN*0.25) { //top, left to right i2 = i/(SEGLEN*0.25); x = vW / 2 - vStrip - 1 + i2 * vStrip * 2; y = vH / 2 - vStrip - 1; } else if (i <= SEGLEN * 0.5) { //right, top to bottom i2 = (i-SEGLEN*0.25)/(SEGLEN*0.25); x = vW / 2 + vStrip; y = vH / 2 - vStrip - 1 + i2 * vStrip * 2; } else if (i <= SEGLEN * 0.75) { //bottom, right to left i2 = (i-SEGLEN*0.5)/(SEGLEN*0.25); x = vW / 2 + vStrip - i2 * vStrip * 2; y = vH / 2 + vStrip; } else if (i <= SEGLEN) { //left, bottom to top i2 = (i-SEGLEN*0.75)/(SEGLEN*0.25); x = vW / 2 - vStrip - 1; y = vH / 2 + vStrip - i2 * vStrip * 2; } } void IRAM_ATTR_YN Segment::setPixelColor(int i, uint32_t col) //WLEDMM: IRAM_ATTR conditionaly { #ifndef WLED_DISABLE_2D int vStrip = i>>16; // hack to allow running on virtual strips (2D segment columns/rows) #endif i &= 0xFFFF; if (i >= virtualLength() || i<0) return; // if pixel would fall out of segment just exit #ifndef WLED_DISABLE_2D if (is2D()) { uint16_t vH = virtualHeight(); // segment height in logical pixels uint16_t vW = virtualWidth(); switch (map1D2D) { case M12_Pixels: // use all available pixels as a long strip setPixelColorXY(i % vW, i / vW, col); break; case M12_pBar: // expand 1D effect vertically or have it play on virtual strips if (vStrip>0) setPixelColorXY(vStrip - 1, vH - i - 1, col); else for (int x = 0; x < vW; x++) setPixelColorXY(x, vH - i - 1, col); break; case M12_pArc: // expand in circular fashion from center if (i==0) setPixelColorXY(0, 0, col); else { //WLEDMM: drawArc(0, 0, i, col); could work as alternative float step = HALF_PI / (2.85f*i); for (float rad = 0.0f; rad <= HALF_PI+step/2; rad += step) { // may want to try float version as well (with or without antialiasing) int x = roundf(sin_t(rad) * i); int y = roundf(cos_t(rad) * i); setPixelColorXY(x, y, col); } // Bresenham’s Algorithm (may not fill every pixel) //int d = 3 - (2*i); //int y = i, x = 0; //while (y >= x) { // setPixelColorXY(x, y, col); // setPixelColorXY(y, x, col); // x++; // if (d > 0) { // y--; // d += 4 * (x - y) + 10; // } else { // d += 4 * x + 6; // } //} } break; case M12_pCorner: for (int x = 0; x <= i; x++) setPixelColorXY(x, i, col); for (int y = 0; y < i; y++) setPixelColorXY(i, y, col); break; case M12_jMap: //WLEDMM jMap if (jMap) ((JMapC *)jMap)->setPixelColor(i, col); break; case M12_sCircle: //WLEDMM if (vStrip > 0) { int x = roundf(sin_t(360*i/SEGLEN*DEG_TO_RAD) * vW * (vStrip+1)/nrOfVStrips()); int y = roundf(cos_t(360*i/SEGLEN*DEG_TO_RAD) * vW * (vStrip+1)/nrOfVStrips()); setPixelColorXY(x + vW/2, y + vH/2, col); } else // pArc -> circle drawArc(vW/2, vH/2, i/2, col); break; case M12_sBlock: //WLEDMM if (vStrip > 0) { //vStrip+1 is distance from centre, i is how much of the square is filled uint16_t x=0,y=0; xyFromBlock(x,y, i, vW, vH, (vStrip+1)*2); setPixelColorXY(x, y, col); } else { // pCorner -> block for (int x = vW / 2 - i - 1; x <= vW / 2 + i; x++) { // top and bottom horizontal lines setPixelColorXY(x, vH / 2 - i - 1, col); setPixelColorXY(x, vH / 2 + i , col); } for (int y = vH / 2 - i - 1 + 1; y <= vH / 2 + i - 1; y++) { //left and right vertical lines setPixelColorXY(vW / 2 - i - 1, y, col); setPixelColorXY(vW / 2 + i , y, col); } } break; } return; } else if (Segment::maxHeight!=1 && (width()==1 || height()==1)) { if (start < Segment::maxWidth*Segment::maxHeight) { // we have a vertical or horizontal 1D segment (WARNING: virtual...() may be transposed) int x = 0, y = 0; if (virtualHeight()>1) y = i; if (virtualWidth() >1) x = i; setPixelColorXY(x, y, col); return; } } #endif if (ledsrgb) ledsrgb[i] = col; uint16_t len = length(); uint8_t _bri_t = currentBri(on ? opacity : 0); if (!_bri_t && !transitional && fadeTransition) return; // if _bri_t == 0 && segment is not transitionig && transitions are enabled then save a few CPU cycles if (_bri_t < 255) { byte r = scale8(R(col), _bri_t); byte g = scale8(G(col), _bri_t); byte b = scale8(B(col), _bri_t); byte w = scale8(W(col), _bri_t); col = RGBW32(r, g, b, w); } // expand pixel (taking into account start, grouping, spacing [and offset]) i = i * groupLength(); if (reverse) { // is segment reversed? if (mirror) { // is segment mirrored? i = (len - 1) / 2 - i; //only need to index half the pixels } else { i = (len - 1) - i; } } i += start; // starting pixel in a group // set all the pixels in the group for (int j = 0; j < grouping; j++) { uint16_t indexSet = i + ((reverse) ? -j : j); if (indexSet >= start && indexSet < stop) { if (mirror) { //set the corresponding mirrored pixel uint16_t indexMir = stop - indexSet + start - 1; indexMir += offset; // offset/phase if (indexMir >= stop) indexMir -= len; // wrap strip.setPixelColor(indexMir, col); } indexSet += offset; // offset/phase if (indexSet >= stop) indexSet -= len; // wrap strip.setPixelColor(indexSet, col); } } } // anti-aliased normalized version of setPixelColor() void Segment::setPixelColor(float i, uint32_t col, bool aa) { int vStrip = int(i/10.0f); // hack to allow running on virtual strips (2D segment columns/rows) i -= int(i); if (i<0.0f || i>1.0f) return; // not normalized float fC = i * (virtualLength()-1); if (aa) { uint16_t iL = roundf(fC-0.49f); uint16_t iR = roundf(fC+0.49f); float dL = (fC - iL)*(fC - iL); float dR = (iR - fC)*(iR - fC); uint32_t cIL = getPixelColor(iL | (vStrip<<16)); uint32_t cIR = getPixelColor(iR | (vStrip<<16)); if (iR!=iL) { // blend L pixel cIL = color_blend(col, cIL, uint8_t(dL*255.0f)); setPixelColor(iL | (vStrip<<16), cIL); // blend R pixel cIR = color_blend(col, cIR, uint8_t(dR*255.0f)); setPixelColor(iR | (vStrip<<16), cIR); } else { // exact match (x & y land on a pixel) setPixelColor(iL | (vStrip<<16), col); } } else { setPixelColor(uint16_t(roundf(fC)) | (vStrip<<16), col); } } uint32_t Segment::getPixelColor(int i) { #ifndef WLED_DISABLE_2D int vStrip = i>>16; #endif i &= 0xFFFF; #ifndef WLED_DISABLE_2D if (is2D()) { uint16_t vH = virtualHeight(); // segment height in logical pixels uint16_t vW = virtualWidth(); switch (map1D2D) { case M12_Pixels: return getPixelColorXY(i % vW, i / vW); break; case M12_pBar: if (vStrip>0) return getPixelColorXY(vStrip - 1, vH - i -1); else return getPixelColorXY(0, vH - i -1); break; case M12_pArc: case M12_pCorner: // use longest dimension return vW>vH ? getPixelColorXY(i, 0) : getPixelColorXY(0, i); break; case M12_jMap: //WLEDMM jMap if (jMap) return ((JMapC *)jMap)->getPixelColor(i); break; case M12_sCircle: //WLEDMM if (vStrip > 0) { int x = roundf(sin_t(360*i/SEGLEN*DEG_TO_RAD) * vW * (vStrip+1)/nrOfVStrips()); int y = roundf(cos_t(360*i/SEGLEN*DEG_TO_RAD) * vW * (vStrip+1)/nrOfVStrips()); return getPixelColorXY(x + vW/2, y + vH/2); } else return vW>vH ? getPixelColorXY(i, 0) : getPixelColorXY(0, i); break; case M12_sBlock: //WLEDMM if (vStrip > 0) { uint16_t x=0,y=0; xyFromBlock(x,y, i, vW, vH, (vStrip+1)*2); return getPixelColorXY(x, y); } else return getPixelColorXY(vW / 2, vH / 2 - i - 1); break; } return 0; } #endif if (ledsrgb) return RGBW32(ledsrgb[i].r, ledsrgb[i].g, ledsrgb[i].b, 0); if (reverse) i = virtualLength() - i - 1; i *= groupLength(); i += start; /* offset/phase */ i += offset; if (i >= stop) i -= length(); return strip.getPixelColor(i); } uint8_t Segment::differs(Segment& b) const { uint8_t d = 0; if (start != b.start) d |= SEG_DIFFERS_BOUNDS; if (stop != b.stop) d |= SEG_DIFFERS_BOUNDS; if (offset != b.offset) d |= SEG_DIFFERS_GSO; if (grouping != b.grouping) d |= SEG_DIFFERS_GSO; if (spacing != b.spacing) d |= SEG_DIFFERS_GSO; if (opacity != b.opacity) d |= SEG_DIFFERS_BRI; if (mode != b.mode) d |= SEG_DIFFERS_FX; if (speed != b.speed) d |= SEG_DIFFERS_FX; if (intensity != b.intensity) d |= SEG_DIFFERS_FX; if (palette != b.palette) d |= SEG_DIFFERS_FX; if (custom1 != b.custom1) d |= SEG_DIFFERS_FX; if (custom2 != b.custom2) d |= SEG_DIFFERS_FX; if (custom3 != b.custom3) d |= SEG_DIFFERS_FX; if (startY != b.startY) d |= SEG_DIFFERS_BOUNDS; if (stopY != b.stopY) d |= SEG_DIFFERS_BOUNDS; //bit pattern: (msb first) sound:3, mapping:3, transposed, mirrorY, reverseY, [transitional, reset,] paused, mirrored, on, reverse, [selected] if ((options & 0b1111111110011110U) != (b.options & 0b1111111110011110U)) d |= SEG_DIFFERS_OPT; if ((options & 0x0001U) != (b.options & 0x0001U)) d |= SEG_DIFFERS_SEL; for (uint8_t i = 0; i < NUM_COLORS; i++) if (colors[i] != b.colors[i]) d |= SEG_DIFFERS_COL; return d; } void Segment::refreshLightCapabilities() { uint8_t capabilities = 0; uint16_t segStartIdx = 0xFFFFU; uint16_t segStopIdx = 0; if (start < Segment::maxWidth * Segment::maxHeight) { // we are withing 2D matrix (includes 1D segments) for (int y = startY; y < stopY; y++) for (int x = start; x < stop; x++) { uint16_t index = x + Segment::maxWidth * y; if (index < strip.customMappingSize) index = strip.customMappingTable[index]; // convert logical address to physical if (index < 0xFFFFU) { if (segStartIdx > index) segStartIdx = index; if (segStopIdx < index) segStopIdx = index; } if (segStartIdx == segStopIdx) segStopIdx++; // we only have 1 pixel segment } } else { // we are on the strip located after the matrix segStartIdx = start; segStopIdx = stop; } for (uint8_t b = 0; b < busses.getNumBusses(); b++) { Bus *bus = busses.getBus(b); if (bus == nullptr || bus->getLength()==0) break; if (!bus->isOk()) continue; if (bus->getStart() >= segStopIdx) continue; if (bus->getStart() + bus->getLength() <= segStartIdx) continue; //uint8_t type = bus->getType(); if (bus->hasRGB() || (cctFromRgb && bus->hasCCT())) capabilities |= SEG_CAPABILITY_RGB; if (!cctFromRgb && bus->hasCCT()) capabilities |= SEG_CAPABILITY_CCT; if (correctWB && (bus->hasRGB() || bus->hasCCT())) capabilities |= SEG_CAPABILITY_CCT; //white balance correction (CCT slider) if (bus->hasWhite()) { uint8_t aWM = Bus::getGlobalAWMode() == AW_GLOBAL_DISABLED ? bus->getAutoWhiteMode() : Bus::getGlobalAWMode(); bool whiteSlider = (aWM == RGBW_MODE_DUAL || aWM == RGBW_MODE_MANUAL_ONLY); // white slider allowed // if auto white calculation from RGB is active (Accurate/Brighter), force RGB controls even if there are no RGB busses if (!whiteSlider) capabilities |= SEG_CAPABILITY_RGB; // if auto white calculation from RGB is disabled/optional (None/Dual), allow white channel adjustments if ( whiteSlider) capabilities |= SEG_CAPABILITY_W; } } _capabilities = capabilities; } /* * Fills segment with color */ void Segment::fill(uint32_t c) { const uint_fast16_t cols = is2D() ? virtualWidth() : virtualLength(); // WLEDMM use fast int types const uint_fast16_t rows = virtualHeight(); // will be 1 for 1D for(uint_fast16_t y = 0; y < rows; y++) for (uint_fast16_t x = 0; x < cols; x++) { if (is2D()) setPixelColorXY((uint16_t)x, (uint16_t)y, c); else setPixelColor((uint16_t)x, c); } } // Blends the specified color with the existing pixel color. void Segment::blendPixelColor(int n, uint32_t color, uint8_t blend) { setPixelColor(n, color_blend(getPixelColor(n), color, blend)); } // Adds the specified color with the existing pixel color perserving color balance. void Segment::addPixelColor(int n, uint32_t color, bool fast) { uint32_t col = getPixelColor(n); uint8_t r = R(col); uint8_t g = G(col); uint8_t b = B(col); uint8_t w = W(col); if (fast) { r = qadd8(r, R(color)); g = qadd8(g, G(color)); b = qadd8(b, B(color)); w = qadd8(w, W(color)); col = RGBW32(r,g,b,w); } else { col = color_add(col, color); } setPixelColor(n, col); } void Segment::fadePixelColor(uint16_t n, uint8_t fade) { CRGB pix = CRGB(getPixelColor(n)).nscale8_video(fade); setPixelColor(n, pix); } /* * fade out function, higher rate = quicker fade */ void Segment::fade_out(uint8_t rate) { const uint_fast16_t cols = is2D() ? virtualWidth() : virtualLength(); // WLEDMM use fast int types const uint_fast16_t rows = virtualHeight(); // will be 1 for 1D uint_fast8_t fadeRate = (255-rate) >> 1; float mappedRate_r = 1.0f / (float(fadeRate) +1.1f); // WLEDMM use reciprocal 1/mappedRate -> faster on non-FPU chips uint32_t color2 = colors[1]; // SEGCOLOR(1); // target color // WLEDMM minor optimization int w2 = W(color2); int r2 = R(color2); int g2 = G(color2); int b2 = B(color2); for (uint_fast16_t y = 0; y < rows; y++) for (uint_fast16_t x = 0; x < cols; x++) { uint32_t color = is2D() ? getPixelColorXY(x, y) : getPixelColor(x); int w1 = W(color); int r1 = R(color); int g1 = G(color); int b1 = B(color); int wdelta = mappedRate_r * (w2 - w1); // WLEDMM use receprocal - its faster int rdelta = mappedRate_r * (r2 - r1); int gdelta = mappedRate_r * (g2 - g1); int bdelta = mappedRate_r * (b2 - b1); // if fade isn't complete, make sure delta is at least 1 (fixes rounding issues) wdelta += (w2 == w1) ? 0 : (w2 > w1) ? 1 : -1; rdelta += (r2 == r1) ? 0 : (r2 > r1) ? 1 : -1; gdelta += (g2 == g1) ? 0 : (g2 > g1) ? 1 : -1; bdelta += (b2 == b1) ? 0 : (b2 > b1) ? 1 : -1; //if ((wdelta == 0) && (rdelta == 0) && (gdelta == 0) && (bdelta == 0)) continue; // WLEDMM delta = zero => no change // causes problem with text overlay if (is2D()) setPixelColorXY((uint16_t)x, (uint16_t)y, r1 + rdelta, g1 + gdelta, b1 + bdelta, w1 + wdelta); else setPixelColor((uint16_t)x, r1 + rdelta, g1 + gdelta, b1 + bdelta, w1 + wdelta); } } // fades all pixels to black using nscale8() void Segment::fadeToBlackBy(uint8_t fadeBy) { const uint_fast16_t cols = is2D() ? virtualWidth() : virtualLength(); // WLEDMM use fast int types const uint_fast16_t rows = virtualHeight(); // will be 1 for 1D const uint_fast8_t scaledown = 255-fadeBy; // WLEDMM faster to pre-compute this // WLEDMM minor optimization if(is2D()) { for (uint_fast16_t y = 0; y < rows; y++) for (uint_fast16_t x = 0; x < cols; x++) { setPixelColorXY((uint16_t)x, (uint16_t)y, CRGB(getPixelColorXY(x,y)).nscale8(scaledown)); } } else { for (uint_fast16_t x = 0; x < cols; x++) { setPixelColor((uint16_t)x, CRGB(getPixelColor((uint16_t)x)).nscale8(scaledown)); } } } /* * blurs segment content, source: FastLED colorutils.cpp */ void Segment::blur(uint8_t blur_amount) { #ifndef WLED_DISABLE_2D if (is2D()) { // compatibility with 2D const uint_fast16_t cols = virtualWidth(); // WLEDMM use fast int types const uint_fast16_t rows = virtualHeight(); for (uint_fast16_t i = 0; i < rows; i++) blurRow(i, blur_amount); // blur all rows for (uint_fast16_t k = 0; k < cols; k++) blurCol(k, blur_amount); // blur all columns return; } #endif uint8_t keep = 255 - blur_amount; uint8_t seep = blur_amount >> 1; CRGB carryover = CRGB::Black; uint_fast16_t vlength = virtualLength(); for(uint_fast16_t i = 0; i < vlength; i++) { CRGB cur = CRGB(getPixelColor(i)); CRGB part = cur; CRGB before = cur; // WLEDMM part.nscale8(seep); cur.nscale8(keep); cur += carryover; if(i > 0) { uint32_t c = getPixelColor(i-1); uint8_t r = R(c); uint8_t g = G(c); uint8_t b = B(c); setPixelColor((uint16_t)(i-1), qadd8(r, part.red), qadd8(g, part.green), qadd8(b, part.blue)); } if (before != cur) // WLEDMM optimization: don't write same color again setPixelColor((uint16_t)i,cur.red, cur.green, cur.blue); carryover = part; } } /* * Put a value 0 to 255 in to get a color value. * The colours are a transition r -> g -> b -> back to r * Inspired by the Adafruit examples. */ uint32_t Segment::color_wheel(uint8_t pos) { if (palette) return color_from_palette(pos, false, true, 0); pos = 255 - pos; if(pos < 85) { return ((uint32_t)(255 - pos * 3) << 16) | ((uint32_t)(0) << 8) | (pos * 3); } else if(pos < 170) { pos -= 85; return ((uint32_t)(0) << 16) | ((uint32_t)(pos * 3) << 8) | (255 - pos * 3); } else { pos -= 170; return ((uint32_t)(pos * 3) << 16) | ((uint32_t)(255 - pos * 3) << 8) | (0); } } /* * Returns a new, random wheel index with a minimum distance of 42 from pos. */ uint8_t Segment::get_random_wheel_index(uint8_t pos) { // WLEDMM use fast int types, use native min/max uint_fast8_t r = 0, x = 0, y = 0, d = 0; while(d < 42) { r = random8(); x = abs(int(pos - r)); y = 255 - x; d = min(x, y); } return r; } /* * Gets a single color from the currently selected palette. * @param i Palette Index (if mapping is true, the full palette will be _virtualSegmentLength long, if false, 255). Will wrap around automatically. * @param mapping if true, LED position in segment is considered for color * @param wrap FastLED palettes will usually wrap back to the start smoothly. Set false to get a hard edge * @param mcol If the default palette 0 is selected, return the standard color 0, 1 or 2 instead. If >2, Party palette is used instead * @param pbri Value to scale the brightness of the returned color by. Default is 255. (no scaling) * @returns Single color from palette */ uint32_t Segment::color_from_palette(uint_fast16_t i, bool mapping, bool wrap, uint8_t mcol, uint8_t pbri) // WLEDMM use fast int types { // default palette or no RGB support on segment if ((palette == 0 && mcol < NUM_COLORS) || !_isRGB) { uint32_t color = currentColor(mcol, colors[mcol]); color = gamma32(color); if (pbri == 255) return color; return RGBW32(scale8_video(R(color),pbri), scale8_video(G(color),pbri), scale8_video(B(color),pbri), scale8_video(W(color),pbri)); } uint8_t paletteIndex = i; uint_fast16_t vLen = mapping ? virtualLength() : 1; if (mapping && vLen > 1) paletteIndex = (i*255)/(vLen -1); if (!wrap) paletteIndex = scale8(paletteIndex, 240); //cut off blend at palette "end" CRGB fastled_col; CRGBPalette16 curPal; if (transitional && _t) curPal = _t->_palT; else loadPalette(curPal, palette); fastled_col = ColorFromPalette(curPal, paletteIndex, pbri, (strip.paletteBlend == 3)? NOBLEND:LINEARBLEND); // NOTE: paletteBlend should be global return RGBW32(fastled_col.r, fastled_col.g, fastled_col.b, 0); } //WLEDMM netmindz ar palette uint8_t * Segment::getAudioPalette(int pal) { // https://forum.makerforums.info/t/hi-is-it-possible-to-define-a-gradient-palette-at-runtime-the-define-gradient-palette-uses-the/63339 um_data_t *um_data; if (!usermods.getUMData(&um_data, USERMOD_ID_AUDIOREACTIVE)) { um_data = simulateSound(SEGMENT.soundSim); } uint8_t *fftResult = (uint8_t*)um_data->u_data[2]; static uint8_t xyz[16]; // Needs to be 4 times however many colors are being used. // 3 colors = 12, 4 colors = 16, etc. xyz[0] = 0; // anchor of first color - must be zero xyz[1] = 0; xyz[2] = 0; xyz[3] = 0; CRGB rgb = getCRGBForBand(1, fftResult, pal); xyz[4] = 1; // anchor of first color xyz[5] = rgb.r; xyz[6] = rgb.g; xyz[7] = rgb.b; rgb = getCRGBForBand(128, fftResult, pal); xyz[8] = 128; xyz[9] = rgb.r; xyz[10] = rgb.g; xyz[11] = rgb.b; rgb = getCRGBForBand(255, fftResult, pal); xyz[12] = 255; // anchor of last color - must be 255 xyz[13] = rgb.r; xyz[14] = rgb.g; xyz[15] = rgb.b; return xyz; } /////////////////////////////////////////////////////////////////////////////// // WS2812FX class implementation /////////////////////////////////////////////////////////////////////////////// //WLEDMM from util.cpp // enumerate all ledmapX.json files on FS and extract ledmap names if existing void WS2812FX::enumerateLedmaps() { ledMaps = 1; for (int i=1; i<10; i++) { char fileName[33]; snprintf_P(fileName, sizeof(fileName), PSTR("/ledmap%d.json"), i); bool isFile = WLED_FS.exists(fileName); #ifndef ESP8266 if (ledmapNames[i-1]) { //clear old name delete[] ledmapNames[i-1]; ledmapNames[i-1] = nullptr; } #endif if (isFile) { ledMaps |= 1 << i; #ifndef ESP8266 if (requestJSONBufferLock(21)) { //WLEDMM: upstream code loops over all ledmap files, read them all, every byte (!!!!) and only get the name of the file!!! File f; f = WLED_FS.open(fileName, "r"); if (f) { f.find("\"n\":"); char name[33]; f.readBytesUntil('\n', name, sizeof(name)); USER_PRINTF("enumerateLedmaps %s %s\n", fileName, name); size_t len = 0; if (name != nullptr) { len = strlen(name); if (len > 0 && len < 33) { ledmapNames[i-1] = new char[len+1]; if (ledmapNames[i-1]) strlcpy(ledmapNames[i-1], name, 33); } } if (!ledmapNames[i-1]) { char tmp[33]; snprintf_P(tmp, 32, PSTR("ledmap%d.json"), i); len = strlen(tmp); ledmapNames[i-1] = new char[len+1]; if (ledmapNames[i-1]) strlcpy(ledmapNames[i-1], tmp, 33); } } f.close(); releaseJSONBufferLock(); } #endif } } //WLEDMM add segment names to be used as ledmap names uint8_t segment_index = 0; for (segment &seg : _segments) { if (seg.name != nullptr && strcmp(seg.name, "") != 0) { char fileName[33]; snprintf_P(fileName, sizeof(fileName), PSTR("/lm%s.json"), seg.name); bool isFile = WLED_FS.exists(fileName); if (isFile) ledMaps |= 1 << (10+segment_index); } segment_index++; } } //do not call this method from system context (network callback) void WS2812FX::finalizeInit(void) { //reset segment runtimes suspendStripService = true; // WELDMM avoid running effects on an incomplete strip for (segment &seg : _segments) { seg.markForReset(); seg.resetIfRequired(); } // for the lack of better place enumerate ledmaps here // if we do it in json.cpp (serializeInfo()) we are getting flashes on LEDs // unfortunately this means we do not get updates after uploads enumerateLedmaps(); _hasWhiteChannel = _isOffRefreshRequired = false; //if busses failed to load, add default (fresh install, FS issue, ...) if (busses.getNumBusses() == 0) { DEBUG_PRINTLN(F("No busses, init default")); const uint8_t defDataPins[] = {DATA_PINS}; const uint16_t defCounts[] = {PIXEL_COUNTS}; const uint8_t defNumBusses = ((sizeof defDataPins) / (sizeof defDataPins[0])); const uint8_t defNumCounts = ((sizeof defCounts) / (sizeof defCounts[0])); uint16_t prevLen = 0; for (uint8_t i = 0; i < defNumBusses && i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) { uint8_t defPin[] = {defDataPins[i]}; uint16_t start = prevLen; uint16_t count = defCounts[(i < defNumCounts) ? i : defNumCounts -1]; prevLen += count; BusConfig defCfg = BusConfig(DEFAULT_LED_TYPE, defPin, start, count, DEFAULT_LED_COLOR_ORDER, false, 0, RGBW_MODE_MANUAL_ONLY); if (busses.add(defCfg) == -1) break; } } _length = 0; for (uint8_t i=0; igetStart() + bus->getLength() > MAX_LEDS) break; //RGBW mode is enabled if at least one of the strips is RGBW _hasWhiteChannel |= bus->hasWhite(); //refresh is required to remain off if at least one of the strips requires the refresh. _isOffRefreshRequired |= bus->isOffRefreshRequired(); uint16_t busEnd = bus->getStart() + bus->getLength(); if (busEnd > _length) _length = busEnd; #ifdef ESP8266 if ((!IS_DIGITAL(bus->getType()) || IS_2PIN(bus->getType()))) continue; uint8_t pins[5]; if (!bus->getPins(pins)) continue; BusDigital* bd = static_cast(bus); if (pins[0] == 3) bd->reinit(); #endif } if (isMatrix) setUpMatrix(); else { Segment::maxWidth = _length; Segment::maxHeight = 1; } //initialize leds array. TBD: realloc if nr of leds change if (Segment::_globalLeds) { purgeSegments(true); free(Segment::_globalLeds); Segment::_globalLeds = nullptr; } if (useLedsArray && getLengthTotal()>0) { // WLEDMM avoid malloc(0) size_t arrSize = sizeof(CRGB) * getLengthTotal(); // softhack007 disabled; putting leds into psram leads to horrible slowdown on WROVER boards (see setUpLeds()) //#if defined(ARDUINO_ARCH_ESP32) && defined(BOARD_HAS_PSRAM) && defined(WLED_USE_PSRAM) //if (psramFound()) // Segment::_globalLeds = (CRGB*) ps_malloc(arrSize); //else //#endif if (arrSize > 0) Segment::_globalLeds = (CRGB*) malloc(arrSize); // WLEDMM avoid malloc(0) if (Segment::_globalLeds != nullptr) memset(Segment::_globalLeds, 0, arrSize); // WLEDMM avoid dereferencing nullptr } //segments are created in makeAutoSegments(); DEBUG_PRINTLN(F("Loading custom palettes")); loadCustomPalettes(); // (re)load all custom palettes DEBUG_PRINTLN(F("Loading custom ledmaps")); deserializeMap(); // (re)load default ledmap _isServicing = false; // WLEDMM suspendStripService = false; // WELDMM ready, run ! } // WLEDMM wait until strip is idle (=not servicing). // on 8266 this function does nothing, because we can only do "buisy waiting" on ESP32 #define MAX_IDLE_WAIT_MS 50 // seems to work in most cases void WS2812FX::waitUntilIdle(void) { #if defined(ARDUINO_ARCH_ESP32) && defined(WLEDMM_PROTECT_SERVICE) if (isServicing()) { unsigned long waitStarted = millis(); do { delay(2); // Suspending for 1 tick (or more) gives other tasks a chance to run. //yield(); // seems to be a no-op on esp32 } while (isServicing() && (millis() - waitStarted < MAX_IDLE_WAIT_MS)); USER_PRINTF("strip.waitUntilIdle(): strip %sidle after %d ms. (task %s)\n", isServicing()?"not ":"", int(millis() - waitStarted), pcTaskGetTaskName(NULL)); } return; #else return; #endif } void WS2812FX::service() { unsigned long nowUp = millis(); // Be aware, millis() rolls over every 49 days // WLEDMM avoid losing precision now = nowUp + timebase; #if defined(ARDUINO_ARCH_ESP32) && defined(WLEDMM_FASTPATH) if ((_frametime > 2) && (_frametime < 32) && (nowUp - _lastShow) < (_frametime/2)) return; // WLEDMM experimental - stabilizes frametimes but increases CPU load else if (nowUp - _lastShow < MIN_SHOW_DELAY) return; // WLEDMM fallback #else if (nowUp - _lastShow < MIN_SHOW_DELAY) return; #endif bool doShow = false; _isServicing = true; _segment_index = 0; for (segment &seg : _segments) { // reset the segment runtime data if needed seg.resetIfRequired(); if (!seg.isActive()) continue; // last condition ensures all solid segments are updated at the same time if(nowUp >= seg.next_time || _triggered || (doShow && seg.mode == FX_MODE_STATIC)) // WLEDMM ">=" instead of ">" { if (seg.grouping == 0) seg.grouping = 1; //sanity check doShow = true; uint16_t frameDelay = FRAMETIME; // WLEDMM avoid name clash with "delay" function if (!seg.freeze) { //only run effect function if not frozen _virtualSegmentLength = seg.virtualLength(); _colors_t[0] = seg.currentColor(0, seg.colors[0]); _colors_t[1] = seg.currentColor(1, seg.colors[1]); _colors_t[2] = seg.currentColor(2, seg.colors[2]); seg.currentPalette(_currentPalette, seg.palette); if (!cctFromRgb || correctWB) busses.setSegmentCCT(seg.currentBri(seg.cct, true), correctWB); for (uint8_t c = 0; c < NUM_COLORS; c++) _colors_t[c] = gamma32(_colors_t[c]); // effect blending (execute previous effect) // actual code may be a bit more involved as effects have runtime data including allocated memory //if (seg.transitional && seg._modeP) (*_mode[seg._modeP])(progress()); frameDelay = (*_mode[seg.currentMode(seg.mode)])(); if (seg.mode != FX_MODE_HALLOWEEN_EYES) seg.call++; if (seg.transitional && frameDelay > FRAMETIME) frameDelay = FRAMETIME; // force faster updates during transition seg.handleTransition(); } seg.next_time = nowUp + frameDelay; } _segment_index++; } _virtualSegmentLength = 0; busses.setSegmentCCT(-1); if(doShow) { yield(); show(); } _triggered = false; _isServicing = false; } void IRAM_ATTR WS2812FX::setPixelColor(int i, uint32_t col) { if (i < customMappingSize) i = customMappingTable[i]; if (i >= _length) return; busses.setPixelColor(i, col); } uint32_t WS2812FX::getPixelColor(uint_fast16_t i) // WLEDMM fast int types { if (i < customMappingSize) i = customMappingTable[i]; if (i >= _length) return 0; return busses.getPixelColor(i); } //DISCLAIMER //The following function attemps to calculate the current LED power usage, //and will limit the brightness to stay below a set amperage threshold. //It is NOT a measurement and NOT guaranteed to stay within the ablMilliampsMax margin. //Stay safe with high amperage and have a reasonable safety margin! //I am NOT to be held liable for burned down garages! //fine tune power estimation constants for your setup #define MA_FOR_ESP 100 //how much mA does the ESP use (Wemos D1 about 80mA, ESP32 about 120mA) //you can set it to 0 if the ESP is powered by USB and the LEDs by external void WS2812FX::estimateCurrentAndLimitBri() { //power limit calculation //each LED can draw up 195075 "power units" (approx. 53mA) //one PU is the power it takes to have 1 channel 1 step brighter per brightness step //so A=2,R=255,G=0,B=0 would use 510 PU per LED (1mA is about 3700 PU) bool useWackyWS2815PowerModel = false; byte actualMilliampsPerLed = milliampsPerLed; if(milliampsPerLed == 255) { useWackyWS2815PowerModel = true; actualMilliampsPerLed = 12; // from testing an actual strip } if (ablMilliampsMax < 150 || actualMilliampsPerLed == 0) { //0 mA per LED and too low numbers turn off calculation currentMilliamps = 0; busses.setBrightness(_brightness); return; } uint16_t pLen = getLengthPhysical(); uint32_t puPerMilliamp = 195075 / actualMilliampsPerLed; uint32_t powerBudget = (ablMilliampsMax - MA_FOR_ESP) * puPerMilliamp; //100mA for ESP power if (powerBudget > puPerMilliamp * pLen) { //each LED uses about 1mA in standby, exclude that from power budget powerBudget -= puPerMilliamp * pLen; } else { powerBudget = 0; } uint32_t powerSum = 0; for (uint_fast8_t bNum = 0; bNum < busses.getNumBusses(); bNum++) { Bus *bus = busses.getBus(bNum); if (bus->getType() >= TYPE_NET_DDP_RGB) continue; //exclude non-physical network busses uint16_t len = bus->getLength(); uint32_t busPowerSum = 0; for (uint_fast16_t i = 0; i < len; i++) { //sum up the usage of each LED uint32_t c = bus->getPixelColor(i); byte r = R(c), g = G(c), b = B(c), w = W(c); if(useWackyWS2815PowerModel) { //ignore white component on WS2815 power calculation busPowerSum += (max(max(r,g),b)) * 3; // WLEDMM use native min/max } else { busPowerSum += (r + g + b + w); } } if (bus->hasWhite()) { //RGBW led total output with white LEDs enabled is still 50mA, so each channel uses less busPowerSum *= 3; busPowerSum = busPowerSum >> 2; //same as /= 4 } powerSum += busPowerSum; } uint32_t powerSum0 = powerSum; powerSum *= _brightness; if (powerSum > powerBudget) //scale brightness down to stay in current limit { float scale = (float)powerBudget / (float)powerSum; uint16_t scaleI = scale * 255; uint8_t scaleB = (scaleI > 255) ? 255 : scaleI; uint8_t newBri = scale8(_brightness, scaleB); busses.setBrightness(newBri); //to keep brightness uniform, sets virtual busses too currentMilliamps = (powerSum0 * newBri) / puPerMilliamp; } else { currentMilliamps = powerSum / puPerMilliamp; busses.setBrightness(_brightness); } currentMilliamps += MA_FOR_ESP; //add power of ESP back to estimate currentMilliamps += pLen; //add standby power back to estimate } void WS2812FX::show(void) { // avoid race condition, caputre _callback value show_callback callback = _callback; if (callback) callback(); estimateCurrentAndLimitBri(); // some buses send asynchronously and this method will return before // all of the data has been sent. // See https://github.com/Makuna/NeoPixelBus/wiki/ESP32-NeoMethods#neoesp32rmt-methods unsigned long b4show = millis(); // WLEDMM the time before calling "show" busses.show(); unsigned long now = millis(); unsigned long diff = now - _lastShow; uint16_t fpsCurr = 200; if (diff > 0) fpsCurr = 1000 / diff; _cumulativeFps = (3 * _cumulativeFps + fpsCurr) >> 2; #if defined(ARDUINO_ARCH_ESP32) && defined(WLEDMM_FASTPATH) _lastShow = b4show; // WLEDMM this is more accurate, however it also icreases CPU load - strip.service will run more frequently #else _lastShow = now; #endif #ifdef ARDUINO_ARCH_ESP32 // WLEDMM more accurate FPS measurement for ESP32 uint64_t now500 = esp_timer_get_time() / 2; // native timer; micros /2 -> millis * 500 int64_t diff500 = now500 - _lastShow500; if ((diff500 > 300) && (diff500 < 800000)) { // exclude stupid values (timer rollover, major hickups) float fpcCurr500 = 500000.0f / float(diff500); if (fpcCurr500 > 2) _cumulativeFps500 = (3 * _cumulativeFps500 + (500.0 * fpcCurr500)) / 4; // average for some smoothing } _lastShow500 = now500; #endif } /** * Returns a true value if any of the strips are still being updated. * On some hardware (ESP32), strip updates are done asynchronously. */ bool WS2812FX::isUpdating() { return !busses.canAllShow(); } /** * Returns the refresh rate of the LED strip. Useful for finding out whether a given setup is fast enough. * Only updates on show() or is set to 0 fps if last show is more than 2 secs ago, so accurary varies */ uint16_t WS2812FX::getFps() { if (millis() - _lastShow > 2000) return 0; #ifdef ARDUINO_ARCH_ESP32 return ((_cumulativeFps500 + 250) / 500); // +250 for proper rounding #else return _cumulativeFps +1; #endif } void WS2812FX::setTargetFps(uint8_t fps) { if (fps > 0 && fps <= 251) _targetFps = fps; // WLEDMM allow higher framerates _frametime = 1000 / _targetFps; if (_frametime < 1) _frametime = 1; // WLEDMM better safe than sorry } void WS2812FX::setMode(uint8_t segid, uint8_t m) { if (segid >= _segments.size()) return; if (m >= getModeCount()) m = getModeCount() - 1; if (_segments[segid].mode != m) { _segments[segid].startTransition(_transitionDur); // set effect transitions //_segments[segid].markForReset(); _segments[segid].mode = m; } } //applies to all active and selected segments void WS2812FX::setColor(uint8_t slot, uint32_t c) { if (slot >= NUM_COLORS) return; for (segment &seg : _segments) { if (seg.isActive() && seg.isSelected()) { seg.setColor(slot, c); } } } void WS2812FX::setCCT(uint16_t k) { for (segment &seg : _segments) { if (seg.isActive() && seg.isSelected()) { seg.setCCT(k); } } } void WS2812FX::setBrightness(uint8_t b, bool direct) { if (gammaCorrectBri) b = gamma8(b); if (_brightness == b) return; _brightness = b; if (_brightness == 0) { //unfreeze all segments on power off for (segment &seg : _segments) { seg.freeze = false; } } if (direct) { // would be dangerous if applied immediately (could exceed ABL), but will not output until the next show() busses.setBrightness(b); } else { unsigned long t = millis(); if (_segments[0].next_time > t + 22 && t - _lastShow > MIN_SHOW_DELAY) show(); //apply brightness change immediately if no refresh soon } } uint8_t WS2812FX::getFirstSelectedSegId(void) { size_t i = 0; for (segment &seg : _segments) { if (seg.isActive() && seg.isSelected()) return i; i++; } // if none selected, use the main segment return getMainSegmentId(); } void WS2812FX::setMainSegmentId(uint8_t n) { _mainSegment = 0; if (n < _segments.size()) { _mainSegment = n; } return; } uint8_t WS2812FX::getLastActiveSegmentId(void) { for (size_t i = _segments.size() -1; i > 0; i--) { if (_segments[i].isActive()) return i; } return 0; } uint8_t WS2812FX::getActiveSegmentsNum(void) { uint8_t c = 0; for (size_t i = 0; i < _segments.size(); i++) { if (_segments[i].isActive()) c++; } return c; } uint16_t WS2812FX::getLengthTotal(void) { // WLEDMM fast int types uint_fast16_t len = Segment::maxWidth * Segment::maxHeight; // will be _length for 1D (see finalizeInit()) but should cover whole matrix for 2D if (isMatrix && _length > len) len = _length; // for 2D with trailing strip return len; } uint16_t WS2812FX::getLengthPhysical(void) { // WLEDMM fast int types uint_fast16_t len = 0; for (unsigned b = 0; b < busses.getNumBusses(); b++) { // WLEDMM use native (fast) types Bus *bus = busses.getBus(b); if (bus->getType() >= TYPE_NET_DDP_RGB) continue; //exclude non-physical network busses len += bus->getLength(); } return len; } //used for JSON API info.leds.rgbw. Little practical use, deprecate with info.leds.rgbw. //returns if there is an RGBW bus (supports RGB and White, not only white) //not influenced by auto-white mode, also true if white slider does not affect output white channel bool WS2812FX::hasRGBWBus(void) { for (unsigned b = 0; b < busses.getNumBusses(); b++) { // WLEDMM use native (fast) types Bus *bus = busses.getBus(b); if (bus == nullptr || bus->getLength()==0) break; if (bus->hasRGB() && bus->hasWhite()) return true; } return false; } bool WS2812FX::hasCCTBus(void) { if (cctFromRgb && !correctWB) return false; for (unsigned b = 0; b < busses.getNumBusses(); b++) { // WLEDMM use native (fast) types Bus *bus = busses.getBus(b); if (bus == nullptr || bus->getLength()==0) break; switch (bus->getType()) { case TYPE_ANALOG_5CH: case TYPE_ANALOG_2CH: return true; } } return false; } void WS2812FX::purgeSegments(bool force) { // remove all inactive segments (from the back) int deleted = 0; if (_segments.size() <= 1) return; for (size_t i = _segments.size()-1; i > 0; i--) if (_segments[i].stop == 0 || force) { deleted++; _segments.erase(_segments.begin() + i); } if (deleted) { _segments.shrink_to_fit(); if (_mainSegment >= _segments.size()) setMainSegmentId(0); } } Segment& WS2812FX::getSegment(uint8_t id) { return _segments[id >= _segments.size() ? getMainSegmentId() : id]; // vectors } void WS2812FX::setSegment(uint8_t n, uint16_t i1, uint16_t i2, uint8_t grouping, uint8_t spacing, uint16_t offset, uint16_t startY, uint16_t stopY) { if (n >= _segments.size()) return; _segments[n].set(i1, i2, grouping, spacing, offset, startY, stopY); } void WS2812FX::restartRuntime() { for (segment &seg : _segments) seg.markForReset(); } void WS2812FX::resetSegments(bool boundsOnly) { //WLEDMM add boundsonly USER_PRINTF("resetSegments %d %dx%d\n", boundsOnly, Segment::maxWidth, Segment::maxHeight); if (!boundsOnly) { _segments.clear(); // destructs all Segment as part of clearing #ifndef WLED_DISABLE_2D segment seg = isMatrix ? Segment(0, Segment::maxWidth, 0, Segment::maxHeight) : Segment(0, _length); #else segment seg = Segment(0, _length); #endif _segments.push_back(seg); _mainSegment = 0; } else { //WLEDMM boundsonly for (segment &seg : _segments) { bool recreateLeds = false; #ifndef WLED_DISABLE_2D seg.start = 0; seg.stop = Segment::maxWidth; seg.startY = 0; seg.stopY = Segment::maxHeight; #else seg.start = 0; seg.stop = _length; #endif seg.allocLeds(); } } } void WS2812FX::makeAutoSegments(bool forceReset) { if (autoSegments) { //make one segment per bus uint16_t segStarts[MAX_NUM_SEGMENTS] = {0}; uint16_t segStops [MAX_NUM_SEGMENTS] = {0}; size_t s = 0; #ifndef WLED_DISABLE_2D // 2D segment is the 1st one using entire matrix if (isMatrix) { segStarts[0] = 0; segStops[0] = Segment::maxWidth*Segment::maxHeight; s++; } #endif for (size_t i = s; i < busses.getNumBusses(); i++) { Bus* b = busses.getBus(i); segStarts[s] = b->getStart(); segStops[s] = segStarts[s] + b->getLength(); #ifndef WLED_DISABLE_2D if (isMatrix && segStops[s] < Segment::maxWidth*Segment::maxHeight) continue; // ignore buses comprising matrix if (isMatrix && segStarts[s] < Segment::maxWidth*Segment::maxHeight) segStarts[s] = Segment::maxWidth*Segment::maxHeight; #endif //check for overlap with previous segments for (size_t j = 0; j < s; j++) { if (segStops[j] > segStarts[s] && segStarts[j] < segStops[s]) { //segments overlap, merge segStarts[j] = min(segStarts[s],segStarts[j]); segStops [j] = max(segStops [s],segStops [j]); segStops[s] = 0; s--; } } s++; } _segments.clear(); _segments.reserve(s); // prevent reallocations // there is always at least one segment (but we need to differentiate between 1D and 2D) #ifndef WLED_DISABLE_2D if (isMatrix) _segments.push_back(Segment(0, Segment::maxWidth, 0, Segment::maxHeight)); else #endif _segments.push_back(Segment(segStarts[0], segStops[0])); for (size_t i = 1; i < s; i++) { _segments.push_back(Segment(segStarts[i], segStops[i])); } } else { if (forceReset || getSegmentsNum() == 0) resetSegments(); //expand the main seg to the entire length, but only if there are no other segments, or reset is forced else if (getActiveSegmentsNum() == 1) { size_t i = getLastActiveSegmentId(); #ifndef WLED_DISABLE_2D _segments[i].start = 0; _segments[i].stop = Segment::maxWidth; _segments[i].startY = 0; _segments[i].stopY = Segment::maxHeight; _segments[i].grouping = 1; _segments[i].spacing = 0; #else _segments[i].start = 0; _segments[i].stop = _length; #endif } } _mainSegment = 0; fixInvalidSegments(); } void WS2812FX::fixInvalidSegments() { //make sure no segment is longer than total (sanity check) for (size_t i = getSegmentsNum()-1; i > 0; i--) { if (isMatrix) { #ifndef WLED_DISABLE_2D if (_segments[i].start >= Segment::maxWidth * Segment::maxHeight) { // 1D segment at the end of matrix if (_segments[i].start >= _length || _segments[i].startY > 0 || _segments[i].stopY > 1) { _segments.erase(_segments.begin()+i); continue; } if (_segments[i].stop > _length) _segments[i].stop = _length; continue; } if (_segments[i].start >= Segment::maxWidth || _segments[i].startY >= Segment::maxHeight) { _segments.erase(_segments.begin()+i); continue; } if (_segments[i].stop > Segment::maxWidth) _segments[i].stop = Segment::maxWidth; if (_segments[i].stopY > Segment::maxHeight) _segments[i].stopY = Segment::maxHeight; #endif } else { if (_segments[i].start >= _length) { _segments.erase(_segments.begin()+i); continue; } if (_segments[i].stop > _length) _segments[i].stop = _length; } } // this is always called as the last step after finalizeInit(), update covered bus types for (segment &seg : _segments) seg.refreshLightCapabilities(); } //true if all segments align with a bus, or if a segment covers the total length //irrelevant in 2D set-up bool WS2812FX::checkSegmentAlignment() { bool aligned = false; for (segment &seg : _segments) { for (uint8_t b = 0; bgetStart() && seg.stop == bus->getStart() + bus->getLength()) aligned = true; } if (seg.start == 0 && seg.stop == _length) aligned = true; if (!aligned) return false; } return true; } //After this function is called, setPixelColor() will use that segment (offsets, grouping, ... will apply) //Note: If called in an interrupt (e.g. JSON API), original segment must be restored, //otherwise it can lead to a crash on ESP32 because _segment_index is modified while in use by the main thread uint8_t WS2812FX::setPixelSegment(uint8_t n) { uint8_t prevSegId = _segment_index; if (n < _segments.size()) { _segment_index = n; _virtualSegmentLength = _segments[_segment_index].virtualLength(); } return prevSegId; } void WS2812FX::setRange(uint16_t i, uint16_t i2, uint32_t col) { if (i2 >= i) { for (uint_fast16_t x = i; x <= i2; x++) setPixelColor((uint16_t)x, col); // WLEDMM use fast int types } else { for (uint_fast16_t x = i2; x <= i; x++) setPixelColor((uint16_t)x, col); } } void WS2812FX::setTransitionMode(bool t) { for (segment &seg : _segments) if (!seg.transitional) seg.startTransition(t ? _transitionDur : 0); } #ifdef WLED_DEBUG void WS2812FX::printSize() { size_t size = 0; for (const Segment &seg : _segments) size += seg.getSize(); DEBUG_PRINTF("Segments: %d -> %uB\n", _segments.size(), size); DEBUG_PRINTF("Modes: %d*%d=%uB\n", sizeof(mode_ptr), _mode.size(), (_mode.capacity()*sizeof(mode_ptr))); DEBUG_PRINTF("Data: %d*%d=%uB\n", sizeof(const char *), _modeData.size(), (_modeData.capacity()*sizeof(const char *))); DEBUG_PRINTF("Map: %d*%d=%uB\n", sizeof(uint16_t), (int)customMappingSize, customMappingSize*sizeof(uint16_t)); size = getLengthTotal(); if (useLedsArray) DEBUG_PRINTF("Buffer: %d*%u=%uB\n", sizeof(CRGB), size, size*sizeof(CRGB)); } #endif void WS2812FX::loadCustomPalettes() { byte tcp[72]; //support gradient palettes with up to 18 entries CRGBPalette16 targetPalette; customPalettes.clear(); // start fresh for (int index = 0; index<10; index++) { char fileName[32]; sprintf_P(fileName, PSTR("/palette%d.json"), index); StaticJsonDocument<1536> pDoc; // barely enough to fit 72 numbers if (WLED_FS.exists(fileName)) { DEBUG_PRINT(F("Reading palette from ")); DEBUG_PRINTLN(fileName); if (readObjectFromFile(fileName, nullptr, &pDoc)) { JsonArray pal = pDoc[F("palette")]; if (!pal.isNull() && pal.size()>4) { // not an empty palette (at least 2 entries) if (pal[0].is() && pal[1].is()) { // we have an array of index & hex strings size_t palSize = min(pal.size(), (size_t)36); // WLEDMM use native min/max palSize -= palSize % 2; // make sure size is multiple of 2 for (size_t i=0, j=0; i()<256; i+=2, j+=4) { uint8_t rgbw[] = {0,0,0,0}; tcp[ j ] = (uint8_t) pal[ i ].as(); // index colorFromHexString(rgbw, pal[i+1].as()); // will catch non-string entires for (size_t c=0; c<3; c++) tcp[j+1+c] = rgbw[c]; // only use RGB component DEBUG_PRINTF("%d(%d) : %d %d %d\n", i, int(tcp[j]), int(tcp[j+1]), int(tcp[j+2]), int(tcp[j+3])); } } else { size_t palSize = min(pal.size(), (size_t)72); // WLEDMM use native min/max palSize -= palSize % 4; // make sure size is multiple of 4 for (size_t i=0; i()<256; i+=4) { tcp[ i ] = (uint8_t) pal[ i ].as(); // index tcp[i+1] = (uint8_t) pal[i+1].as(); // R tcp[i+2] = (uint8_t) pal[i+2].as(); // G tcp[i+3] = (uint8_t) pal[i+3].as(); // B DEBUG_PRINTF("%d(%d) : %d %d %d\n", i, int(tcp[i]), int(tcp[i+1]), int(tcp[i+2]), int(tcp[i+3])); } } customPalettes.push_back(targetPalette.loadDynamicGradientPalette(tcp)); } } } else { break; } } } //load custom mapping table from JSON file (called from finalizeInit() or deserializeState()) bool WS2812FX::deserializeMap(uint8_t n) { // 2D support creates its own ledmap (on the fly) if a ledmap.json exists it will overwrite built one. char fileName[32]; //WLEDMM: als support segment name ledmaps bool isFile = false;; if (n<10) { strcpy_P(fileName, PSTR("/ledmap")); if (n) sprintf(fileName +7, "%d", n); //WLEDMM: trick to not include 0 in ledmap.json strcat(fileName, ".json"); isFile = WLED_FS.exists(fileName); } else { //WLEDM add segment name as ledmap.name uint8_t segment_index = 0; for (segment &seg : _segments) { if (n == 10 + segment_index && !isFile && seg.name != nullptr) { sprintf_P(fileName, PSTR("/%s.json"), seg.name); isFile = WLED_FS.exists(fileName); } if (isFile) break; segment_index++; } } if (!isFile) { // erase custom mapping if selecting nonexistent ledmap.json (n==0) //WLEDM: doubt this is necessary as return false causes setupMatrix to deal with this !!!! if (!isMatrix && !n) { customMappingSize = 0; loadedLedmap = 0; //WLEDMM } return false; } if (!requestJSONBufferLock(7)) return false; // WLEDMM: before changing maps, make sure our strip is _not_ servicing effects in parallel if (strip.isServicing()) { USER_PRINTLN(F("deserializeMap(): strip is still drawing effects, waiting ...")); strip.waitUntilIdle(); } //WLEDMM: change upstream code: do not load complete ledmaps in json as this blows up memory, use file read instead //read the file File f; f = WLED_FS.open(fileName, "r"); if (!f) { releaseJSONBufferLock(); return false; //if file does not exist just exit } USER_PRINT(F("Reading LED map from ")); //WLEDMM use USER_PRINT USER_PRINTLN(fileName); //WLEDMM: read width and height (mandatory in file!!) f.find("\"width\":"); f.readBytesUntil('\n', fileName, sizeof(fileName)); //hack: use fileName as we have this allocated already uint16_t maxWidth = atoi(fileName); f.find("\"height\":"); f.readBytesUntil('\n', fileName, sizeof(fileName)); uint16_t maxHeight = atoi(fileName); USER_PRINTF("deserializeMap %d x %d\n", maxWidth, maxHeight); if (maxWidth * maxHeight <= 0) { releaseJSONBufferLock(); return false; } //WLEDMM: support ledmap file properties width and height Segment::maxWidth = maxWidth; Segment::maxHeight = maxHeight; resetSegments(true); //WLEDMM not makeAutoSegments() as we only want to change bounds //WLEDMM recreate customMappingTable if more space needed if (Segment::maxWidth * Segment::maxHeight > customMappingTableSize) { USER_PRINTF("deserializemap customMappingTable alloc %d from %d\n", Segment::maxWidth * Segment::maxHeight, customMappingTableSize); //if (customMappingTable != nullptr) delete[] customMappingTable; //customMappingTable = new uint16_t[Segment::maxWidth * Segment::maxHeight]; // don't use new / delete if (customMappingTable != nullptr) { customMappingTable = (uint16_t*) reallocf(customMappingTable, sizeof(uint16_t) * Segment::maxWidth * Segment::maxHeight); // reallocf will free memory if it cannot resize } if (customMappingTable == nullptr) { // second try DEBUG_PRINTLN("deserializeMap: trying to get fresh memory block."); customMappingTable = (uint16_t*) calloc(Segment::maxWidth * Segment::maxHeight, sizeof(uint16_t)); if (customMappingTable == nullptr) DEBUG_PRINTLN("deserializeMap: alloc failed!"); } if (customMappingTable != nullptr) customMappingTableSize = Segment::maxWidth * Segment::maxHeight; } if (customMappingTable != nullptr) { customMappingSize = maxWidth * maxHeight; //WLEDMM: find the map values f.find("\"map\":["); uint16_t i=0; do { //for each element in the array int mapi = f.readStringUntil(',').toInt(); // USER_PRINTF(", %d", mapi); customMappingTable[i++] = (uint16_t) (mapi<0 ? 0xFFFFU : mapi); } while (f.available()); loadedLedmap = n; f.close(); DEBUG_PRINTF("Custom ledmap: %d\n", loadedLedmap); #ifdef WLED_DEBUG_MAPS for (uint16_t j=0; j