/sevenSeg/perSegment/set```
14 | Payload ```3```
15 | #### perSegment -- ssLEDPerSegment
16 | The number of individual LEDs per segment. There are 7 segments per digit.
17 | #### perPeriod -- ssLEDPerPeriod
18 | The number of individual LEDs per period. A ':' has 2x periods.
19 | #### startIdx -- ssStartLED
20 | Index of the LED that the display starts at. Allows a seven segment display to be in the middle of a string.
21 | #### timeEnable -- ssTimeEnabled
22 | When true, when displayMask is configured for a time output and no message is set the time will be displayed.
23 | #### scrollSpd -- ssScrollSpeed
24 | Time, in milliseconds, between message shifts when the length of displayMsg exceeds the length of the displayMask.
25 | #### displayMask -- ssDisplayMask
26 | This should represent the configuration of the physical display.
27 |
28 | HH - 0-23. hh - 1-12, kk - 1-24 hours
29 | MM or mm - 0-59 minutes
30 | SS or ss = 0-59 seconds
31 | : for a colon
32 | All others for alpha numeric, (will be blank when displaying time)
33 |
34 | ##### Example
35 | ```HHMMSS ```
36 | ```hh:MM:SS ```
37 | #### displayMsg -- ssDisplayMessage
38 | Message to be displayed across the display. If the length exceeds the length of the displayMask the message will scroll at scrollSpd. To 'remove' a message or revert back to time, if timeEnabled is true, set the message to '~'.
39 | #### displayCfg -- ssDisplayConfig
40 | The order that your LEDs are configured. All seven segments in the display need to be wired the same way.
41 |
42 | -------
43 | / A / 0 - EDCGFAB
44 | / F / B 1 - EDCBAFG
45 | / / 2 - GCDEFAB
46 | ------- 3 - GBAFEDC
47 | / G / 4 - FABGEDC
48 | / E / C 5 - FABCDEG
49 | / /
50 | -------
51 | D
52 |
53 |
54 | ## Version
55 | 20211009 - Initial release
56 |
--------------------------------------------------------------------------------
/pio-scripts/output_bins.py:
--------------------------------------------------------------------------------
1 | Import('env')
2 | import os
3 | import shutil
4 | import gzip
5 |
6 | OUTPUT_DIR = "build_output{}".format(os.path.sep)
7 |
8 | def _get_cpp_define_value(env, define):
9 | define_list = [item[-1] for item in env["CPPDEFINES"] if item[0] == define]
10 |
11 | if define_list:
12 | return define_list[0]
13 |
14 | return None
15 |
16 | def _create_dirs(dirs=["firmware", "map"]):
17 | # check if output directories exist and create if necessary
18 | if not os.path.isdir(OUTPUT_DIR):
19 | os.mkdir(OUTPUT_DIR)
20 |
21 | for d in dirs:
22 | if not os.path.isdir("{}{}".format(OUTPUT_DIR, d)):
23 | os.mkdir("{}{}".format(OUTPUT_DIR, d))
24 |
25 | def bin_rename_copy(source, target, env):
26 | _create_dirs()
27 | variant = env["PIOENV"]
28 |
29 | # create string with location and file names based on variant
30 | map_file = "{}map{}{}.map".format(OUTPUT_DIR, os.path.sep, variant)
31 | bin_file = "{}firmware{}{}.bin".format(OUTPUT_DIR, os.path.sep, variant)
32 |
33 | release_name = _get_cpp_define_value(env, "WLED_RELEASE_NAME")
34 |
35 | if release_name:
36 | _create_dirs(["release"])
37 | version = _get_cpp_define_value(env, "WLED_VERSION")
38 | release_file = "{}release{}WLED_{}_{}.bin".format(OUTPUT_DIR, os.path.sep, version, release_name)
39 | shutil.copy(str(target[0]), release_file)
40 |
41 | # check if new target files exist and remove if necessary
42 | for f in [map_file, bin_file]:
43 | if os.path.isfile(f):
44 | os.remove(f)
45 |
46 | # copy firmware.bin to firmware/.bin
47 | shutil.copy(str(target[0]), bin_file)
48 |
49 | # copy firmware.map to map/.map
50 | if os.path.isfile("firmware.map"):
51 | shutil.move("firmware.map", map_file)
52 |
53 | def bin_gzip(source, target, env):
54 | _create_dirs()
55 | variant = env["PIOENV"]
56 |
57 | # create string with location and file names based on variant
58 | bin_file = "{}firmware{}{}.bin".format(OUTPUT_DIR, os.path.sep, variant)
59 | gzip_file = "{}firmware{}{}.bin.gz".format(OUTPUT_DIR, os.path.sep, variant)
60 |
61 | # check if new target files exist and remove if necessary
62 | if os.path.isfile(gzip_file): os.remove(gzip_file)
63 |
64 | # write gzip firmware file
65 | with open(bin_file,"rb") as fp:
66 | with gzip.open(gzip_file, "wb", compresslevel = 9) as f:
67 | shutil.copyfileobj(fp, f)
68 |
69 | env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", [bin_rename_copy, bin_gzip])
70 |
--------------------------------------------------------------------------------
/usermods/Fix_unreachable_netservices_v2/readme.md:
--------------------------------------------------------------------------------
1 | # Fix unreachable net services V2
2 |
3 | **Attention: This usermod compiles only for ESP8266**
4 |
5 | This usermod-v2 modification performs a ping request to the local IP address every 60 seconds. By this procedure the net services of WLED remains accessible in some problematic WLAN environments.
6 |
7 | The modification works with static or DHCP IP address configuration.
8 |
9 | _Story:_
10 |
11 | Unfortunately, with all ESP projects where a web server or other network services are running, I have the problem that after some time the web server is no longer accessible. Now I found out that the connection is at least reestablished when a ping request is executed by the device.
12 |
13 | With this modification, in the worst case, the network functions are not available for 60 seconds until the next ping request.
14 |
15 | ## Webinterface
16 |
17 | The number of pings and reconnects is displayed on the info page in the web interface.
18 | The ping delay can be changed. Changes persist after a reboot.
19 |
20 | ## JSON API
21 |
22 | The usermod supports the following state changes:
23 |
24 | | JSON key | Value range | Description |
25 | |-------------|------------------|---------------------------------|
26 | | PingDelayMs | 5000 to 18000000 | Deactivdate/activate the sensor |
27 |
28 | Changes also persist after a reboot.
29 |
30 | ## Installation
31 |
32 | 1. Copy the file `usermod_Fix_unreachable_netservices.h` to the `wled00` directory.
33 | 2. Register the usermod by adding `#include "usermod_Fix_unreachable_netservices.h"` in the top and `registerUsermod(new FixUnreachableNetServices());` in the bottom of `usermods_list.cpp`.
34 |
35 | Example **usermods_list.cpp**:
36 |
37 | ```cpp
38 | #include "wled.h"
39 | /*
40 | * Register your v2 usermods here!
41 | * (for v1 usermods using just usermod.cpp, you can ignore this file)
42 | */
43 |
44 | /*
45 | * Add/uncomment your usermod filename here (and once more below)
46 | * || || ||
47 | * \/ \/ \/
48 | */
49 | //#include "usermod_v2_example.h"
50 | //#include "usermod_temperature.h"
51 | //#include "usermod_v2_empty.h"
52 | #include "usermod_Fix_unreachable_netservices.h"
53 |
54 | void registerUsermods()
55 | {
56 | /*
57 | * Add your usermod class name here
58 | * || || ||
59 | * \/ \/ \/
60 | */
61 | //usermods.add(new MyExampleUsermod());
62 | //usermods.add(new UsermodTemperature());
63 | //usermods.add(new UsermodRenameMe());
64 | usermods.add(new FixUnreachableNetServices());
65 |
66 | }
67 | ```
68 |
69 | Hopefully I can help someone with that - @gegu
70 |
--------------------------------------------------------------------------------
/usermods/buzzer/usermod_v2_buzzer.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 |
3 | #include "wled.h"
4 | #include "Arduino.h"
5 |
6 | #include
7 |
8 | #define USERMOD_ID_BUZZER 900
9 | #ifndef USERMOD_BUZZER_PIN
10 | #define USERMOD_BUZZER_PIN GPIO_NUM_32
11 | #endif
12 |
13 | /*
14 | * Usermods allow you to add own functionality to WLED more easily
15 | * See: https://github.com/Aircoookie/WLED/wiki/Add-own-functionality
16 | *
17 | * Using a usermod:
18 | * 1. Copy the usermod into the sketch folder (same folder as wled00.ino)
19 | * 2. Register the usermod by adding #include "usermod_filename.h" in the top and registerUsermod(new MyUsermodClass()) in the bottom of usermods_list.cpp
20 | */
21 |
22 | class BuzzerUsermod : public Usermod {
23 | private:
24 | unsigned long lastTime_ = 0;
25 | unsigned long delay_ = 0;
26 | std::deque> sequence_ {};
27 | public:
28 | /*
29 | * setup() is called once at boot. WiFi is not yet connected at this point.
30 | * You can use it to initialize variables, sensors or similar.
31 | */
32 | void setup() {
33 | // Setup the pin, and default to LOW
34 | pinMode(USERMOD_BUZZER_PIN, OUTPUT);
35 | digitalWrite(USERMOD_BUZZER_PIN, LOW);
36 |
37 | // Beep on startup
38 | sequence_.push_back({ HIGH, 50 });
39 | sequence_.push_back({ LOW, 0 });
40 | }
41 |
42 |
43 | /*
44 | * connected() is called every time the WiFi is (re)connected
45 | * Use it to initialize network interfaces
46 | */
47 | void connected() {
48 | // Double beep on WiFi
49 | sequence_.push_back({ LOW, 100 });
50 | sequence_.push_back({ HIGH, 50 });
51 | sequence_.push_back({ LOW, 30 });
52 | sequence_.push_back({ HIGH, 50 });
53 | sequence_.push_back({ LOW, 0 });
54 | }
55 |
56 | /*
57 | * loop() is called continuously. Here you can check for events, read sensors, etc.
58 | */
59 | void loop() {
60 | if (sequence_.size() < 1) return; // Wait until there is a sequence
61 | if (millis() - lastTime_ <= delay_) return; // Wait until delay has elapsed
62 |
63 | auto event = sequence_.front();
64 | sequence_.pop_front();
65 |
66 | digitalWrite(USERMOD_BUZZER_PIN, event.first);
67 | delay_ = event.second;
68 |
69 | lastTime_ = millis();
70 | }
71 |
72 |
73 | /*
74 | * getId() allows you to optionally give your V2 usermod an unique ID (please define it in const.h!).
75 | * This could be used in the future for the system to determine whether your usermod is installed.
76 | */
77 | uint16_t getId()
78 | {
79 | return USERMOD_ID_BUZZER;
80 | }
81 | };
--------------------------------------------------------------------------------
/wled00/src/dependencies/blynk/Blynk/BlynkEveryN.h:
--------------------------------------------------------------------------------
1 |
2 | #ifndef BLYNKEVERYN_H
3 | #define BLYNKEVERYN_H
4 |
5 | #include "BlynkDebug.h"
6 |
7 | millis_time_t blynk_count_millis() {
8 | const millis_time_t ms = BlynkMillis();
9 | return ms;
10 | }
11 |
12 | uint16_t blynk_count_seconds16() {
13 | const millis_time_t ms = BlynkMillis();
14 | return (ms / 1000);
15 | }
16 |
17 | uint16_t blynk_count_minutes16()
18 | {
19 | const millis_time_t ms = BlynkMillis();
20 | return (ms / (60000L)) & 0xFFFF;
21 | }
22 |
23 | uint8_t blynk_count_hours8()
24 | {
25 | const millis_time_t ms = BlynkMillis();
26 | return (ms / (3600000L)) & 0xFF;
27 | }
28 |
29 | template
30 | class BlynkPeriodic {
31 | public:
32 | T mPrev;
33 | T mPeriod;
34 |
35 | BlynkPeriodic() { reset(); mPeriod = 1; };
36 | BlynkPeriodic(T period) { reset(); setPeriod(period); };
37 | void setPeriod( T period) { mPeriod = period; };
38 | T getTime() { return (T)(timeGetter()); };
39 | T getPeriod() { return mPeriod; };
40 | T getElapsed() { return getTime() - mPrev; }
41 | T getRemaining() { return mPeriod - getElapsed(); }
42 | T getLastTriggerTime() { return mPrev; }
43 | bool ready() {
44 | bool isReady = (getElapsed() >= mPeriod);
45 | if( isReady ) { reset(); }
46 | return isReady;
47 | }
48 | void reset() { mPrev = getTime(); };
49 | void trigger() { mPrev = getTime() - mPeriod; };
50 |
51 | operator bool() { return ready(); }
52 | };
53 |
54 | typedef BlynkPeriodic BlynkEveryNMillis;
55 | typedef BlynkPeriodic BlynkEveryNSeconds;
56 | typedef BlynkPeriodic BlynkEveryNMinutes;
57 | typedef BlynkPeriodic BlynkEveryNHours;
58 |
59 | #define BLYNK_EVERY_N_MILLIS_I(NAME,N) static BlynkEveryNMillis NAME(N); if(NAME)
60 | #define BLYNK_EVERY_N_SECONDS_I(NAME,N) static BlynkEveryNSeconds NAME(N); if(NAME)
61 | #define BLYNK_EVERY_N_MINUTES_I(NAME,N) static BlynkEveryNMinutes NAME(N); if(NAME)
62 | #define BLYNK_EVERY_N_HOURS_I(NAME,N) static BlynkEveryNHours NAME(N); if(NAME)
63 |
64 | #define BLYNK_EVERY_N_MILLIS(N) BLYNK_EVERY_N_MILLIS_I(BLYNK_CONCAT2(PER, __COUNTER__),N)
65 | #define BLYNK_EVERY_N_SECONDS(N) BLYNK_EVERY_N_SECONDS_I(BLYNK_CONCAT2(PER, __COUNTER__),N)
66 | #define BLYNK_EVERY_N_MINUTES(N) BLYNK_EVERY_N_MINUTES_I(BLYNK_CONCAT2(PER, __COUNTER__),N)
67 | #define BLYNK_EVERY_N_HOURS(N) BLYNK_EVERY_N_HOURS_I(BLYNK_CONCAT2(PER, __COUNTER__),N)
68 |
69 | #endif
70 |
--------------------------------------------------------------------------------
/wled00/src/dependencies/blynk/BlynkSimpleEsp.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file BlynkSimpleEsp32.h
3 | * @author Volodymyr Shymanskyy
4 | * @license This project is released under the MIT License (MIT)
5 | * @copyright Copyright (c) 2015 Volodymyr Shymanskyy
6 | * @date Oct 2016
7 | * @brief
8 | *
9 | */
10 |
11 | #ifndef BlynkSimpleEsp_h
12 | #define BlynkSimpleEsp_h
13 |
14 | #define BLYNK_SEND_ATOMIC
15 |
16 | #include "Blynk/BlynkApiArduino.h"
17 | #include "Blynk/BlynkProtocol.h"
18 | #include "Blynk/BlynkArduinoClient.h"
19 | #ifdef ARDUINO_ARCH_ESP32
20 | #include
21 | #else
22 | #include
23 | #endif
24 |
25 | class BlynkWifi
26 | : public BlynkProtocol
27 | {
28 | typedef BlynkProtocol Base;
29 | public:
30 | BlynkWifi(BlynkArduinoClient& transp)
31 | : Base(transp)
32 | {}
33 |
34 | void connectWiFi(const char* ssid, const char* pass)
35 | {
36 | BLYNK_LOG2(BLYNK_F("Connecting to "), ssid);
37 | WiFi.mode(WIFI_STA);
38 | if (pass && strlen(pass)) {
39 | WiFi.begin(ssid, pass);
40 | } else {
41 | WiFi.begin(ssid);
42 | }
43 | while (WiFi.status() != WL_CONNECTED) {
44 | BlynkDelay(500);
45 | }
46 | BLYNK_LOG1(BLYNK_F("Connected to WiFi"));
47 |
48 | BLYNK_LOG_IP("IP: ", WiFi.localIP());
49 | }
50 |
51 | void config(const char* auth,
52 | const char* domain = BLYNK_DEFAULT_DOMAIN,
53 | uint16_t port = BLYNK_DEFAULT_PORT)
54 | {
55 | Base::begin(auth);
56 | this->conn.begin(domain, port);
57 | }
58 |
59 | void config(const char* auth,
60 | IPAddress ip,
61 | uint16_t port = BLYNK_DEFAULT_PORT)
62 | {
63 | Base::begin(auth);
64 | this->conn.begin(ip, port);
65 | }
66 |
67 | void begin(const char* auth,
68 | const char* ssid,
69 | const char* pass,
70 | const char* domain = BLYNK_DEFAULT_DOMAIN,
71 | uint16_t port = BLYNK_DEFAULT_PORT)
72 | {
73 | connectWiFi(ssid, pass);
74 | config(auth, domain, port);
75 | while(this->connect() != true) {}
76 | }
77 |
78 | void begin(const char* auth,
79 | const char* ssid,
80 | const char* pass,
81 | IPAddress ip,
82 | uint16_t port = BLYNK_DEFAULT_PORT)
83 | {
84 | connectWiFi(ssid, pass);
85 | config(auth, ip, port);
86 | while(this->connect() != true) {}
87 | }
88 |
89 | };
90 |
91 | extern BlynkWifi Blynk;
92 |
93 | #endif
94 |
--------------------------------------------------------------------------------
/wled00/data/welcome.htm:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Welcome!
8 |
50 |
51 |
52 | 
53 |
54 |
Welcome to WLED!
55 | Thank you for installing my application!
56 | Next steps:
57 | Connect the module to your local WiFi here!
58 |
59 | Just trying this out in AP mode?
60 |
61 |
62 |
63 |
--------------------------------------------------------------------------------
/wled00/src/dependencies/espalexa/EspalexaDevice.h:
--------------------------------------------------------------------------------
1 | #ifndef EspalexaDevice_h
2 | #define EspalexaDevice_h
3 |
4 | #include "Arduino.h"
5 | #include
6 |
7 | class EspalexaDevice;
8 |
9 | typedef std::function BrightnessCallbackFunction;
10 | typedef std::function DeviceCallbackFunction;
11 | typedef std::function ColorCallbackFunction;
12 |
13 | enum class EspalexaColorMode : uint8_t { none = 0, ct = 1, hs = 2, xy = 3 };
14 | enum class EspalexaDeviceType : uint8_t { onoff = 0, dimmable = 1, whitespectrum = 2, color = 3, extendedcolor = 4 };
15 | enum class EspalexaDeviceProperty : uint8_t { none = 0, on = 1, off = 2, bri = 3, hs = 4, ct = 5, xy = 6 };
16 |
17 | class EspalexaDevice {
18 | private:
19 | String _deviceName;
20 | BrightnessCallbackFunction _callback = nullptr;
21 | DeviceCallbackFunction _callbackDev = nullptr;
22 | ColorCallbackFunction _callbackCol = nullptr;
23 | uint8_t _val, _val_last, _sat = 0;
24 | uint16_t _hue = 0, _ct = 0;
25 | float _x = 0.5f, _y = 0.5f;
26 | uint32_t _rgb = 0;
27 | uint8_t _id = 0;
28 | EspalexaDeviceType _type;
29 | EspalexaDeviceProperty _changed = EspalexaDeviceProperty::none;
30 | EspalexaColorMode _mode = EspalexaColorMode::xy;
31 |
32 | public:
33 | EspalexaDevice();
34 | ~EspalexaDevice();
35 | EspalexaDevice(String deviceName, BrightnessCallbackFunction bcb, uint8_t initialValue =0);
36 | EspalexaDevice(String deviceName, DeviceCallbackFunction dcb, EspalexaDeviceType t =EspalexaDeviceType::dimmable, uint8_t initialValue =0);
37 | EspalexaDevice(String deviceName, ColorCallbackFunction ccb, uint8_t initialValue =0);
38 |
39 | String getName();
40 | uint8_t getId();
41 | EspalexaDeviceProperty getLastChangedProperty();
42 | uint8_t getValue();
43 | uint8_t getLastValue(); //last value that was not off (1-255)
44 | bool getState();
45 | uint8_t getPercent();
46 | uint8_t getDegrees();
47 | uint16_t getHue();
48 | uint8_t getSat();
49 | uint16_t getCt();
50 | uint32_t getKelvin();
51 | float getX();
52 | float getY();
53 | uint32_t getRGB();
54 | uint8_t getR();
55 | uint8_t getG();
56 | uint8_t getB();
57 | uint8_t getW();
58 | EspalexaColorMode getColorMode();
59 | EspalexaDeviceType getType();
60 |
61 | void setId(uint8_t id);
62 | void setPropertyChanged(EspalexaDeviceProperty p);
63 | void setValue(uint8_t bri);
64 | void setState(bool onoff);
65 | void setPercent(uint8_t perc);
66 | void setName(String name);
67 | void setColor(uint16_t ct);
68 | void setColor(uint16_t hue, uint8_t sat);
69 | void setColorXY(float x, float y);
70 | void setColor(uint8_t r, uint8_t g, uint8_t b);
71 |
72 | void doCallback();
73 | };
74 |
75 | #endif
--------------------------------------------------------------------------------
/.github/workflows/wled-ci.yml:
--------------------------------------------------------------------------------
1 | name: PlatformIO CI
2 |
3 | on: [push, pull_request]
4 |
5 | jobs:
6 |
7 | get_default_envs:
8 | name: Gather Environments
9 | runs-on: ubuntu-latest
10 | steps:
11 | - uses: actions/checkout@v2
12 | - name: Cache pip
13 | uses: actions/cache@v2
14 | with:
15 | path: ~/.cache/pip
16 | key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
17 | restore-keys: |
18 | ${{ runner.os }}-pip-
19 | - uses: actions/setup-python@v2
20 | - name: Install PlatformIO
21 | run: pip install -r requirements.txt
22 | - name: Get default environments
23 | id: envs
24 | run: |
25 | echo "::set-output name=environments::$(pio project config --json-output | jq -cr '.[0][1][0][1]')"
26 | outputs:
27 | environments: ${{ steps.envs.outputs.environments }}
28 |
29 |
30 | build:
31 | name: Build Enviornments
32 | runs-on: ubuntu-latest
33 | needs: get_default_envs
34 | strategy:
35 | matrix:
36 | environment: ${{ fromJSON(needs.get_default_envs.outputs.environments) }}
37 | steps:
38 | - uses: actions/checkout@v2
39 | - name: Cache pip
40 | uses: actions/cache@v2
41 | with:
42 | path: ~/.cache/pip
43 | key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
44 | restore-keys: |
45 | ${{ runner.os }}-pip-
46 | - name: Cache PlatformIO
47 | uses: actions/cache@v2
48 | with:
49 | path: ~/.platformio
50 | key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
51 | - name: Set up Python
52 | uses: actions/setup-python@v2
53 | - name: Install PlatformIO
54 | run: pip install -r requirements.txt
55 | - name: Build firmware
56 | env:
57 | WLED_RELEASE: True
58 | run: pio run -e ${{ matrix.environment }}
59 | - uses: actions/upload-artifact@v2
60 | with:
61 | name: firmware-${{ matrix.environment }}
62 | path: |
63 | build_output/firmware/*.bin
64 | build_output/firmware/*.gz
65 | - uses: actions/upload-artifact@v2
66 | if: startsWith(github.ref, 'refs/tags/')
67 | with:
68 | name: firmware-release
69 | path: build_output/release/*.bin
70 | release:
71 | name: Create Release
72 | runs-on: ubuntu-latest
73 | needs: [get_default_envs, build]
74 | if: startsWith(github.ref, 'refs/tags/')
75 | steps:
76 | - uses: actions/download-artifact@v2
77 | with:
78 | name: firmware-release
79 | - name: Create draft release
80 | uses: softprops/action-gh-release@v1
81 | with:
82 | draft: True
83 | files: |
84 | *.bin
85 | env:
86 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
87 |
--------------------------------------------------------------------------------
/usermods/JSON_IR_remote/21-key_ir.json:
--------------------------------------------------------------------------------
1 | {
2 | "desc": "21-key",
3 | "0xFFA25D": {
4 | "label": "On",
5 | "pos": "1x1",
6 | "cmd": "T=1"
7 | },
8 | "0xFF629D": {
9 | "label": "Off",
10 | "pos": "1x2",
11 | "cmd": "T=0"
12 | },
13 | "0xFFE21D": {
14 | "label": "Flash",
15 | "pos": "1x3",
16 | "cmnt": "Cycle Effects",
17 | "cmd": "CY=0&FX=~"
18 | },
19 | "0xFF22DD": {
20 | "label": "Strobe",
21 | "pos": "2x1",
22 | "cmnt": "Sinelon Dual",
23 | "cmd": "CY=0&FX=93"
24 | },
25 | "0xFF02FD": {
26 | "label": "Fade",
27 | "pos": "2x2",
28 | "cmnt": "Rain",
29 | "cmd": "CY=0&FX=43"
30 | },
31 | "0xFFC23D": {
32 | "label": "Smooth",
33 | "pos": "2x3",
34 | "cmnt": "Aurora",
35 | "cmd": "CY=0&FX=38"
36 | },
37 | "0xFFE01F": {
38 | "label": "Bright +",
39 | "pos": "3x1",
40 | "cmd": "A=~16"
41 | },
42 | "0xFFA857": {
43 | "label": "Bright -",
44 | "pos": "3x2",
45 | "cmd": "A=~-16"
46 | },
47 | "0xFF906F": {
48 | "label": "White",
49 | "pos": "3x3",
50 | "cmd": "FP=5&CL=hFFFFFF&C2=hFFFFFF&C3=hA8A8A8"
51 | },
52 | "0xFF6897": {
53 | "label": "Red",
54 | "pos": "4x1",
55 | "cmnt": "Lava",
56 | "cmd": "FP=8"
57 | },
58 | "0xFF9867": {
59 | "label": "Green",
60 | "pos": "4x2",
61 | "cmnt": "Forest",
62 | "cmd": "FP=10"
63 | },
64 | "0xFFB04F": {
65 | "label": "Blue",
66 | "pos": "4x3",
67 | "cmnt": "Breeze",
68 | "cmd": "FP=15"
69 | },
70 | "0xFF30CF": {
71 | "label": "Tomato",
72 | "pos": "5x1",
73 | "cmd": "FP=5&CL=hFF6347&C2=hFFBF47&C3=hA85859"
74 | },
75 | "0xFF18E7": {
76 | "label": "LightGreen",
77 | "pos": "5x2",
78 | "cmnt": "Rivendale",
79 | "cmd": "FP=14"
80 | },
81 | "0xFF7A85": {
82 | "label": "SkyBlue",
83 | "pos": "5x3",
84 | "cmnt": "Ocean",
85 | "cmd": "FP=9"
86 | },
87 | "0xFF10EF": {
88 | "label": "Orange",
89 | "pos": "6x1",
90 | "cmnt": "Orangery",
91 | "cmd": "FP=47"
92 | },
93 | "0xFF38C7": {
94 | "label": "Aqua",
95 | "pos": "6x2",
96 | "cmd": "FP=5&CL=hFFFF&C2=h7FFF&C3=h39A895"
97 | },
98 | "0xFF5AA5": {
99 | "label": "Purple",
100 | "pos": "6x3",
101 | "cmd": "FP=5&CL=h663399&C2=h993399&C3=h473864"
102 | },
103 | "0xFF42BD": {
104 | "label": "Yellow",
105 | "pos": "7x1",
106 | "cmd": "FP=5&CL=hFFFF00&C2=hFFC800&C3=hFDFFDE"
107 | },
108 | "0xFF4AB5": {
109 | "label": "Cyan",
110 | "pos": "7x2",
111 | "cmnt": "Beech",
112 | "cmd": "FP=22"
113 | },
114 | "0xFF52AD": {
115 | "label": "Pink",
116 | "pos": "7x3",
117 | "cmd": "FP=5&CL=hFFC0CB&C2=hFFD4C0&C3=hA88C96"
118 | }
119 | }
--------------------------------------------------------------------------------
/wled00/src/dependencies/blynk/Blynk/BlynkConfig.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file BlynkConfig.h
3 | * @author Volodymyr Shymanskyy
4 | * @license This project is released under the MIT License (MIT)
5 | * @copyright Copyright (c) 2015 Volodymyr Shymanskyy
6 | * @date Jan 2015
7 | * @brief Configuration of different aspects of library
8 | *
9 | */
10 |
11 | #ifndef BlynkConfig_h
12 | #define BlynkConfig_h
13 |
14 | #include "BlynkDetectDevice.h"
15 |
16 | /***************************************************
17 | * Change these settings to match your need
18 | ***************************************************/
19 |
20 | #define BLYNK_DEFAULT_DOMAIN "blynk-cloud.com"
21 | #define BLYNK_DEFAULT_PORT 80
22 | #define BLYNK_DEFAULT_PORT_SSL 8441
23 |
24 | /***************************************************
25 | * Professional settings
26 | ***************************************************/
27 | // Library version.
28 | #define BLYNK_VERSION "0.5.3"
29 |
30 | // Heartbeat period in seconds.
31 | #ifndef BLYNK_HEARTBEAT
32 | #define BLYNK_HEARTBEAT 10
33 | #endif
34 |
35 | // Network timeout in milliseconds.
36 | #ifndef BLYNK_TIMEOUT_MS
37 | #define BLYNK_TIMEOUT_MS 2000UL
38 | #endif
39 |
40 | // Limit the amount of outgoing commands per second.
41 | #ifndef BLYNK_MSG_LIMIT
42 | #define BLYNK_MSG_LIMIT 15
43 | #endif
44 |
45 | // Limit the incoming command length.
46 | #ifndef BLYNK_MAX_READBYTES
47 | #define BLYNK_MAX_READBYTES 256
48 | #endif
49 |
50 | // Limit the outgoing command length.
51 | #ifndef BLYNK_MAX_SENDBYTES
52 | #define BLYNK_MAX_SENDBYTES 128
53 | #endif
54 |
55 | // Uncomment to use Let's Encrypt Root CA
56 | //#define BLYNK_SSL_USE_LETSENCRYPT
57 |
58 | // Uncomment to disable built-in analog and digital operations.
59 | //#define BLYNK_NO_BUILTIN
60 |
61 | // Uncomment to disable providing info about device to the server.
62 | //#define BLYNK_NO_INFO
63 |
64 | // Uncomment to enable debug prints.
65 | //#define BLYNK_DEBUG
66 |
67 | // Uncomment to force-enable 128 virtual pins
68 | //#define BLYNK_USE_128_VPINS
69 |
70 | // Uncomment to disable fancy logo
71 | //#define BLYNK_NO_FANCY_LOGO
72 |
73 | // Uncomment to enable 3D fancy logo
74 | //#define BLYNK_FANCY_LOGO_3D
75 |
76 | // Uncomment to enable experimental functions.
77 | //#define BLYNK_EXPERIMENTAL
78 |
79 | // Uncomment to disable all float/double usage
80 | //#define BLYNK_NO_FLOAT
81 |
82 | // Uncomment to switch to direct-connect mode
83 | //#define BLYNK_USE_DIRECT_CONNECT
84 |
85 |
86 | // Uncomment to append command body to header (uses more RAM)
87 | //#define BLYNK_SEND_ATOMIC
88 |
89 | // Split whole command into chunks (in bytes)
90 | //#define BLYNK_SEND_CHUNK 64
91 |
92 | // Wait after sending each chunk (in milliseconds)
93 | //#define BLYNK_SEND_THROTTLE 10
94 |
95 | #endif
96 |
--------------------------------------------------------------------------------
/wled00/src/dependencies/dmx/ESPDMX.cpp:
--------------------------------------------------------------------------------
1 | // - - - - -
2 | // ESPDMX - A Arduino library for sending and receiving DMX using the builtin serial hardware port.
3 | // ESPDMX.cpp: Library implementation file
4 | //
5 | // Copyright (C) 2015 Rick
6 | // This work is licensed under a GNU style license.
7 | //
8 | // Last change: Marcel Seerig
9 | //
10 | // Documentation and samples are available at https://github.com/Rickgg/ESP-Dmx
11 | // - - - - -
12 |
13 | /* ----- LIBRARIES ----- */
14 | #include
15 |
16 | #include "ESPDMX.h"
17 |
18 |
19 |
20 | #define dmxMaxChannel 512
21 | #define defaultMax 32
22 |
23 | #define DMXSPEED 250000
24 | #define DMXFORMAT SERIAL_8N2
25 | #define BREAKSPEED 83333
26 | #define BREAKFORMAT SERIAL_8N1
27 |
28 | bool dmxStarted = false;
29 | int sendPin = 2; //dafault on ESP8266
30 |
31 | //DMX value array and size. Entry 0 will hold startbyte
32 | uint8_t dmxData[dmxMaxChannel] = {};
33 | int chanSize;
34 |
35 |
36 | void DMXESPSerial::init() {
37 | chanSize = defaultMax;
38 |
39 | Serial1.begin(DMXSPEED);
40 | pinMode(sendPin, OUTPUT);
41 | dmxStarted = true;
42 | }
43 |
44 | // Set up the DMX-Protocol
45 | void DMXESPSerial::init(int chanQuant) {
46 |
47 | if (chanQuant > dmxMaxChannel || chanQuant <= 0) {
48 | chanQuant = defaultMax;
49 | }
50 |
51 | chanSize = chanQuant;
52 |
53 | Serial1.begin(DMXSPEED);
54 | pinMode(sendPin, OUTPUT);
55 | dmxStarted = true;
56 | }
57 |
58 | // Function to read DMX data
59 | uint8_t DMXESPSerial::read(int Channel) {
60 | if (dmxStarted == false) init();
61 |
62 | if (Channel < 1) Channel = 1;
63 | if (Channel > dmxMaxChannel) Channel = dmxMaxChannel;
64 | return(dmxData[Channel]);
65 | }
66 |
67 | // Function to send DMX data
68 | void DMXESPSerial::write(int Channel, uint8_t value) {
69 | if (dmxStarted == false) init();
70 |
71 | if (Channel < 1) Channel = 1;
72 | if (Channel > chanSize) Channel = chanSize;
73 | if (value < 0) value = 0;
74 | if (value > 255) value = 255;
75 |
76 | dmxData[Channel] = value;
77 | }
78 |
79 | void DMXESPSerial::end() {
80 | chanSize = 0;
81 | Serial1.end();
82 | dmxStarted = false;
83 | }
84 |
85 | void DMXESPSerial::update() {
86 | if (dmxStarted == false) init();
87 |
88 | //Send break
89 | digitalWrite(sendPin, HIGH);
90 | Serial1.begin(BREAKSPEED, BREAKFORMAT);
91 | Serial1.write(0);
92 | Serial1.flush();
93 | delay(1);
94 | Serial1.end();
95 |
96 | //send data
97 | Serial1.begin(DMXSPEED, DMXFORMAT);
98 | digitalWrite(sendPin, LOW);
99 | Serial1.write(dmxData, chanSize);
100 | Serial1.flush();
101 | delay(1);
102 | Serial1.end();
103 | }
104 |
105 | // Function to update the DMX bus
106 |
--------------------------------------------------------------------------------
/wled00/src/dependencies/timezone/Timezone.h:
--------------------------------------------------------------------------------
1 | /*----------------------------------------------------------------------*
2 | * Arduino Timezone Library v1.0 *
3 | * Jack Christensen Mar 2012 *
4 | * *
5 | * This work is licensed under the Creative Commons Attribution- *
6 | * ShareAlike 3.0 Unported License. To view a copy of this license, *
7 | * visit http://creativecommons.org/licenses/by-sa/3.0/ or send a *
8 | * letter to Creative Commons, 171 Second Street, Suite 300, *
9 | * San Francisco, California, 94105, USA. *
10 | *----------------------------------------------------------------------*/
11 |
12 | #ifndef Timezone_h
13 | #define Timezone_h
14 | #if ARDUINO >= 100
15 | #include
16 | #else
17 | #include
18 | #endif
19 |
20 | #include "../time/TimeLib.h" //http://www.arduino.cc/playground/Code/Time
21 |
22 | //convenient constants for dstRules
23 | enum week_t {Last, First, Second, Third, Fourth};
24 | enum dow_t {Sun=1, Mon, Tue, Wed, Thu, Fri, Sat};
25 | enum month_t {Jan=1, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec};
26 |
27 | //structure to describe rules for when daylight/summer time begins,
28 | //or when standard time begins.
29 | struct TimeChangeRule
30 | {
31 | uint8_t week; //First, Second, Third, Fourth, or Last week of the month
32 | uint8_t dow; //day of week, 1=Sun, 2=Mon, ... 7=Sat
33 | uint8_t month; //1=Jan, 2=Feb, ... 12=Dec
34 | uint8_t hour; //0-23
35 | int16_t offset; //offset from UTC in minutes
36 | };
37 |
38 | class Timezone
39 | {
40 | public:
41 | Timezone(TimeChangeRule dstStart, TimeChangeRule stdStart);
42 | Timezone(int address);
43 | time_t toLocal(time_t utc);
44 | time_t toLocal(time_t utc, TimeChangeRule **tcr);
45 | time_t toUTC(time_t local);
46 | boolean utcIsDST(time_t utc);
47 | boolean locIsDST(time_t local);
48 | void readRules(int address);
49 | void writeRules(int address);
50 |
51 | private:
52 | void calcTimeChanges(int yr);
53 | time_t toTime_t(TimeChangeRule r, int yr);
54 | TimeChangeRule _dst; //rule for start of dst or summer time for any year
55 | TimeChangeRule _std; //rule for start of standard time for any year
56 | time_t _dstUTC; //dst start for given/current year, given in UTC
57 | time_t _stdUTC; //std time start for given/current year, given in UTC
58 | time_t _dstLoc; //dst start for given/current year, given in local time
59 | time_t _stdLoc; //std time start for given/current year, given in local time
60 | };
61 | #endif
62 |
--------------------------------------------------------------------------------
/usermods/project_cars_shiftlight/wled06_usermod.ino:
--------------------------------------------------------------------------------
1 | /*
2 | * Car rev display and shift indicator for Project Cars
3 | *
4 | * This works via the UDP telemetry function. You'll need to enable it in the settings of the game.
5 | * I've had good results with settings around 5 (20 fps).
6 | *
7 | */
8 | #include "wled.h"
9 |
10 | const uint8_t PCARS_dimcolor = 20;
11 | WiFiUDP UDP;
12 | const unsigned int PCARS_localUdpPort = 5606; // local port to listen on
13 | char PCARS_packet[2048];
14 |
15 | char PCARS_tempChar[2]; // Temporary array for u16 conversion
16 |
17 | u16 PCARS_RPM;
18 | u16 PCARS_maxRPM;
19 |
20 | long PCARS_lastRead = millis() - 2001;
21 | float PCARS_rpmRatio;
22 |
23 | void PCARS_readValues() {
24 |
25 | int PCARS_packetSize = UDP.parsePacket();
26 | if (PCARS_packetSize) {
27 | int len = UDP.read(PCARS_packet, PCARS_packetSize);
28 | if (len > 0) {
29 | PCARS_packet[len] = 0;
30 | }
31 | if (len == 1367) { // Telemetry packet. Ignoring everything else.
32 | PCARS_lastRead = millis();
33 |
34 | realtimeLock(realtimeTimeoutMs, REALTIME_MODE_GENERIC);
35 | // current RPM
36 | memcpy(&PCARS_tempChar, &PCARS_packet[124], 2);
37 | PCARS_RPM = (PCARS_tempChar[1] << 8) + PCARS_tempChar[0];
38 |
39 | // max RPM
40 | memcpy(&PCARS_tempChar, &PCARS_packet[126], 2);
41 | PCARS_maxRPM = (PCARS_tempChar[1] << 8) + PCARS_tempChar[0];
42 |
43 | if (PCARS_maxRPM) {
44 | PCARS_rpmRatio = constrain((float)PCARS_RPM / (float)PCARS_maxRPM, 0, 1);
45 | } else {
46 | PCARS_rpmRatio = 0.0;
47 | }
48 | }
49 | }
50 | }
51 | void PCARS_buildcolorbars() {
52 | boolean activated = false;
53 | float ledratio = 0;
54 | uint16_t totalLen = strip.getLengthTotal();
55 |
56 | for (uint16_t i = 0; i < totalLen; i++) {
57 | if (PCARS_rpmRatio < .95 || (millis() % 100 > 70 )) {
58 |
59 | ledratio = (float)i / (float)totalLen;
60 | if (ledratio < PCARS_rpmRatio) {
61 | activated = true;
62 | } else {
63 | activated = false;
64 | }
65 | if (ledratio > 0.66) {
66 | setRealtimePixel(i, 0, 0, PCARS_dimcolor + ((255 - PCARS_dimcolor)*activated), 0);
67 | } else if (ledratio > 0.33) {
68 | setRealtimePixel(i, PCARS_dimcolor + ((255 - PCARS_dimcolor)*activated), 0, 0, 0);
69 | } else {
70 | setRealtimePixel(i, 0, PCARS_dimcolor + ((255 - PCARS_dimcolor)*activated), 0, 0);
71 | }
72 | }
73 | else {
74 | setRealtimePixel(i, 0, 0, 0, 0);
75 |
76 | }
77 | }
78 | colorUpdated(5);
79 | strip.show();
80 | }
81 |
82 | void userSetup()
83 | {
84 | UDP.begin(PCARS_localUdpPort);
85 | }
86 |
87 | void userConnected()
88 | {
89 | // new wifi, who dis?
90 | }
91 |
92 | void userLoop()
93 | {
94 | PCARS_readValues();
95 | if (PCARS_lastRead > millis() - 2000) {
96 | PCARS_buildcolorbars();
97 | }
98 | }
--------------------------------------------------------------------------------
6 |
--------------------------------------------------------------------------------
/pio-scripts/set_version.py:
--------------------------------------------------------------------------------
1 | Import('env')
2 | import json
3 |
4 | PACKAGE_FILE = "package.json"
5 |
6 | with open(PACKAGE_FILE, "r") as package:
7 | version = json.load(package)["version"]
8 | env.Append(BUILD_FLAGS=[f"-DWLED_VERSION={version}"])
9 |
--------------------------------------------------------------------------------
/usermods/TTGO-T-Display/platformio_override.ini:
--------------------------------------------------------------------------------
1 | [env:esp32dev]
2 | build_flags = ${common.build_flags_esp32}
3 | ; PIN defines - uncomment and change, if needed:
4 | ; -D LEDPIN=2
5 | -D BTNPIN=35
6 | ; -D IRPIN=4
7 | ; -D RLYPIN=12
8 | ; -D RLYMDE=1
9 |
--------------------------------------------------------------------------------
/usermods/word-clock-matrix/readme.md:
--------------------------------------------------------------------------------
1 | ## Word clock usermod
2 |
3 | By @bwente
4 |
5 | See https://www.hackster.io/bwente/word-clock-with-just-two-components-073834 for the hardware guide!
6 | Includes a customizable feature to lower the brightness at night.
7 |
--------------------------------------------------------------------------------
/wled00/src/dependencies/ws2812fx/readme.txt:
--------------------------------------------------------------------------------
1 | https://github.com/kitesurfer1404/WS2812FX/
2 |
3 | The WS2812FX implementation was heavily altered and differs from its master branch.
4 | Due to regular changes to the library code it is kept in the source dir for now.
5 |
--------------------------------------------------------------------------------
/tools/WLED_ESP32_16MB.csv:
--------------------------------------------------------------------------------
1 | # Name, Type, SubType, Offset, Size, Flags
2 | nvs, data, nvs, 0x9000, 0x5000,
3 | otadata, data, ota, 0xe000, 0x2000,
4 | app0, app, ota_0, 0x10000, 0x200000,
5 | app1, app, ota_1, 0x210000,0x200000,
6 | spiffs, data, spiffs, 0x410000,0xBE0000,
--------------------------------------------------------------------------------
/tools/WLED_ESP32_8MB.csv:
--------------------------------------------------------------------------------
1 | # Name, Type, SubType, Offset, Size, Flags
2 | nvs, data, nvs, 0x9000, 0x5000,
3 | otadata, data, ota, 0xe000, 0x2000,
4 | app0, app, ota_0, 0x10000, 0x200000,
5 | app1, app, ota_1, 0x210000,0x200000,
6 | spiffs, data, spiffs, 0x410000,0x3F0000,
--------------------------------------------------------------------------------
/tools/WLED_ESP32_4MB_1MB_FS.csv:
--------------------------------------------------------------------------------
1 | # Name, Type, SubType, Offset, Size, Flags
2 | nvs, data, nvs, 0x9000, 0x5000,
3 | otadata, data, ota, 0xe000, 0x2000,
4 | app0, app, ota_0, 0x10000, 0x180000,
5 | app1, app, ota_1, 0x190000,0x180000,
6 | spiffs, data, spiffs, 0x310000,0xF0000,
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .pio
2 | .cache
3 | .pioenvs
4 | .piolibdeps
5 | .vscode
6 | !.vscode/extensions.json
7 | /wled00/Release
8 | /wled00/extLibs
9 | /platformio_override.ini
10 | /wled00/my_config.h
11 | /build_output
12 | .DS_Store
13 | .gitignore
14 | .clang-format
15 | node_modules
16 | .idea
17 | .direnv
18 |
--------------------------------------------------------------------------------
/pio-scripts/user_config_copy.py:
--------------------------------------------------------------------------------
1 | Import('env')
2 | import os
3 | import shutil
4 |
5 | # copy WLED00/my_config_sample.h to WLED00/my_config.h
6 | if os.path.isfile("wled00/my_config.h"):
7 | print ("*** use existing my_config.h ***")
8 | else:
9 | shutil.copy("wled00/my_config_sample.h", "wled00/my_config.h")
10 |
--------------------------------------------------------------------------------
/usermods/BH1750_v2/usermods_list.cpp:
--------------------------------------------------------------------------------
1 | #include "wled.h"
2 | /*
3 | * Register your v2 usermods here!
4 | */
5 | #ifdef USERMOD_BH1750
6 | #include "../usermods/BH1750_v2/usermod_BH1750.h"
7 | #endif
8 |
9 | void registerUsermods()
10 | {
11 | #ifdef USERMOD_BH1750
12 | usermods.add(new Usermod_BH1750());
13 | #endif
14 | }
15 |
--------------------------------------------------------------------------------
/usermods/RTC/readme.md:
--------------------------------------------------------------------------------
1 | # DS1307/DS3231 Real time clock
2 |
3 | Gets the time from I2C RTC module on boot. This allows clocks to operate e.g. if temporarily no WiFi is available.
4 | The stored time is updated each time NTP is synced.
5 |
6 | ## Installation
7 |
8 | Add the build flag `-D USERMOD_RTC` to your platformio environment.
9 |
--------------------------------------------------------------------------------
/pio-scripts/strip-floats.py:
--------------------------------------------------------------------------------
1 | Import('env')
2 |
3 | #
4 | # Dump build environment (for debug)
5 | #print env.Dump()
6 | #
7 |
8 | flags = " ".join(env['LINKFLAGS'])
9 | flags = flags.replace("-u _printf_float", "")
10 | flags = flags.replace("-u _scanf_float", "")
11 | newflags = flags.split()
12 |
13 | env.Replace(
14 | LINKFLAGS=newflags
15 | )
--------------------------------------------------------------------------------
/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Storage.hpp:
--------------------------------------------------------------------------------
1 | #pragma once
2 |
3 | namespace AsyncMqttClientInternals {
4 | struct PendingPubRel {
5 | uint16_t packetId;
6 | };
7 |
8 | struct PendingAck {
9 | uint8_t packetType;
10 | uint8_t headerFlag;
11 | uint16_t packetId;
12 | };
13 | } // namespace AsyncMqttClientInternals
14 |
--------------------------------------------------------------------------------
/pio-scripts/obj-dump.py:
--------------------------------------------------------------------------------
1 | # Little convenience script to get an object dump
2 |
3 | Import('env')
4 |
5 | def obj_dump_after_elf(source, target, env):
6 | print("Create firmware.asm")
7 | env.Execute("xtensa-lx106-elf-objdump "+ "-D " + str(target[0]) + " > "+ "${PROGNAME}.asm")
8 |
9 | env.AddPostAction("$BUILD_DIR/${PROGNAME}.elf", [obj_dump_after_elf])
10 |
--------------------------------------------------------------------------------
/usermods/SN_Photoresistor/usermods_list.cpp:
--------------------------------------------------------------------------------
1 | #include "wled.h"
2 | /*
3 | * Register your v2 usermods here!
4 | */
5 | #ifdef USERMOD_SN_PHOTORESISTOR
6 | #include "../usermods/SN_Photoresistor/usermod_sn_photoresistor.h"
7 | #endif
8 |
9 | void registerUsermods()
10 | {
11 | #ifdef USERMOD_SN_PHOTORESISTOR
12 | usermods.add(new Usermod_SN_Photoresistor());
13 | #endif
14 | }
--------------------------------------------------------------------------------
/.gitpod.yml:
--------------------------------------------------------------------------------
1 | tasks:
2 | - command: platformio run
3 |
4 | image:
5 | file: .gitpod.Dockerfile
6 |
7 | vscode:
8 | extensions:
9 | - ms-vscode.cpptools@0.26.3:u3GsZ5PK12Ddr79vh4TWgQ==
10 | - eamodio.gitlens@10.2.1:e0IYyp0efFqVsrZwsIe8CA==
11 | - Atishay-Jain.All-Autocomplete@0.0.23:fbZNfSpnd8XkAHGfAPS2rA==
12 | - 2gua.rainbow-brackets@0.0.6:Tbu8dTz0i+/bgcKQTQ5b8g==
13 |
--------------------------------------------------------------------------------
/tools/multi-update.cmd:
--------------------------------------------------------------------------------
1 | @echo off
2 | SETLOCAL
3 | SET FWPATH=c:\path\to\your\WLED\build_output\firmware
4 | GOTO ESPS
5 |
6 | :UPDATEONE
7 | IF NOT EXIST %FWPATH%\%2 GOTO SKIP
8 | ping -w 1000 -n 1 %1 | find "TTL=" || GOTO SKIP
9 | ECHO Updating %1
10 | curl -s -F "update=@%FWPATH%/%2" %1/update >nul
11 | :SKIP
12 | GOTO:EOF
13 |
14 | :ESPS
15 | call :UPDATEONE 192.168.x.x firmware.bin
16 | call :UPDATEONE ....
17 |
--------------------------------------------------------------------------------
/usermods/EXAMPLE_v2/readme.md:
--------------------------------------------------------------------------------
1 | # Usermods API v2 example usermod
2 |
3 | In this usermod file you can find the documentation on how to take advantage of the new version 2 usermods!
4 |
5 | ## Installation
6 |
7 | Copy `usermod_v2_example.h` to the wled00 directory.
8 | Uncomment the corresponding lines in `usermods_list.cpp` and compile!
9 | _(You shouldn't need to actually install this, it does nothing useful)_
10 |
11 |
--------------------------------------------------------------------------------
/wled00/usermod_v2_empty.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 |
3 | #include "wled.h"
4 |
5 | //This is an empty v2 usermod template. Please see the file usermod_v2_example.h in the EXAMPLE_v2 usermod folder for documentation on the functions you can use!
6 |
7 | class UsermodRenameMe : public Usermod {
8 | private:
9 |
10 | public:
11 | void setup() {
12 |
13 | }
14 |
15 | void loop() {
16 |
17 | }
18 | };
--------------------------------------------------------------------------------
/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/Packet.hpp:
--------------------------------------------------------------------------------
1 | #pragma once
2 |
3 | namespace AsyncMqttClientInternals {
4 | class Packet {
5 | public:
6 | virtual ~Packet() {}
7 |
8 | virtual void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) = 0;
9 | virtual void parsePayload(char* data, size_t len, size_t* currentBytePosition) = 0;
10 | };
11 | } // namespace AsyncMqttClientInternals
12 |
--------------------------------------------------------------------------------
/tools/multi-update.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | FWPATH=/path/to/your/WLED/build_output/firmware
3 |
4 | update_one() {
5 | if [ -f $FWPATH/$2 ]; then
6 | ping -c 1 $1 >/dev/null
7 | PINGRESULT=$?
8 | if [ $PINGRESULT -eq 0 ]; then
9 | echo Updating $1
10 | curl -s -F "update=@${FWPATH}/$2" $1/update >/dev/null
11 | return 0
12 | fi
13 | return 1
14 | fi
15 | }
16 |
17 | update_one 192.168.x.x firmware.bin
18 | update_one 192.168.x.x firmware.bin
19 | # ...
--------------------------------------------------------------------------------
/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/DisconnectReasons.hpp:
--------------------------------------------------------------------------------
1 | #pragma once
2 |
3 | enum class AsyncMqttClientDisconnectReason : int8_t {
4 | TCP_DISCONNECTED = 0,
5 |
6 | MQTT_UNACCEPTABLE_PROTOCOL_VERSION = 1,
7 | MQTT_IDENTIFIER_REJECTED = 2,
8 | MQTT_SERVER_UNAVAILABLE = 3,
9 | MQTT_MALFORMED_CREDENTIALS = 4,
10 | MQTT_NOT_AUTHORIZED = 5,
11 |
12 | ESP8266_NOT_ENOUGH_SPACE = 6,
13 |
14 | TLS_BAD_FINGERPRINT = 7
15 | };
16 |
--------------------------------------------------------------------------------
/wled00/src/dependencies/network/Network.h:
--------------------------------------------------------------------------------
1 | #ifdef ESP8266
2 | #include