Jan/WLED_MM_Infinity
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/audioreactive-prototype' into audio-reactive

Browse Source
This commit is contained in:
Ewowi
2022-09-02 16:50:03 +02:00
parent ea3c337c7a 77ace76e32
commit 19a56d3ebd
18 changed files with 3376 additions and 3299 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
platformio.ini
View File

@@ -264,6 +264,7 @@ board_build.ldscript = ${common.ldscript_4m1m}
build_unflags = ${common.build_unflags}
build_flags = ${common.build_flags_esp8266} -D WLED_RELEASE_NAME=ESP8266
lib_deps = ${esp8266.lib_deps}
monitor_filters = esp8266_exception_decoder
[env:esp8266_2m]
board = esp_wroom_02

62
usermods/audioreactive/audio_reactive.h
View File

@@ -24,7 +24,7 @@
// #define MIC_LOGGER // MIC sampling & sound input debugging (serial plotter)
// #define FFT_SAMPLING_LOG // FFT result debugging
// #define SR_DEBUG // generic SR DEBUG messages
// #define NO_MIC_LOGGER // exclude MIC_LOGGER from SR_DEBUG
#ifdef SR_DEBUG
#define DEBUGSR_PRINT(x) Serial.print(x)
@@ -103,6 +103,7 @@ static void autoResetPeak(void); // peak auto-reset function
////////////////////
// Begin FFT Code //
////////////////////
#ifdef UM_AUDIOREACTIVE_USE_NEW_FFT
// lib_deps += https://github.com/kosme/arduinoFFT#develop @ 1.9.2
#define FFT_SPEED_OVER_PRECISION // enables use of reciprocals (1/x etc), and an a few other speedups
@@ -135,7 +136,6 @@ static float windowWeighingFactors[samplesFFT] = {0.0f};
#endif
// Try and normalize fftBin values to a max of 4096, so that 4096/16 = 256.
// Oh, and bins 0,1,2 are no good, so we'll zero them out.
static float fftCalc[NUM_GEQ_CHANNELS] = {0.0f};
static float fftAvg[NUM_GEQ_CHANNELS] = {0.0f}; // Calculated frequency channel results, with smoothing (used if dynamics limiter is ON)
#ifdef SR_DEBUG
@@ -172,7 +172,7 @@ static float fftAddAvg(int from, int to) {
return result / float(to - from + 1);
}
// FFT main code
// FFT main task
void FFTcode(void * parameter)
{
DEBUGSR_PRINT("FFT started on core: "); DEBUGSR_PRINTLN(xPortGetCoreID());
@@ -417,6 +417,10 @@ static void autoResetPeak(void) {
}
////////////////////
// usermod class //
////////////////////
//class name. Use something descriptive and leave the ": public Usermod" part :)
class AudioReactive : public Usermod {
@@ -533,6 +537,10 @@ class AudioReactive : public Usermod {
static const char UDP_SYNC_HEADER_v1[];
// private methods
////////////////////
// Debug support //
////////////////////
void logAudio()
{
#ifdef MIC_LOGGER
@@ -604,6 +612,10 @@ class AudioReactive : public Usermod {
} // logAudio()
//////////////////////
// Audio Processing //
//////////////////////
/*
* A "PI controller" multiplier to automatically adjust sound sensitivity.
*
@@ -698,7 +710,7 @@ class AudioReactive : public Usermod {
last_soundAgc = soundAgc;
} // agcAvg()
// post-processing and filtering of MIC sample (micDataReal) from FFTcode()
void getSample()
{
float sampleAdj; // Gain adjusted sample value
@@ -793,6 +805,26 @@ class AudioReactive : public Usermod {
}
//////////////////////
// UDP Sound Sync //
//////////////////////
// try to establish UDP sound sync connection
void connectUDPSoundSync(void) {
// This function tries to establish a UDP sync connection if needed
// necessary as we also want to transmit in "AP Mode", but the standard "connected()" callback only reacts on STA connection
static unsigned long last_connection_attempt = 0;
if ((audioSyncPort <= 0) || ((audioSyncEnabled & 0x03) == 0)) return; // Sound Sync not enabled
if (udpSyncConnected) return; // already connected
if (!(apActive || interfacesInited)) return; // neither AP nor other connections availeable
if (millis() - last_connection_attempt < 15000) return; // only try once in 15 seconds
// if we arrive here, we need a UDP connection but don't have one
last_connection_attempt = millis();
connected(); // try to start UDP
}
void transmitAudioData()
{
if (!udpSyncConnected) return;
@@ -820,12 +852,10 @@ class AudioReactive : public Usermod {
return;
} // transmitAudioData()
static bool isValidUdpSyncVersion(const char *header) {
return strncmp_P(header, PSTR(UDP_SYNC_HEADER), 6) == 0;
}
bool receiveAudioData() // check & process new data. return TRUE in case that new audio data was received.
{
if (!udpSyncConnected) return false;
@@ -875,6 +905,10 @@ class AudioReactive : public Usermod {
}
//////////////////////
// usermod functions//
//////////////////////
public:
//Functions called by WLED or other usermods
@@ -967,6 +1001,7 @@ class AudioReactive : public Usermod {
disableSoundProcessing = true;
}
if (enabled) connectUDPSoundSync();
initDone = true;
}
@@ -977,6 +1012,11 @@ class AudioReactive : public Usermod {
*/
void connected()
{
if (udpSyncConnected) { // clean-up: if open, close old UDP sync connection
udpSyncConnected = false;
fftUdp.stop();
}
if (audioSyncPort > 0 && (audioSyncEnabled & 0x03)) {
#ifndef ESP8266
udpSyncConnected = fftUdp.beginMulticast(IPAddress(239, 0, 0, 1), audioSyncPort);
@@ -1079,6 +1119,8 @@ class AudioReactive : public Usermod {
autoResetPeak(); // auto-reset sample peak after strip minShowDelay
if (!udpSyncConnected) udpSamplePeak = false; // reset UDP samplePeak while UDP is unconnected
connectUDPSoundSync(); // ensure we have a connection - if needed
// UDP Microphone Sync - receive mode
if ((audioSyncEnabled & 0x02) && udpSyncConnected) {
// Only run the audio listener code if we're in Receive mode
@@ -1196,6 +1238,10 @@ class AudioReactive : public Usermod {
}
////////////////////////////
// Settings and Info Page //
////////////////////////////
/*
* addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
* Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
@@ -1317,6 +1363,10 @@ class AudioReactive : public Usermod {
infoArr.add(fftTime-sampleTime);
infoArr.add("ms");
#endif
// add a small horizontal line, for better readability
infoArr = user.createNestedArray(F("<hr style=\"height:1px;border-width:0;color:gray;background-color:gray\" />"));
infoArr.add(F(" <hr style=\"height:1px;border-width:0;color:gray;background-color:gray\" /> "));
}
}

75
wled00/FX.cpp
View File

@@ -3470,9 +3470,9 @@ static const char _data_FX_MODE_DRIP[] PROGMEM = "Drip@Gravity,# of drips;!,!;!;
typedef struct Tetris {
float pos;
float speed;
uint32_t col;
uint16_t aux0; // 2D-fication of SEGENV.aux0 (brick size)
uint16_t aux1; // 2D-fication of SEGENV.aux1 (stack size)
uint8_t col; // color index
uint16_t brick; // brick size in pixels
uint16_t stack; // stack size in pixels
uint32_t step; // 2D-fication of SEGENV.step (state)
} tetris;
@@ -3491,7 +3491,7 @@ uint16_t mode_tetrix(void) {
static void runStrip(size_t stripNr, Tetris *drop) {
// initialize dropping on first call or segment full
if (SEGENV.call == 0) {
drop->aux1 = 0; // reset brick stack size
drop->stack = 0; // reset brick stack size
drop->step = 0;
//for (int i=0; i<SEGLEN; i++) SEGMENT.setPixelColor(i | int((stripNr+1)<<16), SEGCOLOR(1)); // will fill virtual strip only
}
@@ -3504,9 +3504,9 @@ uint16_t mode_tetrix(void) {
speed = map(speed, 1, 255, 5000, 250); // time taken for full (SEGLEN) drop
drop->speed = float(SEGLEN * FRAMETIME) / float(speed); // set speed
drop->pos = SEGLEN; // start at end of segment (no need to subtract 1)
drop->col = SEGMENT.color_from_palette(random8(0,15)<<4,false,false,0); // limit color choices so there is enough HUE gap
drop->col = random8(0,15)<<4; // limit color choices so there is enough HUE gap
drop->step = 1; // drop state (0 init, 1 forming, 2 falling)
drop->aux0 = (SEGMENT.intensity ? (SEGMENT.intensity>>5)+1 : random8(1,5)) * (1+(SEGLEN>>6)); // size of brick
drop->brick = (SEGMENT.intensity ? (SEGMENT.intensity>>5)+1 : random8(1,5)) * (1+(SEGLEN>>6)); // size of brick
}
if (drop->step == 1) { // forming
@@ -3516,24 +3516,27 @@ uint16_t mode_tetrix(void) {
}
if (drop->step == 2) { // falling
if (drop->pos > drop->aux1) { // fall until top of stack
if (drop->pos > drop->stack) { // fall until top of stack
drop->pos -= drop->speed; // may add gravity as: speed += gravity
if (uint16_t(drop->pos) < drop->aux1) drop->pos = drop->aux1;
for (int i=int(drop->pos); i<SEGLEN; i++) SEGMENT.setPixelColor(i | int((stripNr+1)<<16), i<int(drop->pos)+drop->aux0 ? drop->col : SEGCOLOR(1));
if (uint16_t(drop->pos) < drop->stack) drop->pos = drop->stack;
for (int i=int(drop->pos); i<SEGLEN; i++) {
uint32_t col = i<int(drop->pos)+drop->brick ? SEGMENT.color_from_palette(drop->col, false, false, 0) : SEGCOLOR(1);
SEGMENT.setPixelColor(i | int((stripNr+1)<<16), col);
}
} else { // we hit bottom
drop->step = 0; // proceed with next brick, go back to init
drop->aux1 += drop->aux0; // increase the stack size
if (drop->aux1 >= SEGLEN) drop->step = millis() + 2000; // fade out stack
drop->stack += drop->brick; // increase the stack size
if (drop->stack >= SEGLEN) drop->step = millis() + 2000; // fade out stack
}
}
if (drop->step > 2) {
drop->aux0 = 0; // reset brick size (no more growing)
if (drop->step > 2) { // fade strip
drop->brick = 0; // reset brick size (no more growing)
if (drop->step > millis()) {
// allow fading of virtual strip
for (int i=0; i<SEGLEN; i++) SEGMENT.blendPixelColor(i | int((stripNr+1)<<16), SEGCOLOR(1), 25); // 10% blend
for (int i=0; i<SEGLEN; i++) SEGMENT.blendPixelColor(i | int((stripNr+1)<<16), SEGCOLOR(1), 25); // 10% blend with Bg color
} else {
drop->aux1 = 0; // reset brick stack size
drop->stack = 0; // reset brick stack size
drop->step = 0; // proceed with next brick
}
}
@@ -6254,7 +6257,7 @@ uint16_t mode_gravcentric(void) { // Gravcentric. By Andrew
return FRAMETIME;
} // mode_gravcentric()
static const char _data_FX_MODE_GRAVCENTRIC[] PROGMEM = "Gravcentric@Rate of fall,Sensitivity;!;!;ix=128,mp12=2,ssim=0,1d,vo"; // Circle, Beatsin
static const char _data_FX_MODE_GRAVCENTRIC[] PROGMEM = "Gravcentric@Rate of fall,Sensitivity;!;!;ix=128,mp12=3,ssim=0,1d,vo"; // Corner, Beatsin
///////////////////////
@@ -6390,7 +6393,7 @@ uint16_t mode_midnoise(void) { // Midnoise. By Andrew Tuline.
return FRAMETIME;
} // mode_midnoise()
static const char _data_FX_MODE_MIDNOISE[] PROGMEM = "Midnoise@Fade rate,Maximum length;,!;!;ix=128,mp12=2,ssim=0,1d,vo"; // Circle, Beatsin
static const char _data_FX_MODE_MIDNOISE[] PROGMEM = "Midnoise@Fade rate,Maximum length;,!;!;ix=128,mp12=1,ssim=0,1d,vo"; // Bar, Beatsin
//////////////////////
@@ -6515,7 +6518,7 @@ uint16_t mode_plasmoid(void) { // Plasmoid. By Andrew Tuline.
}
float volumeSmth = *(float*) um_data->u_data[0];
SEGMENT.fadeToBlackBy(64);
SEGMENT.fadeToBlackBy(32);
plasmoip->thisphase += beatsin8(6,-4,4); // You can change direction and speed individually.
plasmoip->thatphase += beatsin8(7,-4,4); // Two phase values to make a complex pattern. By Andrew Tuline.
@@ -6667,7 +6670,8 @@ uint16_t mode_blurz(void) { // Blurz. By Andrew Tuline.
SEGENV.aux0 = 0;
}
SEGMENT.fade_out(SEGMENT.speed);
int fadeoutDelay = (256 - SEGMENT.speed) / 32;
if ((fadeoutDelay <= 1 ) || ((SEGENV.call % fadeoutDelay) == 0)) SEGMENT.fade_out(SEGMENT.speed);
SEGENV.step += FRAMETIME;
if (SEGENV.step > SPEED_FORMULA_L) {
@@ -6735,7 +6739,9 @@ uint16_t mode_freqmap(void) { // Map FFT_MajorPeak to SEGLEN.
float my_magnitude = *(float*) um_data->u_data[5] / 4.0f;
if (FFT_MajorPeak < 1) FFT_MajorPeak = 1; // log10(0) is "forbidden" (throws exception)
SEGMENT.fade_out(SEGMENT.speed);
if (SEGENV.call == 0) SEGMENT.fill(BLACK);
int fadeoutDelay = (256 - SEGMENT.speed) / 32;
if ((fadeoutDelay <= 1 ) || ((SEGENV.call % fadeoutDelay) == 0)) SEGMENT.fade_out(SEGMENT.speed);
int locn = (log10f((float)FFT_MajorPeak) - 1.78f) * (float)SEGLEN/(MAX_FREQ_LOG10 - 1.78f); // log10 frequency range is from 1.78 to 3.71. Let's scale to SEGLEN.
if (locn < 1) locn = 0; // avoid underflow
@@ -6750,7 +6756,7 @@ uint16_t mode_freqmap(void) { // Map FFT_MajorPeak to SEGLEN.
return FRAMETIME;
} // mode_freqmap()
static const char _data_FX_MODE_FREQMAP[] PROGMEM = "Freqmap@Fade rate,Starting color;,!;!;mp12=2,ssim=0,1d,fr"; // Circle, Beatsin
static const char _data_FX_MODE_FREQMAP[] PROGMEM = "Freqmap@Fade rate,Starting color;,!;!;mp12=0,ssim=0,1d,fr"; // Pixels, Beatsin
///////////////////////
@@ -6805,7 +6811,7 @@ uint16_t mode_freqmatrix(void) { // Freqmatrix. By Andreas Plesch
return FRAMETIME;
} // mode_freqmatrix()
static const char _data_FX_MODE_FREQMATRIX[] PROGMEM = "Freqmatrix@Time delay,Sound effect,Low bin,High bin,Sensivity;;;mp12=0,ssim=0,1d,fr"; // Pixels, Beatsin
static const char _data_FX_MODE_FREQMATRIX[] PROGMEM = "Freqmatrix@Time delay,Sound effect,Low bin,High bin,Sensivity;;;mp12=3,ssim=0,1d,fr"; // Corner, Beatsin
//////////////////////
@@ -6826,7 +6832,10 @@ uint16_t mode_freqpixels(void) { // Freqpixel. By Andrew Tuline.
if (FFT_MajorPeak < 1) FFT_MajorPeak = 1; // log10(0) is "forbidden" (throws exception)
uint16_t fadeRate = 2*SEGMENT.speed - SEGMENT.speed*SEGMENT.speed/255; // Get to 255 as quick as you can.
SEGMENT.fade_out(fadeRate);
if (SEGENV.call == 0) SEGMENT.fill(BLACK);
int fadeoutDelay = (256 - SEGMENT.speed) / 64;
if ((fadeoutDelay <= 1 ) || ((SEGENV.call % fadeoutDelay) == 0)) SEGMENT.fade_out(fadeRate);
for (int i=0; i < SEGMENT.intensity/32+1; i++) {
uint16_t locn = random16(0,SEGLEN);
@@ -6958,7 +6967,7 @@ uint16_t mode_gravfreq(void) { // Gravfreq. By Andrew Tuline.
return FRAMETIME;
} // mode_gravfreq()
static const char _data_FX_MODE_GRAVFREQ[] PROGMEM = "Gravfreq@Rate of fall,Sensivity;,!;!;ix=128,mp12=2,ssim=0,1d,fr"; // Circle, Beatsin
static const char _data_FX_MODE_GRAVFREQ[] PROGMEM = "Gravfreq@Rate of fall,Sensivity;,!;!;ix=128,mp12=0,ssim=0,1d,fr"; // Pixels, Beatsin
//////////////////////
@@ -6972,7 +6981,10 @@ uint16_t mode_noisemove(void) { // Noisemove. By: Andrew Tuli
}
uint8_t *fftResult = (uint8_t*)um_data->u_data[2];
SEGMENT.fade_out(224); // Just in case something doesn't get faded.
if (SEGENV.call == 0) SEGMENT.fill(BLACK);
//SEGMENT.fade_out(224); // Just in case something doesn't get faded.
int fadeoutDelay = (256 - SEGMENT.speed) / 96;
if ((fadeoutDelay <= 1 ) || ((SEGENV.call % fadeoutDelay) == 0)) SEGMENT.fadeToBlackBy(4+ SEGMENT.speed/4);
uint8_t numBins = map(SEGMENT.intensity,0,255,0,16); // Map slider to fftResult bins.
for (int i=0; i<numBins; i++) { // How many active bins are we using.
@@ -6998,13 +7010,16 @@ uint16_t mode_rocktaves(void) { // Rocktaves. Same note from eac
float FFT_MajorPeak = *(float*) um_data->u_data[4];
float my_magnitude = *(float*) um_data->u_data[5] / 16.0f;
SEGMENT.fadeToBlackBy(64); // Just in case something doesn't get faded.
if (SEGENV.call == 0) SEGMENT.fill(BLACK);
SEGMENT.fadeToBlackBy(16); // Just in case something doesn't get faded.
float frTemp = FFT_MajorPeak;
uint8_t octCount = 0; // Octave counter.
uint8_t volTemp = 0;
if (my_magnitude > 32) volTemp = 255; // We need to squelch out the background noise.
volTemp = 32.0f + my_magnitude * 1.5f; // brightness = volume (overflows are handled in next lines)
if (my_magnitude < 48) volTemp = 0; // We need to squelch out the background noise.
if (my_magnitude > 144) volTemp = 255; // everything above this is full brightness
while ( frTemp > 249 ) {
octCount++; // This should go up to 5.
@@ -7020,7 +7035,7 @@ uint16_t mode_rocktaves(void) { // Rocktaves. Same note from eac
return FRAMETIME;
} // mode_rocktaves()
static const char _data_FX_MODE_ROCKTAVES[] PROGMEM = "Rocktaves@;,!;!;mp12=0,ssim=0,1d,fr"; // Pixels, Beatsin
static const char _data_FX_MODE_ROCKTAVES[] PROGMEM = "Rocktaves@;,!;!;mp12=1,ssim=0,1d,fr"; // Bar, Beatsin
///////////////////////
@@ -7104,7 +7119,9 @@ uint16_t mode_2DGEQ(void) { // By Will Tatam. Code reduction by Ewoud Wijma.
rippleTime = true;
}
SEGMENT.fadeToBlackBy(SEGMENT.speed);
if (SEGENV.call == 0) SEGMENT.fill(BLACK);
int fadeoutDelay = (256 - SEGMENT.speed) / 64;
if ((fadeoutDelay <= 1 ) || ((SEGENV.call % fadeoutDelay) == 0)) SEGMENT.fadeToBlackBy(SEGMENT.speed);
for (int x=0; x < cols; x++) {
uint8_t band = map(x, 0, cols-1, 0, NUM_BANDS - 1);

45
wled00/FX.h
View File

@@ -357,26 +357,21 @@ typedef struct Segment {
union {
uint16_t options; //bit pattern: msb first: [transposed mirrorY reverseY] transitional (tbd) paused needspixelstate mirrored on reverse selected
struct {
bool selected : 1; // 0 : selected
bool reverse : 1; // 1 : reversed
bool on : 1; // 2 : is On
bool mirror : 1; // 3 : mirrored
bool pxs : 1; // 4 : indicates that the effect does not use FRAMETIME or needs getPixelColor (?)
bool freeze : 1; // 5 : paused/frozen
bool reset : 1; // 6 : indicates that Segment runtime requires reset
bool transitional: 1; // 7 : transitional (there is transition occuring)
bool reverse_y : 1; // 8 : reversed Y (2D)
bool mirror_y : 1; // 9 : mirrored Y (2D)
bool transpose : 1; // 10 : transposed (2D, swapped X & Y)
uint8_t map1D2D : 3; // 11-13 : mapping for 1D effect on 2D (0-use as strip, 1-expand vertically, 2-circular/arc, 3-rectangular/corner, ...)
uint8_t soundSim : 2; // 14-15 : 0-3 sound simulation types
bool selected : 1; // 0 : selected
bool reverse : 1; // 1 : reversed
bool on : 1; // 2 : is On
bool mirror : 1; // 3 : mirrored
bool freeze : 1; // 4 : paused/frozen
bool reset : 1; // 5 : indicates that Segment runtime requires reset
bool transitional: 1; // 6 : transitional (there is transition occuring)
bool reverse_y : 1; // 7 : reversed Y (2D)
bool mirror_y : 1; // 8 : mirrored Y (2D)
bool transpose : 1; // 9 : transposed (2D, swapped X & Y)
uint8_t map1D2D : 3; // 10-12 : mapping for 1D effect on 2D (0-use as strip, 1-expand vertically, 2-circular/arc, 3-rectangular/corner, ...)
uint8_t soundSim : 3; // 13-15 : 0-7 sound simulation types
};
};
uint8_t grouping, spacing;
//struct {
// uint8_t grouping : 4; // maximum 15 pixels in a group
// uint8_t spacing : 4; // maximum 15 pixels per gap
//};
uint8_t opacity;
uint32_t colors[NUM_COLORS];
uint8_t cct; //0==1900K, 255==10091K
@@ -418,17 +413,20 @@ typedef struct Segment {
// transition data, valid only if transitional==true, holds values during transition
struct Transition {
uint32_t _colorT[NUM_COLORS];
uint8_t _briT; // temporary brightness
uint8_t _cctT; // temporary CCT
CRGBPalette16 _palT; // temporary palette
uint8_t _modeP; // previous mode/effect
uint8_t _briT; // temporary brightness
uint8_t _cctT; // temporary CCT
CRGBPalette16 _palT; // temporary palette
uint8_t _modeP; // previous mode/effect
//uint16_t _aux0, _aux1; // previous mode/effect runtime data
//uint32_t _step, _call; // previous mode/effect runtime data
//byte *_data; // previous mode/effect runtime data
uint32_t _start;
uint16_t _dur;
Transition(uint16_t dur=750) : _briT(255), _cctT(127), _palT(CRGBPalette16(CRGB::Black)), _modeP(FX_MODE_STATIC), _start(millis()), _dur(dur) {}
Transition(uint16_t d, uint8_t b, uint8_t c, const uint32_t *o) : _briT(b), _cctT(c), _palT(CRGBPalette16(CRGB::Black)), _modeP(FX_MODE_STATIC), _start(millis()), _dur(d) {
for (size_t i=0; i<NUM_COLORS; i++) _colorT[i] = o[i];
}
} *_t; // this struct will bootloop ESP
} *_t;
public:
@@ -530,8 +528,7 @@ typedef struct Segment {
* Safe to call from interrupts and network requests.
*/
inline void markForReset(void) { reset = true; } // setOption(SEG_OPTION_RESET, true)
//inline void setUpLeds() { if (!leds) leds = (CRGB*)malloc(sizeof(CRGB)*length()); }
void setUpLeds(void);
void setUpLeds(void); // set up leds[] array for loseless getPixelColor()
// transition functions
void startTransition(uint16_t dur); // transition has to start before actual segment values change

8
wled00/FX_fcn.cpp
View File

@@ -297,8 +297,8 @@ void Segment::startTransition(uint16_t dur) {
if (!_t) _t = new Transition(dur); // no previous transition running
if (!_t) return; // failed to allocate data
_t->_briT = _briT;
_t->_cctT = _cctT;
_t->_briT = _briT;
_t->_cctT = _cctT;
_t->_palT = _palT;
_t->_modeP = _modeP;
for (size_t i=0; i<NUM_COLORS; i++) _t->_colorT[i] = _colorT[i];
@@ -625,7 +625,7 @@ uint8_t Segment::differs(Segment& b) const {
if (stopY != b.stopY) d |= SEG_DIFFERS_BOUNDS;
//bit pattern: msb first: [transposed mirrorY reverseY] transitional (tbd) paused needspixelstate mirrored on reverse selected
if ((options & 0b1111111100101110) != (b.options & 0b1111111100101110)) d |= SEG_DIFFERS_OPT;
if ((options & 0b1111111110011110) != (b.options & 0b1111111110011110)) d |= SEG_DIFFERS_OPT;
if ((options & 0x01) != (b.options & 0x01)) d |= SEG_DIFFERS_SEL;
for (uint8_t i = 0; i < NUM_COLORS; i++) if (colors[i] != b.colors[i]) d |= SEG_DIFFERS_COL;
@@ -1545,7 +1545,7 @@ const char JSON_mode_names[] PROGMEM = R"=====(["Mode names have moved"])=====";
const char JSON_palette_names[] PROGMEM = R"=====([
"Default","* Random Cycle","* Color 1","* Colors 1&2","* Color Gradient","* Colors Only","Party","Cloud","Lava","Ocean",
"Forest","Rainbow","Rainbow Bands","Sunset","Rivendell","Breeze","Red & Blue","Yellowout","Analogous","Splash",
"Pastel","Sunset 2","Beech","Vintage","Departure","Landscape","Beach","Sherbet","Hult","Hult 64",
"Pastel","Sunset 2","Beach","Vintage","Departure","Landscape","Beech","Sherbet","Hult","Hult 64",
"Drywet","Jul","Grintage","Rewhi","Tertiary","Fire","Icefire","Cyane","Light Pink","Autumn",
"Magenta","Magred","Yelmag","Yelblu","Orange & Teal","Tiamat","April Night","Orangery","C9","Sakura",
"Aurora","Atlantica","C9 2","C9 New","Temperature","Aurora 2","Retro Clown","Candy","Toxy Reaf","Fairy Reaf",

13
wled00/const.h
View File

@@ -226,13 +226,12 @@
#define SEG_OPTION_REVERSED 1
#define SEG_OPTION_ON 2
#define SEG_OPTION_MIRROR 3 //Indicates that the effect will be mirrored within the segment
#define SEG_OPTION_NONUNITY 4 //Indicates that the effect does not use FRAMETIME or needs getPixelColor
#define SEG_OPTION_FREEZE 5 //Segment contents will not be refreshed
#define SEG_OPTION_RESET 6 //Segment runtime requires reset
#define SEG_OPTION_TRANSITIONAL 7
#define SEG_OPTION_REVERSED_Y 8
#define SEG_OPTION_MIRROR_Y 9
#define SEG_OPTION_TRANSPOSED 10
#define SEG_OPTION_FREEZE 4 //Segment contents will not be refreshed
#define SEG_OPTION_RESET 5 //Segment runtime requires reset
#define SEG_OPTION_TRANSITIONAL 6
#define SEG_OPTION_REVERSED_Y 7
#define SEG_OPTION_MIRROR_Y 8
#define SEG_OPTION_TRANSPOSED 9
//Segment differs return byte
#define SEG_DIFFERS_BRI 0x01

6
wled00/data/index.js
View File

@@ -653,8 +653,8 @@ function populateInfo(i)
}
}
var vcn = "Kuuhaku";
if (i.ver.startsWith("0.13.")) vcn = "Toki";
if (i.ver.includes("-bl")) vcn = "Ryujin";
if (i.ver.startsWith("0.14.")) vcn = "Hoshi";
if (i.ver.includes("-bl")) vcn = "Supāku";
if (i.cn) vcn = i.cn;
cn += `v${i.ver} "${vcn}"<br><br><table>
@@ -714,7 +714,7 @@ function populateSegments(s)
}
let map2D = `<div id="seg${i}map2D" data-map="map2D" class="lbl-s hide">Expand 1D FX<br>
<div class="sel-p"><select class="sel-p" id="seg${i}mp12" onchange="setMp12(${i})">
<option value="0" ${inst.mp12==0?' selected':''}>Pxels</option>
<option value="0" ${inst.mp12==0?' selected':''}>Pixels</option>
<option value="1" ${inst.mp12==1?' selected':''}>Bar</option>
<option value="2" ${inst.mp12==2?' selected':''}>Arc</option>
<option value="3" ${inst.mp12==3?' selected':''}>Corner</option>

1
wled00/data/settings_um.htm
View File

@@ -230,6 +230,7 @@
Global SPI GPIOs (HW)<br>
<i style="color: orange;">(only changable on ESP32, change requires reboot!)</i><br>
MOSI:<input type="number" min="-1" max="33" name="MOSI" onchange="check(this,'if')" class="s" placeholder="MOSI">
MISO:<input type="number" min="-1" max="33" name="MISO" onchange="check(this,'if')" class="s" placeholder="MISO">
SCLK:<input type="number" min="-1" max="33" name="SCLK" onchange="check(this,'if')" class="s" placeholder="SCLK">
<div id="um">Loading settings...</div>
<hr><button type="button" onclick="B()">Back</button><button type="submit">Save</button>

4
wled00/data/simple.js
View File

@@ -505,8 +505,8 @@ function populateInfo(i)
}
}
var vcn = "Kuuhaku";
if (i.ver.startsWith("0.13.")) vcn = "Toki";
if (i.ver.includes("-bl")) vcn = "Ryujin";
if (i.ver.startsWith("0.14.")) vcn = "Hoshi";
if (i.ver.includes("-bl")) vcn = "Supāku";
if (i.cn) vcn = i.cn;
cn += `v${i.ver} "${vcn}"<br><br><table>

318
wled00/html_settings.h
View File

@@ -1583,166 +1583,166 @@ const uint8_t PAGE_settings_sec[] PROGMEM = {
// Autogenerated from wled00/data/settings_um.htm, do not edit!!
const uint16_t PAGE_settings_um_length = 2514;
const uint16_t PAGE_settings_um_length = 2526;
const uint8_t PAGE_settings_um[] PROGMEM = {
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x13, 0xdd, 0x58, 0xdb, 0x72, 0xdb, 0x38,
0x12, 0x7d, 0xd7, 0x57, 0xd0, 0x88, 0xcb, 0x26, 0x4b, 0x34, 0x25, 0xc7, 0x3b, 0xb3, 0x89, 0x24,
0xc8, 0x93, 0x38, 0xc9, 0x44, 0x9b, 0x8b, 0x5d, 0xa5, 0xb9, 0xd4, 0x96, 0xd7, 0x35, 0xa6, 0x44,
0x48, 0x42, 0x4c, 0x81, 0x5c, 0x00, 0xf4, 0x65, 0x65, 0xfd, 0xfb, 0x9e, 0x06, 0x49, 0x5d, 0x1c,
0x3b, 0xb3, 0x33, 0x5b, 0xfb, 0xb2, 0x2f, 0x12, 0x09, 0x36, 0x9a, 0x8d, 0xd3, 0xdd, 0xa7, 0xbb,
0xd9, 0xdb, 0x79, 0x73, 0x7a, 0xf2, 0xd3, 0xdf, 0xcf, 0xde, 0x7a, 0x33, 0x3b, 0x4f, 0xfb, 0xbd,
0xea, 0x57, 0xc4, 0x89, 0x97, 0xc6, 0x6a, 0xca, 0x99, 0x50, 0xac, 0xdf, 0x9b, 0x0b, 0x1b, 0x7b,
0xe3, 0x59, 0xac, 0x8d, 0xb0, 0x9c, 0x15, 0x76, 0x72, 0xf0, 0xa2, 0x5e, 0x6d, 0xa8, 0x78, 0x2e,
0x38, 0xbb, 0x96, 0xe2, 0x26, 0xcf, 0xb4, 0x65, 0xde, 0x38, 0x53, 0x56, 0x28, 0x88, 0xdd, 0xc8,
0xc4, 0xce, 0xf8, 0x77, 0xed, 0xf6, 0x4a, 0xf4, 0xc1, 0xa3, 0x44, 0x5c, 0xcb, 0xb1, 0x38, 0x70,
0x37, 0xa1, 0x54, 0xd2, 0xca, 0x38, 0x3d, 0x30, 0xe3, 0x38, 0x15, 0xfc, 0x30, 0x9c, 0xc7, 0xb7,
0x72, 0x5e, 0xcc, 0x57, 0xf7, 0x85, 0x11, 0xda, 0xdd, 0xc4, 0x23, 0xdc, 0xab, 0x8c, 0x7d, 0xf5,
0xe6, 0x7e, 0xcf, 0x4a, 0x9b, 0x8a, 0xfe, 0xcf, 0x90, 0x9c, 0x67, 0x89, 0x37, 0x14, 0xd6, 0x4a,
0x35, 0x35, 0xbd, 0x56, 0xb9, 0xde, 0x33, 0x63, 0x2d, 0x73, 0xdb, 0x6f, 0x5c, 0xc7, 0xda, 0xcb,
0x6e, 0x94, 0xd0, 0x61, 0x9a, 0x8d, 0x65, 0x1e, 0x16, 0x3a, 0xbb, 0x31, 0x61, 0xc2, 0x93, 0x6c,
0x5c, 0xcc, 0x61, 0x5f, 0x58, 0xcc, 0x4f, 0x26, 0x53, 0xbe, 0x58, 0x86, 0xb9, 0x54, 0x86, 0x9f,
0x7f, 0x1f, 0xfe, 0x35, 0x7c, 0x11, 0xbe, 0x0c, 0x0f, 0xdb, 0xe1, 0xe1, 0xe1, 0x05, 0x2d, 0x9e,
0xf2, 0x73, 0xa6, 0xcd, 0x75, 0xc2, 0xc2, 0xdf, 0xff, 0xbb, 0xa0, 0xb7, 0xf0, 0x9d, 0xc3, 0x50,
0x15, 0xf3, 0x4f, 0xbc, 0xdd, 0x9d, 0x14, 0x6a, 0x6c, 0x65, 0xa6, 0xbc, 0xe9, 0x20, 0xf1, 0x45,
0xb0, 0xd0, 0xc2, 0x16, 0x5a, 0x79, 0x49, 0x34, 0x15, 0xf6, 0x6d, 0x2a, 0xc8, 0x80, 0xd7, 0x77,
0xee, 0xd1, 0x72, 0x25, 0x2a, 0xcd, 0xe9, 0x86, 0xa8, 0xd8, 0xdb, 0x63, 0xd9, 0xe8, 0x8b, 0x18,
0x5b, 0xc6, 0xb9, 0xbd, 0xcb, 0x45, 0x36, 0xa1, 0xb5, 0x9d, 0x57, 0x5a, 0xc7, 0x77, 0x91, 0x34,
0xee, 0x7f, 0x6b, 0xff, 0x7b, 0x3f, 0x58, 0xdc, 0x48, 0x95, 0x64, 0x37, 0x51, 0x96, 0x0b, 0xe5,
0xb3, 0x99, 0xb5, 0xb9, 0xe9, 0xb4, 0x5a, 0x53, 0x69, 0x67, 0xc5, 0x28, 0x1a, 0x67, 0xf3, 0xd6,
0x2b, 0xa9, 0xc7, 0x59, 0x96, 0x5d, 0x49, 0xd1, 0xfa, 0xf5, 0xe3, 0xdb, 0x37, 0xad, 0x1b, 0x79,
0x25, 0x5b, 0x35, 0x86, 0xcf, 0x8a, 0x12, 0xd4, 0x03, 0x53, 0x2d, 0xb0, 0x0d, 0xed, 0xaf, 0x1f,
0x6a, 0x6f, 0xad, 0xa4, 0x42, 0xf6, 0x9b, 0x11, 0xe9, 0x64, 0x53, 0x3a, 0xcd, 0xe2, 0xe4, 0x6f,
0x43, 0x5f, 0x84, 0x96, 0xef, 0xb4, 0x83, 0x45, 0x2a, 0xac, 0xa7, 0x78, 0x12, 0x8d, 0xb5, 0x88,
0xad, 0xa8, 0x00, 0xf0, 0x59, 0xe9, 0x2b, 0x16, 0x74, 0x55, 0x04, 0x65, 0xaf, 0xac, 0xd5, 0x72,
0x54, 0x58, 0x81, 0x07, 0x7a, 0xcc, 0x42, 0x11, 0x84, 0x0f, 0xd7, 0x09, 0x07, 0xbc, 0xce, 0x8a,
0x5b, 0xdb, 0xfa, 0x12, 0x5f, 0xc7, 0xb5, 0x82, 0xaf, 0x04, 0x63, 0x73, 0xa7, 0xa0, 0xc2, 0x06,
0x61, 0x12, 0x8d, 0xb2, 0xe4, 0x2e, 0x8a, 0x73, 0x18, 0x9d, 0x9c, 0xcc, 0x64, 0x9a, 0xf8, 0x8a,
0xe4, 0xe3, 0x24, 0x79, 0x7b, 0x0d, 0x2b, 0x3e, 0x4a, 0x83, 0x70, 0x15, 0xda, 0x67, 0x64, 0x33,
0x0b, 0xfd, 0x80, 0xf7, 0x17, 0x3f, 0x0a, 0xfb, 0x8b, 0x1f, 0x2c, 0x1f, 0x97, 0x13, 0x5a, 0x67,
0x1a, 0xe6, 0x41, 0x0e, 0xb1, 0x6e, 0xb2, 0x54, 0x44, 0x69, 0x36, 0xf5, 0xd9, 0x5b, 0x5a, 0xf7,
0xaa, 0xc3, 0x03, 0x18, 0x6f, 0x22, 0x53, 0xe1, 0x8e, 0x81, 0xe0, 0xd6, 0x38, 0xee, 0xc7, 0x6a,
0x1d, 0x9e, 0xc4, 0xc6, 0x89, 0x9c, 0x16, 0x3a, 0x76, 0x68, 0x95, 0xc7, 0xf0, 0x26, 0x31, 0x36,
0x24, 0xd1, 0x3f, 0xd4, 0x40, 0xc1, 0x57, 0x39, 0x40, 0x13, 0x5e, 0x1e, 0x4f, 0x85, 0x97, 0xc4,
0x36, 0xde, 0x01, 0xbc, 0x1b, 0x00, 0x0f, 0xe1, 0x0e, 0x46, 0x2f, 0xe8, 0x20, 0x3c, 0x2a, 0xbf,
0x20, 0x04, 0x9d, 0xbe, 0x28, 0xd7, 0x99, 0xcd, 0xc6, 0x59, 0xba, 0xb7, 0xe7, 0xbb, 0xb0, 0x6c,
0x87, 0xbe, 0x4b, 0x02, 0x4e, 0x12, 0xe9, 0xd0, 0x66, 0x1a, 0x5a, 0x29, 0x14, 0x07, 0x56, 0xcc,
0xe9, 0xe0, 0xe3, 0x41, 0xce, 0x82, 0xe0, 0xfe, 0xbe, 0x12, 0xc3, 0xfe, 0x79, 0x0e, 0x83, 0xdf,
0x41, 0xbf, 0xf7, 0x29, 0x4b, 0x44, 0xe4, 0x9d, 0xa5, 0x22, 0x36, 0xc2, 0x03, 0x10, 0x42, 0x7b,
0x14, 0x3a, 0xde, 0xe0, 0x0c, 0x26, 0x85, 0x5b, 0x1a, 0xcd, 0xb6, 0xc6, 0x32, 0xf3, 0x82, 0x00,
0x52, 0x09, 0xec, 0x75, 0xb9, 0x81, 0x77, 0x50, 0x4a, 0xb0, 0x62, 0xce, 0x82, 0x48, 0x2a, 0x00,
0xfa, 0xfe, 0xa7, 0x4f, 0x1f, 0x39, 0xfb, 0x9c, 0x79, 0x55, 0x4a, 0x1b, 0x0f, 0xf9, 0x68, 0xe3,
0x94, 0xa0, 0x60, 0x5b, 0xe9, 0xf1, 0x6e, 0x33, 0x3d, 0x38, 0xe7, 0x4d, 0xe4, 0x83, 0xd8, 0xe1,
0xdc, 0x6f, 0xdf, 0x6f, 0xe7, 0xd1, 0xe0, 0x31, 0x41, 0xfe, 0x95, 0xe0, 0x78, 0x26, 0xc6, 0x57,
0x14, 0xa3, 0xc1, 0x82, 0xd8, 0x42, 0x71, 0x11, 0x11, 0xdb, 0x44, 0x5a, 0xe4, 0x69, 0x3c, 0x46,
0x14, 0x9d, 0x5f, 0x20, 0xd8, 0x60, 0xa7, 0x29, 0x46, 0xc6, 0x6a, 0xff, 0xe0, 0x28, 0xe8, 0xca,
0x89, 0xcf, 0x70, 0x8e, 0x91, 0xd0, 0xc0, 0x5d, 0x44, 0x14, 0x90, 0x48, 0x54, 0xb0, 0x05, 0x6e,
0x55, 0x2d, 0xd8, 0x0e, 0x8f, 0x82, 0x60, 0x31, 0xc9, 0xb4, 0x4f, 0x7a, 0x25, 0xf8, 0x40, 0xf6,
0x88, 0x65, 0xa2, 0x54, 0xa8, 0xa9, 0x9d, 0x75, 0x65, 0xb3, 0x19, 0x40, 0x91, 0xdd, 0xe1, 0x44,
0x33, 0xe7, 0xf2, 0x22, 0x58, 0xe0, 0x56, 0x44, 0xd7, 0x71, 0x5a, 0xc0, 0x4e, 0x12, 0xc5, 0x22,
0xf4, 0xca, 0x09, 0xd4, 0xae, 0x85, 0x80, 0xb0, 0xbd, 0x43, 0xb8, 0xc1, 0xb5, 0x99, 0xe6, 0x2c,
0x95, 0x73, 0xc1, 0xba, 0x23, 0xe4, 0xd4, 0xd5, 0xf2, 0x91, 0xfd, 0xf7, 0xf7, 0xd5, 0x4a, 0xef,
0xe0, 0x70, 0x75, 0xdd, 0x3f, 0x7a, 0xf9, 0x95, 0x1e, 0x2d, 0x92, 0x5a, 0xcd, 0xf6, 0x93, 0xd5,
0x9e, 0xa3, 0x63, 0x06, 0x0f, 0xab, 0xa9, 0x60, 0x1d, 0xf6, 0x6c, 0x32, 0x99, 0xb0, 0xe5, 0x52,
0xa4, 0x46, 0x2c, 0xcc, 0x8d, 0xb4, 0xe3, 0x99, 0x5f, 0xe2, 0x16, 0x2c, 0xc6, 0x08, 0x11, 0x36,
0x7c, 0xf3, 0x8a, 0x75, 0xca, 0xab, 0x93, 0x8f, 0xd5, 0xd5, 0xa7, 0xd3, 0xe1, 0x60, 0xbd, 0xf8,
0xa1, 0xba, 0x3c, 0x19, 0xb2, 0x8e, 0x7b, 0x6d, 0x37, 0x11, 0x93, 0xb8, 0x48, 0x6d, 0xa7, 0xf4,
0xd9, 0x92, 0x90, 0xfb, 0xff, 0x44, 0x6d, 0x1d, 0x7c, 0xc8, 0xbe, 0x33, 0xbc, 0x91, 0x22, 0x15,
0x56, 0x94, 0xdc, 0x1f, 0xd0, 0xc1, 0x89, 0x53, 0xec, 0xb9, 0x0a, 0xe5, 0x05, 0x78, 0xe2, 0xd4,
0x55, 0x80, 0x08, 0x69, 0xa7, 0xa5, 0x20, 0xe1, 0xa0, 0x12, 0x96, 0x41, 0xe0, 0xaa, 0x1b, 0x57,
0x61, 0xad, 0x49, 0x06, 0x5d, 0x72, 0x8a, 0x47, 0x21, 0x5a, 0x07, 0xe4, 0x37, 0x42, 0x99, 0x34,
0x6d, 0x17, 0x13, 0x59, 0x1a, 0x40, 0x31, 0x6b, 0x81, 0xbe, 0xed, 0xc9, 0x1a, 0x7a, 0x4b, 0xd0,
0x9f, 0xdb, 0x8b, 0x3e, 0x6f, 0x83, 0x53, 0x9c, 0x53, 0xf2, 0xc2, 0xcc, 0x7c, 0x5a, 0x0b, 0x5c,
0xad, 0x2c, 0xef, 0x9d, 0x49, 0x41, 0x6d, 0xc7, 0x57, 0xd2, 0x4f, 0x8b, 0x3e, 0x61, 0xca, 0x23,
0x66, 0xac, 0x4e, 0x4b, 0xaf, 0x5e, 0xc3, 0x09, 0x9a, 0x7e, 0x27, 0x05, 0xc8, 0x1d, 0xe9, 0x1c,
0x02, 0x3c, 0xd4, 0xe2, 0x15, 0xb0, 0x0a, 0xc9, 0xe8, 0xca, 0x7f, 0x93, 0xef, 0xf7, 0x66, 0xda,
0x73, 0xce, 0xaa, 0xfa, 0x93, 0xce, 0xf3, 0xef, 0xdb, 0xf9, 0x2d, 0xeb, 0xef, 0x77, 0xd7, 0xd8,
0xcb, 0x50, 0x3f, 0x82, 0x3d, 0xb4, 0xb0, 0x42, 0x5d, 0x29, 0x18, 0x4e, 0xe1, 0x65, 0x29, 0x38,
0xa4, 0x1a, 0xa7, 0x45, 0x82, 0x87, 0xf0, 0x70, 0x70, 0xbc, 0x61, 0x03, 0x54, 0x04, 0x9d, 0xf5,
0x7d, 0x13, 0xcf, 0x9b, 0xd6, 0xad, 0x2e, 0x1f, 0x3f, 0xb0, 0x5a, 0x63, 0xaf, 0x71, 0x68, 0xdd,
0x53, 0xf5, 0xa1, 0x35, 0x0e, 0xbd, 0x7d, 0xba, 0x73, 0x7d, 0x11, 0xa2, 0xaa, 0x3a, 0xe8, 0x1c,
0x73, 0x99, 0x30, 0xad, 0x5b, 0x04, 0xd5, 0xad, 0x72, 0x32, 0xad, 0xd2, 0x71, 0x94, 0xa1, 0x40,
0xc5, 0x8a, 0x75, 0x52, 0xce, 0x1c, 0xe1, 0x8d, 0xb2, 0x5b, 0x16, 0x1a, 0xbe, 0x5f, 0x86, 0x3d,
0xb3, 0xba, 0x10, 0x6c, 0xbf, 0xe9, 0xab, 0x63, 0x56, 0x12, 0x22, 0xc2, 0xba, 0x83, 0x48, 0x29,
0x43, 0xbb, 0xeb, 0x74, 0x54, 0x84, 0xd7, 0x31, 0xfc, 0xb2, 0xda, 0xb5, 0xbb, 0x50, 0x4b, 0x76,
0x19, 0x56, 0x71, 0xc6, 0xed, 0x46, 0x5c, 0x1d, 0xfb, 0x84, 0xb3, 0x87, 0xd6, 0x8e, 0xb3, 0xa3,
0x97, 0xcc, 0x9b, 0x4b, 0xc5, 0xd9, 0xc1, 0x21, 0xb4, 0xa7, 0xb1, 0x31, 0x9c, 0x19, 0xb6, 0x0f,
0x73, 0x99, 0x54, 0xa8, 0xdb, 0x1d, 0x27, 0x8a, 0xc2, 0x9a, 0x73, 0x16, 0xab, 0xbb, 0x95, 0xcc,
0xed, 0x6d, 0xca, 0xf6, 0xbb, 0xdb, 0xdc, 0x80, 0x3d, 0x54, 0xf7, 0xc9, 0xf6, 0x2d, 0x2b, 0x1e,
0xb8, 0xf3, 0x3b, 0xb8, 0xb3, 0xcb, 0x2e, 0x97, 0x0f, 0x9c, 0x83, 0x40, 0xac, 0x42, 0x40, 0xd4,
0xb6, 0x92, 0x44, 0x22, 0x6e, 0x4f, 0x27, 0x4e, 0xa0, 0x79, 0x88, 0x3a, 0x55, 0x89, 0x5c, 0x7a,
0xbb, 0x0b, 0xbb, 0xec, 0x78, 0x38, 0xe0, 0x0a, 0x32, 0xce, 0xd3, 0xe3, 0xfa, 0x71, 0x4f, 0xaa,
0xbc, 0xb0, 0x1e, 0x41, 0xce, 0xd9, 0x4c, 0x26, 0x09, 0xfa, 0x67, 0xaf, 0x6c, 0x54, 0x77, 0x17,
0x62, 0xd9, 0xa1, 0xdd, 0xbb, 0x0b, 0x79, 0x4c, 0x59, 0x07, 0x2c, 0x61, 0x63, 0x65, 0xf0, 0x24,
0x86, 0xcb, 0x58, 0xff, 0xb2, 0x23, 0x51, 0x07, 0xff, 0x6b, 0x6d, 0xbb, 0x8b, 0x74, 0x09, 0x65,
0x6b, 0xb3, 0xb7, 0x34, 0xed, 0x2e, 0x1c, 0xc6, 0x9c, 0x0c, 0x5f, 0x79, 0x10, 0x1b, 0xbe, 0xad,
0x7a, 0x77, 0x61, 0x96, 0xe8, 0x61, 0x9c, 0xa2, 0x2a, 0x60, 0x7c, 0x3b, 0x93, 0x26, 0xdc, 0xdf,
0x5d, 0x3c, 0x8d, 0xdc, 0x72, 0x3f, 0x40, 0x67, 0x3e, 0xd2, 0xfd, 0xcb, 0xe5, 0x56, 0x4a, 0xbe,
0xd1, 0x59, 0x8e, 0xce, 0x44, 0x95, 0x45, 0xf6, 0xa9, 0x2e, 0x50, 0xa4, 0xd4, 0xe5, 0x06, 0x48,
0xda, 0xcd, 0xfe, 0xd8, 0xbc, 0xbe, 0xfb, 0x0c, 0x4b, 0xeb, 0xe4, 0x09, 0xce, 0x0f, 0x2f, 0xa8,
0xfa, 0x4a, 0x10, 0xfc, 0xe0, 0xf3, 0xd9, 0xcf, 0x3f, 0xd1, 0xc9, 0x64, 0x64, 0xe3, 0x29, 0x49,
0xc1, 0xbd, 0x65, 0x74, 0x94, 0x8b, 0x00, 0xe0, 0xfe, 0x7e, 0x5d, 0xa7, 0xab, 0xa5, 0xa0, 0x34,
0x41, 0xe0, 0xd6, 0x21, 0xd8, 0x95, 0xae, 0x6e, 0x75, 0xb7, 0x13, 0x4f, 0x46, 0x71, 0xdd, 0x47,
0xae, 0x4a, 0x4f, 0xb3, 0xa9, 0xcb, 0x1e, 0xc1, 0xf0, 0xcd, 0xc7, 0x48, 0xc4, 0x6e, 0xd9, 0x93,
0xee, 0x70, 0xe3, 0x74, 0xc1, 0x38, 0xa7, 0x7a, 0x73, 0xc1, 0xc5, 0xf4, 0xe6, 0x82, 0x0b, 0xd8,
0x8d, 0x85, 0x07, 0xcd, 0x6b, 0xb9, 0x1c, 0x9a, 0xd2, 0xc8, 0x60, 0x59, 0x35, 0x32, 0x0f, 0x5b,
0x5c, 0x6a, 0x0a, 0x0f, 0x20, 0xe2, 0x3a, 0x4c, 0x19, 0xe5, 0xb1, 0x06, 0x68, 0x15, 0x76, 0x35,
0xef, 0x57, 0xfd, 0x6e, 0x08, 0xe6, 0x55, 0x2b, 0x3d, 0x45, 0x9a, 0x6e, 0x39, 0xe9, 0x34, 0xa7,
0xab, 0x92, 0x5a, 0x1c, 0x67, 0x92, 0x04, 0x40, 0x13, 0x41, 0xb9, 0xa3, 0x4b, 0xa0, 0xc9, 0xaf,
0xfd, 0x96, 0xb9, 0x7d, 0x60, 0x8a, 0x0a, 0x4e, 0x94, 0x22, 0xe0, 0x0c, 0x27, 0x70, 0x1b, 0x8a,
0xad, 0x86, 0x1b, 0x95, 0x89, 0x30, 0x26, 0x3d, 0x25, 0xa3, 0xa3, 0x54, 0xd2, 0x83, 0xcf, 0x68,
0x2d, 0xcd, 0x26, 0xb9, 0x2f, 0x36, 0x1f, 0x80, 0xe0, 0xeb, 0xda, 0x2c, 0x22, 0x3a, 0x2d, 0xce,
0x4f, 0x0b, 0xf0, 0x35, 0xb5, 0x9a, 0x14, 0x34, 0x22, 0x19, 0x50, 0x20, 0x72, 0x1b, 0x6c, 0xc7,
0xdd, 0x40, 0x4d, 0xb2, 0xfa, 0x40, 0xb5, 0xf5, 0x8f, 0x44, 0x16, 0x99, 0x5e, 0xbe, 0x9d, 0xe2,
0x07, 0x91, 0x8d, 0xee, 0x7c, 0x3d, 0x6d, 0xd9, 0xbd, 0x3d, 0x79, 0xde, 0xbe, 0x38, 0xa6, 0x9f,
0xc8, 0xc1, 0x39, 0xcb, 0xd2, 0x04, 0x25, 0xd7, 0x76, 0xa8, 0xf8, 0xd0, 0x53, 0x58, 0x88, 0x5a,
0x84, 0xe6, 0xfe, 0x55, 0xf2, 0x05, 0xcf, 0x95, 0xa5, 0x66, 0x16, 0xd3, 0xc7, 0x04, 0x5d, 0x32,
0x4e, 0x8f, 0x92, 0xbb, 0xa7, 0x46, 0x26, 0xef, 0xb2, 0x26, 0xf8, 0x7d, 0x63, 0x3a, 0xa2, 0x76,
0x78, 0x31, 0x11, 0xc4, 0xd3, 0xd4, 0x72, 0x1f, 0xbb, 0x51, 0x0d, 0x93, 0x1a, 0x6b, 0xba, 0x96,
0x99, 0xf8, 0xb7, 0xc9, 0x5a, 0xe3, 0xc9, 0x34, 0xfa, 0x62, 0x00, 0x71, 0xb8, 0xc0, 0x68, 0x3d,
0xcb, 0x92, 0x0e, 0xc3, 0x21, 0xd8, 0x32, 0x88, 0xec, 0x0c, 0x13, 0x18, 0x06, 0x10, 0x00, 0x91,
0x5d, 0xd5, 0x2d, 0x35, 0xa8, 0x45, 0x6b, 0x2a, 0xf1, 0xae, 0x17, 0x49, 0xa4, 0x81, 0xcd, 0x77,
0x44, 0xb4, 0xa9, 0x54, 0x02, 0xe9, 0x25, 0x9c, 0x32, 0x1f, 0xfd, 0xf8, 0x6a, 0x3f, 0x79, 0xbb,
0x9c, 0x83, 0x45, 0x54, 0xcc, 0xc3, 0x75, 0x4f, 0x52, 0x52, 0x0a, 0x67, 0x2c, 0xa4, 0x02, 0xea,
0x44, 0x36, 0xbb, 0x13, 0x40, 0xfb, 0x48, 0x85, 0xac, 0xc4, 0x56, 0x6c, 0x34, 0xd3, 0xfd, 0xde,
0xec, 0xa8, 0x4f, 0x4c, 0xd3, 0x6b, 0xe1, 0xe2, 0x32, 0xdc, 0xa8, 0x63, 0xab, 0x5a, 0x0a, 0x66,
0xe8, 0x32, 0x4a, 0x52, 0xb7, 0xaf, 0xe6, 0x69, 0xce, 0x56, 0xe3, 0xc0, 0xf6, 0xac, 0xa4, 0x32,
0x0c, 0x4a, 0x59, 0xa1, 0x92, 0x88, 0xf8, 0xe6, 0x4c, 0x0b, 0x63, 0xbc, 0x9e, 0xec, 0x0f, 0xe3,
0x6b, 0xd1, 0x6b, 0xc9, 0xbe, 0x67, 0x33, 0xaf, 0xfa, 0xca, 0x20, 0xff, 0x85, 0xc9, 0xa9, 0x2c,
0x1e, 0x06, 0x93, 0x44, 0xf8, 0xd8, 0xdc, 0x51, 0x7e, 0x15, 0xa8, 0xa6, 0xd5, 0x6f, 0xb8, 0xa2,
0x9e, 0x75, 0x5b, 0x06, 0x20, 0x1e, 0xe7, 0xfc, 0x05, 0x0b, 0xd1, 0x60, 0xc0, 0x13, 0x98, 0xb8,
0xa8, 0x01, 0x06, 0x94, 0xff, 0x81, 0x0f, 0xc2, 0xcd, 0x79, 0x51, 0x6c, 0xcd, 0x73, 0xe6, 0x7a,
0x48, 0xad, 0xa0, 0xc0, 0xec, 0x26, 0x68, 0xdc, 0x7c, 0x53, 0x1a, 0xee, 0xd3, 0x00, 0x3b, 0x9c,
0x44, 0x8e, 0x88, 0x7f, 0xc1, 0x99, 0x12, 0x69, 0xef, 0x7c, 0x54, 0x33, 0xb7, 0x0a, 0x3a, 0x9e,
0x4b, 0xc8, 0x2c, 0x1b, 0xbd, 0x56, 0xf5, 0xdd, 0xa3, 0xe7, 0xde, 0xdc, 0xff, 0x41, 0xce, 0xe9,
0x73, 0x89, 0x57, 0xe8, 0xd4, 0x67, 0x55, 0x73, 0x0a, 0x12, 0x0a, 0xba, 0x10, 0x74, 0x02, 0x70,
0x88, 0x88, 0x13, 0x70, 0x36, 0x86, 0x63, 0xf0, 0x3d, 0x21, 0xc0, 0x19, 0xa2, 0x12, 0x34, 0x0e,
0x37, 0xcf, 0x1b, 0x9e, 0xc4, 0x3d, 0x5d, 0xfd, 0x66, 0xea, 0x8a, 0x31, 0x9c, 0xa0, 0x98, 0xbb,
0x38, 0xe4, 0x2c, 0xcf, 0x8c, 0x65, 0xd8, 0x57, 0x5a, 0x80, 0xa2, 0x4e, 0xe6, 0x93, 0xdd, 0xa4,
0x20, 0x91, 0xd7, 0x75, 0x21, 0xb7, 0x19, 0x66, 0xc9, 0x1b, 0xd6, 0x6f, 0x6c, 0x2e, 0xce, 0x44,
0x9a, 0xbf, 0xa6, 0x7a, 0x51, 0x58, 0x8b, 0xa3, 0x97, 0xe5, 0xaa, 0xbc, 0x21, 0x9d, 0xe3, 0x54,
0x8e, 0xaf, 0x38, 0x7b, 0x4f, 0xc6, 0x1c, 0xf7, 0x5a, 0xe5, 0x03, 0x18, 0x0c, 0x0d, 0xab, 0x3d,
0x8d, 0x27, 0x36, 0xbd, 0xa6, 0x4d, 0xaf, 0xe3, 0xf1, 0xd5, 0x7a, 0xdf, 0xd6, 0x5b, 0x4a, 0x7b,
0x59, 0x15, 0x2e, 0x2b, 0x11, 0x0d, 0x03, 0x4d, 0x1e, 0x2b, 0x77, 0xea, 0xd4, 0x98, 0x62, 0xbc,
0x6a, 0x2b, 0x5c, 0x4f, 0xdf, 0x99, 0x6a, 0x21, 0x54, 0xb7, 0xf2, 0x67, 0x47, 0x65, 0x70, 0x66,
0x7f, 0xef, 0xd9, 0x61, 0xbb, 0xdd, 0xfe, 0x4b, 0xd7, 0x3b, 0xd9, 0x1e, 0xe6, 0xa1, 0x3a, 0xd9,
0x21, 0x8f, 0x40, 0x61, 0xdf, 0xdb, 0xd4, 0x4b, 0xb1, 0xb1, 0xad, 0x17, 0x43, 0xc4, 0x03, 0xad,
0x8d, 0xbd, 0x67, 0x2f, 0x5f, 0xbc, 0x78, 0x41, 0x5a, 0x8b, 0x34, 0x71, 0xe1, 0x4e, 0xce, 0xd9,
0xce, 0x82, 0xa8, 0xd2, 0xee, 0x52, 0xac, 0x04, 0x66, 0xf6, 0x7c, 0xf3, 0x9b, 0x58, 0x91, 0xc3,
0xc1, 0xcf, 0xfb, 0x8d, 0x1f, 0xd3, 0x6c, 0x14, 0xa7, 0xde, 0xa0, 0x67, 0x8a, 0xbc, 0xff, 0x1c,
0xbb, 0xf0, 0x77, 0xe2, 0xfd, 0x78, 0x36, 0x38, 0x35, 0x9e, 0xff, 0xfe, 0xd7, 0x80, 0x8e, 0xde,
0x93, 0xdb, 0x36, 0x55, 0x33, 0x4b, 0xbf, 0xe1, 0x23, 0x2e, 0xee, 0xe8, 0x8b, 0xa0, 0x9a, 0xd2,
0xf7, 0x38, 0xfa, 0xb4, 0xf1, 0x76, 0x78, 0x76, 0xf4, 0x3c, 0x2c, 0xd7, 0x84, 0xa7, 0xc5, 0x3f,
0x0b, 0x89, 0x0c, 0xc4, 0x05, 0xda, 0x4c, 0xbb, 0x13, 0x50, 0x06, 0x92, 0x4a, 0xcc, 0x80, 0x9d,
0xaa, 0x19, 0xa9, 0x3c, 0x55, 0xd5, 0xe2, 0x75, 0x37, 0x58, 0xf6, 0x87, 0x47, 0xab, 0xe0, 0xc2,
0xd4, 0x48, 0x6e, 0x74, 0x8a, 0xf9, 0xfe, 0x46, 0xe3, 0x41, 0xe3, 0x5c, 0xb0, 0xef, 0x35, 0x56,
0xed, 0xa3, 0xb7, 0xc9, 0xc5, 0x6e, 0x63, 0xdf, 0xc3, 0x54, 0xd9, 0xd9, 0xea, 0x7e, 0x9e, 0x7e,
0x5f, 0xf5, 0x45, 0x91, 0x86, 0xd3, 0x6f, 0xbe, 0xf0, 0xa9, 0xf7, 0x61, 0x1f, 0xe1, 0xee, 0x35,
0x1e, 0x1b, 0x23, 0x2a, 0xbc, 0x87, 0x67, 0x83, 0xff, 0x3d, 0xc8, 0x34, 0x54, 0xff, 0x41, 0x94,
0xdd, 0x1c, 0xfe, 0xa7, 0x60, 0x76, 0x3b, 0x1d, 0xce, 0x1f, 0xfe, 0x38, 0xd0, 0x1f, 0xfe, 0x2c,
0xd2, 0x1f, 0x2a, 0x36, 0x69, 0x50, 0xfe, 0x80, 0xba, 0xfb, 0xf5, 0x27, 0xb4, 0x9a, 0x8f, 0xa3,
0x28, 0xaa, 0xe3, 0x5f, 0xff, 0x1e, 0xa1, 0xac, 0xb8, 0xa1, 0xf1, 0x87, 0xc8, 0xa1, 0x45, 0x2c,
0x88, 0x3f, 0x62, 0x4a, 0xa2, 0x4d, 0xfa, 0x76, 0xfe, 0x6f, 0x7c, 0x47, 0x58, 0x8b, 0x51, 0x17,
0x00, 0x00
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x13, 0xdd, 0x58, 0x5b, 0x73, 0xdb, 0x36,
0x16, 0x7e, 0xf7, 0xaf, 0xa0, 0x11, 0x8f, 0x4d, 0x8e, 0x68, 0x4a, 0x8e, 0xb7, 0xdd, 0x44, 0x12,
0xe4, 0x4d, 0x9c, 0xb4, 0xd1, 0xe6, 0x62, 0xcf, 0x28, 0x6d, 0x67, 0xc7, 0xeb, 0xa9, 0x69, 0x12,
0x92, 0x10, 0x53, 0x20, 0x17, 0x00, 0x7d, 0x59, 0x59, 0xff, 0x7d, 0xbf, 0x03, 0x92, 0xba, 0x38,
0x76, 0xb6, 0xed, 0x4e, 0x5f, 0xf6, 0x45, 0x22, 0x81, 0x73, 0x0e, 0x0e, 0xbe, 0x73, 0x67, 0x7f,
0xfb, 0xcd, 0xc9, 0xf1, 0xe7, 0x7f, 0x9c, 0xbe, 0xf5, 0xa6, 0x76, 0x96, 0x0d, 0xfa, 0xf5, 0xaf,
0x88, 0x53, 0x2f, 0x8b, 0xd5, 0x84, 0x33, 0xa1, 0xd8, 0xa0, 0x3f, 0x13, 0x36, 0xf6, 0x92, 0x69,
0xac, 0x8d, 0xb0, 0x9c, 0x95, 0x76, 0xbc, 0xff, 0xa2, 0x59, 0xdd, 0x52, 0xf1, 0x4c, 0x70, 0x76,
0x2d, 0xc5, 0x4d, 0x91, 0x6b, 0xcb, 0xbc, 0x24, 0x57, 0x56, 0x28, 0x90, 0xdd, 0xc8, 0xd4, 0x4e,
0xf9, 0x77, 0x9d, 0xce, 0x92, 0xf4, 0xc1, 0x56, 0x2a, 0xae, 0x65, 0x22, 0xf6, 0xdd, 0x4b, 0x28,
0x95, 0xb4, 0x32, 0xce, 0xf6, 0x4d, 0x12, 0x67, 0x82, 0x1f, 0x84, 0xb3, 0xf8, 0x56, 0xce, 0xca,
0xd9, 0xf2, 0xbd, 0x34, 0x42, 0xbb, 0x97, 0xf8, 0x12, 0xef, 0x2a, 0x67, 0x5f, 0x9d, 0x3c, 0xe8,
0x5b, 0x69, 0x33, 0x31, 0xf8, 0x09, 0x94, 0xb3, 0x3c, 0xf5, 0x46, 0xc2, 0x5a, 0xa9, 0x26, 0xa6,
0xdf, 0xae, 0xd6, 0xfb, 0x26, 0xd1, 0xb2, 0xb0, 0x83, 0xad, 0xeb, 0x58, 0x7b, 0xf9, 0x8d, 0x12,
0x3a, 0xcc, 0xf2, 0x44, 0x16, 0x61, 0xa9, 0xf3, 0x1b, 0x13, 0xa6, 0x3c, 0xcd, 0x93, 0x72, 0x06,
0xfd, 0xc2, 0x72, 0x76, 0x3c, 0x9e, 0xf0, 0xf9, 0x22, 0x2c, 0xa4, 0x32, 0xfc, 0xec, 0xfb, 0xf0,
0xaf, 0xe1, 0x8b, 0xf0, 0x65, 0x78, 0xd0, 0x09, 0x0f, 0x0e, 0xce, 0x69, 0xf1, 0x84, 0x9f, 0x31,
0x6d, 0xae, 0x53, 0x16, 0xfe, 0xf7, 0xbf, 0x73, 0x3a, 0x85, 0x6f, 0x1f, 0x84, 0xaa, 0x9c, 0x7d,
0xe4, 0x9d, 0xde, 0xb8, 0x54, 0x89, 0x95, 0xb9, 0xf2, 0x26, 0xc3, 0xd4, 0x17, 0xc1, 0x5c, 0x0b,
0x5b, 0x6a, 0xe5, 0xa5, 0xd1, 0x44, 0xd8, 0xb7, 0x99, 0x20, 0x05, 0x5e, 0xdf, 0xb9, 0xad, 0xc5,
0x92, 0x54, 0x9a, 0x93, 0x35, 0x52, 0xb1, 0xbb, 0xcb, 0xf2, 0xcb, 0x2f, 0x22, 0xb1, 0x8c, 0x73,
0x7b, 0x57, 0x88, 0x7c, 0x4c, 0x6b, 0xdb, 0xaf, 0xb4, 0x8e, 0xef, 0x22, 0x69, 0xdc, 0xff, 0x06,
0xff, 0x3b, 0x3f, 0x98, 0xdf, 0x48, 0x95, 0xe6, 0x37, 0x51, 0x5e, 0x08, 0xe5, 0xb3, 0xa9, 0xb5,
0x85, 0xe9, 0xb6, 0xdb, 0x13, 0x69, 0xa7, 0xe5, 0x65, 0x94, 0xe4, 0xb3, 0xf6, 0x2b, 0xa9, 0x93,
0x3c, 0xcf, 0xaf, 0xa4, 0x68, 0xff, 0xf2, 0xe1, 0xed, 0x9b, 0xf6, 0x8d, 0xbc, 0x92, 0xed, 0x06,
0xc3, 0x67, 0x65, 0x05, 0xea, 0xbe, 0xa9, 0x17, 0xd8, 0x9a, 0xf4, 0xd7, 0x0f, 0xa5, 0xb7, 0x97,
0x54, 0x21, 0xfb, 0xd5, 0x88, 0x6c, 0xbc, 0x4e, 0x9d, 0xe5, 0x71, 0xfa, 0xf7, 0x91, 0x2f, 0x42,
0xcb, 0xb7, 0x3b, 0xc1, 0x3c, 0x13, 0xd6, 0x53, 0x3c, 0x8d, 0x12, 0x2d, 0x62, 0x2b, 0x6a, 0x00,
0x7c, 0x56, 0xd9, 0x8a, 0x05, 0x3d, 0x15, 0x41, 0xd8, 0x2b, 0x6b, 0xb5, 0xbc, 0x2c, 0xad, 0xc0,
0x86, 0x4e, 0x58, 0x28, 0x82, 0xf0, 0xe1, 0x3a, 0xe1, 0x80, 0xe3, 0xac, 0xb8, 0xb5, 0xed, 0x2f,
0xf1, 0x75, 0xdc, 0x08, 0xf8, 0x8a, 0x30, 0x36, 0x77, 0x0a, 0x22, 0x6c, 0x10, 0xa6, 0xd1, 0x65,
0x9e, 0xde, 0x45, 0x71, 0x01, 0xa5, 0xd3, 0xe3, 0xa9, 0xcc, 0x52, 0x5f, 0x11, 0x7d, 0x9c, 0xa6,
0x6f, 0xaf, 0xa1, 0xc5, 0x07, 0x69, 0xe0, 0xae, 0x42, 0xfb, 0x8c, 0x74, 0x66, 0xa1, 0x1f, 0xf0,
0xc1, 0xfc, 0x47, 0x61, 0x7f, 0xf6, 0x83, 0xc5, 0xe3, 0x74, 0x42, 0xeb, 0x5c, 0x43, 0x3d, 0xd0,
0xc1, 0xd7, 0x4d, 0x9e, 0x89, 0x28, 0xcb, 0x27, 0x3e, 0x7b, 0x4b, 0xeb, 0x5e, 0x7d, 0x79, 0x00,
0xe3, 0x8d, 0x65, 0x26, 0xdc, 0x35, 0xe0, 0xdc, 0x1a, 0xd7, 0xfd, 0x50, 0xaf, 0xc3, 0x92, 0x60,
0x1c, 0xcb, 0x49, 0xa9, 0x63, 0x87, 0x56, 0x75, 0x0d, 0x6f, 0x1c, 0x83, 0x21, 0x8d, 0xfe, 0xa9,
0x86, 0x0a, 0xb6, 0x2a, 0x00, 0x9a, 0xf0, 0x8a, 0x78, 0x22, 0xbc, 0x34, 0xb6, 0xf1, 0x36, 0xe0,
0x5d, 0x03, 0x78, 0x04, 0x73, 0x30, 0x3a, 0xa0, 0x0b, 0xf7, 0xa8, 0xed, 0x02, 0x17, 0x74, 0xf2,
0xa2, 0x42, 0xe7, 0x36, 0x4f, 0xf2, 0x6c, 0x77, 0xd7, 0x77, 0x6e, 0xd9, 0x09, 0x7d, 0x17, 0x04,
0x9c, 0x28, 0xb2, 0x91, 0xcd, 0x35, 0xa4, 0x92, 0x2b, 0x0e, 0xad, 0x98, 0xd1, 0xc5, 0x93, 0x61,
0xc1, 0x82, 0xe0, 0xfe, 0xbe, 0x26, 0x03, 0xff, 0xac, 0x80, 0xc2, 0x3f, 0x40, 0xbe, 0xf7, 0x31,
0x4f, 0x45, 0xe4, 0x9d, 0x66, 0x22, 0x36, 0xc2, 0x03, 0x10, 0x42, 0x7b, 0xe4, 0x3a, 0xde, 0xf0,
0x14, 0x2a, 0x85, 0x1b, 0x12, 0xcd, 0xa6, 0xc4, 0x2a, 0xf2, 0x82, 0x00, 0x54, 0x29, 0xf4, 0x75,
0xb1, 0x81, 0x33, 0x28, 0x24, 0x58, 0x39, 0x63, 0x41, 0x24, 0x15, 0x00, 0x7d, 0xf7, 0xf9, 0xe3,
0x07, 0xce, 0x3e, 0xe5, 0x5e, 0x1d, 0xd2, 0xc6, 0x43, 0x3c, 0xda, 0x38, 0x23, 0x28, 0xd8, 0x46,
0x78, 0xfc, 0xb0, 0x1e, 0x1e, 0x9c, 0xf3, 0x16, 0xe2, 0x41, 0x6c, 0x73, 0xee, 0x77, 0xee, 0x37,
0xe3, 0x68, 0xf8, 0x18, 0x21, 0xff, 0x8a, 0x30, 0x99, 0x8a, 0xe4, 0x8a, 0x7c, 0x34, 0x98, 0x53,
0xb6, 0x50, 0x5c, 0x44, 0x94, 0x6d, 0x22, 0x2d, 0x8a, 0x2c, 0x4e, 0xe0, 0x45, 0x67, 0xe7, 0x70,
0x36, 0xe8, 0x69, 0xca, 0x4b, 0x63, 0xb5, 0xbf, 0x7f, 0x18, 0xf4, 0xe4, 0xd8, 0x67, 0xb8, 0xc7,
0xa5, 0xd0, 0xc0, 0x5d, 0x44, 0xe4, 0x90, 0x08, 0x54, 0x64, 0x0b, 0xbc, 0xaa, 0x86, 0xb0, 0x13,
0x1e, 0x06, 0xc1, 0x7c, 0x9c, 0x6b, 0x9f, 0xe4, 0x4a, 0xe4, 0x03, 0xd9, 0xa7, 0x2c, 0x13, 0x65,
0x42, 0x4d, 0xec, 0xb4, 0x27, 0x5b, 0xad, 0x00, 0x82, 0xec, 0x36, 0xa7, 0x34, 0x73, 0x26, 0xcf,
0x83, 0x39, 0x5e, 0x45, 0x74, 0x1d, 0x67, 0x25, 0xf4, 0x24, 0x52, 0x2c, 0x42, 0xae, 0x1c, 0x43,
0xec, 0x8a, 0x08, 0x08, 0xdb, 0x3b, 0xb8, 0x1b, 0x4c, 0x9b, 0x6b, 0xce, 0x32, 0x39, 0x13, 0xac,
0x77, 0x89, 0x98, 0xba, 0x5a, 0x3c, 0xc2, 0x7f, 0x7f, 0x5f, 0xaf, 0xf4, 0xf7, 0x0f, 0x96, 0xcf,
0x83, 0xc3, 0x97, 0x5f, 0xc9, 0xd1, 0x22, 0x6d, 0xc4, 0x6c, 0xee, 0x2c, 0x79, 0x0e, 0x8f, 0x18,
0x2c, 0xac, 0x26, 0x82, 0x75, 0xd9, 0xb3, 0xf1, 0x78, 0xcc, 0x16, 0x0b, 0x91, 0x19, 0x31, 0x37,
0x37, 0xd2, 0x26, 0x53, 0xbf, 0xc2, 0x2d, 0x98, 0x27, 0x70, 0x11, 0x36, 0x7a, 0xf3, 0x8a, 0x75,
0xab, 0xa7, 0xe3, 0x0f, 0xf5, 0xd3, 0xc7, 0x93, 0xd1, 0x70, 0xb5, 0xf8, 0xbe, 0x7e, 0x3c, 0x1e,
0xb1, 0xae, 0x3b, 0xb6, 0x97, 0x8a, 0x71, 0x5c, 0x66, 0xb6, 0x5b, 0xd9, 0x6c, 0x41, 0xc8, 0xfd,
0x7f, 0xa2, 0xb6, 0x72, 0x3e, 0x44, 0xdf, 0x29, 0x4e, 0x24, 0x4f, 0x85, 0x16, 0x55, 0xee, 0x0f,
0xe8, 0xe2, 0x94, 0x53, 0xec, 0x99, 0x0a, 0xe5, 0x39, 0xf2, 0xc4, 0x89, 0xab, 0x00, 0x11, 0xc2,
0x4e, 0x4b, 0x41, 0xc4, 0x41, 0x4d, 0x2c, 0x83, 0xc0, 0x55, 0x37, 0xae, 0xc2, 0x46, 0x92, 0x0c,
0x7a, 0x64, 0x14, 0x8f, 0x5c, 0xb4, 0x71, 0xc8, 0x6f, 0xb8, 0x32, 0x49, 0xda, 0x2c, 0x26, 0xb2,
0x52, 0x80, 0x7c, 0xd6, 0x02, 0x7d, 0xdb, 0x97, 0x0d, 0xf4, 0x96, 0xa0, 0x3f, 0xb3, 0xe7, 0x03,
0xde, 0x41, 0x4e, 0x71, 0x46, 0x29, 0x4a, 0x33, 0xf5, 0x69, 0x2d, 0x70, 0xb5, 0xb2, 0x7a, 0x77,
0x2a, 0x05, 0x8d, 0x1e, 0x5f, 0x51, 0x3f, 0x4d, 0xfa, 0x84, 0x2a, 0x8f, 0xa8, 0xb1, 0xbc, 0x2d,
0x1d, 0xbd, 0x82, 0x13, 0x69, 0xfa, 0x07, 0x29, 0x90, 0xdc, 0x11, 0xce, 0x21, 0xc0, 0x43, 0x2d,
0x5e, 0x02, 0xab, 0x10, 0x8c, 0xae, 0xfc, 0xb7, 0xf8, 0x5e, 0x7f, 0xaa, 0x3d, 0x67, 0xac, 0xba,
0x3f, 0xe9, 0x3e, 0xff, 0xbe, 0x53, 0xdc, 0xb2, 0xc1, 0x5e, 0x6f, 0x85, 0xbd, 0x0c, 0xf5, 0x23,
0xd8, 0x43, 0x0a, 0x2b, 0xd5, 0x95, 0x82, 0xe2, 0xe4, 0x5e, 0x96, 0x9c, 0x43, 0xaa, 0x24, 0x2b,
0x53, 0x6c, 0xc2, 0xc2, 0xc1, 0xd1, 0x9a, 0x0e, 0x10, 0x11, 0x74, 0x57, 0xef, 0x2d, 0xec, 0xb7,
0xac, 0x5b, 0x5d, 0x3c, 0x7e, 0x61, 0xb5, 0xc2, 0x5e, 0xe3, 0xd2, 0xba, 0xaf, 0x9a, 0x4b, 0x6b,
0x5c, 0x7a, 0xf3, 0x76, 0x67, 0xfa, 0x3c, 0x44, 0x55, 0x75, 0xd0, 0xb9, 0xcc, 0x65, 0xc2, 0xac,
0x69, 0x11, 0x54, 0xaf, 0x8e, 0xc9, 0xac, 0x0e, 0xc7, 0xcb, 0x1c, 0x05, 0x2a, 0x56, 0xac, 0x9b,
0x71, 0xe6, 0x12, 0xde, 0x65, 0x7e, 0xcb, 0x42, 0xc3, 0xf7, 0x2a, 0xb7, 0x67, 0x56, 0x97, 0x82,
0xed, 0xb5, 0x7c, 0x75, 0xc4, 0xaa, 0x84, 0x08, 0xb7, 0xee, 0xc2, 0x53, 0x2a, 0xd7, 0xee, 0x39,
0x19, 0x75, 0xc2, 0xeb, 0x1a, 0x7e, 0x51, 0x73, 0xed, 0xcc, 0xd5, 0x82, 0x5d, 0x84, 0xb5, 0x9f,
0x71, 0xbb, 0xe6, 0x57, 0x47, 0x3e, 0xe1, 0xec, 0xa1, 0xb5, 0xe3, 0xec, 0xf0, 0x25, 0xf3, 0x66,
0x52, 0x71, 0xb6, 0x7f, 0x00, 0xe9, 0x59, 0x6c, 0x0c, 0x67, 0x86, 0xed, 0x41, 0x5d, 0x26, 0x15,
0xea, 0x76, 0xd7, 0x91, 0xa2, 0xb0, 0x16, 0x9c, 0xc5, 0xea, 0x6e, 0x49, 0x73, 0x7b, 0x9b, 0xb1,
0xbd, 0xde, 0x66, 0x6e, 0x00, 0x0f, 0xd5, 0x7d, 0xd2, 0x7d, 0x43, 0x8b, 0x07, 0xe6, 0xfc, 0x0e,
0xe6, 0xec, 0xb1, 0x8b, 0xc5, 0x03, 0xe3, 0xc0, 0x11, 0x6b, 0x17, 0x10, 0x8d, 0xae, 0x44, 0x91,
0x8a, 0xdb, 0x93, 0xb1, 0x23, 0x68, 0x1d, 0xa0, 0x4e, 0xd5, 0x24, 0x17, 0xde, 0xce, 0xdc, 0x2e,
0xba, 0x1e, 0x2e, 0xb8, 0x84, 0x8c, 0xf3, 0xec, 0xa8, 0xd9, 0xee, 0x4b, 0x55, 0x94, 0xd6, 0x23,
0xc8, 0x39, 0x9b, 0xca, 0x34, 0x45, 0xff, 0xec, 0x55, 0x8d, 0xea, 0xce, 0x5c, 0x2c, 0xba, 0xc4,
0xbd, 0x33, 0x97, 0x47, 0x14, 0x75, 0xc0, 0x12, 0x3a, 0xd6, 0x0a, 0x8f, 0x63, 0x98, 0x8c, 0x0d,
0x2e, 0xba, 0x12, 0x75, 0xf0, 0x7f, 0x96, 0xb6, 0x33, 0xcf, 0x16, 0x10, 0xb6, 0x52, 0x7b, 0x43,
0xd2, 0xce, 0xdc, 0x61, 0xcc, 0x49, 0xf1, 0xa5, 0x05, 0xc1, 0xf0, 0x6d, 0xd1, 0x3b, 0x73, 0xb3,
0x40, 0x0f, 0xe3, 0x04, 0xd5, 0x0e, 0xe3, 0xdb, 0xa9, 0x34, 0xe1, 0xde, 0xce, 0xfc, 0x69, 0xe4,
0x16, 0x7b, 0x01, 0x3a, 0xf3, 0x4b, 0x3d, 0xb8, 0x58, 0x6c, 0x84, 0xe4, 0x1b, 0x9d, 0x17, 0xe8,
0x4c, 0x54, 0x55, 0x64, 0x9f, 0xea, 0x02, 0x45, 0x46, 0x5d, 0x6e, 0x80, 0xa0, 0x5d, 0xef, 0x8f,
0xcd, 0xeb, 0xbb, 0x4f, 0xd0, 0xb4, 0x09, 0x9e, 0xe0, 0xec, 0xe0, 0x9c, 0xaa, 0xaf, 0x44, 0x82,
0x1f, 0x7e, 0x3a, 0xfd, 0xe9, 0x33, 0xdd, 0x4c, 0x46, 0x36, 0x9e, 0x10, 0x15, 0xcc, 0x5b, 0x79,
0x47, 0xb5, 0x08, 0x00, 0xee, 0xef, 0x57, 0x75, 0xba, 0x5e, 0x0a, 0x2a, 0x15, 0x04, 0x5e, 0x1d,
0x82, 0x3d, 0xe9, 0xea, 0x56, 0x6f, 0x33, 0xf0, 0x64, 0x14, 0x37, 0x7d, 0xe4, 0xb2, 0xf4, 0xb4,
0x5a, 0xba, 0xea, 0x11, 0x0c, 0x5f, 0xdf, 0x46, 0x20, 0xf6, 0xaa, 0x9e, 0x74, 0x9b, 0x1b, 0x27,
0x0b, 0xca, 0x39, 0xd1, 0xeb, 0x0b, 0xce, 0xa7, 0xd7, 0x17, 0x9c, 0xc3, 0xae, 0x2d, 0x3c, 0x68,
0x5e, 0xab, 0xe5, 0xd0, 0x54, 0x4a, 0x06, 0x8b, 0xba, 0x91, 0x79, 0xd8, 0xe2, 0x52, 0x53, 0xb8,
0x0f, 0x12, 0xd7, 0x61, 0xca, 0xa8, 0x88, 0x35, 0x40, 0xab, 0xb1, 0x6b, 0xf2, 0x7e, 0xdd, 0xef,
0x86, 0xc8, 0xbc, 0x6a, 0x29, 0xa7, 0xcc, 0xb2, 0x0d, 0x23, 0x9d, 0x14, 0xf4, 0x54, 0xa5, 0x16,
0x97, 0x33, 0x89, 0x02, 0xa0, 0x89, 0xa0, 0xe2, 0xe8, 0x11, 0x68, 0xf2, 0x6b, 0xbb, 0xe5, 0x8e,
0x0f, 0x99, 0xa2, 0x86, 0x13, 0xa5, 0x08, 0x38, 0xc3, 0x08, 0xdc, 0x86, 0x62, 0xa3, 0xe1, 0x46,
0x65, 0x22, 0x8c, 0x49, 0x4e, 0x95, 0xd1, 0x51, 0x2a, 0x69, 0xe3, 0x13, 0x5a, 0x4b, 0xb3, 0x9e,
0xdc, 0xe7, 0xeb, 0x1b, 0x48, 0xf0, 0x4d, 0x6d, 0x16, 0x11, 0xdd, 0x16, 0xf7, 0xa7, 0x05, 0xd8,
0x9a, 0x5a, 0x4d, 0x72, 0x1a, 0x91, 0x0e, 0xc9, 0x11, 0xb9, 0x0d, 0x36, 0xfd, 0x6e, 0xa8, 0xc6,
0x79, 0x73, 0xa1, 0x46, 0xfb, 0x47, 0x3c, 0x8b, 0x54, 0xaf, 0x4e, 0x27, 0xff, 0x81, 0x67, 0xa3,
0x3b, 0x5f, 0x4d, 0x5b, 0x76, 0x77, 0x57, 0x9e, 0x75, 0xce, 0x8f, 0xe8, 0x27, 0x72, 0x70, 0x4e,
0xf3, 0x2c, 0x45, 0xc9, 0xb5, 0x5d, 0x2a, 0x3e, 0xb4, 0x0b, 0x0d, 0x51, 0x8b, 0xd0, 0xdc, 0xbf,
0x4a, 0xbf, 0x60, 0x5f, 0x59, 0x6a, 0x66, 0x31, 0x7d, 0x8c, 0xd1, 0x25, 0xe3, 0xf6, 0x28, 0xb9,
0xbb, 0xea, 0xd2, 0x14, 0x3d, 0xd6, 0x42, 0x7e, 0x5f, 0x9b, 0x8e, 0xa8, 0x1d, 0x9e, 0x8f, 0x05,
0xe5, 0x69, 0x6a, 0xb9, 0x8f, 0xdc, 0xa8, 0x86, 0x49, 0x8d, 0xb5, 0x5c, 0xcb, 0x4c, 0xf9, 0xb7,
0xc5, 0xda, 0xc9, 0x78, 0x12, 0x7d, 0x31, 0x80, 0x38, 0x9c, 0x63, 0xb4, 0x9e, 0xe6, 0x69, 0x97,
0xe1, 0x12, 0x6c, 0x11, 0x44, 0x76, 0x8a, 0x09, 0x0c, 0x03, 0x08, 0x80, 0xc8, 0xaf, 0x9a, 0x96,
0x1a, 0xa9, 0x45, 0x6b, 0x2a, 0xf1, 0xae, 0x17, 0x49, 0xa5, 0x81, 0xce, 0x77, 0x94, 0x68, 0x33,
0xa9, 0x04, 0xc2, 0x4b, 0x38, 0x61, 0x3e, 0xfa, 0xf1, 0x25, 0x3f, 0x59, 0xbb, 0x9a, 0x83, 0x45,
0x54, 0xce, 0xc2, 0x55, 0x4f, 0x52, 0xa5, 0x14, 0xce, 0x58, 0x48, 0x05, 0xd4, 0x91, 0xac, 0x77,
0x27, 0x80, 0xf6, 0x91, 0x0a, 0x59, 0x93, 0x2d, 0xb3, 0xd1, 0x54, 0x0f, 0xfa, 0xd3, 0xc3, 0x01,
0x65, 0x9a, 0x7e, 0x1b, 0x0f, 0x17, 0xe1, 0x5a, 0x1d, 0x5b, 0xd6, 0x52, 0x64, 0x86, 0x1e, 0xa3,
0x20, 0x75, 0x7c, 0x4d, 0x9e, 0xe6, 0x6c, 0x39, 0x0e, 0x6c, 0xce, 0x4a, 0x2a, 0xc7, 0xa0, 0x94,
0x97, 0x2a, 0x8d, 0x28, 0xdf, 0x9c, 0x6a, 0x61, 0x8c, 0xd7, 0x97, 0x83, 0x51, 0x7c, 0x2d, 0xfa,
0x6d, 0x39, 0xf0, 0x6c, 0xee, 0xd5, 0x5f, 0x19, 0xe4, 0xbf, 0x31, 0x39, 0x55, 0xc5, 0xc3, 0x60,
0x92, 0x08, 0x1f, 0x9b, 0x3b, 0xaa, 0xaf, 0x02, 0xf5, 0xb4, 0xfa, 0x0d, 0x53, 0x34, 0xb3, 0x6e,
0xdb, 0x00, 0xc4, 0xa3, 0x82, 0xbf, 0x60, 0x21, 0x1a, 0x0c, 0x58, 0x02, 0x13, 0x17, 0x35, 0xc0,
0x80, 0xf2, 0x37, 0xd8, 0x20, 0x5c, 0x9f, 0x17, 0xc5, 0xc6, 0x3c, 0x67, 0xae, 0x47, 0xd4, 0x0a,
0x0a, 0xcc, 0x6e, 0x82, 0xc6, 0xcd, 0x37, 0x95, 0xe2, 0x3e, 0x0d, 0xb0, 0xa3, 0x71, 0xe4, 0x12,
0xf1, 0xcf, 0xb8, 0x53, 0x2a, 0xed, 0x9d, 0x8f, 0x6a, 0xe6, 0x56, 0x91, 0x8e, 0x67, 0x12, 0x34,
0x8b, 0xad, 0x7e, 0xbb, 0xfe, 0xee, 0xd1, 0x77, 0x27, 0x0f, 0xfe, 0x26, 0x67, 0xf4, 0xb9, 0xc4,
0x2b, 0x75, 0xe6, 0xb3, 0xba, 0x39, 0x45, 0x12, 0x0a, 0x7a, 0x20, 0x74, 0x04, 0x30, 0x88, 0x88,
0x53, 0xe4, 0x6c, 0x0c, 0xc7, 0xc8, 0xf7, 0x84, 0x00, 0x67, 0xf0, 0x4a, 0xa4, 0x71, 0x98, 0x79,
0xb6, 0xe5, 0x49, 0xbc, 0xd3, 0xd3, 0xaf, 0xa6, 0xa9, 0x18, 0xa3, 0x31, 0x8a, 0xb9, 0xf3, 0x43,
0xce, 0x8a, 0xdc, 0x58, 0x06, 0xbe, 0x4a, 0x03, 0x14, 0x75, 0x52, 0x9f, 0xf4, 0x26, 0x01, 0xa9,
0xbc, 0x6e, 0x0a, 0xb9, 0xcd, 0x31, 0x4b, 0xde, 0xb0, 0xc1, 0xd6, 0xfa, 0xe2, 0x54, 0x64, 0xc5,
0x6b, 0xaa, 0x17, 0xa5, 0xb5, 0xb8, 0x7a, 0x55, 0xae, 0xaa, 0x17, 0x92, 0x99, 0x64, 0x32, 0xb9,
0xe2, 0xec, 0x1d, 0x29, 0x73, 0xd4, 0x6f, 0x57, 0x1b, 0x50, 0x18, 0x12, 0x96, 0x3c, 0x5b, 0x4f,
0x30, 0xbd, 0x26, 0xa6, 0xd7, 0x71, 0x72, 0xb5, 0xe2, 0xdb, 0x38, 0xa5, 0xd2, 0x97, 0xd5, 0xee,
0xb2, 0x24, 0xd1, 0x50, 0xd0, 0x14, 0xb1, 0x72, 0xb7, 0xce, 0x8c, 0x29, 0x93, 0x65, 0x5b, 0xe1,
0x7a, 0xfa, 0xee, 0x44, 0x0b, 0xa1, 0x7a, 0xb5, 0x3d, 0xbb, 0x2a, 0x87, 0x31, 0x07, 0xbb, 0xcf,
0x0e, 0x3a, 0x9d, 0xce, 0x5f, 0x7a, 0xde, 0xf1, 0xe6, 0x30, 0x0f, 0xd1, 0xe9, 0x36, 0x59, 0x04,
0x02, 0x07, 0xde, 0xba, 0x5c, 0xf2, 0x8d, 0x4d, 0xb9, 0x18, 0x22, 0x1e, 0x48, 0xdd, 0xda, 0x7d,
0xf6, 0xf2, 0xc5, 0x8b, 0x17, 0x24, 0xb5, 0xcc, 0x52, 0xe7, 0xee, 0x64, 0x9c, 0xcd, 0x28, 0x88,
0x6a, 0xe9, 0x2e, 0xc4, 0x2a, 0x60, 0xa6, 0xcf, 0xd7, 0xbf, 0x89, 0x95, 0x05, 0x0c, 0xfc, 0x7c,
0xb0, 0xf5, 0x63, 0x96, 0x5f, 0xc6, 0x99, 0x37, 0xec, 0x9b, 0xb2, 0x18, 0x3c, 0x07, 0x17, 0xfe,
0x8e, 0xbd, 0x1f, 0x4f, 0x87, 0x27, 0xc6, 0xf3, 0xdf, 0xfd, 0x12, 0xd0, 0xd5, 0xfb, 0x72, 0x53,
0xa7, 0x7a, 0x66, 0x19, 0x6c, 0xf9, 0xf0, 0x8b, 0x3b, 0xfa, 0x22, 0xa8, 0x26, 0xf4, 0x3d, 0x8e,
0x3e, 0x6d, 0xbc, 0x1d, 0x9d, 0x1e, 0x3e, 0x0f, 0xab, 0x35, 0xe1, 0x69, 0xf1, 0xaf, 0x52, 0x22,
0x02, 0xf1, 0x80, 0x36, 0xd3, 0x6e, 0x07, 0x14, 0x81, 0x24, 0x12, 0x33, 0x60, 0xb7, 0x6e, 0x46,
0x6a, 0x4b, 0xd5, 0xb5, 0x78, 0xd5, 0x0d, 0x56, 0xfd, 0xe1, 0xe1, 0xd2, 0xb9, 0x30, 0x35, 0x92,
0x19, 0x9d, 0x60, 0xbe, 0xb7, 0xd6, 0x78, 0xd0, 0x38, 0x17, 0xec, 0x79, 0x5b, 0xcb, 0xf6, 0xd1,
0x5b, 0xcf, 0xc5, 0x8e, 0x71, 0xe0, 0x61, 0xaa, 0xec, 0x6e, 0x74, 0x3f, 0x4f, 0x9f, 0x57, 0x7f,
0x51, 0xa4, 0xe1, 0xf4, 0x9b, 0x07, 0x3e, 0x75, 0x1e, 0xf8, 0x08, 0x77, 0x6f, 0xeb, 0xb1, 0x31,
0xa2, 0xc6, 0x7b, 0x74, 0x3a, 0xfc, 0xf3, 0x41, 0xa6, 0xa1, 0xfa, 0x77, 0xa2, 0xec, 0xe6, 0xf0,
0x3f, 0x04, 0xb3, 0xe3, 0x1c, 0x78, 0x1f, 0x87, 0xa3, 0x93, 0xdf, 0x09, 0x34, 0xb1, 0xfc, 0x21,
0xa4, 0x1d, 0xa3, 0x33, 0xed, 0xfb, 0xee, 0xd6, 0x6f, 0x3c, 0x73, 0x69, 0xdb, 0xf7, 0x7f, 0xd0,
0x9b, 0x88, 0xb3, 0xca, 0x60, 0x14, 0xb2, 0xa8, 0x16, 0x83, 0xe6, 0xab, 0x5d, 0x53, 0x02, 0xa2,
0x28, 0x6a, 0x42, 0x4e, 0xff, 0x39, 0xf9, 0x08, 0xb9, 0x83, 0x32, 0x2f, 0x22, 0x9b, 0xb2, 0x33,
0xa5, 0x6a, 0xfa, 0x5e, 0xff, 0x1f, 0x35, 0x83, 0x43, 0xb5, 0xc5, 0x17, 0x00, 0x00
};

2240
wled00/html_simple.h
View File

File diff suppressed because it is too large Load Diff

3747
wled00/html_ui.h
View File

File diff suppressed because it is too large Load Diff

118
wled00/json.cpp
View File

@@ -79,13 +79,13 @@ void deserializeSegment(JsonObject elem, byte it, byte presetId)
uint16_t grp = elem["grp"] | seg.grouping;
uint16_t spc = elem[F("spc")] | seg.spacing;
uint16_t of = seg.offset;
uint8_t soundSim = elem[F("ssim")] | seg.soundSim;
uint8_t map1D2D = elem[F("mp12")] | seg.map1D2D;
uint8_t soundSim = elem["ssim"] | seg.soundSim;
uint8_t map1D2D = elem["mp12"] | seg.map1D2D;
if ((spc>0 && spc!=seg.spacing) || seg.map1D2D!=map1D2D) seg.fill(BLACK); // clear spacing gaps
seg.map1D2D = map1D2D & 0x07;
seg.soundSim = soundSim & 0x03;
seg.map1D2D = constrain(map1D2D, 0, 7);
seg.soundSim = constrain(soundSim, 0, 7);
uint16_t len = 1;
if (stop > start) len = stop - start;
@@ -162,12 +162,12 @@ void deserializeSegment(JsonObject elem, byte it, byte presetId)
}
#endif
seg.selected = elem["sel"] | seg.selected;
seg.reverse = elem["rev"] | seg.reverse;
seg.mirror = elem[F("mi")] | seg.mirror;
seg.selected = elem["sel"] | seg.selected;
seg.reverse = elem["rev"] | seg.reverse;
seg.mirror = elem["mi"] | seg.mirror;
#ifndef WLED_DISABLE_2D
seg.reverse_y = elem[F("rY")] | seg.reverse_y;
seg.mirror_y = elem[F("mY")] | seg.mirror_y;
seg.reverse_y = elem["rY"] | seg.reverse_y;
seg.mirror_y = elem["mY"] | seg.mirror_y;
seg.transpose = elem[F("tp")] | seg.transpose;
#endif
@@ -185,17 +185,17 @@ void deserializeSegment(JsonObject elem, byte it, byte presetId)
if (elem[F("fxdef")])
{
int16_t sOpt;
sOpt = extractModeDefaults(fx, SET_F("sx")); if (sOpt >= 0) seg.speed = sOpt;
sOpt = extractModeDefaults(fx, SET_F("ix")); if (sOpt >= 0) seg.intensity = sOpt;
sOpt = extractModeDefaults(fx, SET_F("c1")); if (sOpt >= 0) seg.custom1 = sOpt;
sOpt = extractModeDefaults(fx, SET_F("c2")); if (sOpt >= 0) seg.custom2 = sOpt;
sOpt = extractModeDefaults(fx, SET_F("c3")); if (sOpt >= 0) seg.custom3 = sOpt;
sOpt = extractModeDefaults(fx, SET_F("mp12")); if (sOpt >= 0) seg.map1D2D = sOpt & 0x07;
sOpt = extractModeDefaults(fx, SET_F("ssim")); if (sOpt >= 0) seg.soundSim = sOpt & 0x03;
sOpt = extractModeDefaults(fx, "rev"); if (sOpt >= 0) seg.reverse = (bool)sOpt;
sOpt = extractModeDefaults(fx, SET_F("mi")); if (sOpt >= 0) seg.mirror = (bool)sOpt; // NOTE: setting this option is a risky business
sOpt = extractModeDefaults(fx, SET_F("rY")); if (sOpt >= 0) seg.reverse_y = (bool)sOpt;
sOpt = extractModeDefaults(fx, SET_F("mY")); if (sOpt >= 0) seg.mirror_y = (bool)sOpt; // NOTE: setting this option is a risky business
sOpt = extractModeDefaults(fx, "sx"); if (sOpt >= 0) seg.speed = sOpt;
sOpt = extractModeDefaults(fx, "ix"); if (sOpt >= 0) seg.intensity = sOpt;
sOpt = extractModeDefaults(fx, "c1"); if (sOpt >= 0) seg.custom1 = sOpt;
sOpt = extractModeDefaults(fx, "c2"); if (sOpt >= 0) seg.custom2 = sOpt;
sOpt = extractModeDefaults(fx, "c3"); if (sOpt >= 0) seg.custom3 = sOpt;
sOpt = extractModeDefaults(fx, "mp12"); if (sOpt >= 0) seg.map1D2D = constrain(sOpt, 0, 7);
sOpt = extractModeDefaults(fx, "ssim"); if (sOpt >= 0) seg.soundSim = constrain(sOpt, 0, 7);
sOpt = extractModeDefaults(fx, "rev"); if (sOpt >= 0) seg.reverse = (bool)sOpt;
sOpt = extractModeDefaults(fx, "mi"); if (sOpt >= 0) seg.mirror = (bool)sOpt; // NOTE: setting this option is a risky business
sOpt = extractModeDefaults(fx, "rY"); if (sOpt >= 0) seg.reverse_y = (bool)sOpt;
sOpt = extractModeDefaults(fx, "mY"); if (sOpt >= 0) seg.mirror_y = (bool)sOpt; // NOTE: setting this option is a risky business
sOpt = extractModeDefaults(fx, "pal");
if (sOpt >= 0 && sOpt < strip.getPaletteCount() + strip.customPalettes.size()) {
if (sOpt != seg.palette) {
@@ -206,8 +206,8 @@ void deserializeSegment(JsonObject elem, byte it, byte presetId)
}
//getVal also supports inc/decrementing and random
getVal(elem[F("sx")], &seg.speed);
getVal(elem[F("ix")], &seg.intensity);
getVal(elem["sx"], &seg.speed);
getVal(elem["ix"], &seg.intensity);
uint8_t pal = seg.palette;
if (getVal(elem["pal"], &pal, 1, strip.getPaletteCount())) {
if (pal != seg.palette) {
@@ -215,15 +215,15 @@ void deserializeSegment(JsonObject elem, byte it, byte presetId)
seg.palette = pal;
}
}
getVal(elem[F("c1")], &seg.custom1);
getVal(elem[F("c2")], &seg.custom2);
getVal(elem["c1"], &seg.custom1);
getVal(elem["c2"], &seg.custom2);
uint8_t cust3 = seg.custom3;
getVal(elem[F("c3")], &cust3); // we can't pass reference to bifield
seg.custom3 = cust3;
getVal(elem["c3"], &cust3); // we can't pass reference to bifield
seg.custom3 = constrain(cust3, 0, 31);
seg.check1 = elem[F("o1")] | seg.check1;
seg.check2 = elem[F("o2")] | seg.check2;
seg.check3 = elem[F("o3")] | seg.check3;
seg.check1 = elem["o1"] | seg.check1;
seg.check2 = elem["o2"] | seg.check2;
seg.check3 = elem["o3"] | seg.check3;
JsonArray iarr = elem[F("i")]; //set individual LEDs
if (!iarr.isNull()) {
@@ -496,26 +496,26 @@ void serializeSegment(JsonObject& root, Segment& seg, byte id, bool forPreset, b
strcat(colstr, "]");
root["col"] = serialized(colstr);
root["fx"] = seg.mode;
root[F("sx")] = seg.speed;
root[F("ix")] = seg.intensity;
root["pal"] = seg.palette;
root[F("c1")] = seg.custom1;
root[F("c2")] = seg.custom2;
root[F("c3")] = seg.custom3;
root[F("sel")] = seg.isSelected();
root["rev"] = seg.reverse;
root[F("mi")] = seg.mirror;
root["fx"] = seg.mode;
root["sx"] = seg.speed;
root["ix"] = seg.intensity;
root["pal"] = seg.palette;
root["c1"] = seg.custom1;
root["c2"] = seg.custom2;
root["c3"] = seg.custom3;
root["sel"] = seg.isSelected();
root["rev"] = seg.reverse;
root["mi"] = seg.mirror;
if (strip.isMatrix) {
root[F("rY")] = seg.reverse_y;
root[F("mY")] = seg.mirror_y;
root["rY"] = seg.reverse_y;
root["mY"] = seg.mirror_y;
root[F("tp")] = seg.transpose;
}
root[F("o1")] = seg.check1;
root[F("o2")] = seg.check2;
root[F("o3")] = seg.check3;
root[F("ssim")] = seg.soundSim;
root[F("mp12")] = seg.map1D2D;
root["o1"] = seg.check1;
root["o2"] = seg.check2;
root["o3"] = seg.check3;
root["ssim"] = seg.soundSim;
root["mp12"] = seg.map1D2D;
}
void serializeState(JsonObject root, bool forPreset, bool includeBri, bool segmentBounds)
@@ -628,6 +628,7 @@ void serializeInfo(JsonObject root)
JsonArray spi = root.createNestedArray(F("spi"));
spi.add(spi_mosi);
spi.add(spi_sclk);
spi.add(spi_miso);
#endif
root[F("str")] = syncToggleReceive;
@@ -920,12 +921,13 @@ void serializeNodes(JsonObject root)
void serializeModeData(JsonArray fxdata)
{
char lineBuffer[128];
for (size_t i = 0; i < strip.getModeCount(); i++) {
String lineBuffer = FPSTR(strip.getModeData(i));
if (lineBuffer.length() > 0) {
uint8_t endPos = lineBuffer.indexOf('@');
if (endPos>0) fxdata.add(lineBuffer.substring(endPos));
else fxdata.add("");
strncpy_P(lineBuffer, strip.getModeData(i), 127);
if (lineBuffer[0] != 0) {
char* dataPtr = strchr(lineBuffer,'@');
if (dataPtr) fxdata.add(dataPtr);
else fxdata.add("");
}
}
}
@@ -933,12 +935,13 @@ void serializeModeData(JsonArray fxdata)
// deserializes mode names string into JsonArray
// also removes WLED-SR extensions (@...) from deserialised names
void serializeModeNames(JsonArray arr) {
char lineBuffer[128];
for (size_t i = 0; i < strip.getModeCount(); i++) {
String lineBuffer = FPSTR(strip.getModeData(i));
if (lineBuffer.length() > 0) {
uint8_t endPos = lineBuffer.indexOf('@');
if (endPos>0) arr.add(lineBuffer.substring(0, endPos));
else arr.add(lineBuffer);
strncpy_P(lineBuffer, strip.getModeData(i), 127);
if (lineBuffer[0] != 0) {
char* dataPtr = strchr(lineBuffer,'@');
if (dataPtr) *dataPtr = 0; // terminate mode data after name
arr.add(lineBuffer);
}
}
}
@@ -969,7 +972,6 @@ void serveJson(AsyncWebServerRequest* request)
request->send(response);
releaseJSONBufferLock();
} else {
//request->send_P(200, "application/json", JSON_mode_names);
request->send(503, "application/json", F("{\"error\":3}"));
}
return;
@@ -1013,11 +1015,11 @@ void serveJson(AsyncWebServerRequest* request)
serializeInfo(info);
if (subJson != 3)
{
//lDoc[F("effects")] = serialized((const __FlashStringHelper*)JSON_mode_names);
JsonArray effects = lDoc.createNestedArray(F("effects"));
serializeModeNames(effects); // remove WLED-SR extensions from effect names
lDoc[F("palettes")] = serialized((const __FlashStringHelper*)JSON_palette_names);
}
//lDoc["m"] = lDoc.memoryUsage(); // JSON buffer usage, for remote debugging
}
DEBUG_PRINTF("JSON buffer size: %u for request: %d\n", lDoc.memoryUsage(), subJson);

5
wled00/udp.cpp
View File

@@ -665,6 +665,9 @@ void sendSysInfoUDP()
#define DDP_FLAGS1_STORAGE 0x08
#define DDP_FLAGS1_TIME 0x10
#define DDP_TYPE_RGB24 0x0A
#define DDP_TYPE_RGBW32 0x1A // proposal, this is still not an official part of the DDP spec
#define DDP_ID_DISPLAY 1
#define DDP_ID_CONFIG 250
#define DDP_ID_STATUS 251
@@ -724,7 +727,7 @@ uint8_t realtimeBroadcast(uint8_t type, IPAddress client, uint16_t length, uint8
// write the header
/*0*/ddpUdp.write(flags);
/*1*/ddpUdp.write(sequenceNumber++ & 0x0F); // sequence may be unnecessary unless we are sending twice (as requested in Sync settings)
/*2*/ddpUdp.write(0);
/*2*/ddpUdp.write(0); // data type, this is not fully defined by the DDP spec and thus left at "undefined" which is assumed to be 24-bit RGB
/*3*/ddpUdp.write(DDP_ID_DISPLAY);
// data offset in bytes, 32-bit number, MSB first
/*4*/ddpUdp.write(0xFF & (channel >> 24));

19
wled00/util.cpp
View File

@@ -355,17 +355,22 @@ uint8_t extractModeSlider(uint8_t mode, uint8_t slider, char *dest, uint8_t maxL
}
// extracts mode parameter defaults from last section of mode data (e.g. "Juggle@!,Trail;!,!,;!;sx=16,ix=240,1d")
int16_t extractModeDefaults(uint8_t mode, const char *segVar)
{
if (mode < strip.getModeCount()) {
String lineBuffer = FPSTR(strip.getModeData(mode));
if (lineBuffer.length() > 0) {
int16_t start = lineBuffer.lastIndexOf(';');
if (start<0) return -1;
char lineBuffer[128] = "";
strncpy_P(lineBuffer, strip.getModeData(mode), 127);
lineBuffer[127] = '\0'; // terminate string
if (lineBuffer[0] != 0) {
char* startPtr = strrchr(lineBuffer, ';'); // last ";" in FX data
if (!startPtr) return -1;
int16_t stop = lineBuffer.indexOf(segVar, start+1);
if (stop<0) return -1;
return atoi(lineBuffer.substring(stop+strlen(segVar)+1).c_str());
char* stopPtr = strstr(startPtr, segVar);
if (!stopPtr) return -1;
stopPtr += strlen(segVar) +1; // skip "="
return atoi(stopPtr);
}
}
return -1;

4
wled00/wled.h
View File

@@ -8,7 +8,7 @@
*/
// version code in format yymmddb (b = daily build)
#define VERSION 2208301
#define VERSION 2208311
//uncomment this if you have a "my_config.h" file you'd like to use
//#define WLED_USE_MY_CONFIG
@@ -222,7 +222,7 @@ using PSRAMDynamicJsonDocument = BasicJsonDocument<PSRAM_Allocator>;
// Global Variable definitions
WLED_GLOBAL char versionString[] _INIT(TOSTRING(WLED_VERSION));
#define WLED_CODENAME "Toki"
#define WLED_CODENAME "Hoshi"
// AP and OTA default passwords (for maximum security change them!)
WLED_GLOBAL char apPass[65] _INIT(DEFAULT_AP_PASS);

8
wled00/wled_eeprom.cpp
View File

@@ -414,10 +414,10 @@ void deEEP() {
for (byte j = 0; j < numChannels; j++) colX.add(EEPROM.read(memloc + j));
}
segObj["fx"] = EEPROM.read(i+10);
segObj[F("sx")] = EEPROM.read(i+11);
segObj[F("ix")] = EEPROM.read(i+16);
segObj["pal"] = EEPROM.read(i+17);
segObj["fx"] = EEPROM.read(i+10);
segObj["sx"] = EEPROM.read(i+11);
segObj["ix"] = EEPROM.read(i+16);
segObj["pal"] = EEPROM.read(i+17);
} else {
Segment* seg = strip.getSegments();
memcpy(seg, EEPROM.getDataPtr() +i+2, 240);

1
wled00/xml.cpp
View File

@@ -641,6 +641,7 @@ void getSettingsJS(byte subPage, char* dest)
oappend(SET_F("addInfo('SDA','")); oappendi(HW_PIN_SDA); oappend(SET_F("');"));
oappend(SET_F("addInfo('SCL','")); oappendi(HW_PIN_SCL); oappend(SET_F("');"));
oappend(SET_F("addInfo('MOSI','")); oappendi(HW_PIN_DATASPI); oappend(SET_F("');"));
oappend(SET_F("addInfo('MISO','")); oappendi(HW_PIN_MISOSPI); oappend(SET_F("');"));
oappend(SET_F("addInfo('SCLK','")); oappendi(HW_PIN_CLOCKSPI); oappend(SET_F("');"));
usermods.appendConfigData();
}