From 17fdb4f5c90a7f5b6fb5c21f8e4378f170e385f4 Mon Sep 17 00:00:00 2001 From: Robin Meis Date: Thu, 1 Aug 2024 19:49:47 +0200 Subject: [PATCH 01/28] Allow lower values for touch threshold --- wled00/cfg.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wled00/cfg.cpp b/wled00/cfg.cpp index f9a94e228..369ddada0 100644 --- a/wled00/cfg.cpp +++ b/wled00/cfg.cpp @@ -296,7 +296,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) { #ifdef SOC_TOUCH_VERSION_2 // ESP32 S2 and S3 have a function to check touch state but need to attach an interrupt to do so else { - touchAttachInterrupt(btnPin[s], touchButtonISR, 256 + (touchThreshold << 4)); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000) + touchAttachInterrupt(btnPin[s], touchButtonISR, touchThreshold << 4); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000) } #endif } From 96c7716d3efb86254dfbd0e1b3febcdc1b8a928a Mon Sep 17 00:00:00 2001 From: jdiamond Date: Thu, 8 Aug 2024 03:13:33 +0000 Subject: [PATCH 02/28] Added a usermod for interacting with BLE Pixels Dice. --- usermods/pixels_dice_tray/README.md | 252 +++++++++ .../WLED_ESP32_4MB_64KB_FS.csv | 6 + usermods/pixels_dice_tray/dice_state.h | 76 +++ .../pixels_dice_tray/generate_roll_info.py | 230 ++++++++ usermods/pixels_dice_tray/images/effect.webp | Bin 0 -> 14460 bytes usermods/pixels_dice_tray/images/info.webp | Bin 0 -> 24412 bytes .../pixels_dice_tray/images/roll_plot.png | Bin 0 -> 10025 bytes usermods/pixels_dice_tray/images/status.webp | Bin 0 -> 24080 bytes usermods/pixels_dice_tray/led_effects.h | 124 ++++ .../mqtt_client/mqtt_logger.py | 104 ++++ .../mqtt_client/mqtt_plotter.py | 69 +++ .../mqtt_client/requirements.txt | 2 + usermods/pixels_dice_tray/pixels_dice_tray.h | 535 ++++++++++++++++++ .../platformio_override.ini.sample | 114 ++++ usermods/pixels_dice_tray/roll_info.h | 107 ++++ usermods/pixels_dice_tray/tft_menu.h | 479 ++++++++++++++++ wled00/FX.cpp | 7 +- wled00/FX.h | 2 +- wled00/const.h | 1 + wled00/pin_manager.h | 3 +- wled00/usermods_list.cpp | 8 + 21 files changed, 2115 insertions(+), 4 deletions(-) create mode 100644 usermods/pixels_dice_tray/README.md create mode 100644 usermods/pixels_dice_tray/WLED_ESP32_4MB_64KB_FS.csv create mode 100644 usermods/pixels_dice_tray/dice_state.h create mode 100644 usermods/pixels_dice_tray/generate_roll_info.py create mode 100644 usermods/pixels_dice_tray/images/effect.webp create mode 100644 usermods/pixels_dice_tray/images/info.webp create mode 100644 usermods/pixels_dice_tray/images/roll_plot.png create mode 100644 usermods/pixels_dice_tray/images/status.webp create mode 100644 usermods/pixels_dice_tray/led_effects.h create mode 100644 usermods/pixels_dice_tray/mqtt_client/mqtt_logger.py create mode 100644 usermods/pixels_dice_tray/mqtt_client/mqtt_plotter.py create mode 100644 usermods/pixels_dice_tray/mqtt_client/requirements.txt create mode 100644 usermods/pixels_dice_tray/pixels_dice_tray.h create mode 100644 usermods/pixels_dice_tray/platformio_override.ini.sample create mode 100644 usermods/pixels_dice_tray/roll_info.h create mode 100644 usermods/pixels_dice_tray/tft_menu.h diff --git a/usermods/pixels_dice_tray/README.md b/usermods/pixels_dice_tray/README.md new file mode 100644 index 000000000..5440b225c --- /dev/null +++ b/usermods/pixels_dice_tray/README.md @@ -0,0 +1,252 @@ +# A mod for using Pixel Dice with ESP32S3 boards + +A usermod to connect to and handle rolls from [Pixels Dice](https://gamewithpixels.com/). WLED acts as both an display controller, and a gateway to connect the die to the Wifi network. + +High level features: + +* Several LED effects that respond to die rolls + * Effect color and parameters can be modified like any other effect + * Different die can be set to control different segments +* An optional GUI on a TFT screen with custom button controls + * Gives die connection and roll status + * Can do basic LED effect controls + * Can display custom info for different roll types (ie. RPG stats/spell info) +* Publish MQTT events from die rolls + * Also report the selected roll type +* Control settings through the WLED web + +See for a write up of the design process of the hardware and software I used this with. + +I also set up a custom web installer for the usermod at for 8MB ESP32-S3 boards. + +## Table of Contents + + +* [Demos](#demos) + + [TFT GUI](#tft-gui) + + [Multiple Die Controlling Different Segments](#multiple-die-controlling-different-segments) +* [Hardware](#hardware) +* [Library used](#library-used) +* [Compiling](#compiling) + + [platformio_override.ini](#platformio_overrideini) + + [Manual platformio.ini changes](#manual-platformioini-changes) +* [Configuration](#configuration) + + [Controlling Dice Connections](#controlling-dice-connections) + + [Controlling Effects](#controlling-effects) + - [DieSimple](#diesimple) + - [DiePulse](#diepulse) + - [DieCheck](#diecheck) +* [TFT GUI](#tft-gui-1) + + [Status](#status) + + [Effect Menu](#effect-menu) + + [Roll Info](#roll-info) +* [MQTT](#mqtt) +* [Potential Modifications and Additional Features](#potential-modifications-and-additional-features) +* [ESP32 Issues](#esp32-issues) + + + +## Demos + + +### TFT GUI +[![Watch the video](https://img.youtube.com/vi/VNsHq1TbiW8/0.jpg)](https://youtu.be/VNsHq1TbiW8) + + +### Multiple Die Controlling Different Segments +[![Watch the video](https://img.youtube.com/vi/oCDr44C-qwM/0.jpg)](https://youtu.be/oCDr44C-qwM) + + +## Hardware + +The main purpose of this mod is to support [Pixels Dice](https://gamewithpixels.com/). The board acts as a BLE central for the dice acting as peripherals. While any ESP32 variant with BLE capabilities should be able to support this usermod, in practice I found that the original ESP32 did not work. See [ESP32 Issues](#esp32-issues) for a deeper dive. + +The only other ESP32 variant I tested was the ESP32-S3, which worked without issue. While there's still concern over the contention between BLE and WiFi for the radio, I haven't noticed any performance impact in practice. The only special behavior that was needed was setting `noWifiSleep = false;` to allow the OS to sleep the WiFi when the BLE is active. + +The basic build of this usermod doesn't require any special hardware. However, the LCD status GUI was specifically designed for the [LILYGO T-QT Pro](https://www.lilygo.cc/products/t-qt-pro). + +It should be relatively easy to support other displays, though the positioning of the text may need to be adjusted. + + +## Library used + +[axlan/pixels-dice-interface](https://github.com/axlan/arduino-pixels-dice) + +Optional: [Bodmer/TFT_eSPI](https://github.com/Bodmer/TFT_eSPI) + + +## Compiling + + +### platformio_override.ini + +Copy and update the example `platformio_override.ini.sample` to the root directory of your particular build (renaming it `platformio_override.ini`). +This file should be placed in the same directory as `platformio.ini`. This file is set up for the [LILYGO T-QT Pro](https://www.lilygo.cc/products/t-qt-pro). Specifically, the 8MB flash version. See the next section for notes on setting the build flags. For other boards, you may want to use a different environment as the basis. + + +### Manual platformio.ini changes + +Using the `platformio_override.ini.sample` as a reference, you'll need to update the `build_flags` and `lib_deps` of the target you're building for. + +If you don't need the TFT GUI, you just need to add + + +```ini +... +build_flags = + ... + -D USERMOD_PIXELS_DICE_TRAY ;; Enables this UserMod +lib_deps = + ... + ESP32 BLE Arduino + axlan/pixels-dice-interface @ 1.2.0 +... +``` + +For the TFT support you'll need to add `Bodmer/TFT_eSPI` to `lib_deps`, and all of the required TFT parameters to `build_flags` (see `platformio_override.ini.sample`). + +Save the `platformio.ini` file, and perform the desired build. + + +## Configuration + +In addition to configuring which dice to connect to, this mod uses a lot of the built in WLED features: +* The LED segments, effects, and customization parameters +* The buttons for the UI +* The MQTT settings for reporting the dice rolls + + +### Controlling Dice Connections + +**NOTE:** To configure the die itself (set its name, the die LEDs, etc.), you still need to use the Pixels Dice phone App. + +The usermods settings page has the configuration for controlling the dice and the display: + * Ble Scan Duration - The time to look for BLE broadcasts before taking a break + * Rotation - If display used, set this parameter to rotate the display. + +The main setting here though are the Die 0 and 1 settings. A slot is disabled if it's left blank. Putting the name of a die will make that slot only connect to die with that name. Alteratively, if the name is set to `*` the slot will use the first unassociated die it sees. Saving the configuration while a wildcard slot is connected to a die will replace the `*` with that die's name. + +**NOTE:** The slot a die is in is important since that's how they're identified for controlling LED effects. Effects can be set to respond to die 0, 1, or any. + +The configuration also includes the pins configured in the TFT build flags. These are just so the UI recognizes that these pins are being used. The [Bodmer/TFT_eSPI](https://github.com/Bodmer/TFT_eSPI) requires that these are set at build time and changing these values is ignored. + + +### Controlling Effects + +The die effects for rolls take advantage of most of the normal WLED effect features: . + +If you have different segments, they can have different effects driven by the same die, or different dice. + + +#### DieSimple +Turn off LEDs while rolling, than light up solid LEDs in proportion to die roll. + +* Color 1 - Selects the "good" color that increases based on the die roll +* Color 2 - Selects the "background" color for the rest of the segment +* Custom 1 - Sets which die should control this effect. If the value is greater then 1, it will respond to both dice. + + +#### DiePulse +Play `breath` effect while rolling, than apply `blend` effect in proportion to die roll. + +* Color 1 - See `breath` and `blend` +* Color 2 - Selects the "background" color for the rest of the segment +* Palette - See `breath` and `blend` +* Custom 1 - Sets which die should control this effect. If the value is greater then 1, it will respond to both dice. + + +#### DieCheck +Play `running` effect while rolling, than apply `glitter` effect if roll passes threshold, or `gravcenter` if roll is below. + +* Color 1 - See `glitter` and `gravcenter`, used as first color for `running` +* Color 2 - See `glitter` and `gravcenter` +* Color 3 - Used as second color for `running` +* Palette - See `glitter` and `gravcenter` +* Custom 1 - Sets which die should control this effect. If the value is greater then 1, it will respond to both dice. +* Custom 2 - Sets the threshold for success animation. For example if 10, success plays on rolls of 10 or above. + + +## TFT GUI + +The optional TFT GUI currently supports 3 "screens": +1. Status +2. Effect Control +3. Roll Info + +Double pressing the right button goes forward through the screens, and double pressing left goes back (with rollover). + + +### Status +Status Menu + +Shows the status of each die slot (0 on top and 1 on the bottom). + +If a die is connected, its roll stats and battery status are shown. The rolls will continue to be tracked even when viewing other screens. + +Long press either button to clear the roll stats. + + +### Effect Menu +Effect Menu + +Allows limited customization of the die effect for the currently selected LED segment. + +The left button moves the cursor (blue box) up and down the options for the current field. + +The right button updates the value for the field. + +The first field is the effect. Updating it will switch between the die effects. + +The DieCheck effect has an additional field "PASS". Pressing the right button on this field will copy the current face up value from the most recently rolled die. + +Long pressing either value will set the effect parameters (color, palette, controlling dice, etc.) to a default set of values. + + +### Roll Info +Roll Info Menu + +Sets the "roll type" reported by MQTT events and can show additional info. + +Pressing the right button goes forward through the rolls, and double pressing left goes back (with rollover). + +The names and info for the rolls are generated from the `usermods/pixels_dice_tray/generate_roll_info.py` script. It updates `usermods/pixels_dice_tray/roll_info.h` with code generated from a simple markdown language. + + +## MQTT + +See for general MQTT configuration for WLED. + +The usermod produces two types of events + +* `$mqttDeviceTopic/dice/roll` - JSON that reports each die roll event with the following keys. + - name - The name of the die that triggered the event + - state - Integer indicating the die state `[UNKNOWN = 0, ON_FACE = 1, HANDLING = 2, ROLLING = 3, CROOKED = 4]` + - val - The value on the die's face. For d20 1-20 + - time - The uptime timestamp the roll was received in milliseconds. +* `$mqttDeviceTopic/dice/roll_label` - A string that indicates the roll type selected in the [Roll Info](#roll-info) TFT menu. + +Where `$mqttDeviceTopic` is the topic set in the WLED MQTT configuration. + +Events can be logged to a CSV file using the script `usermods/pixels_dice_tray/mqtt_client/mqtt_logger.py`. These can then be used to generate interactive HTML plots with `usermods/pixels_dice_tray/mqtt_client/mqtt_plotter.py`. + +Roll Plot + + +## Potential Modifications and Additional Features + +This usermod is in support of a particular dice box project, but it would be fairly straightforward to extend for other applications. +* Add more dice - There's no reason that several more dice slots couldn't be allowed. In addition LED effects that use multiple dice could be added (e.g. a contested roll). +* Better support for die other then d20's. There's a few places where I assume the die is a d20. It wouldn't be that hard to support arbitrary die sizes. +* TFT Menu - The menu system is pretty extensible. I put together some basic things I found useful, and was mainly limited by the screen size. +* Die controlled UI - I originally planned to make an alternative UI that used the die directly. You'd press a button, and the current face up on the die would trigger an action. This was an interesting idea, but didn't seem to practical since I could more flexibly reproduce this by responding to the dice MQTT events. + + +## ESP32 Issues + +I really wanted to have this work on the original ESP32 boards to lower the barrier to entry, but there were several issues. + +First, the BLE stack requires a lot of flash. I had to make a special partitioning plan `WLED_ESP32_4MB_64KB_FS.csv` to even fit the build on 4MB devices. This only has 64KB of file system space, which is limited, but still functional. + +The bigger issue is that the build consistently crashes if the BLE scan task starts up. It's a bit unclear to me exactly what is failing since the backtrace is showing an exception in `new[]` memory allocation in the UDP stack. There appears to be a ton of heap available, so my guess is that this is a synchronization issue of some sort from the tasks running in parallel. I tried messing with the task core affinity a bit but didn't make much progress. It's not really clear what difference between the ESP32S3 and ESP32 would cause this difference. + +At the end of the day, its generally not advised to run the BLE and Wifi at the same time anyway (though it appears to work without issue on the ESP32S3). Probably the best path forward would be to switch between them. This would actually not be too much of an issue, since discovering and getting data from the die should be possible to do in bursts (at least in theory). diff --git a/usermods/pixels_dice_tray/WLED_ESP32_4MB_64KB_FS.csv b/usermods/pixels_dice_tray/WLED_ESP32_4MB_64KB_FS.csv new file mode 100644 index 000000000..ffa509e6d --- /dev/null +++ b/usermods/pixels_dice_tray/WLED_ESP32_4MB_64KB_FS.csv @@ -0,0 +1,6 @@ +# Name, Type, SubType, Offset, Size, Flags +nvs, data, nvs, 0x9000, 0x5000, +otadata, data, ota, 0xe000, 0x2000, +app0, app, ota_0, 0x10000, 0x1F0000, +app1, app, ota_1, 0x200000,0x1F0000, +spiffs, data, spiffs, 0x3F0000,0x10000, \ No newline at end of file diff --git a/usermods/pixels_dice_tray/dice_state.h b/usermods/pixels_dice_tray/dice_state.h new file mode 100644 index 000000000..eee4759fd --- /dev/null +++ b/usermods/pixels_dice_tray/dice_state.h @@ -0,0 +1,76 @@ +/** + * Structs for passing around usermod state + */ +#pragma once + +#include // https://github.com/axlan/arduino-pixels-dice + +/** + * Here's how the rolls are tracked in this usermod. + * 1. The arduino-pixels-dice library reports rolls and state mapped to + * PixelsDieID. + * 2. The "configured_die_names" sets which die to connect to and their order. + * 3. The rest of the usermod references the die by this order (ie. the LED + * effect is triggered for rolls for die 0). + */ + +static constexpr size_t MAX_NUM_DICE = 2; +static constexpr uint8_t INVALID_ROLL_VALUE = 0xFF; + +/** + * The state of the connected die, and new events since the last update. + */ +struct DiceUpdate { + // The vectors to hold results queried from the library + // Since vectors allocate data, it's more efficient to keep reusing an instance + // instead of declaring them on the stack. + std::vector dice_list; + pixels::RollUpdates roll_updates; + pixels::BatteryUpdates battery_updates; + // The PixelsDieID for each dice index. 0 if the die isn't connected. + // The ordering here matches configured_die_names. + std::array connected_die_ids{0, 0}; +}; + +struct DiceSettings { + // The mapping of dice names, to the index of die used for effects (ie. The + // die named "Cat" is die 0). BLE discovery will stop when all the dice are + // found. The die slot is disabled if the name is empty. If the name is "*", + // the slot will use the first unassociated die it sees. + std::array configured_die_names{"*", "*"}; + // A label set to describe the next die roll. Index into GetRollName(). + uint8_t roll_label = INVALID_ROLL_VALUE; +}; + +// These are updated in the main loop, but accessed by the effect functions as +// well. My understand is that both of these accesses should be running on the +// same "thread/task" since WLED doesn't directly create additional threads. The +// exception would be network callbacks and interrupts, but I don't believe +// these accesses are triggered by those. If synchronization was needed, I could +// look at the example in `requestJSONBufferLock()`. +std::array last_die_events; + +static pixels::RollEvent GetLastRoll() { + pixels::RollEvent last_roll; + for (const auto& event : last_die_events) { + if (event.timestamp > last_roll.timestamp) { + last_roll = event; + } + } + return last_roll; +} + +/** + * Returns true if the container has an item that matches the value. + */ +template +static bool Contains(const C& container, T value) { + return std::find(container.begin(), container.end(), value) != + container.end(); +} + +// These aren't known until runtime since they're being added dynamically. +static uint8_t FX_MODE_SIMPLE_D20 = 0xFF; +static uint8_t FX_MODE_PULSE_D20 = 0xFF; +static uint8_t FX_MODE_CHECK_D20 = 0xFF; +std::array DIE_LED_MODES = {0xFF, 0xFF, 0xFF}; diff --git a/usermods/pixels_dice_tray/generate_roll_info.py b/usermods/pixels_dice_tray/generate_roll_info.py new file mode 100644 index 000000000..589597086 --- /dev/null +++ b/usermods/pixels_dice_tray/generate_roll_info.py @@ -0,0 +1,230 @@ +''' +File for generating roll labels and info text for the InfoMenu. + +Uses a very limited markdown language for styling text. +''' +import math +from pathlib import Path +import re +from textwrap import indent + +# Variables for calculating values in info text +CASTER_LEVEL = 9 +SPELL_ABILITY_MOD = 6 +BASE_ATK_BONUS = 6 +SIZE_BONUS = 1 +STR_BONUS = 2 +DEX_BONUS = -1 + +# TFT library color values +TFT_BLACK =0x0000 +TFT_NAVY =0x000F +TFT_DARKGREEN =0x03E0 +TFT_DARKCYAN =0x03EF +TFT_MAROON =0x7800 +TFT_PURPLE =0x780F +TFT_OLIVE =0x7BE0 +TFT_LIGHTGREY =0xD69A +TFT_DARKGREY =0x7BEF +TFT_BLUE =0x001F +TFT_GREEN =0x07E0 +TFT_CYAN =0x07FF +TFT_RED =0xF800 +TFT_MAGENTA =0xF81F +TFT_YELLOW =0xFFE0 +TFT_WHITE =0xFFFF +TFT_ORANGE =0xFDA0 +TFT_GREENYELLOW =0xB7E0 +TFT_PINK =0xFE19 +TFT_BROWN =0x9A60 +TFT_GOLD =0xFEA0 +TFT_SILVER =0xC618 +TFT_SKYBLUE =0x867D +TFT_VIOLET =0x915C + + +class Size: + def __init__(self, w, h): + self.w = w + self.h = h + + +# Font 1 6x8 +# Font 2 12x16 +CHAR_SIZE = { + 1: Size(6, 8), + 2: Size(12, 16), +} + +SCREEN_SIZE = Size(128, 128) + +# Calculates distance for short range spell. +def short_range() -> int: + return 25 + 5 * CASTER_LEVEL + +# Entries in markdown language. +# Parameter 0 of the tuple is the roll name +# Parameter 1 of the tuple is the roll info. +# The text will be shown when the roll type is selected. An error will be raised +# if the text would unexpectedly goes past the end of the screen. There are a +# few styling parameters that need to be on their own lines: +# $COLOR - The color for the text +# $SIZE - Sets the text size (see CHAR_SIZE) +# $WRAP - By default text won't wrap and generate an error. This enables text wrapping. Lines will wrap mid-word. +ENTRIES = [ + tuple(["Barb Chain", f'''\ +$COLOR({TFT_RED}) +Barb Chain +$COLOR({TFT_WHITE}) +Atk/CMD {BASE_ATK_BONUS + SPELL_ABILITY_MOD} +Range: {short_range()} +$WRAP(1) +$SIZE(1) +Summon {1 + math.floor((CASTER_LEVEL-1)/3)} chains. Make a melee atk 1d6 or a trip CMD=AT. On a hit make Will save or shaken 1d4 rnds. +''']), + tuple(["Saves", f'''\ +$COLOR({TFT_GREEN}) +Saves +$COLOR({TFT_WHITE}) +FORT 8 +REFLEX 8 +WILL 9 +''']), + tuple(["Skill", f'''\ +Skill +''']), + tuple(["Attack", f'''\ +Attack +Melee +{BASE_ATK_BONUS + SIZE_BONUS + STR_BONUS} +Range +{BASE_ATK_BONUS + SIZE_BONUS + DEX_BONUS} +''']), + tuple(["Cure", f'''\ +Cure +Lit 1d8+{min(5, CASTER_LEVEL)} +Mod 2d8+{min(10, CASTER_LEVEL)} +Ser 3d8+{min(15, CASTER_LEVEL)} +''']), + tuple(["Concentrate", f'''\ +Concentrat ++{CASTER_LEVEL + SPELL_ABILITY_MOD} +$SIZE(1) +Defensive 15+2*SP_LV +Dmg 10+DMG+SP_LV +Grapple 10+CMB+SP_LV +''']), +] + +RE_SIZE = re.compile(r'\$SIZE\(([0-9])\)') +RE_COLOR = re.compile(r'\$COLOR\(([0-9]+)\)') +RE_WRAP = re.compile(r'\$WRAP\(([0-9])\)') + +END_HEADER_TXT = '// GENERATED\n' + +def main(): + roll_info_file = Path(__file__).parent / 'roll_info.h' + old_contents = open(roll_info_file, 'r').read() + + end_header = old_contents.index(END_HEADER_TXT) + + with open(roll_info_file, 'w') as fd: + fd.write(old_contents[:end_header+len(END_HEADER_TXT)]) + + for key, entry in enumerate(ENTRIES): + size = 2 + wrap = False + y_loc = 0 + results = [] + for line in entry[1].splitlines(): + if line.startswith('$'): + m_size = RE_SIZE.match(line) + m_color = RE_COLOR.match(line) + m_wrap = RE_WRAP.match(line) + if m_size: + size = int(m_size.group(1)) + results.append(f'tft.setTextSize({size});') + elif m_color: + results.append( + f'tft.setTextColor({int(m_color.group(1))});') + elif m_wrap: + wrap = bool(int(m_wrap.group(1))) + else: + print(f'Entry {key} unknown modifier "{line}".') + exit(1) + else: + max_chars_per_line = math.floor( + SCREEN_SIZE.w / CHAR_SIZE[size].w) + if len(line) > max_chars_per_line: + if wrap: + while len(line) > max_chars_per_line: + results.append( + f'tft.println("{line[:max_chars_per_line]}");') + line = line[max_chars_per_line:].lstrip() + y_loc += CHAR_SIZE[size].h + else: + print(f'Entry {key} line "{line}" too long.') + exit(1) + + if len(line) > 0: + y_loc += CHAR_SIZE[size].h + results.append(f'tft.println("{line}");') + + if y_loc > SCREEN_SIZE.h: + print( + f'Entry {key} line "{line}" went past bottom of screen.') + exit(1) + + result = indent('\n'.join(results), ' ') + + fd.write(f'''\ +static void PrintRoll{key}() {{ +{result} +}} + +''') + + results = [] + for key, entry in enumerate(ENTRIES): + results.append(f'''\ +case {key}: + return "{entry[0]}";''') + + cases = indent('\n'.join(results), ' ') + + fd.write(f'''\ +static const char* GetRollName(uint8_t key) {{ + switch (key) {{ +{cases} + }} + return ""; +}} + +''') + + results = [] + for key, entry in enumerate(ENTRIES): + results.append(f'''\ +case {key}: + PrintRoll{key}(); + return;''') + + cases = indent('\n'.join(results), ' ') + + fd.write(f'''\ +static void PrintRollInfo(uint8_t key) {{ + tft.setTextColor(TFT_WHITE); + tft.setCursor(0, 0); + tft.setTextSize(2); + switch (key) {{ +{cases} + }} + tft.setTextColor(TFT_RED); + tft.setCursor(0, 60); + tft.println("Unknown"); +}} + +''') + + fd.write(f'static constexpr size_t NUM_ROLL_INFOS = {len(ENTRIES)};\n') + + +main() diff --git a/usermods/pixels_dice_tray/images/effect.webp b/usermods/pixels_dice_tray/images/effect.webp new file mode 100644 index 0000000000000000000000000000000000000000..989ed1eb9e7b46b10bc80b9478bab17bc0c52cab GIT binary patch literal 14460 zcmV-?ID^MhNk&F=H~;`wMM6+kP&goHH~;{Ud;y&SDzO3d0zQ#MoJ%F6uP383DyIIGHpY`5K|y+%hqaJN(CSE?{4w?u-`<7bEM&0Z?2@$MSA=aAHp3}jGnI!J?0B@Ytsv&|FEA91 zvJ`)63f^6a>qbJ4iC`<(i}?Qx3cg*Qk>@h~Fi?9Aj!4T@|Xc88?`G@H4Viv-#yAuRpgw@Fa!IFvIspKZU zas4TNR2DSWva_5WakV{2;7wgQ96g|sA{b~ezVj4LednR|xvH_>x;s!fV0R}9o5l81 zo&@{b`kQ|vwlm3z8=gcsSkw8hOiK3wnf3xJKF^Sj%Hq5p4btooNxn?t7PyT~0p`(f z+nRgp*3d_q^xyKUFZH!i&WK_)OCw4hBs4kWcgWft>C$~^AAS#E2v^$kQ-!=AxY*jC zb(lf0*M1i1Q4vruN2dHC*{}49ZyW;$5Jm>=TT4DO@4HJ-a29g!CP4|E1_SvgW$W>A zu|7GnO-7}n)~#tSo;4|Cw-eyx<98MD1b2Nabq^F4oUSxa=n#5*|7#R{DGeFM zyhg|c&3IF`z{7xaBc6v`Y_Eo6m63zHG0O>GyXeT-_t9(AV$zlJ0VAO;oH@N@T+D z`8{%LRY0)$MT)nq&YKx@M2v-O{HC-=5p5^UPl?(lX2`z|aPQF>xpfR$2yU z+gDR{mX_Q=R!z)GSXCWE0?MX3BKsZOU)NltH`SdN>mhQ=3dXWyXHl3N4MgiC2 z*T~=RRgaNBMNkA-biG8F&_ap{eXpFY59Ni=Z#Hx&Rm2#rXSO3xW8SeXq`4Yo2`O^5 zJmIAbcc�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 literal 0 HcmV?d00001 diff --git a/usermods/pixels_dice_tray/images/roll_plot.png b/usermods/pixels_dice_tray/images/roll_plot.png new file mode 100644 index 0000000000000000000000000000000000000000..47f5688635c067128e70cad6ad1b105e82d2296d GIT binary patch literal 10025 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 this value. + */ + +/** + * Return the last die roll based on the custom1 effect setting. + */ +static pixels::RollEvent GetLastRollForSegment() { + // If an invalid die is selected, fallback to using the most recent roll from + // any die. + if (SEGMENT.custom1 >= MAX_NUM_DICE) { + return GetLastRoll(); + } else { + return last_die_events[SEGMENT.custom1]; + } +} + + +/* + * Alternating pixels running function (copied static function). + */ +// paletteBlend: 0 - wrap when moving, 1 - always wrap, 2 - never wrap, 3 - none (undefined) +#define PALETTE_SOLID_WRAP (strip.paletteBlend == 1 || strip.paletteBlend == 3) +static uint16_t running_copy(uint32_t color1, uint32_t color2, bool theatre = false) { + int width = (theatre ? 3 : 1) + (SEGMENT.intensity >> 4); // window + uint32_t cycleTime = 50 + (255 - SEGMENT.speed); + uint32_t it = strip.now / cycleTime; + bool usePalette = color1 == SEGCOLOR(0); + + for (int i = 0; i < SEGLEN; i++) { + uint32_t col = color2; + if (usePalette) color1 = SEGMENT.color_from_palette(i, true, PALETTE_SOLID_WRAP, 0); + if (theatre) { + if ((i % width) == SEGENV.aux0) col = color1; + } else { + int pos = (i % (width<<1)); + if ((pos < SEGENV.aux0-width) || ((pos >= SEGENV.aux0) && (pos < SEGENV.aux0+width))) col = color1; + } + SEGMENT.setPixelColor(i,col); + } + + if (it != SEGENV.step) { + SEGENV.aux0 = (SEGENV.aux0 +1) % (theatre ? width : (width<<1)); + SEGENV.step = it; + } + return FRAMETIME; +} + +static uint16_t simple_roll() { + auto roll = GetLastRollForSegment(); + if (roll.state != pixels::RollState::ON_FACE) { + SEGMENT.fill(0); + } else { + uint16_t num_segments = float(roll.current_face + 1) / 20.0 * SEGLEN; + for (int i = 0; i <= num_segments; i++) { + SEGMENT.setPixelColor(i, SEGCOLOR(0)); + } + for (int i = num_segments; i < SEGLEN; i++) { + SEGMENT.setPixelColor(i, SEGCOLOR(1)); + } + } + return FRAMETIME; +} +// See https://kno.wled.ge/interfaces/json-api/#effect-metadata +// Name - DieSimple +// Parameters - +// * Selected Die (custom1) +// Colors - Uses color1 and color2 +// Palette - Not used +// Flags - Effect is optimized for use on 1D LED strips. +// Defaults - Selected Die set to 0xFF (USER_ANY_DIE) +static const char _data_FX_MODE_SIMPLE_DIE[] PROGMEM = + "DieSimple@,,Selected Die;!,!;;1;c1=255"; + +static uint16_t pulse_roll() { + auto roll = GetLastRollForSegment(); + if (roll.state != pixels::RollState::ON_FACE) { + return mode_breath(); + } else { + uint16_t ret = mode_blends(); + uint16_t num_segments = float(roll.current_face + 1) / 20.0 * SEGLEN; + for (int i = num_segments; i < SEGLEN; i++) { + SEGMENT.setPixelColor(i, SEGCOLOR(1)); + } + return ret; + } +} +static const char _data_FX_MODE_PULSE_DIE[] PROGMEM = + "DiePulse@!,!,Selected Die;!,!;!;1;sx=24,pal=50,c1=255"; + +static uint16_t check_roll() { + auto roll = GetLastRollForSegment(); + if (roll.state != pixels::RollState::ON_FACE) { + return running_copy(SEGCOLOR(0), SEGCOLOR(2)); + } else { + if (roll.current_face + 1 >= SEGMENT.custom2) { + return mode_glitter(); + } else { + return mode_gravcenter(); + } + } +} +static const char _data_FX_MODE_CHECK_DIE[] PROGMEM = + "DieCheck@!,!,Selected Die,Target Roll;1,2,3;!;1;pal=0,ix=128,m12=2,si=0,c1=255,c2=10"; diff --git a/usermods/pixels_dice_tray/mqtt_client/mqtt_logger.py b/usermods/pixels_dice_tray/mqtt_client/mqtt_logger.py new file mode 100644 index 000000000..a3e4aa014 --- /dev/null +++ b/usermods/pixels_dice_tray/mqtt_client/mqtt_logger.py @@ -0,0 +1,104 @@ +#!/usr/bin/env python +import argparse +import json +import os +from pathlib import Path +import time + +# Dependency installed with `pip install paho-mqtt`. +# https://pypi.org/project/paho-mqtt/ +import paho.mqtt.client as mqtt + +state = {"label": "None"} + + +# Define MQTT callbacks +def on_connect(client, userdata, connect_flags, reason_code, properties): + print("Connected with result code " + str(reason_code)) + state["start_time"] = None + client.subscribe(f"{state['root_topic']}#") + + +def on_message(client, userdata, msg): + if msg.topic.endswith("roll_label"): + state["label"] = msg.payload.decode("ascii") + print(f"Label set to {state['label']}") + elif msg.topic.endswith("roll"): + json_str = msg.payload.decode("ascii") + msg_data = json.loads(json_str) + # Convert the relative timestamps reported to the dice to an approximate absolute time. + # The "last_time" check is to detect if the ESP32 was restarted or the counter rolled over. + if state["start_time"] is None or msg_data["time"] < state["last_time"]: + state["start_time"] = time.time() - (msg_data["time"] / 1000.0) + state["last_time"] = msg_data["time"] + timestamp = state["start_time"] + (msg_data["time"] / 1000.0) + state["csv_fd"].write( + f"{timestamp:.3f}, {msg_data['name']}, {state['label']}, {msg_data['state']}, {msg_data['val']}\n" + ) + state["csv_fd"].flush() + if msg_data["state"] == 1: + print( + f"{timestamp:.3f}: {msg_data['name']} rolled {msg_data['val']}") + + +def main(): + parser = argparse.ArgumentParser( + description="Log die rolls from WLED MQTT events to CSV.") + + # IP address (with a default value) + parser.add_argument( + "--host", + type=str, + default="127.0.0.1", + help="Host address of broker (default: 127.0.0.1)", + ) + parser.add_argument( + "--port", type=int, default=1883, help="Broker TCP port (default: 1883)" + ) + parser.add_argument("--user", type=str, help="Optional MQTT username") + parser.add_argument("--password", type=str, help="Optional MQTT password") + parser.add_argument( + "--topic", + type=str, + help="Optional MQTT topic to listen to. For example if topic is 'wled/e5a658/dice/', subscript to to 'wled/e5a658/dice/#'. By default, listen to all topics looking for ones that end in 'roll_label' and 'roll'.", + ) + parser.add_argument( + "-o", + "--output-dir", + type=Path, + default=Path(__file__).absolute().parent / "logs", + help="Directory to log to", + ) + args = parser.parse_args() + + timestr = time.strftime("%Y-%m-%d") + os.makedirs(args.output_dir, exist_ok=True) + state["csv_fd"] = open(args.output_dir / f"roll_log_{timestr}.csv", "a") + + # Create `an MQTT client + client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2) + + # Set MQTT callbacks + client.on_connect = on_connect + client.on_message = on_message + + if args.user and args.password: + client.username_pw_set(args.user, args.password) + + state["root_topic"] = "" + + # Connect to the MQTT broker + client.connect(args.host, args.port, 60) + + try: + while client.loop(timeout=1.0) == mqtt.MQTT_ERR_SUCCESS: + time.sleep(0.1) + except KeyboardInterrupt: + exit(0) + + print("Connection Failure") + exit(1) + + +if __name__ == "__main__": + main() diff --git a/usermods/pixels_dice_tray/mqtt_client/mqtt_plotter.py b/usermods/pixels_dice_tray/mqtt_client/mqtt_plotter.py new file mode 100644 index 000000000..3ce0b7bf1 --- /dev/null +++ b/usermods/pixels_dice_tray/mqtt_client/mqtt_plotter.py @@ -0,0 +1,69 @@ +import argparse +from http import server +import os +from pathlib import Path +import socketserver + +import pandas as pd +import plotly.express as px + +# python -m http.server 8000 --directory /tmp/ + + +def main(): + parser = argparse.ArgumentParser( + description="Generate an html plot of rolls captured by mqtt_logger.py") + parser.add_argument("input_file", type=Path, help="Log file to plot") + parser.add_argument( + "-s", + "--start-server", + action="store_true", + help="After generating the plot, run a webserver pointing to it", + ) + parser.add_argument( + "-o", + "--output-dir", + type=Path, + default=Path(__file__).absolute().parent / "logs", + help="Directory to log to", + ) + args = parser.parse_args() + + df = pd.read_csv( + args.input_file, names=["timestamp", "die", "label", "state", "roll"] + ) + + df_filt = df[df["state"] == 1] + + time = (df_filt["timestamp"] - df_filt["timestamp"].min()) / 60 / 60 + + fig = px.bar( + df_filt, + x=time, + y="roll", + color="label", + labels={ + "x": "Game Time (min)", + }, + title=f"Roll Report: {args.input_file.name}", + ) + + output_path = args.output_dir / (args.input_file.stem + ".html") + + fig.write_html(output_path) + if args.start_server: + PORT = 8000 + os.chdir(args.output_dir) + try: + with socketserver.TCPServer( + ("", PORT), server.SimpleHTTPRequestHandler + ) as httpd: + print( + f"Serving HTTP on http://0.0.0.0:{PORT}/{output_path.name}") + httpd.serve_forever() + except KeyboardInterrupt: + pass + + +if __name__ == "__main__": + main() diff --git a/usermods/pixels_dice_tray/mqtt_client/requirements.txt b/usermods/pixels_dice_tray/mqtt_client/requirements.txt new file mode 100644 index 000000000..8fb305c7e --- /dev/null +++ b/usermods/pixels_dice_tray/mqtt_client/requirements.txt @@ -0,0 +1,2 @@ +plotly-express +paho-mqtt \ No newline at end of file diff --git a/usermods/pixels_dice_tray/pixels_dice_tray.h b/usermods/pixels_dice_tray/pixels_dice_tray.h new file mode 100644 index 000000000..238af314e --- /dev/null +++ b/usermods/pixels_dice_tray/pixels_dice_tray.h @@ -0,0 +1,535 @@ +#pragma once + +#include // https://github.com/axlan/arduino-pixels-dice +#include "wled.h" + +#include "dice_state.h" +#include "led_effects.h" +#include "tft_menu.h" + +// Set this parameter to rotate the display. 1-3 rotate by 90,180,270 degrees. +#ifndef USERMOD_PIXELS_DICE_TRAY_ROTATION + #define USERMOD_PIXELS_DICE_TRAY_ROTATION 0 +#endif + +// How often we are redrawing screen +#ifndef USERMOD_PIXELS_DICE_TRAY_REFRESH_RATE_MS + #define USERMOD_PIXELS_DICE_TRAY_REFRESH_RATE_MS 200 +#endif + +// Time with no updates before screen turns off (-1 to disable) +#ifndef USERMOD_PIXELS_DICE_TRAY_TIMEOUT_MS + #define USERMOD_PIXELS_DICE_TRAY_TIMEOUT_MS 5 * 60 * 1000 +#endif + +// Duration of each search for BLE devices. +#ifndef BLE_SCAN_DURATION_SEC + #define BLE_SCAN_DURATION_SEC 4 +#endif + +// Time between searches for BLE devices. +#ifndef BLE_TIME_BETWEEN_SCANS_SEC + #define BLE_TIME_BETWEEN_SCANS_SEC 5 +#endif + +#define WLED_DEBOUNCE_THRESHOLD \ + 50 // only consider button input of at least 50ms as valid (debouncing) +#define WLED_LONG_PRESS \ + 600 // long press if button is released after held for at least 600ms +#define WLED_DOUBLE_PRESS \ + 350 // double press if another press within 350ms after a short press + +class PixelsDiceTrayUsermod : public Usermod { + private: + bool enabled = true; + + DiceUpdate dice_update; + + // Settings + uint32_t ble_scan_duration_sec = BLE_SCAN_DURATION_SEC; + unsigned rotation = USERMOD_PIXELS_DICE_TRAY_ROTATION; + DiceSettings dice_settings; + +#if USING_TFT_DISPLAY + MenuController menu_ctrl; +#endif + + static void center(String& line, uint8_t width) { + int len = line.length(); + if (len < width) + for (byte i = (width - len) / 2; i > 0; i--) + line = ' ' + line; + for (byte i = line.length(); i < width; i++) + line += ' '; + } + + // NOTE: THIS MOD DOES NOT SUPPORT CHANGING THE SPI PINS FROM THE UI! The + // TFT_eSPI library requires that they are compiled in. + static void SetSPIPinsFromMacros() { +#if USING_TFT_DISPLAY + spi_mosi = TFT_MOSI; + // Done in TFT library. + if (TFT_MISO == TFT_MOSI) { + spi_miso = -1; + } + spi_sclk = TFT_SCLK; +#endif + } + + void UpdateDieNames( + const std::array& new_die_names) { + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + // If the saved setting was a wildcard, and that connected to a die, use + // the new name instead of the wildcard. Saving this "locks" the name in. + bool overriden_wildcard = + new_die_names[i] == "*" && dice_update.connected_die_ids[i] != 0; + if (!overriden_wildcard && + new_die_names[i] != dice_settings.configured_die_names[i]) { + dice_settings.configured_die_names[i] = new_die_names[i]; + dice_update.connected_die_ids[i] = 0; + last_die_events[i] = pixels::RollEvent(); + } + } + } + + public: + PixelsDiceTrayUsermod() +#if USING_TFT_DISPLAY + : menu_ctrl(&dice_settings) +#endif + { + } + + // Functions called by WLED + + /* + * setup() is called once at boot. WiFi is not yet connected at this point. + * You can use it to initialize variables, sensors or similar. + */ + void setup() override { + DEBUG_PRINTLN(F("DiceTray: init")); +#if USING_TFT_DISPLAY + SetSPIPinsFromMacros(); + PinManagerPinType spiPins[] = { + {spi_mosi, true}, {spi_miso, false}, {spi_sclk, true}}; + if (!pinManager.allocateMultiplePins(spiPins, 3, PinOwner::HW_SPI)) { + enabled = false; + } else { + PinManagerPinType displayPins[] = { + {TFT_CS, true}, {TFT_DC, true}, {TFT_RST, true}, {TFT_BL, true}}; + if (!pinManager.allocateMultiplePins( + displayPins, sizeof(displayPins) / sizeof(PinManagerPinType), + PinOwner::UM_FourLineDisplay)) { + pinManager.deallocateMultiplePins(spiPins, 3, PinOwner::HW_SPI); + enabled = false; + } + } + + if (!enabled) { + DEBUG_PRINTLN(F("DiceTray: TFT Display pin allocations failed.")); + return; + } +#endif + + // Need to enable WiFi sleep: + // "E (1513) wifi:Error! Should enable WiFi modem sleep when both WiFi and Bluetooth are enabled!!!!!!" + noWifiSleep = false; + + // Get the mode indexes that the effects are registered to. + FX_MODE_SIMPLE_D20 = strip.addEffect(255, &simple_roll, _data_FX_MODE_SIMPLE_DIE); + FX_MODE_PULSE_D20 = strip.addEffect(255, &pulse_roll, _data_FX_MODE_PULSE_DIE); + FX_MODE_CHECK_D20 = strip.addEffect(255, &check_roll, _data_FX_MODE_CHECK_DIE); + DIE_LED_MODES = {FX_MODE_SIMPLE_D20, FX_MODE_PULSE_D20, FX_MODE_CHECK_D20}; + + // Start a background task scanning for dice. + // On completion the discovered dice are connected to. + pixels::ScanForDice(ble_scan_duration_sec, BLE_TIME_BETWEEN_SCANS_SEC); + +#if USING_TFT_DISPLAY + menu_ctrl.Init(rotation); +#endif + } + + /* + * connected() is called every time the WiFi is (re)connected + * Use it to initialize network interfaces + */ + void connected() override { + // Serial.println("Connected to WiFi!"); + } + + /* + * loop() is called continuously. Here you can check for events, read sensors, + * etc. + * + * Tips: + * 1. You can use "if (WLED_CONNECTED)" to check for a successful network + * connection. Additionally, "if (WLED_MQTT_CONNECTED)" is available to check + * for a connection to an MQTT broker. + * + * 2. Try to avoid using the delay() function. NEVER use delays longer than 10 + * milliseconds. Instead, use a timer check as shown here. + */ + void loop() override { + static long last_loop_time = 0; + static long last_die_connected_time = millis(); + + char mqtt_topic_buffer[MQTT_MAX_TOPIC_LEN + 16]; + char mqtt_data_buffer[128]; + + // Check if we time interval for redrawing passes. + if (millis() - last_loop_time < USERMOD_PIXELS_DICE_TRAY_REFRESH_RATE_MS) { + return; + } + last_loop_time = millis(); + + // Update dice_list with the connected dice + pixels::ListDice(dice_update.dice_list); + // Get all the roll/battery updates since the last loop + pixels::GetDieRollUpdates(dice_update.roll_updates); + pixels::GetDieBatteryUpdates(dice_update.battery_updates); + + // Go through list of connected die. + // TODO: Blacklist die that are connected to, but don't match the configured + // names. + std::array die_connected = {false, false}; + for (auto die_id : dice_update.dice_list) { + bool matched = false; + // First check if we've already matched this ID to a connected die. + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + if (die_id == dice_update.connected_die_ids[i]) { + die_connected[i] = true; + matched = true; + break; + } + } + + // If this isn't already matched, check if its name matches an expected name. + if (!matched) { + auto die_name = pixels::GetDieDescription(die_id).name; + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + if (0 == dice_update.connected_die_ids[i] && + die_name == dice_settings.configured_die_names[i]) { + dice_update.connected_die_ids[i] = die_id; + die_connected[i] = true; + matched = true; + DEBUG_PRINTF_P(PSTR("DiceTray: %u (%s) connected.\n"), i, + die_name.c_str()); + break; + } + } + + // If it doesn't match any expected names, check if there's any wildcards to match. + if (!matched) { + auto description = pixels::GetDieDescription(die_id); + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + if (dice_settings.configured_die_names[i] == "*") { + dice_update.connected_die_ids[i] = die_id; + die_connected[i] = true; + dice_settings.configured_die_names[i] = die_name; + DEBUG_PRINTF_P(PSTR("DiceTray: %u (%s) connected as wildcard.\n"), + i, die_name.c_str()); + break; + } + } + } + } + } + + // Clear connected die that aren't still present. + bool all_found = true; + bool none_found = true; + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + if (!die_connected[i]) { + if (dice_update.connected_die_ids[i] != 0) { + dice_update.connected_die_ids[i] = 0; + last_die_events[i] = pixels::RollEvent(); + DEBUG_PRINTF_P(PSTR("DiceTray: %u disconnected.\n"), i); + } + + if (!dice_settings.configured_die_names[i].empty()) { + all_found = false; + } + } else { + none_found = false; + } + } + + // Update last_die_events + for (const auto& roll : dice_update.roll_updates) { + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + if (dice_update.connected_die_ids[i] == roll.first) { + last_die_events[i] = roll.second; + } + } + if (WLED_MQTT_CONNECTED) { + snprintf(mqtt_topic_buffer, sizeof(mqtt_topic_buffer), PSTR("%s/%s"), + mqttDeviceTopic, "dice/roll"); + const char* name = pixels::GetDieDescription(roll.first).name.c_str(); + snprintf(mqtt_data_buffer, sizeof(mqtt_data_buffer), + "{\"name\":\"%s\",\"state\":%d,\"val\":%d,\"time\":%d}", name, + int(roll.second.state), roll.second.current_face + 1, + roll.second.timestamp); + mqtt->publish(mqtt_topic_buffer, 0, false, mqtt_data_buffer); + } + } + +#if USERMOD_PIXELS_DICE_TRAY_TIMEOUT_MS > 0 && USING_TFT_DISPLAY + // If at least one die is configured, but none are found + if (none_found) { + if (millis() - last_die_connected_time > + USERMOD_PIXELS_DICE_TRAY_TIMEOUT_MS) { + // Turn off LEDs and backlight and go to sleep. + // Since none of the wake up pins are wired up, expect to sleep + // until power cycle or reset, so don't need to handle normal + // wakeup. + bri = 0; + applyFinalBri(); + menu_ctrl.EnableBacklight(false); + gpio_hold_en((gpio_num_t)TFT_BL); + gpio_deep_sleep_hold_en(); + esp_deep_sleep_start(); + } + } else { + last_die_connected_time = millis(); + } +#endif + + if (pixels::IsScanning() && all_found) { + DEBUG_PRINTF_P(PSTR("DiceTray: All dice found. Stopping search.\n")); + pixels::StopScanning(); + } else if (!pixels::IsScanning() && !all_found) { + DEBUG_PRINTF_P(PSTR("DiceTray: Resuming dice search.\n")); + pixels::ScanForDice(ble_scan_duration_sec, BLE_TIME_BETWEEN_SCANS_SEC); + } +#if USING_TFT_DISPLAY + menu_ctrl.Update(dice_update); +#endif + } + + /* + * 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. Below it is shown how this + * could be used for e.g. a light sensor + */ + void addToJsonInfo(JsonObject& root) override { + JsonObject user = root["u"]; + if (user.isNull()) + user = root.createNestedObject("u"); + + JsonArray lightArr = user.createNestedArray("DiceTray"); // name + lightArr.add(enabled ? F("installed") : F("disabled")); // unit + } + + /* + * addToJsonState() can be used to add custom entries to the /json/state part + * of the JSON API (state object). Values in the state object may be modified + * by connected clients + */ + void addToJsonState(JsonObject& root) override { + // root["user0"] = userVar0; + } + + /* + * readFromJsonState() can be used to receive data clients send to the + * /json/state part of the JSON API (state object). Values in the state object + * may be modified by connected clients + */ + void readFromJsonState(JsonObject& root) override { + // userVar0 = root["user0"] | userVar0; //if "user0" key exists in JSON, + // update, else keep old value if (root["bri"] == 255) + // Serial.println(F("Don't burn down your garage!")); + } + + /* + * addToConfig() can be used to add custom persistent settings to the cfg.json + * file in the "um" (usermod) object. It will be called by WLED when settings + * are actually saved (for example, LED settings are saved) If you want to + * force saving the current state, use serializeConfig() in your loop(). + * + * CAUTION: serializeConfig() will initiate a filesystem write operation. + * It might cause the LEDs to stutter and will cause flash wear if called too + * often. Use it sparingly and always in the loop, never in network callbacks! + * + * addToConfig() will also not yet add your setting to one of the settings + * pages automatically. To make that work you still have to add the setting to + * the HTML, xml.cpp and set.cpp manually. + * + * I highly recommend checking out the basics of ArduinoJson serialization and + * deserialization in order to use custom settings! + */ + void addToConfig(JsonObject& root) override { + JsonObject top = root.createNestedObject("DiceTray"); + top["ble_scan_duration"] = ble_scan_duration_sec; + top["die_0"] = dice_settings.configured_die_names[0]; + top["die_1"] = dice_settings.configured_die_names[1]; +#if USING_TFT_DISPLAY + top["rotation"] = rotation; + JsonArray pins = top.createNestedArray("pin"); + pins.add(TFT_CS); + pins.add(TFT_DC); + pins.add(TFT_RST); + pins.add(TFT_BL); +#endif + } + + void appendConfigData() override { + // Slightly annoying that you can't put text before an element. + // The an item on the usermod config page has the following HTML: + // ```html + // Die 0 + // + // + // ``` + // addInfo let's you add data before or after the two input fields. + // + // To work around this, add info text to the end of the preceding item. + // + // See addInfo in wled00/data/settings_um.htm for details on what this function does. + oappend(SET_F( + "addInfo('DiceTray:ble_scan_duration',1,'

Set to \"*\" to " + "connect to any die.
Leave Blank to disable.
Saving will replace \"*\" with die names.','');")); +#if USING_TFT_DISPLAY + oappend(SET_F("ddr=addDropdown('DiceTray','rotation');")); + oappend(SET_F("addOption(ddr,'0 deg',0);")); + oappend(SET_F("addOption(ddr,'90 deg',1);")); + oappend(SET_F("addOption(ddr,'180 deg',2);")); + oappend(SET_F("addOption(ddr,'270 deg',3);")); + oappend(SET_F( + "addInfo('DiceTray:rotation',1,'
DO NOT CHANGE " + "SPI PINS.
CHANGES ARE IGNORED.','');")); + oappend(SET_F("addInfo('TFT:pin[]',0,'','SPI CS');")); + oappend(SET_F("addInfo('TFT:pin[]',1,'','SPI DC');")); + oappend(SET_F("addInfo('TFT:pin[]',2,'','SPI RST');")); + oappend(SET_F("addInfo('TFT:pin[]',3,'','SPI BL');")); +#endif + } + + /* + * readFromConfig() can be used to read back the custom settings you added + * with addToConfig(). This is called by WLED when settings are loaded + * (currently this only happens once immediately after boot) + * + * readFromConfig() is called BEFORE setup(). This means you can use your + * persistent values in setup() (e.g. pin assignments, buffer sizes), but also + * that if you want to write persistent values to a dynamic buffer, you'd need + * to allocate it here instead of in setup. If you don't know what that is, + * don't fret. It most likely doesn't affect your use case :) + */ + bool readFromConfig(JsonObject& root) override { + // we look for JSON object: + // {"DiceTray":{"rotation":0,"font_size":1}} + JsonObject top = root["DiceTray"]; + if (top.isNull()) { + DEBUG_PRINTLN(F("DiceTray: No config found. (Using defaults.)")); + return false; + } + + if (top.containsKey("die_0") && top.containsKey("die_1")) { + const std::array new_die_names{ + top["die_0"], top["die_1"]}; + UpdateDieNames(new_die_names); + } else { + DEBUG_PRINTLN(F("DiceTray: No die names found.")); + } + +#if USING_TFT_DISPLAY + unsigned new_rotation = min(top["rotation"] | rotation, 3u); + + // Restore the SPI pins to their compiled in defaults. + SetSPIPinsFromMacros(); + + if (new_rotation != rotation) { + rotation = new_rotation; + menu_ctrl.Init(rotation); + } + + // Update with any modified settings. + menu_ctrl.Redraw(); +#endif + + // use "return !top["newestParameter"].isNull();" when updating Usermod with + // new features + return !top["DiceTray"].isNull(); + } + + /** + * handleButton() can be used to override default button behaviour. Returning true + * will prevent button working in a default way. + * Replicating button.cpp + */ +#if USING_TFT_DISPLAY + bool handleButton(uint8_t b) override { + if (!enabled || b > 1 // buttons 0,1 only + || buttonType[b] == BTN_TYPE_SWITCH || buttonType[b] == BTN_TYPE_NONE || + buttonType[b] == BTN_TYPE_RESERVED || + buttonType[b] == BTN_TYPE_PIR_SENSOR || + buttonType[b] == BTN_TYPE_ANALOG || + buttonType[b] == BTN_TYPE_ANALOG_INVERTED) { + return false; + } + + unsigned long now = millis(); + static bool buttonPressedBefore[2] = {false}; + static bool buttonLongPressed[2] = {false}; + static unsigned long buttonPressedTime[2] = {0}; + static unsigned long buttonWaitTime[2] = {0}; + + //momentary button logic + if (!buttonLongPressed[b] && isButtonPressed(b)) { //pressed + if (!buttonPressedBefore[b]) { + buttonPressedTime[b] = now; + } + buttonPressedBefore[b] = true; + + if (now - buttonPressedTime[b] > WLED_LONG_PRESS) { //long press + menu_ctrl.HandleButton(ButtonType::LONG, b); + buttonLongPressed[b] = true; + return true; + } + } else if (!isButtonPressed(b) && buttonPressedBefore[b]) { //released + + long dur = now - buttonPressedTime[b]; + if (dur < WLED_DEBOUNCE_THRESHOLD) { + buttonPressedBefore[b] = false; + return true; + } //too short "press", debounce + + bool doublePress = buttonWaitTime[b]; //did we have short press before? + buttonWaitTime[b] = 0; + + if (!buttonLongPressed[b]) { //short press + // if this is second release within 350ms it is a double press (buttonWaitTime!=0) + if (doublePress) { + menu_ctrl.HandleButton(ButtonType::DOUBLE, b); + } else { + buttonWaitTime[b] = now; + } + } + buttonPressedBefore[b] = false; + buttonLongPressed[b] = false; + } + // if 350ms elapsed since last press/release it is a short press + if (buttonWaitTime[b] && now - buttonWaitTime[b] > WLED_DOUBLE_PRESS && + !buttonPressedBefore[b]) { + buttonWaitTime[b] = 0; + menu_ctrl.HandleButton(ButtonType::SINGLE, b); + } + + return true; + } +#endif + + /* + * getId() allows you to optionally give your V2 usermod an unique ID (please + * define it in const.h!). This could be used in the future for the system to + * determine whether your usermod is installed. + */ + uint16_t getId() { return USERMOD_ID_PIXELS_DICE_TRAY; } + + // More methods can be added in the future, this example will then be + // extended. Your usermod will remain compatible as it does not need to + // implement all methods from the Usermod base class! +}; diff --git a/usermods/pixels_dice_tray/platformio_override.ini.sample b/usermods/pixels_dice_tray/platformio_override.ini.sample new file mode 100644 index 000000000..844ff1bb2 --- /dev/null +++ b/usermods/pixels_dice_tray/platformio_override.ini.sample @@ -0,0 +1,114 @@ +[platformio] +default_envs = t_qt_pro_8MB, esp32s3dev_8MB_qspi + +# ------------------------------------------------------------------------------ +# T-QT Pro 8MB with integrated 128x128 TFT screen +# ------------------------------------------------------------------------------ +[env:t_qt_pro_8MB] +board = esp32-s3-devkitc-1 ;; generic dev board; +platform = ${esp32s3.platform} +upload_speed = 921600 +build_unflags = ${common.build_unflags} +board_build.partitions = ${esp32.large_partitions} +board_build.f_flash = 80000000L +board_build.flash_mode = qio +monitor_filters = esp32_exception_decoder +build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=T-QT-PRO-8MB + -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0 + -D ARDUINO_USB_CDC_ON_BOOT=1 -D ARDUINO_USB_MODE=1 ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB") + + -D USERMOD_PIXELS_DICE_TRAY ;; Enables this UserMod + -D USERMOD_PIXELS_DICE_TRAY_BL_ACTIVE_LOW=1 + -D USERMOD_PIXELS_DICE_TRAY_ROTATION=2 + + ;-D WLED_DEBUG + ;;;;;;;;;;;;;;;;;; TFT_eSPI Settings ;;;;;;;;;;;;;;;;;;;;;;;; + ;-DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG + -D USER_SETUP_LOADED=1 + + ; Define the TFT driver, pins etc. from: https://github.com/Bodmer/TFT_eSPI/blob/master/User_Setups/Setup211_LilyGo_T_QT_Pro_S3.h + ; GC9A01 128 x 128 display with no chip select line + -D USER_SETUP_ID=211 + -D GC9A01_DRIVER=1 + -D TFT_WIDTH=128 + -D TFT_HEIGHT=128 + + -D TFT_BACKLIGHT_ON=0 + -D TFT_ROTATION=3 + -D CGRAM_OFFSET=1 + + -D TFT_MISO=-1 + -D TFT_MOSI=2 + -D TFT_SCLK=3 + -D TFT_CS=5 + -D TFT_DC=6 + -D TFT_RST=1 + -D TFT_BL=10 + -D LOAD_GLCD=1 + -D LOAD_FONT2=1 + -D LOAD_FONT4=1 + -D LOAD_FONT6=1 + -D LOAD_FONT7=1 + -D LOAD_FONT8=1 + -D LOAD_GFXFF=1 + ; Avoid SPIFFS dependancy that was causing compile issues. + ;-D SMOOTH_FONT=1 + -D SPI_FREQUENCY=40000000 + -D SPI_READ_FREQUENCY=20000000 + -D SPI_TOUCH_FREQUENCY=2500000 + +lib_deps = ${esp32s3.lib_deps} + ${esp32.AR_lib_deps} + ESP32 BLE Arduino + bodmer/TFT_eSPI @ 2.5.43 + axlan/pixels-dice-interface @ 1.2.0 + +# ------------------------------------------------------------------------------ +# ESP32S3 dev board with 8MB flash and no extended RAM. +# ------------------------------------------------------------------------------ +[env:esp32s3dev_8MB_qspi] +board = esp32-s3-devkitc-1 ;; generic dev board; +platform = ${esp32s3.platform} +upload_speed = 921600 +build_unflags = ${common.build_unflags} +board_build.partitions = ${esp32.large_partitions} +board_build.f_flash = 80000000L +board_build.flash_mode = qio +monitor_filters = esp32_exception_decoder +build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_8MB_qspi + -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0 + -D ARDUINO_USB_CDC_ON_BOOT=1 -D ARDUINO_USB_MODE=1 ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB") + + -D USERMOD_PIXELS_DICE_TRAY ;; Enables this UserMod + + ;-D WLED_DEBUG +lib_deps = ${esp32s3.lib_deps} + ${esp32.AR_lib_deps} + ESP32 BLE Arduino + axlan/pixels-dice-interface @ 1.2.0 + +# ------------------------------------------------------------------------------ +# ESP32 dev board without screen +# ------------------------------------------------------------------------------ +# THIS DOES NOT WORK!!!!!! +# While it builds and programs onto the device, I ran into a series of issues +# trying to actually run. +# Right after the AP init there's an allocation exception which claims to be in +# the UDP server. There seems to be a ton of heap remaining, so the exact error +# might be a red herring. +# It appears that the BLE scanning task is conflicting with the networking tasks. +# I was successfully running simple applications with the pixels-dice-interface +# on ESP32 dev boards, so it may be an issue with too much being scheduled in +# parallel. Also not clear exactly what difference between the ESP32 and the +# ESP32S3 would be causing this, though they do run different BLE versions. +# May be related to some of the issues discussed in: +# https://github.com/Aircoookie/WLED/issues/1382 +; [env:esp32dev] +; build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=ESP32 +; ; Enable Pixels dice mod +; -D USERMOD_PIXELS_DICE_TRAY +; lib_deps = ${esp32.lib_deps} +; ESP32 BLE Arduino +; axlan/pixels-dice-interface @ 1.2.0 +; ; Tiny file system partition, no core dump to fit BLE library. +; board_build.partitions = usermods/pixels_dice_tray/WLED_ESP32_4MB_64KB_FS.csv diff --git a/usermods/pixels_dice_tray/roll_info.h b/usermods/pixels_dice_tray/roll_info.h new file mode 100644 index 000000000..fd8203134 --- /dev/null +++ b/usermods/pixels_dice_tray/roll_info.h @@ -0,0 +1,107 @@ +#pragma once + +#include + +extern TFT_eSPI tft; + +// The following functions are generated by: +// usermods/pixels_dice_tray/generate_roll_info.py + +// GENERATED +static void PrintRoll0() { + tft.setTextColor(63488); + tft.println("Barb Chain"); + tft.setTextColor(65535); + tft.println("Atk/CMD 12"); + tft.println("Range: 70"); + tft.setTextSize(1); + tft.println("Summon 3 chains. Make"); + tft.println("a melee atk 1d6 or a "); + tft.println("trip CMD=AT. On a hit"); + tft.println("make Will save or sha"); + tft.println("ken 1d4 rnds."); +} + +static void PrintRoll1() { + tft.setTextColor(2016); + tft.println("Saves"); + tft.setTextColor(65535); + tft.println("FORT 8"); + tft.println("REFLEX 8"); + tft.println("WILL 9"); +} + +static void PrintRoll2() { + tft.println("Skill"); +} + +static void PrintRoll3() { + tft.println("Attack"); + tft.println("Melee +9"); + tft.println("Range +6"); +} + +static void PrintRoll4() { + tft.println("Cure"); + tft.println("Lit 1d8+5"); + tft.println("Mod 2d8+9"); + tft.println("Ser 3d8+9"); +} + +static void PrintRoll5() { + tft.println("Concentrat"); + tft.println("+15"); + tft.setTextSize(1); + tft.println("Defensive 15+2*SP_LV"); + tft.println("Dmg 10+DMG+SP_LV"); + tft.println("Grapple 10+CMB+SP_LV"); +} + +static const char* GetRollName(uint8_t key) { + switch (key) { + case 0: + return "Barb Chain"; + case 1: + return "Saves"; + case 2: + return "Skill"; + case 3: + return "Attack"; + case 4: + return "Cure"; + case 5: + return "Concentrate"; + } + return ""; +} + +static void PrintRollInfo(uint8_t key) { + tft.setTextColor(TFT_WHITE); + tft.setCursor(0, 0); + tft.setTextSize(2); + switch (key) { + case 0: + PrintRoll0(); + return; + case 1: + PrintRoll1(); + return; + case 2: + PrintRoll2(); + return; + case 3: + PrintRoll3(); + return; + case 4: + PrintRoll4(); + return; + case 5: + PrintRoll5(); + return; + } + tft.setTextColor(TFT_RED); + tft.setCursor(0, 60); + tft.println("Unknown"); +} + +static constexpr size_t NUM_ROLL_INFOS = 6; diff --git a/usermods/pixels_dice_tray/tft_menu.h b/usermods/pixels_dice_tray/tft_menu.h new file mode 100644 index 000000000..0b8fd8394 --- /dev/null +++ b/usermods/pixels_dice_tray/tft_menu.h @@ -0,0 +1,479 @@ +/** + * Code for using the 128x128 LCD and two buttons on the T-QT Pro as a GUI. + */ +#pragma once + +#ifndef TFT_WIDTH + #warning TFT parameters not specified, not using screen. +#else + #include + #include // https://github.com/axlan/arduino-pixels-dice + #include "wled.h" + + #include "dice_state.h" + #include "roll_info.h" + + #define USING_TFT_DISPLAY 1 + + #ifndef TFT_BL + #define TFT_BL -1 + #endif + +// Bitmask for icon +const uint8_t LIGHTNING_ICON_8X8[] PROGMEM = { + 0b00001111, 0b00010010, 0b00100100, 0b01001111, + 0b10000001, 0b11110010, 0b00010100, 0b00011000, +}; + +TFT_eSPI tft = TFT_eSPI(TFT_WIDTH, TFT_HEIGHT); + +/** + * Print text with box surrounding it. + * + * @param txt Text to draw + * @param color Color for box lines + */ +static void PrintLnInBox(const char* txt, uint32_t color) { + int16_t sx = tft.getCursorX(); + int16_t sy = tft.getCursorY(); + tft.setCursor(sx + 2, sy); + tft.print(txt); + int16_t w = tft.getCursorX() - sx + 1; + tft.println(); + int16_t h = tft.getCursorY() - sy - 1; + tft.drawRect(sx, sy, w, h, color); +} + +/** + * Override the current colors for the selected segment to the defaults for the + * selected die effect. + */ +void SetDefaultColors(uint8_t mode) { + Segment& seg = strip.getFirstSelectedSeg(); + if (mode == FX_MODE_SIMPLE_D20) { + seg.setColor(0, GREEN); + seg.setColor(1, 0); + } else if (mode == FX_MODE_PULSE_D20) { + seg.setColor(0, GREEN); + seg.setColor(1, RED); + } else if (mode == FX_MODE_CHECK_D20) { + seg.setColor(0, RED); + seg.setColor(1, 0); + seg.setColor(2, GREEN); + } +} + +/** + * Get the pointer to the custom2 value for the current LED segment. This is + * used to set the target roll for relevant effects. + */ +static uint8_t* GetCurrentRollTarget() { + return &strip.getFirstSelectedSeg().custom2; +} + +/** + * Class for drawing a histogram of roll results. + */ +class RollCountWidget { + private: + int16_t xs = 0; + int16_t ys = 0; + uint16_t border_color = TFT_RED; + uint16_t bar_color = TFT_GREEN; + uint16_t bar_width = 6; + uint16_t max_bar_height = 60; + unsigned roll_counts[20] = {0}; + unsigned total = 0; + unsigned max_count = 0; + + public: + RollCountWidget(int16_t xs = 0, int16_t ys = 0, + uint16_t border_color = TFT_RED, + uint16_t bar_color = TFT_GREEN, uint16_t bar_width = 6, + uint16_t max_bar_height = 60) + : xs(xs), + ys(ys), + border_color(border_color), + bar_color(bar_color), + bar_width(bar_width), + max_bar_height(max_bar_height) {} + + void Clear() { + memset(roll_counts, 0, sizeof(roll_counts)); + total = 0; + max_count = 0; + } + + unsigned GetNumRolls() const { return total; } + + void AddRoll(unsigned val) { + if (val > 19) { + return; + } + roll_counts[val]++; + total++; + max_count = max(roll_counts[val], max_count); + } + + void Draw() { + // Add 2 pixels to lengths for boarder width. + tft.drawRect(xs, ys, bar_width * 20 + 2, max_bar_height + 2, border_color); + for (size_t i = 0; i < 20; i++) { + if (roll_counts[i] > 0) { + // Scale bar by highest count. + uint16_t bar_height = round(float(roll_counts[i]) / float(max_count) * + float(max_bar_height)); + // Add space between bars + uint16_t padding = (bar_width > 1) ? 1 : 0; + // Need to start from top of bar and draw down + tft.fillRect(xs + 1 + bar_width * i, + ys + 1 + max_bar_height - bar_height, bar_width - padding, + bar_height, bar_color); + } + } + } +}; + +enum class ButtonType { SINGLE, DOUBLE, LONG }; + +// Base class for different menu pages. +class MenuBase { + public: + /** + * Handle new die events and connections. Called even when menu isn't visible. + */ + virtual void Update(const DiceUpdate& dice_update) = 0; + + /** + * Draw menu to the screen. + */ + virtual void Draw(const DiceUpdate& dice_update, bool force_redraw) = 0; + + /** + * Handle button presses if the menu is currently active. + */ + virtual void HandleButton(ButtonType type, uint8_t b) = 0; + + protected: + static DiceSettings* settings; + friend class MenuController; +}; +DiceSettings* MenuBase::settings = nullptr; + +/** + * Menu to show connection status and roll histograms. + */ +class DiceStatusMenu : public MenuBase { + public: + DiceStatusMenu() + : die_roll_counts{RollCountWidget{0, 20, TFT_BLUE, TFT_GREEN, 6, 40}, + RollCountWidget{0, SECTION_HEIGHT + 20, TFT_BLUE, + TFT_GREEN, 6, 40}} {} + + void Update(const DiceUpdate& dice_update) override { + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + const auto die_id = dice_update.connected_die_ids[i]; + const auto connected = die_id != 0; + // Redraw if connection status changed. + die_updated[i] |= die_id != last_die_ids[i]; + last_die_ids[i] = die_id; + + if (connected) { + bool charging = false; + for (const auto& battery : dice_update.battery_updates) { + if (battery.first == die_id) { + if (die_battery[i].battery_level == INVALID_BATTERY || + battery.second.is_charging != die_battery[i].is_charging) { + die_updated[i] = true; + } + die_battery[i] = battery.second; + } + } + + for (const auto& roll : dice_update.roll_updates) { + if (roll.first == die_id && + roll.second.state == pixels::RollState::ON_FACE) { + die_roll_counts[i].AddRoll(roll.second.current_face); + die_updated[i] = true; + } + } + } + } + } + + void Draw(const DiceUpdate& dice_update, bool force_redraw) override { + // This could probably be optimized for partial redraws. + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + const int16_t ys = SECTION_HEIGHT * i; + const auto die_id = dice_update.connected_die_ids[i]; + const auto connected = die_id != 0; + // Screen updates might be slow, yield in case network task needs to do + // work. + yield(); + bool battery_update = + connected && (millis() - last_update[i] > BATTERY_REFRESH_RATE_MS); + if (force_redraw || die_updated[i] || battery_update) { + last_update[i] = millis(); + tft.fillRect(0, ys, TFT_WIDTH, SECTION_HEIGHT, TFT_BLACK); + tft.drawRect(0, ys, TFT_WIDTH, SECTION_HEIGHT, TFT_BLUE); + if (settings->configured_die_names[i].empty()) { + tft.setTextColor(TFT_RED); + tft.setCursor(2, ys + 4); + tft.setTextSize(2); + tft.println("Connection"); + tft.setCursor(2, tft.getCursorY()); + tft.println("Disabled"); + } else if (!connected) { + tft.setTextColor(TFT_RED); + tft.setCursor(2, ys + 4); + tft.setTextSize(2); + tft.println(settings->configured_die_names[i].c_str()); + tft.setCursor(2, tft.getCursorY()); + tft.print("Waiting..."); + } else { + tft.setTextColor(TFT_WHITE); + tft.setCursor(0, ys + 2); + tft.setTextSize(1); + tft.println(settings->configured_die_names[i].c_str()); + tft.print("Cnt "); + tft.print(die_roll_counts[i].GetNumRolls()); + if (die_battery[i].battery_level != INVALID_BATTERY) { + tft.print(" Bat "); + tft.print(die_battery[i].battery_level); + tft.print("%"); + if (die_battery[i].is_charging) { + tft.drawBitmap(tft.getCursorX(), tft.getCursorY(), + LIGHTNING_ICON_8X8, 8, 8, TFT_YELLOW); + } + } + die_roll_counts[i].Draw(); + } + die_updated[i] = false; + } + } + } + + void HandleButton(ButtonType type, uint8_t b) override { + if (type == ButtonType::LONG) { + for (size_t i = 0; i < MAX_NUM_DICE; i++) { + die_roll_counts[i].Clear(); + die_updated[i] = true; + } + } + }; + + private: + static constexpr long BATTERY_REFRESH_RATE_MS = 60 * 1000; + static constexpr int16_t SECTION_HEIGHT = TFT_HEIGHT / MAX_NUM_DICE; + static constexpr uint8_t INVALID_BATTERY = 0xFF; + std::array last_update{0, 0}; + std::array last_die_ids{0, 0}; + std::array die_updated{false, false}; + std::array die_battery = { + pixels::BatteryEvent{INVALID_BATTERY, false}, + pixels::BatteryEvent{INVALID_BATTERY, false}}; + std::array die_roll_counts; +}; + +/** + * Some limited controls for setting the die effects on the current LED + * segment. + */ +class EffectMenu : public MenuBase { + public: + EffectMenu() = default; + + void Update(const DiceUpdate& dice_update) override {} + + void Draw(const DiceUpdate& dice_update, bool force_redraw) override { + // NOTE: This doesn't update automatically if the effect is updated on the + // web UI and vice-versa. + if (force_redraw) { + tft.fillScreen(TFT_BLACK); + uint8_t mode = strip.getFirstSelectedSeg().mode; + if (Contains(DIE_LED_MODES, mode)) { + char lineBuffer[CHAR_WIDTH_BIG + 1]; + extractModeName(mode, JSON_mode_names, lineBuffer, CHAR_WIDTH_BIG); + tft.setTextColor(TFT_WHITE); + tft.setCursor(0, 0); + tft.setTextSize(2); + PrintLnInBox(lineBuffer, (field_idx == 0) ? TFT_BLUE : TFT_BLACK); + if (mode == FX_MODE_CHECK_D20) { + snprintf(lineBuffer, sizeof(lineBuffer), "PASS: %u", + *GetCurrentRollTarget()); + PrintLnInBox(lineBuffer, (field_idx == 1) ? TFT_BLUE : TFT_BLACK); + } + } else { + char lineBuffer[CHAR_WIDTH_SMALL + 1]; + extractModeName(mode, JSON_mode_names, lineBuffer, CHAR_WIDTH_SMALL); + tft.setTextColor(TFT_WHITE); + tft.setCursor(0, 0); + tft.setTextSize(1); + tft.println(lineBuffer); + } + } + } + + /** + * Button 0 navigates up and down the settings for the effect. + * Button 1 changes the value for the selected settings. + * Long pressing a button resets the effect parameters to their defaults for + * the current die effect. + */ + void HandleButton(ButtonType type, uint8_t b) override { + Segment& seg = strip.getFirstSelectedSeg(); + auto mode_itr = + std::find(DIE_LED_MODES.begin(), DIE_LED_MODES.end(), seg.mode); + if (mode_itr != DIE_LED_MODES.end()) { + mode_idx = mode_itr - DIE_LED_MODES.begin(); + } + + if (mode_itr == DIE_LED_MODES.end()) { + seg.setMode(DIE_LED_MODES[mode_idx]); + } else { + if (type == ButtonType::LONG) { + // Need to set mode to different value so defaults are actually loaded. + seg.setMode(0); + seg.setMode(DIE_LED_MODES[mode_idx], true); + SetDefaultColors(DIE_LED_MODES[mode_idx]); + } else if (b == 0) { + field_idx = (field_idx + 1) % DIE_LED_MODE_NUM_FIELDS[mode_idx]; + } else { + if (field_idx == 0) { + mode_idx = (mode_idx + 1) % DIE_LED_MODES.size(); + seg.setMode(DIE_LED_MODES[mode_idx]); + } else if (DIE_LED_MODES[mode_idx] == FX_MODE_CHECK_D20 && + field_idx == 1) { + *GetCurrentRollTarget() = GetLastRoll().current_face + 1; + } + } + } + }; + + private: + static constexpr std::array DIE_LED_MODE_NUM_FIELDS = {1, 1, 2}; + static constexpr size_t CHAR_WIDTH_BIG = 10; + static constexpr size_t CHAR_WIDTH_SMALL = 21; + size_t mode_idx = 0; + size_t field_idx = 0; +}; + +constexpr std::array EffectMenu::DIE_LED_MODE_NUM_FIELDS; + +/** + * Menu for setting the roll label and some info for that roll type. + */ +class InfoMenu : public MenuBase { + public: + InfoMenu() = default; + + void Update(const DiceUpdate& dice_update) override {} + + void Draw(const DiceUpdate& dice_update, bool force_redraw) override { + if (force_redraw) { + tft.fillScreen(TFT_BLACK); + if (settings->roll_label != INVALID_ROLL_VALUE) { + PrintRollInfo(settings->roll_label); + } else { + tft.setTextColor(TFT_RED); + tft.setCursor(0, 60); + tft.setTextSize(2); + tft.println("Set Roll"); + } + } + } + + /** + * Single clicking navigates through the roll types. Button 0 goes down, and + * button 1 goes up with wrapping. + */ + void HandleButton(ButtonType type, uint8_t b) override { + if (settings->roll_label >= NUM_ROLL_INFOS) { + settings->roll_label = 0; + } else if (b == 0) { + settings->roll_label = (settings->roll_label == 0) + ? NUM_ROLL_INFOS - 1 + : settings->roll_label - 1; + } else if (b == 1) { + settings->roll_label = (settings->roll_label + 1) % NUM_ROLL_INFOS; + } + if (WLED_MQTT_CONNECTED) { + char mqtt_topic_buffer[MQTT_MAX_TOPIC_LEN + 16]; + snprintf(mqtt_topic_buffer, sizeof(mqtt_topic_buffer), PSTR("%s/%s"), + mqttDeviceTopic, "dice/settings->roll_label"); + mqtt->publish(mqtt_topic_buffer, 0, false, + GetRollName(settings->roll_label)); + } + }; +}; + +/** + * Interface for the rest of the app to update the menus. + */ +class MenuController { + public: + MenuController(DiceSettings* settings) { MenuBase::settings = settings; } + + void Init(unsigned rotation) { + tft.init(); + tft.setRotation(rotation); + tft.fillScreen(TFT_BLACK); + tft.setTextColor(TFT_RED); + tft.setCursor(0, 60); + tft.setTextDatum(MC_DATUM); + tft.setTextSize(2); + EnableBacklight(true); + + force_redraw = true; + } + + // Set the pin to turn the backlight on or off if available. + static void EnableBacklight(bool enable) { + #if TFT_BL > 0 + #if USERMOD_PIXELS_DICE_TRAY_BL_ACTIVE_LOW + enable = !enable; + #endif + digitalWrite(TFT_BL, enable); + #endif + } + + /** + * Double clicking navigates between menus. Button 0 goes down, and button 1 + * goes up with wrapping. + */ + void HandleButton(ButtonType type, uint8_t b) { + force_redraw = true; + // Switch menus with double click + if (ButtonType::DOUBLE == type) { + if (b == 0) { + current_index = + (current_index == 0) ? menu_ptrs.size() - 1 : current_index - 1; + } else { + current_index = (current_index + 1) % menu_ptrs.size(); + } + } else { + menu_ptrs[current_index]->HandleButton(type, b); + } + } + + void Update(const DiceUpdate& dice_update) { + for (auto menu_ptr : menu_ptrs) { + menu_ptr->Update(dice_update); + } + menu_ptrs[current_index]->Draw(dice_update, force_redraw); + force_redraw = false; + } + + void Redraw() { force_redraw = true; } + + private: + size_t current_index = 0; + bool force_redraw = true; + + DiceStatusMenu status_menu; + EffectMenu effect_menu; + InfoMenu info_menu; + const std::array menu_ptrs = {&status_menu, &effect_menu, + &info_menu}; +}; +#endif diff --git a/wled00/FX.cpp b/wled00/FX.cpp index bded21060..8c24ab166 100644 --- a/wled00/FX.cpp +++ b/wled00/FX.cpp @@ -7899,18 +7899,21 @@ static const char _data_RESERVED[] PROGMEM = "RSVD"; // add (or replace reserved) effect mode and data into vector // use id==255 to find unallocated gaps (with "Reserved" data string) // if vector size() is smaller than id (single) data is appended at the end (regardless of id) -void WS2812FX::addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name) { +// return the actual id used for the effect or 255 if the add failed. +uint8_t WS2812FX::addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name) { if (id == 255) { // find empty slot for (size_t i=1; i<_mode.size(); i++) if (_modeData[i] == _data_RESERVED) { id = i; break; } } if (id < _mode.size()) { - if (_modeData[id] != _data_RESERVED) return; // do not overwrite alerady added effect + if (_modeData[id] != _data_RESERVED) return 255; // do not overwrite an already added effect _mode[id] = mode_fn; _modeData[id] = mode_name; + return id; } else { _mode.push_back(mode_fn); _modeData.push_back(mode_name); if (_modeCount < _mode.size()) _modeCount++; + return (_mode.size() <= 255) ? _mode.size() - 1 : 255; } } diff --git a/wled00/FX.h b/wled00/FX.h index 57de5df44..b914fec2f 100644 --- a/wled00/FX.h +++ b/wled00/FX.h @@ -771,8 +771,8 @@ class WS2812FX { // 96 bytes setPixelColor(unsigned n, uint32_t c), // paints absolute strip pixel with index n and color c show(void), // initiates LED output setTargetFps(uint8_t fps), - addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name), // add effect to the list; defined in FX.cpp setupEffectData(void); // add default effects to the list; defined in FX.cpp + uint8_t addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name); // add effect to the list; defined in FX.cpp inline void restartRuntime() { for (Segment &seg : _segments) seg.markForReset(); } inline void setTransitionMode(bool t) { for (Segment &seg : _segments) seg.startTransition(t ? _transitionDur : 0); } diff --git a/wled00/const.h b/wled00/const.h index 0ff70e47d..7a08635f3 100644 --- a/wled00/const.h +++ b/wled00/const.h @@ -200,6 +200,7 @@ #define USERMOD_ID_INA226 50 //Usermod "usermod_ina226.h" #define USERMOD_ID_AHT10 51 //Usermod "usermod_aht10.h" #define USERMOD_ID_LD2410 52 //Usermod "usermod_ld2410.h" +#define USERMOD_ID_PIXELS_DICE_TRAY 53 //Usermod "pixels_dice_tray.h" //Access point behavior #define AP_BEHAVIOR_BOOT_NO_CONN 0 //Open AP when no connection after boot diff --git a/wled00/pin_manager.h b/wled00/pin_manager.h index 1cec0550d..2fc003880 100644 --- a/wled00/pin_manager.h +++ b/wled00/pin_manager.h @@ -63,7 +63,8 @@ enum struct PinOwner : uint8_t { UM_PWM_OUTPUTS = USERMOD_ID_PWM_OUTPUTS, // 0x26 // Usermod "usermod_pwm_outputs.h" UM_LDR_DUSK_DAWN = USERMOD_ID_LDR_DUSK_DAWN, // 0x2B // Usermod "usermod_LDR_Dusk_Dawn_v2.h" UM_MAX17048 = USERMOD_ID_MAX17048, // 0x2F // Usermod "usermod_max17048.h" - UM_BME68X = USERMOD_ID_BME68X // 0x31 // Usermod "usermod_bme68x.h -- Uses "standard" HW_I2C pins + UM_BME68X = USERMOD_ID_BME68X, // 0x31 // Usermod "usermod_bme68x.h -- Uses "standard" HW_I2C pins + UM_PIXELS_DICE_TRAY = USERMOD_ID_PIXELS_DICE_TRAY, // 0x35 // Usermod "pixels_dice_tray.h" -- Needs compile time specified 6 pins for display including SPI. }; static_assert(0u == static_cast(PinOwner::None), "PinOwner::None must be zero, so default array initialization works as expected"); diff --git a/wled00/usermods_list.cpp b/wled00/usermods_list.cpp index a39aa5f41..f3b05e582 100644 --- a/wled00/usermods_list.cpp +++ b/wled00/usermods_list.cpp @@ -106,6 +106,10 @@ #include "../usermods/ST7789_display/ST7789_Display.h" #endif +#ifdef USERMOD_PIXELS_DICE_TRAY + #include "../usermods/pixels_dice_tray/pixels_dice_tray.h" +#endif + #ifdef USERMOD_SEVEN_SEGMENT #include "../usermods/seven_segment_display/usermod_v2_seven_segment_display.h" #endif @@ -331,6 +335,10 @@ void registerUsermods() usermods.add(new St7789DisplayUsermod()); #endif + #ifdef USERMOD_PIXELS_DICE_TRAY + usermods.add(new PixelsDiceTrayUsermod()); + #endif + #ifdef USERMOD_SEVEN_SEGMENT usermods.add(new SevenSegmentDisplay()); #endif From ed5eb2822827399d9dfeb55db9a5068bb2bec8f9 Mon Sep 17 00:00:00 2001 From: Arthur Suzuki Date: Wed, 22 Nov 2023 02:36:06 +0100 Subject: [PATCH 03/28] Added POV image effect Setup is really easy, after first boot and WiFi/LEDs setup: go to wled.local/edit and upload a couple image to WLed's filesystem. Only PNG is supported right now, further support for GIF is planned. The image should be as wide as the 1D segment you want to apply to. When done, go to the Effect page on the UI, select "POV Image" effect. You could also update the image with a post to the JSON-API like this: curl -X POST http://[wled]/json/state -d '{"seg":{"id":0,"fx":114,"f":"/axel.png"}}' The segment should move at around 120RPM (that's 2revolutions per seconds) for an image to showup. More informations and pictures here : https://lumina.toys --- platformio_override.sample.ini | 4 + usermods/pov_display/usermod_pov_display.h | 85 ++++++++++++++++++++++ wled00/const.h | 1 + wled00/usermods_list.cpp | 8 ++ 4 files changed, 98 insertions(+) create mode 100644 usermods/pov_display/usermod_pov_display.h diff --git a/platformio_override.sample.ini b/platformio_override.sample.ini index be959e46a..7f6524922 100644 --- a/platformio_override.sample.ini +++ b/platformio_override.sample.ini @@ -29,6 +29,8 @@ lib_deps = ${esp8266.lib_deps} ; ;gmag11/QuickESPNow @ ~0.7.0 # will also load QuickDebug ; https://github.com/blazoncek/QuickESPNow.git#optional-debug ;; exludes debug library ; ${esp32.AR_lib_deps} ;; used for USERMOD_AUDIOREACTIVE +; bitbank2/PNGdec@^1.0.1 ;; used for POV display uncomment following + build_unflags = ${common.build_unflags} build_flags = ${common.build_flags} ${esp8266.build_flags} ; @@ -152,6 +154,8 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} ; -D TACHO_PIN=33 ; -D PWM_PIN=32 ; +; Use POV Display usermod +; -D USERMOD_POV_DISPLAY ; Use built-in or custom LED as a status indicator (assumes LED is connected to GPIO16) ; -D STATUSLED=16 ; diff --git a/usermods/pov_display/usermod_pov_display.h b/usermods/pov_display/usermod_pov_display.h new file mode 100644 index 000000000..b1fc0dba6 --- /dev/null +++ b/usermods/pov_display/usermod_pov_display.h @@ -0,0 +1,85 @@ +#pragma once +#include "wled.h" +#include + +void * openFile(const char *filename, int32_t *size) { + f = WLED_FS.open(filename); + *size = f.size(); + return &f; +} + +void closeFile(void *handle) { + if (f) f.close(); +} + +int32_t readFile(PNGFILE *pFile, uint8_t *pBuf, int32_t iLen) +{ + int32_t iBytesRead; + iBytesRead = iLen; + File *f = static_cast(pFile->fHandle); + // Note: If you read a file all the way to the last byte, seek() stops working + if ((pFile->iSize - pFile->iPos) < iLen) + iBytesRead = pFile->iSize - pFile->iPos - 1; // <-- ugly work-around + if (iBytesRead <= 0) + return 0; + iBytesRead = (int32_t)f->read(pBuf, iBytesRead); + pFile->iPos = f->position(); + return iBytesRead; +} + +int32_t seekFile(PNGFILE *pFile, int32_t iPosition) +{ + int i = micros(); + File *f = static_cast(pFile->fHandle); + f->seek(iPosition); + pFile->iPos = (int32_t)f->position(); + i = micros() - i; + return pFile->iPos; +} + +void draw(PNGDRAW *pDraw) { + uint16_t usPixels[SEGLEN]; + png.getLineAsRGB565(pDraw, usPixels, PNG_RGB565_LITTLE_ENDIAN, 0xffffffff); + for(int x=0; x < SEGLEN; x++) { + uint16_t color = usPixels[x]; + byte r = ((color >> 11) & 0x1F); + byte g = ((color >> 5) & 0x3F); + byte b = (color & 0x1F); + SEGMENT.setPixelColor(x, RGBW32(r,g,b,0)); + } + strip.show(); +} + +uint16_t mode_pov_image(void) { + const char * filepath = SEGMENT.name; + int rc = png.open(filepath, openFile, closeFile, readFile, seekFile, draw); + if (rc == PNG_SUCCESS) { + rc = png.decode(NULL, 0); + png.close(); + return FRAMETIME; + } + return FRAMETIME; +} + +class PovDisplayUsermod : public Usermod +{ + public: + static const char _data_FX_MODE_POV_IMAGE[] PROGMEM = "POV Image@!;;;1"; + + PNG png; + File f; + + void setup() { + strip.addEffect(255, &mode_pov_image, _data_FX_MODE_POV_IMAGE); + } + + void loop() { + } + + uint16_t getId() + { + return USERMOD_ID_POV_DISPLAY; + } + + void connected() {} +}; diff --git a/wled00/const.h b/wled00/const.h index 0ff70e47d..72e1a3bae 100644 --- a/wled00/const.h +++ b/wled00/const.h @@ -200,6 +200,7 @@ #define USERMOD_ID_INA226 50 //Usermod "usermod_ina226.h" #define USERMOD_ID_AHT10 51 //Usermod "usermod_aht10.h" #define USERMOD_ID_LD2410 52 //Usermod "usermod_ld2410.h" +#define USERMOD_ID_POV_DISPLAY 53 //Usermod "usermod_pov_display.h" //Access point behavior #define AP_BEHAVIOR_BOOT_NO_CONN 0 //Open AP when no connection after boot diff --git a/wled00/usermods_list.cpp b/wled00/usermods_list.cpp index a39aa5f41..be2239d65 100644 --- a/wled00/usermods_list.cpp +++ b/wled00/usermods_list.cpp @@ -210,6 +210,10 @@ #include "../usermods/LDR_Dusk_Dawn_v2/usermod_LDR_Dusk_Dawn_v2.h" #endif +#ifdef USERMOD_POV_DISPLAY + #include "../usermods/pov_display/usermod_pov_display.h" +#endif + #ifdef USERMOD_STAIRCASE_WIPE #include "../usermods/stairway_wipe_basic/stairway-wipe-usermod-v2.h" #endif @@ -454,4 +458,8 @@ void registerUsermods() #ifdef USERMOD_LD2410 usermods.add(new LD2410Usermod()); #endif + + #ifdef USERMOD_POV_DISPLAY + usermods.add(new PovDisplayUsermod()); + #endif } From cde5314d416777e255fec5f9b6437705669e6f27 Mon Sep 17 00:00:00 2001 From: jdiamond Date: Sun, 11 Aug 2024 01:23:41 +0000 Subject: [PATCH 04/28] Add "dice" to environment names, and add more information about fitting in a 4MB partition. --- usermods/pixels_dice_tray/README.md | 4 +++- usermods/pixels_dice_tray/platformio_override.ini.sample | 9 +++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/usermods/pixels_dice_tray/README.md b/usermods/pixels_dice_tray/README.md index 5440b225c..6daa4fa72 100644 --- a/usermods/pixels_dice_tray/README.md +++ b/usermods/pixels_dice_tray/README.md @@ -63,6 +63,8 @@ The main purpose of this mod is to support [Pixels Dice](https://gamewithpixels. The only other ESP32 variant I tested was the ESP32-S3, which worked without issue. While there's still concern over the contention between BLE and WiFi for the radio, I haven't noticed any performance impact in practice. The only special behavior that was needed was setting `noWifiSleep = false;` to allow the OS to sleep the WiFi when the BLE is active. +In addition, the BLE stack requires a lot of flash. This build takes 1.9MB with the TFT code, or 1.85MB without it. This makes it too big to fit in the `tools/WLED_ESP32_4MB_256KB_FS.csv` partition layout, and I needed to make a `WLED_ESP32_4MB_64KB_FS.csv` to even fit on 4MB devices. This only has 64KB of file system space, which is functional, but users with more than a handful of presets would run into problems with 64KB only. This means that while 4MB can be supported, larger flash sizes are needed for full functionality. + The basic build of this usermod doesn't require any special hardware. However, the LCD status GUI was specifically designed for the [LILYGO T-QT Pro](https://www.lilygo.cc/products/t-qt-pro). It should be relatively easy to support other displays, though the positioning of the text may need to be adjusted. @@ -245,7 +247,7 @@ This usermod is in support of a particular dice box project, but it would be fai I really wanted to have this work on the original ESP32 boards to lower the barrier to entry, but there were several issues. -First, the BLE stack requires a lot of flash. I had to make a special partitioning plan `WLED_ESP32_4MB_64KB_FS.csv` to even fit the build on 4MB devices. This only has 64KB of file system space, which is limited, but still functional. +First there are the issues with the partition sizes for 4MB mentioned in the [Hardware](#hardware) section. The bigger issue is that the build consistently crashes if the BLE scan task starts up. It's a bit unclear to me exactly what is failing since the backtrace is showing an exception in `new[]` memory allocation in the UDP stack. There appears to be a ton of heap available, so my guess is that this is a synchronization issue of some sort from the tasks running in parallel. I tried messing with the task core affinity a bit but didn't make much progress. It's not really clear what difference between the ESP32S3 and ESP32 would cause this difference. diff --git a/usermods/pixels_dice_tray/platformio_override.ini.sample b/usermods/pixels_dice_tray/platformio_override.ini.sample index 844ff1bb2..b712f8b2e 100644 --- a/usermods/pixels_dice_tray/platformio_override.ini.sample +++ b/usermods/pixels_dice_tray/platformio_override.ini.sample @@ -1,10 +1,10 @@ [platformio] -default_envs = t_qt_pro_8MB, esp32s3dev_8MB_qspi +default_envs = t_qt_pro_8MB_dice, esp32s3dev_8MB_qspi_dice # ------------------------------------------------------------------------------ # T-QT Pro 8MB with integrated 128x128 TFT screen # ------------------------------------------------------------------------------ -[env:t_qt_pro_8MB] +[env:t_qt_pro_8MB_dice] board = esp32-s3-devkitc-1 ;; generic dev board; platform = ${esp32s3.platform} upload_speed = 921600 @@ -66,7 +66,7 @@ lib_deps = ${esp32s3.lib_deps} # ------------------------------------------------------------------------------ # ESP32S3 dev board with 8MB flash and no extended RAM. # ------------------------------------------------------------------------------ -[env:esp32s3dev_8MB_qspi] +[env:esp32s3dev_8MB_qspi_dice] board = esp32-s3-devkitc-1 ;; generic dev board; platform = ${esp32s3.platform} upload_speed = 921600 @@ -103,7 +103,8 @@ lib_deps = ${esp32s3.lib_deps} # ESP32S3 would be causing this, though they do run different BLE versions. # May be related to some of the issues discussed in: # https://github.com/Aircoookie/WLED/issues/1382 -; [env:esp32dev] +; [env:esp32dev_dice] +; extends = env:esp32dev ; build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=ESP32 ; ; Enable Pixels dice mod ; -D USERMOD_PIXELS_DICE_TRAY From b73f049484f961da6fb13388506a36410748cb4c Mon Sep 17 00:00:00 2001 From: jdiamond Date: Tue, 13 Aug 2024 04:40:59 +0000 Subject: [PATCH 05/28] Clean up addEffect() changes. --- wled00/FX.cpp | 6 ++++-- wled00/FX.h | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/wled00/FX.cpp b/wled00/FX.cpp index 8c24ab166..fc1d96ce2 100644 --- a/wled00/FX.cpp +++ b/wled00/FX.cpp @@ -7909,11 +7909,13 @@ uint8_t WS2812FX::addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name) _mode[id] = mode_fn; _modeData[id] = mode_name; return id; - } else { + } else if(_mode.size() < 255) { // 255 is reserved for indicating the effect wasn't added _mode.push_back(mode_fn); _modeData.push_back(mode_name); if (_modeCount < _mode.size()) _modeCount++; - return (_mode.size() <= 255) ? _mode.size() - 1 : 255; + return _mode.size() - 1; + } else { + return 255; // The vector is full so return 255 } } diff --git a/wled00/FX.h b/wled00/FX.h index b914fec2f..14c19edb7 100644 --- a/wled00/FX.h +++ b/wled00/FX.h @@ -772,7 +772,6 @@ class WS2812FX { // 96 bytes show(void), // initiates LED output setTargetFps(uint8_t fps), setupEffectData(void); // add default effects to the list; defined in FX.cpp - uint8_t addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name); // add effect to the list; defined in FX.cpp inline void restartRuntime() { for (Segment &seg : _segments) seg.markForReset(); } inline void setTransitionMode(bool t) { for (Segment &seg : _segments) seg.startTransition(t ? _transitionDur : 0); } @@ -808,7 +807,8 @@ class WS2812FX { // 96 bytes getActiveSegmentsNum(void), getFirstSelectedSegId(void), getLastActiveSegmentId(void), - getActiveSegsLightCapabilities(bool selectedOnly = false); + getActiveSegsLightCapabilities(bool selectedOnly = false), + addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name); // add effect to the list; defined in FX.cpp inline uint8_t getBrightness(void) { return _brightness; } // returns current strip brightness inline uint8_t getMaxSegments(void) { return MAX_NUM_SEGMENTS; } // returns maximum number of supported segments (fixed value) From f6c47ac19cd9fc2b6b2861289b86f2ef963a329a Mon Sep 17 00:00:00 2001 From: Blaz Kristan Date: Sun, 18 Aug 2024 10:45:16 +0200 Subject: [PATCH 06/28] Fix some compiler warnings --- wled00/FX_2Dfcn.cpp | 10 +++++----- wled00/FX_fcn.cpp | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/wled00/FX_2Dfcn.cpp b/wled00/FX_2Dfcn.cpp index 0fd5bb09f..44919f925 100644 --- a/wled00/FX_2Dfcn.cpp +++ b/wled00/FX_2Dfcn.cpp @@ -185,14 +185,14 @@ void IRAM_ATTR Segment::setPixelColorXY(int x, int y, uint32_t col) x *= groupLength(); // expand to physical pixels y *= groupLength(); // expand to physical pixels - unsigned W = width(); - unsigned H = height(); + int W = width(); + int H = height(); if (x >= W || y >= H) return; // if pixel would fall out of segment just exit uint32_t tmpCol = col; - for (unsigned j = 0; j < grouping; j++) { // groupping vertically - for (unsigned g = 0; g < grouping; g++) { // groupping horizontally - unsigned xX = (x+g), yY = (y+j); + for (int j = 0; j < grouping; j++) { // groupping vertically + for (int g = 0; g < grouping; g++) { // groupping horizontally + int xX = (x+g), yY = (y+j); if (xX >= W || yY >= H) continue; // we have reached one dimension's end #ifndef WLED_DISABLE_MODE_BLEND diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp index c6c0dad4d..bc5c8b051 100644 --- a/wled00/FX_fcn.cpp +++ b/wled00/FX_fcn.cpp @@ -905,8 +905,8 @@ uint32_t IRAM_ATTR Segment::getPixelColor(int i) const #ifndef WLED_DISABLE_2D if (is2D()) { - unsigned vH = virtualHeight(); // segment height in logical pixels - unsigned vW = virtualWidth(); + int vH = virtualHeight(); // segment height in logical pixels + int vW = virtualWidth(); switch (map1D2D) { case M12_Pixels: return getPixelColorXY(i % vW, i / vW); From 665693a513d893788b539d1ac55f12b2a34dd258 Mon Sep 17 00:00:00 2001 From: Robin Meis Date: Sun, 18 Aug 2024 13:31:14 +0200 Subject: [PATCH 07/28] Remove minimum threshold according to https://github.com/Aircoookie/WLED/pull/4081#issuecomment-2295198219 --- wled00/set.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wled00/set.cpp b/wled00/set.cpp index 13295df21..48cf93c80 100644 --- a/wled00/set.cpp +++ b/wled00/set.cpp @@ -289,7 +289,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage) #ifdef SOC_TOUCH_VERSION_2 // ESP32 S2 and S3 have a fucntion to check touch state but need to attach an interrupt to do so else { - touchAttachInterrupt(btnPin[i], touchButtonISR, 256 + (touchThreshold << 4)); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000) + touchAttachInterrupt(btnPin[i], touchButtonISR, touchThreshold << 4); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000) } #endif } From e5a426419c78cdd51f6ebdc4555a3576e14a0256 Mon Sep 17 00:00:00 2001 From: Maximilian Mewes Date: Mon, 19 Aug 2024 22:07:08 +0200 Subject: [PATCH 08/28] Improve mqtt support, add battery percentage and voltage --- usermods/Battery/usermod_v2_Battery.h | 78 ++++++++++++++++++++++++--- 1 file changed, 71 insertions(+), 7 deletions(-) diff --git a/usermods/Battery/usermod_v2_Battery.h b/usermods/Battery/usermod_v2_Battery.h index f240d55f5..e22717db4 100644 --- a/usermods/Battery/usermod_v2_Battery.h +++ b/usermods/Battery/usermod_v2_Battery.h @@ -115,6 +115,58 @@ class UsermodBattery : public Usermod #endif } +#ifndef WLED_DISABLE_MQTT + void addMqttSensor(const String &name, const String &type, const String &topic, const String &deviceClass, const String &unitOfMeasurement = "", const bool &isDiagnostic = false) + { + // String t = String(F("homeassistant/sensor/")) + mqttClientID + F("/") + name + F("/config"); + + StaticJsonDocument<600> doc; + char uid[128], json_str[1024], buf[128]; + + doc[F("name")] = name; + doc[F("stat_t")] = topic; + sprintf_P(uid, PSTR("%s_%s_sensor"), name, escapedMac.c_str()); + doc[F("uniq_id")] = uid; + doc[F("dev_cla")] = deviceClass; + // doc[F("exp_aft")] = 1800; + + if(type == "binary_sensor") { + doc[F("pl_on")] = "on"; + doc[F("pl_off")] = "off"; + } + + if(unitOfMeasurement != "") + doc[F("unit_of_measurement")] = unitOfMeasurement; + + if(isDiagnostic) + doc[F("entity_category")] = "diagnostic"; + + + JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device + device[F("name")] = serverDescription; + device[F("ids")] = String(F("wled-sensor-")) + mqttClientID; + device[F("mf")] = F(WLED_BRAND); + device[F("mdl")] = F(WLED_PRODUCT_NAME); + device[F("sw")] = versionString; + + sprintf_P(buf, PSTR("homeassistant/%s/%s/%s/config"), type, mqttClientID, uid); + DEBUG_PRINTLN(buf); + size_t payload_size = serializeJson(doc, json_str); + DEBUG_PRINTLN(json_str); + + mqtt->publish(buf, 0, true, json_str, payload_size); + } + + void publishMqtt(const char* topic, const char* state) + { + if (WLED_MQTT_CONNECTED) { + char buf[128]; + snprintf_P(buf, 127, PSTR("%s/%s"), mqttDeviceTopic, topic); + mqtt->publish(buf, 0, false, state); + } + } +#endif + public: //Functions called by WLED @@ -223,13 +275,8 @@ class UsermodBattery : public Usermod turnOff(); #ifndef WLED_DISABLE_MQTT - // SmartHome stuff - // still don't know much about MQTT and/or HA - if (WLED_MQTT_CONNECTED) { - char buf[64]; // buffer for snprintf() - snprintf_P(buf, 63, PSTR("%s/voltage"), mqttDeviceTopic); - mqtt->publish(buf, 0, false, String(bat->getVoltage()).c_str()); - } + publishMqtt("battery", String(bat->getLevel(), 0).c_str()); + publishMqtt("voltage", String(bat->getVoltage()).c_str()); #endif } @@ -513,6 +560,23 @@ class UsermodBattery : public Usermod return !battery[FPSTR(_readInterval)].isNull(); } +#ifndef WLED_DISABLE_MQTT + void onMqttConnect(bool sessionPresent) + { + // Home Assistant Autodiscovery + + // battery percentage + char mqttBatteryTopic[128]; + snprintf_P(mqttBatteryTopic, 127, PSTR("%s/battery"), mqttDeviceTopic); + this->addMqttSensor(F("Battery"), "sensor", mqttBatteryTopic, "battery", "%", true); + + // voltage + char mqttVoltageTopic[128]; + snprintf_P(mqttVoltageTopic, 127, PSTR("%s/voltage"), mqttDeviceTopic); + this->addMqttSensor(F("Voltage"), "sensor", mqttVoltageTopic, "voltage", "V", true); + } +#endif + /** * TBD: Generate a preset sample for low power indication * a button on the config page would be cool, currently not possible From b8f15333d857f92b9346c16f75eab300882f87e2 Mon Sep 17 00:00:00 2001 From: Maximilian Mewes Date: Mon, 19 Aug 2024 22:12:21 +0200 Subject: [PATCH 09/28] update `readme.md` --- usermods/Battery/readme.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/usermods/Battery/readme.md b/usermods/Battery/readme.md index 84a6f5054..c3d3d8bf4 100644 --- a/usermods/Battery/readme.md +++ b/usermods/Battery/readme.md @@ -131,6 +131,11 @@ Specification from: [Molicel INR18650-M35A, 3500mAh 10A Lithium-ion battery, 3.6 ## 📝 Change Log +2024-08-19 + +- Improved MQTT support +- Added battery percentage & battery voltage as MQTT topic + 2024-05-11 - Documentation updated From cc24119a590e3256ad2e81841bfa3cf76ed00bfc Mon Sep 17 00:00:00 2001 From: Maximilian Mewes Date: Mon, 19 Aug 2024 22:22:46 +0200 Subject: [PATCH 10/28] remove unnecessary comments --- usermods/Battery/usermod_v2_Battery.h | 43 ++------------------------- 1 file changed, 3 insertions(+), 40 deletions(-) diff --git a/usermods/Battery/usermod_v2_Battery.h b/usermods/Battery/usermod_v2_Battery.h index e22717db4..c9d3b639e 100644 --- a/usermods/Battery/usermod_v2_Battery.h +++ b/usermods/Battery/usermod_v2_Battery.h @@ -117,9 +117,7 @@ class UsermodBattery : public Usermod #ifndef WLED_DISABLE_MQTT void addMqttSensor(const String &name, const String &type, const String &topic, const String &deviceClass, const String &unitOfMeasurement = "", const bool &isDiagnostic = false) - { - // String t = String(F("homeassistant/sensor/")) + mqttClientID + F("/") + name + F("/config"); - + { StaticJsonDocument<600> doc; char uid[128], json_str[1024], buf[128]; @@ -128,11 +126,11 @@ class UsermodBattery : public Usermod sprintf_P(uid, PSTR("%s_%s_sensor"), name, escapedMac.c_str()); doc[F("uniq_id")] = uid; doc[F("dev_cla")] = deviceClass; - // doc[F("exp_aft")] = 1800; if(type == "binary_sensor") { doc[F("pl_on")] = "on"; doc[F("pl_off")] = "off"; + doc[F("exp_aft")] = 1800; } if(unitOfMeasurement != "") @@ -141,7 +139,6 @@ class UsermodBattery : public Usermod if(isDiagnostic) doc[F("entity_category")] = "diagnostic"; - JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device device[F("name")] = serverDescription; device[F("ids")] = String(F("wled-sensor-")) + mqttClientID; @@ -525,7 +522,6 @@ class UsermodBattery : public Usermod #ifdef ARDUINO_ARCH_ESP32 newBatteryPin = battery[F("pin")] | newBatteryPin; #endif - // calculateTimeLeftEnabled = battery[F("time-left")] | calculateTimeLeftEnabled; setMinBatteryVoltage(battery[F("min-voltage")] | bat->getMinVoltage()); setMaxBatteryVoltage(battery[F("max-voltage")] | bat->getMaxVoltage()); setCalibration(battery[F("calibration")] | bat->getCalibration()); @@ -575,40 +571,7 @@ class UsermodBattery : public Usermod snprintf_P(mqttVoltageTopic, 127, PSTR("%s/voltage"), mqttDeviceTopic); this->addMqttSensor(F("Voltage"), "sensor", mqttVoltageTopic, "voltage", "V", true); } -#endif - - /** - * TBD: Generate a preset sample for low power indication - * a button on the config page would be cool, currently not possible - */ - void generateExamplePreset() - { - // StaticJsonDocument<300> j; - // JsonObject preset = j.createNestedObject(); - // preset["mainseg"] = 0; - // JsonArray seg = preset.createNestedArray("seg"); - // JsonObject seg0 = seg.createNestedObject(); - // seg0["id"] = 0; - // seg0["start"] = 0; - // seg0["stop"] = 60; - // seg0["grp"] = 0; - // seg0["spc"] = 0; - // seg0["on"] = true; - // seg0["bri"] = 255; - - // JsonArray col0 = seg0.createNestedArray("col"); - // JsonArray col00 = col0.createNestedArray(); - // col00.add(255); - // col00.add(0); - // col00.add(0); - - // seg0["fx"] = 1; - // seg0["sx"] = 128; - // seg0["ix"] = 128; - - // savePreset(199, "Low power Indicator", preset); - } - +#endif /* * From 2d6365dc6a6a0bdb6606312478e8439eff6fa7b4 Mon Sep 17 00:00:00 2001 From: Maximilian Mewes Date: Tue, 20 Aug 2024 12:37:01 +0200 Subject: [PATCH 11/28] Add HA-discovery as config option --- usermods/Battery/usermod_v2_Battery.h | 61 +++++++++++++++++++++------ 1 file changed, 48 insertions(+), 13 deletions(-) diff --git a/usermods/Battery/usermod_v2_Battery.h b/usermods/Battery/usermod_v2_Battery.h index c9d3b639e..136d3a71a 100644 --- a/usermods/Battery/usermod_v2_Battery.h +++ b/usermods/Battery/usermod_v2_Battery.h @@ -50,6 +50,7 @@ class UsermodBattery : public Usermod // bool initDone = false; bool initializing = true; + bool HomeAssistantDiscovery = false; // strings to reduce flash memory usage (used more than twice) static const char _name[]; @@ -59,6 +60,7 @@ class UsermodBattery : public Usermod static const char _preset[]; static const char _duration[]; static const char _init[]; + static const char _haDiscovery[]; /** * Helper for rounding floating point values @@ -69,6 +71,17 @@ class UsermodBattery : public Usermod return (float)(nx / 100); } + /** + * Helper for converting a string to lowercase + */ + String stringToLower(String str) + { + for(int i = 0; i < str.length(); i++) + if(str[i] >= 'A' && str[i] <= 'Z') + str[i] += 32; + return str; + } + /** * Turn off all leds */ @@ -123,14 +136,14 @@ class UsermodBattery : public Usermod doc[F("name")] = name; doc[F("stat_t")] = topic; - sprintf_P(uid, PSTR("%s_%s_sensor"), name, escapedMac.c_str()); + sprintf_P(uid, PSTR("%s_%s_%s"), escapedMac.c_str(), stringToLower(name).c_str(), type); doc[F("uniq_id")] = uid; doc[F("dev_cla")] = deviceClass; + doc[F("exp_aft")] = 1800; if(type == "binary_sensor") { doc[F("pl_on")] = "on"; doc[F("pl_off")] = "off"; - doc[F("exp_aft")] = 1800; } if(unitOfMeasurement != "") @@ -332,6 +345,7 @@ class UsermodBattery : public Usermod battery[F("calibration")] = bat->getCalibration(); battery[F("voltage-multiplier")] = bat->getVoltageMultiplier(); battery[FPSTR(_readInterval)] = readingInterval; + battery[FPSTR(_haDiscovery)] = HomeAssistantDiscovery; JsonObject ao = battery.createNestedObject(F("auto-off")); // auto off section ao[FPSTR(_enabled)] = autoOffEnabled; @@ -351,8 +365,8 @@ class UsermodBattery : public Usermod getJsonValue(battery[F("max-voltage")], cfg.maxVoltage); getJsonValue(battery[F("calibration")], cfg.calibration); getJsonValue(battery[F("voltage-multiplier")], cfg.voltageMultiplier); - setReadingInterval(battery[FPSTR(_readInterval)] | readingInterval); + setHomeAssistantDiscovery(battery[FPSTR(_haDiscovery)] | HomeAssistantDiscovery); JsonObject ao = battery[F("auto-off")]; setAutoOffEnabled(ao[FPSTR(_enabled)] | autoOffEnabled); @@ -464,17 +478,18 @@ class UsermodBattery : public Usermod void appendConfigData() { // Total: 462 Bytes - oappend(SET_F("td=addDropdown('Battery', 'type');")); // 35 Bytes - oappend(SET_F("addOption(td, 'Unkown', '0');")); // 30 Bytes - oappend(SET_F("addOption(td, 'LiPo', '1');")); // 28 Bytes - oappend(SET_F("addOption(td, 'LiOn', '2');")); // 28 Bytes + oappend(SET_F("td=addDropdown('Battery','type');")); // 34 Bytes + oappend(SET_F("addOption(td,'Unkown','0');")); // 28 Bytes + oappend(SET_F("addOption(td,'LiPo','1');")); // 26 Bytes + oappend(SET_F("addOption(td,'LiOn','2');")); // 26 Bytes oappend(SET_F("addInfo('Battery:type',1,'requires reboot');")); // 81 Bytes - oappend(SET_F("addInfo('Battery:min-voltage', 1, 'v');")); // 40 Bytes - oappend(SET_F("addInfo('Battery:max-voltage', 1, 'v');")); // 40 Bytes - oappend(SET_F("addInfo('Battery:interval', 1, 'ms');")); // 38 Bytes - oappend(SET_F("addInfo('Battery:auto-off:threshold', 1, '%');")); // 47 Bytes - oappend(SET_F("addInfo('Battery:indicator:threshold', 1, '%');")); // 48 Bytes - oappend(SET_F("addInfo('Battery:indicator:duration', 1, 's');")); // 47 Bytes + oappend(SET_F("addInfo('Battery:min-voltage',1,'v');")); // 38 Bytes + oappend(SET_F("addInfo('Battery:max-voltage',1,'v');")); // 38 Bytes + oappend(SET_F("addInfo('Battery:interval',1,'ms');")); // 36 Bytes + oappend(SET_F("addInfo('Battery:HA-discovery',1,'');")); // 38 Bytes + oappend(SET_F("addInfo('Battery:auto-off:threshold',1,'%');")); // 45 Bytes + oappend(SET_F("addInfo('Battery:indicator:threshold',1,'%');")); // 46 Bytes + oappend(SET_F("addInfo('Battery:indicator:duration',1,'s');")); // 45 Bytes // this option list would exeed the oappend() buffer // a list of all presets to select one from @@ -527,6 +542,7 @@ class UsermodBattery : public Usermod setCalibration(battery[F("calibration")] | bat->getCalibration()); setVoltageMultiplier(battery[F("voltage-multiplier")] | bat->getVoltageMultiplier()); setReadingInterval(battery[FPSTR(_readInterval)] | readingInterval); + setHomeAssistantDiscovery(battery[FPSTR(_haDiscovery)] | HomeAssistantDiscovery); getUsermodConfigFromJsonObject(battery); @@ -560,6 +576,8 @@ class UsermodBattery : public Usermod void onMqttConnect(bool sessionPresent) { // Home Assistant Autodiscovery + if (!HomeAssistantDiscovery) + return; // battery percentage char mqttBatteryTopic[128]; @@ -812,6 +830,22 @@ class UsermodBattery : public Usermod { return lowPowerIndicationDone; } + + /** + * Set Home Assistant auto discovery + */ + void setHomeAssistantDiscovery(bool enable) + { + HomeAssistantDiscovery = enable; + } + + /** + * Get Home Assistant auto discovery + */ + bool getHomeAssistantDiscovery() + { + return HomeAssistantDiscovery; + } }; // strings to reduce flash memory usage (used more than twice) @@ -822,3 +856,4 @@ const char UsermodBattery::_threshold[] PROGMEM = "threshold"; const char UsermodBattery::_preset[] PROGMEM = "preset"; const char UsermodBattery::_duration[] PROGMEM = "duration"; const char UsermodBattery::_init[] PROGMEM = "init"; +const char UsermodBattery::_haDiscovery[] PROGMEM = "HA-discovery"; From e7babc071ddfe84b6b7da0c5666cb2b842a396bd Mon Sep 17 00:00:00 2001 From: Damian Schneider Date: Tue, 20 Aug 2024 20:15:17 +0200 Subject: [PATCH 12/28] replaced PWM LUT with calculation --- wled00/bus_manager.cpp | 43 ++++++++++-------------------------------- 1 file changed, 10 insertions(+), 33 deletions(-) diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp index d0e32b211..2ae624fee 100644 --- a/wled00/bus_manager.cpp +++ b/wled00/bus_manager.cpp @@ -497,45 +497,22 @@ uint32_t BusPwm::getPixelColor(uint16_t pix) { return RGBW32(_data[0], _data[0], _data[0], _data[0]); } -#ifndef ESP8266 -static const uint16_t cieLUT[256] = { - 0, 2, 4, 5, 7, 9, 11, 13, 15, 16, - 18, 20, 22, 24, 26, 27, 29, 31, 33, 35, - 34, 36, 37, 39, 41, 43, 45, 47, 49, 52, - 54, 56, 59, 61, 64, 67, 69, 72, 75, 78, - 81, 84, 87, 90, 94, 97, 100, 104, 108, 111, - 115, 119, 123, 127, 131, 136, 140, 144, 149, 154, - 158, 163, 168, 173, 178, 183, 189, 194, 200, 205, - 211, 217, 223, 229, 235, 241, 247, 254, 261, 267, - 274, 281, 288, 295, 302, 310, 317, 325, 333, 341, - 349, 357, 365, 373, 382, 391, 399, 408, 417, 426, - 436, 445, 455, 464, 474, 484, 494, 505, 515, 526, - 536, 547, 558, 569, 580, 592, 603, 615, 627, 639, - 651, 663, 676, 689, 701, 714, 727, 741, 754, 768, - 781, 795, 809, 824, 838, 853, 867, 882, 897, 913, - 928, 943, 959, 975, 991, 1008, 1024, 1041, 1058, 1075, - 1092, 1109, 1127, 1144, 1162, 1180, 1199, 1217, 1236, 1255, - 1274, 1293, 1312, 1332, 1352, 1372, 1392, 1412, 1433, 1454, - 1475, 1496, 1517, 1539, 1561, 1583, 1605, 1628, 1650, 1673, - 1696, 1719, 1743, 1767, 1791, 1815, 1839, 1864, 1888, 1913, - 1939, 1964, 1990, 2016, 2042, 2068, 2095, 2121, 2148, 2176, - 2203, 2231, 2259, 2287, 2315, 2344, 2373, 2402, 2431, 2461, - 2491, 2521, 2551, 2581, 2612, 2643, 2675, 2706, 2738, 2770, - 2802, 2835, 2867, 2900, 2934, 2967, 3001, 3035, 3069, 3104, - 3138, 3174, 3209, 3244, 3280, 3316, 3353, 3389, 3426, 3463, - 3501, 3539, 3576, 3615, 3653, 3692, 3731, 3770, 3810, 3850, - 3890, 3930, 3971, 4012, 4053, 4095 -}; -#endif - void BusPwm::show() { if (!_valid) return; unsigned numPins = NUM_PWM_PINS(_type); unsigned maxBri = (1<<_depth) - 1; #ifdef ESP8266 unsigned pwmBri = (unsigned)(roundf(powf((float)_bri / 255.0f, 1.7f) * (float)maxBri)); // using gamma 1.7 to extrapolate PWM duty cycle - #else - unsigned pwmBri = cieLUT[_bri] >> (12 - _depth); // use CIE LUT + #else // use CIE brightness formula + unsigned pwmBri = (unsigned)_bri * 100; + if(pwmBri < 2040) pwmBri = ((pwmBri << _depth) + 115043) / 230087; //adding '0.5' before division for correct rounding + else { + pwmBri += 4080; + float temp = (float)pwmBri / 29580; + temp = temp * temp * temp * (1<<_depth) - 1; + pwmBri = (unsigned)temp; + } + Serial.println(pwmBri); #endif for (unsigned i = 0; i < numPins; i++) { unsigned scaled = (_data[i] * pwmBri) / 255; From 1cc47b02cf7d828c9424773478f3d1f2b9805cf5 Mon Sep 17 00:00:00 2001 From: Damian Schneider Date: Wed, 21 Aug 2024 08:06:32 +0200 Subject: [PATCH 13/28] use CIE brightness also for ESP8266 --- wled00/bus_manager.cpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp index 2ae624fee..24cb7993d 100644 --- a/wled00/bus_manager.cpp +++ b/wled00/bus_manager.cpp @@ -501,9 +501,7 @@ void BusPwm::show() { if (!_valid) return; unsigned numPins = NUM_PWM_PINS(_type); unsigned maxBri = (1<<_depth) - 1; - #ifdef ESP8266 - unsigned pwmBri = (unsigned)(roundf(powf((float)_bri / 255.0f, 1.7f) * (float)maxBri)); // using gamma 1.7 to extrapolate PWM duty cycle - #else // use CIE brightness formula + // use CIE brightness formula unsigned pwmBri = (unsigned)_bri * 100; if(pwmBri < 2040) pwmBri = ((pwmBri << _depth) + 115043) / 230087; //adding '0.5' before division for correct rounding else { @@ -512,8 +510,6 @@ void BusPwm::show() { temp = temp * temp * temp * (1<<_depth) - 1; pwmBri = (unsigned)temp; } - Serial.println(pwmBri); - #endif for (unsigned i = 0; i < numPins; i++) { unsigned scaled = (_data[i] * pwmBri) / 255; if (_reversed) scaled = maxBri - scaled; From 0bbd6b7c4b677249b584f90abbacde6f44f0ea85 Mon Sep 17 00:00:00 2001 From: Blaz Kristan Date: Thu, 22 Aug 2024 17:08:51 +0200 Subject: [PATCH 14/28] Minor optimisation - disable JSON live - WS error string - button irelevant check --- wled00/button.cpp | 2 +- wled00/wled.h | 4 ++-- wled00/ws.cpp | 8 ++++++-- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/wled00/button.cpp b/wled00/button.cpp index 23d7b8a90..8b366e055 100644 --- a/wled00/button.cpp +++ b/wled00/button.cpp @@ -308,7 +308,7 @@ void handleButton() buttonLongPressed[b] = true; } - } else if (!isButtonPressed(b) && buttonPressedBefore[b]) { //released + } else if (buttonPressedBefore[b]) { //released long dur = now - buttonPressedTime[b]; // released after rising-edge short press action diff --git a/wled00/wled.h b/wled00/wled.h index b9e675edc..7ef41d961 100644 --- a/wled00/wled.h +++ b/wled00/wled.h @@ -36,7 +36,7 @@ #undef WLED_ENABLE_ADALIGHT // disable has priority over enable #endif //#define WLED_ENABLE_DMX // uses 3.5kb (use LEDPIN other than 2) -#define WLED_ENABLE_JSONLIVE // peek LED output via /json/live (WS binary peek is always enabled) +//#define WLED_ENABLE_JSONLIVE // peek LED output via /json/live (WS binary peek is always enabled) #ifndef WLED_DISABLE_LOXONE #define WLED_ENABLE_LOXONE // uses 1.2kb #endif @@ -331,7 +331,7 @@ typedef class WiFiOptions { struct { uint8_t selectedWiFi : 4; // max 16 SSIDs uint8_t apChannel : 4; - bool apHide : 1; + uint8_t apHide : 3; uint8_t apBehavior : 3; bool noWifiSleep : 1; bool force802_3g : 1; diff --git a/wled00/ws.cpp b/wled00/ws.cpp index d0bac144d..3dec548f4 100644 --- a/wled00/ws.cpp +++ b/wled00/ws.cpp @@ -96,6 +96,8 @@ void wsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventTyp //pong message was received (in response to a ping request maybe) DEBUG_PRINTLN(F("WS pong.")); + } else { + DEBUG_PRINTLN(F("WS unknown event.")); } } @@ -104,10 +106,11 @@ void sendDataWs(AsyncWebSocketClient * client) if (!ws.count()) return; if (!requestJSONBufferLock(12)) { + const char* error = PSTR("{\"error\":3}"); if (client) { - client->text(F("{\"error\":3}")); // ERR_NOBUF + client->text(FPSTR(error)); // ERR_NOBUF } else { - ws.textAll(F("{\"error\":3}")); // ERR_NOBUF + ws.textAll(FPSTR(error)); // ERR_NOBUF } return; } @@ -120,6 +123,7 @@ void sendDataWs(AsyncWebSocketClient * client) size_t len = measureJson(*pDoc); DEBUG_PRINTF_P(PSTR("JSON buffer size: %u for WS request (%u).\n"), pDoc->memoryUsage(), len); + // the following may no longer be necessary as heap management has been fixed by @willmmiles in AWS size_t heap1 = ESP.getFreeHeap(); DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); #ifdef ESP8266 From dd5212476512b3fae88ec6aca6561f4057e60dd4 Mon Sep 17 00:00:00 2001 From: ChuckMash <86080247+ChuckMash@users.noreply.github.com> Date: Thu, 22 Aug 2024 20:24:03 -0700 Subject: [PATCH 15/28] Added some byte definitions to WiZmote ESP-NOW message --- wled00/remote.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/wled00/remote.cpp b/wled00/remote.cpp index 9c8d67d0d..9d8b94df0 100644 --- a/wled00/remote.cpp +++ b/wled00/remote.cpp @@ -25,11 +25,11 @@ typedef struct WizMoteMessageStructure { uint8_t program; // 0x91 for ON button, 0x81 for all others uint8_t seq[4]; // Incremetal sequence number 32 bit unsigned integer LSB first - uint8_t byte5; // Unknown (seen 0x20) + uint8_t dt1; // Button Data Type (0x32) uint8_t button; // Identifies which button is being pressed - uint8_t byte8; // Unknown, but always 0x01 - uint8_t byte9; // Unnkown, but always 0x64 - + uint8_t dt2; // Battery Level Data Type (0x01) + uint8_t batLevel; // Battery Level 0-100 + uint8_t byte10; // Unknown, maybe checksum uint8_t byte11; // Unknown, maybe checksum uint8_t byte12; // Unknown, maybe checksum @@ -225,4 +225,4 @@ void handleRemote(uint8_t *incomingData, size_t len) { #else void handleRemote(uint8_t *incomingData, size_t len) {} -#endif \ No newline at end of file +#endif From c1c707c77ad8f97260557e953d1c7537700f5755 Mon Sep 17 00:00:00 2001 From: Frank <91616163+softhack007@users.noreply.github.com> Date: Wed, 4 Sep 2024 11:38:03 +0200 Subject: [PATCH 16/28] 8266 compatibility builds for older chips (another attempt t o solve #3690 and #3685) some users have reported that releases after 0.14.0 are not working reliably. So we add a few "compat" for 8266 that try to reproduce the buildenv of 0.14.0 as much as possible. * platform and platform_packages from 0.14.0 * not using PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48 * due to smaller IRAM, we had to move some functions back from IRAM to normal flash (may cause slowdown) --- platformio.ini | 56 ++++++++++++++++++++++++++++++++++++++++++++- wled00/FX_2Dfcn.cpp | 6 ++--- wled00/FX_fcn.cpp | 16 ++++++------- wled00/const.h | 8 +++++++ 4 files changed, 74 insertions(+), 12 deletions(-) diff --git a/platformio.ini b/platformio.ini index 5ebc43f55..9888ea102 100644 --- a/platformio.ini +++ b/platformio.ini @@ -10,7 +10,7 @@ # ------------------------------------------------------------------------------ # CI/release binaries -default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, nodemcuv2_160, esp8266_2m_160, esp01_1m_full_160, esp32dev, esp32_eth, esp32dev_audioreactive, lolin_s2_mini, esp32c3dev, esp32s3dev_16MB_opi, esp32s3dev_8MB_opi, esp32s3_4M_qspi, esp32_wrover +default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, nodemcuv2_160, esp8266_2m_160, esp01_1m_full_160, nodemcuv2_compat, esp8266_2m_compat, esp01_1m_full_compat, esp32dev, esp32_eth, esp32dev_audioreactive, lolin_s2_mini, esp32c3dev, esp32s3dev_16MB_opi, esp32s3dev_8MB_opi, esp32s3_4M_qspi, esp32_wrover src_dir = ./wled00 data_dir = ./wled00/data @@ -205,6 +205,38 @@ lib_deps = ESP8266PWM ${env.lib_deps} +;; compatibilty flags - same as 0.14.0 which seems to work better on some 8266 boards. Not using PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48 +build_flags_compat = + -DESP8266 + -DFP_IN_IROM + ;;-Wno-deprecated-declarations + -Wno-misleading-indentation + ;;-Wno-attributes ;; silence warnings about unknown attribute 'maybe_unused' in NeoPixelBus + -DPIO_FRAMEWORK_ARDUINO_ESPRESSIF_SDK22x_190703 + -DPIO_FRAMEWORK_ARDUINO_LWIP_HIGHER_BANDWIDTH + -DVTABLES_IN_FLASH + -DMIMETYPE_MINIMAL + -DWLED_SAVE_IRAM ;; needed to prevent linker error + +;; this platform version was used for WLED 0.14.0 +platform_compat = espressif8266@4.2.0 +platform_packages_compat = + platformio/toolchain-xtensa @ ~2.100300.220621 #2.40802.200502 + platformio/tool-esptool #@ ~1.413.0 + platformio/tool-esptoolpy #@ ~1.30000.0 + +;; experimental - for using older NeoPixelBus 2.7.9 +lib_deps_compat = + ESPAsyncTCP @ 1.2.2 + ESPAsyncUDP + ESP8266PWM + fastled/FastLED @ 3.6.0 + IRremoteESP8266 @ 2.8.2 + makuna/NeoPixelBus @ 2.7.9 + https://github.com/blazoncek/QuickESPNow.git#optional-debug + https://github.com/Aircoookie/ESPAsyncWebServer.git @ 2.2.1 + + [esp32] #platform = https://github.com/tasmota/platform-espressif32/releases/download/v2.0.2.3/platform-espressif32-2.0.2.3.zip platform = espressif32@3.5.0 @@ -315,6 +347,14 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME= lib_deps = ${esp8266.lib_deps} monitor_filters = esp8266_exception_decoder +[env:nodemcuv2_compat] +extends = env:nodemcuv2 +;; using platform version and build options from WLED 0.14.0 +platform = ${esp8266.platform_compat} +platform_packages = ${esp8266.platform_packages_compat} +build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=ESP8266_compat #-DWLED_DISABLE_2D +;; lib_deps = ${esp8266.lib_deps_compat} ;; experimental - use older NeoPixelBus 2.7.9 + [env:nodemcuv2_160] extends = env:nodemcuv2 board_build.f_cpu = 160000000L @@ -329,6 +369,13 @@ build_unflags = ${common.build_unflags} build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=ESP02 lib_deps = ${esp8266.lib_deps} +[env:esp8266_2m_compat] +extends = env:esp8266_2m +;; using platform version and build options from WLED 0.14.0 +platform = ${esp8266.platform_compat} +platform_packages = ${esp8266.platform_packages_compat} +build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=ESP02_compat #-DWLED_DISABLE_2D + [env:esp8266_2m_160] extends = env:esp8266_2m board_build.f_cpu = 160000000L @@ -344,6 +391,13 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME= ; -D WLED_USE_REAL_MATH ;; may fix wrong sunset/sunrise times, at the cost of 7064 bytes FLASH and 975 bytes RAM lib_deps = ${esp8266.lib_deps} +[env:esp01_1m_full_compat] +extends = env:esp01_1m_full +;; using platform version and build options from WLED 0.14.0 +platform = ${esp8266.platform_compat} +platform_packages = ${esp8266.platform_packages_compat} +build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=ESP01_compat -D WLED_DISABLE_OTA #-DWLED_DISABLE_2D + [env:esp01_1m_full_160] extends = env:esp01_1m_full board_build.f_cpu = 160000000L diff --git a/wled00/FX_2Dfcn.cpp b/wled00/FX_2Dfcn.cpp index 44919f925..efae0e5e3 100644 --- a/wled00/FX_2Dfcn.cpp +++ b/wled00/FX_2Dfcn.cpp @@ -161,14 +161,14 @@ void WS2812FX::setUpMatrix() { #ifndef WLED_DISABLE_2D // XY(x,y) - gets pixel index within current segment (often used to reference leds[] array element) -uint16_t IRAM_ATTR Segment::XY(uint16_t x, uint16_t y) +uint16_t IRAM_ATTR_YN Segment::XY(uint16_t x, uint16_t y) { unsigned width = virtualWidth(); // segment width in logical pixels (can be 0 if segment is inactive) unsigned height = virtualHeight(); // segment height in logical pixels (is always >= 1) return isActive() ? (x%width) + (y%height) * width : 0; } -void IRAM_ATTR Segment::setPixelColorXY(int x, int y, uint32_t col) +void IRAM_ATTR_YN Segment::setPixelColorXY(int x, int y, uint32_t col) { if (!isActive()) return; // not active if (x >= virtualWidth() || y >= virtualHeight() || x<0 || y<0) return; // if pixel would fall out of virtual segment just exit @@ -264,7 +264,7 @@ void Segment::setPixelColorXY(float x, float y, uint32_t col, bool aa) #endif // returns RGBW values of pixel -uint32_t IRAM_ATTR Segment::getPixelColorXY(int x, int y) const { +uint32_t IRAM_ATTR_YN Segment::getPixelColorXY(int x, int y) const { if (!isActive()) return 0; // not active if (x >= virtualWidth() || y >= virtualHeight() || x<0 || y<0) return 0; // if pixel would fall out of virtual segment just exit if (reverse ) x = virtualWidth() - x - 1; diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp index bc5c8b051..7a6fa40b5 100644 --- a/wled00/FX_fcn.cpp +++ b/wled00/FX_fcn.cpp @@ -146,7 +146,7 @@ Segment& Segment::operator= (Segment &&orig) noexcept { } // allocates effect data buffer on heap and initialises (erases) it -bool IRAM_ATTR Segment::allocateData(size_t len) { +bool IRAM_ATTR_YN Segment::allocateData(size_t len) { if (len == 0) return false; // nothing to do if (data && _dataLen >= len) { // already allocated enough (reduce fragmentation) if (call == 0) memset(data, 0, len); // erase buffer if called during effect initialisation @@ -170,7 +170,7 @@ bool IRAM_ATTR Segment::allocateData(size_t len) { return true; } -void IRAM_ATTR Segment::deallocateData() { +void IRAM_ATTR_YN Segment::deallocateData() { if (!data) { _dataLen = 0; return; } //DEBUG_PRINTF_P(PSTR("--- Released data (%p): %d/%d -> %p\n"), this, _dataLen, Segment::getUsedSegmentData(), data); if ((Segment::getUsedSegmentData() > 0) && (_dataLen > 0)) { // check that we don't have a dangling / inconsistent data pointer @@ -202,7 +202,7 @@ void Segment::resetIfRequired() { reset = false; } -CRGBPalette16 IRAM_ATTR &Segment::loadPalette(CRGBPalette16 &targetPalette, uint8_t pal) { +CRGBPalette16 IRAM_ATTR_YN &Segment::loadPalette(CRGBPalette16 &targetPalette, uint8_t pal) { if (pal < 245 && pal > GRADIENT_PALETTE_COUNT+13) pal = 0; if (pal > 245 && (strip.customPalettes.size() == 0 || 255U-pal > strip.customPalettes.size()-1)) pal = 0; // TODO remove strip dependency by moving customPalettes out of strip //default palette. Differs depending on effect @@ -417,7 +417,7 @@ uint8_t IRAM_ATTR Segment::currentBri(bool useCct) const { return (useCct ? cct : (on ? opacity : 0)); } -uint8_t IRAM_ATTR Segment::currentMode() const { +uint8_t IRAM_ATTR_YN Segment::currentMode() const { #ifndef WLED_DISABLE_MODE_BLEND unsigned prog = progress(); if (modeBlending && prog < 0xFFFFU) return _t->_modeT; @@ -425,7 +425,7 @@ uint8_t IRAM_ATTR Segment::currentMode() const { return mode; } -uint32_t IRAM_ATTR Segment::currentColor(uint8_t slot) const { +uint32_t IRAM_ATTR_YN Segment::currentColor(uint8_t slot) const { if (slot >= NUM_COLORS) slot = 0; #ifndef WLED_DISABLE_MODE_BLEND return isInTransition() ? color_blend(_t->_segT._colorT[slot], colors[slot], progress(), true) : colors[slot]; @@ -618,7 +618,7 @@ uint16_t IRAM_ATTR Segment::virtualHeight() const { return vHeight; } -uint16_t IRAM_ATTR Segment::nrOfVStrips() const { +uint16_t IRAM_ATTR_YN Segment::nrOfVStrips() const { unsigned vLen = 1; #ifndef WLED_DISABLE_2D if (is2D()) { @@ -701,7 +701,7 @@ uint16_t IRAM_ATTR Segment::virtualLength() const { return vLength; } -void IRAM_ATTR Segment::setPixelColor(int i, uint32_t col) +void IRAM_ATTR_YN Segment::setPixelColor(int i, uint32_t col) { if (!isActive()) return; // not active #ifndef WLED_DISABLE_2D @@ -895,7 +895,7 @@ void Segment::setPixelColor(float i, uint32_t col, bool aa) } #endif -uint32_t IRAM_ATTR Segment::getPixelColor(int i) const +uint32_t IRAM_ATTR_YN Segment::getPixelColor(int i) const { if (!isActive()) return 0; // not active #ifndef WLED_DISABLE_2D diff --git a/wled00/const.h b/wled00/const.h index d5cd049d5..af6d4a70b 100644 --- a/wled00/const.h +++ b/wled00/const.h @@ -628,4 +628,12 @@ #define HW_PIN_MISOSPI MISO #endif +// IRAM_ATTR for 8266 with 32Kb IRAM causes error: section `.text1' will not fit in region `iram1_0_seg' +// this hack removes the IRAM flag for some 1D/2D functions - somewhat slower, but it solves problems with some older 8266 chips +#ifdef WLED_SAVE_IRAM + #define IRAM_ATTR_YN +#else + #define IRAM_ATTR_YN IRAM_ATTR +#endif + #endif From b9080f9479fc18bc1b3ba28ba55ec546ea256e87 Mon Sep 17 00:00:00 2001 From: Blaz Kristan Date: Wed, 4 Sep 2024 21:17:21 +0200 Subject: [PATCH 17/28] Mirroring bugfix. --- wled00/FX_2Dfcn.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wled00/FX_2Dfcn.cpp b/wled00/FX_2Dfcn.cpp index efae0e5e3..df2dc8d06 100644 --- a/wled00/FX_2Dfcn.cpp +++ b/wled00/FX_2Dfcn.cpp @@ -211,7 +211,7 @@ void IRAM_ATTR_YN Segment::setPixelColorXY(int x, int y, uint32_t col) else strip.setPixelColorXY(start + xX, startY + height() - yY - 1, tmpCol); } if (mirror_y && mirror) { //set the corresponding vertically AND horizontally mirrored pixel - strip.setPixelColorXY(width() - xX - 1, height() - yY - 1, tmpCol); + strip.setPixelColorXY(start + width() - xX - 1, startY + height() - yY - 1, tmpCol); } } } From 0642b17ab0135bebc15890d8a14b303744311598 Mon Sep 17 00:00:00 2001 From: Blaz Kristan Date: Fri, 6 Sep 2024 17:54:36 +0200 Subject: [PATCH 18/28] Bugfix --- usermods/ST7789_display/ST7789_display.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/usermods/ST7789_display/ST7789_display.h b/usermods/ST7789_display/ST7789_display.h index 281fba25d..59f6d9271 100644 --- a/usermods/ST7789_display/ST7789_display.h +++ b/usermods/ST7789_display/ST7789_display.h @@ -23,6 +23,9 @@ #ifndef TFT_RST #error Please define TFT_RST #endif + #ifndef TFT_CS + #error Please define TFT_CS + #endif #ifndef LOAD_GLCD #error Please define LOAD_GLCD #endif @@ -377,7 +380,7 @@ class St7789DisplayUsermod : public Usermod { oappend(SET_F("addInfo('ST7789:pin[]',0,'','SPI CS');")); oappend(SET_F("addInfo('ST7789:pin[]',1,'','SPI DC');")); oappend(SET_F("addInfo('ST7789:pin[]',2,'','SPI RST');")); - oappend(SET_F("addInfo('ST7789:pin[]',2,'','SPI BL');")); + oappend(SET_F("addInfo('ST7789:pin[]',3,'','SPI BL');")); } /* From 81cec6a25ae6447d3ec8b7169d522ea7992cfb5e Mon Sep 17 00:00:00 2001 From: Frank <91616163+softhack007@users.noreply.github.com> Date: Fri, 6 Sep 2024 19:36:24 +0200 Subject: [PATCH 19/28] Update usermod_seven_segment_reloaded.h - prevent array bounds violation (solves #4121) I'm not the maintainer of this usermod, but its obvious that the code might overrun array bounds, so fixing this. --- .../usermod_seven_segment_reloaded.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h b/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h index 5c2fac0d4..572d4cebd 100644 --- a/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h +++ b/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h @@ -236,6 +236,8 @@ private: } void _setLeds(int lednr, int lastSeenLedNr, bool range, int countSegments, int number, bool colon) { + if ((lednr < 0) || (lednr >= umSSDRLength)) return; // prevent array bounds violation + if ((number < 0) || (countSegments < 0) || (lastSeenLedNr <0)) return; // prevent array out of range access if ((colon && umSSDRColonblink) || umSSDRNumbers[number][countSegments]) { From 340a9f8b762195b10f64ff42af9228e5140bb6b3 Mon Sep 17 00:00:00 2001 From: Frank <91616163+softhack007@users.noreply.github.com> Date: Fri, 6 Sep 2024 20:09:25 +0200 Subject: [PATCH 20/28] better bugfix for seven-seg-reloaded * only reject invalid ranges when array access will be actually performed * fixed another stupid pointer arithmetic error Hint: I AM NOT THE MAINTAINER of this usermod. I'm just fixing an obvious coding error without knowing what the usermod really does. --- .../usermod_seven_segment_reloaded.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h b/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h index 572d4cebd..111df2967 100644 --- a/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h +++ b/usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h @@ -165,7 +165,7 @@ private: void _showElements(String *map, int timevar, bool isColon, bool removeZero ) { - if (!(*map).equals("") && !(*map) == NULL) { + if ((map != nullptr) && (*map != nullptr) && !(*map).equals("")) { int length = String(timevar).length(); bool addZero = false; if (length == 1) { @@ -237,12 +237,12 @@ private: void _setLeds(int lednr, int lastSeenLedNr, bool range, int countSegments, int number, bool colon) { if ((lednr < 0) || (lednr >= umSSDRLength)) return; // prevent array bounds violation - if ((number < 0) || (countSegments < 0) || (lastSeenLedNr <0)) return; // prevent array out of range access + if (!(colon && umSSDRColonblink) && ((number < 0) || (countSegments < 0))) return; if ((colon && umSSDRColonblink) || umSSDRNumbers[number][countSegments]) { if (range) { - for(int i = lastSeenLedNr; i <= lednr; i++) { + for(int i = max(0, lastSeenLedNr); i <= lednr; i++) { umSSDRMask[i] = true; } } else { From 20444ee7d5f6cc255783e66adcb6a3a41806e2b7 Mon Sep 17 00:00:00 2001 From: Blaz Kristan Date: Tue, 10 Sep 2024 15:20:34 +0200 Subject: [PATCH 21/28] Debug optimisations --- wled00/button.cpp | 16 +++--- wled00/cfg.cpp | 6 +- wled00/e131.cpp | 8 +-- wled00/json.cpp | 7 +-- wled00/mqtt.cpp | 3 +- wled00/ntp.cpp | 7 +-- wled00/presets.cpp | 11 ++-- wled00/remote.cpp | 3 +- wled00/set.cpp | 10 ++-- wled00/src/dependencies/toki/Toki.h | 4 +- wled00/udp.cpp | 20 +++---- wled00/wled.cpp | 87 +++++++++++++---------------- wled00/wled_server.cpp | 5 +- wled00/ws.cpp | 8 +-- wled00/xml.cpp | 3 +- 15 files changed, 84 insertions(+), 114 deletions(-) diff --git a/wled00/button.cpp b/wled00/button.cpp index 8b366e055..b5a4e9436 100644 --- a/wled00/button.cpp +++ b/wled00/button.cpp @@ -125,7 +125,7 @@ void handleSwitch(uint8_t b) { // isButtonPressed() handles inverted/noninverted logic if (buttonPressedBefore[b] != isButtonPressed(b)) { - DEBUG_PRINT(F("Switch: State changed ")); DEBUG_PRINTLN(b); + DEBUG_PRINTF_P(PSTR("Switch: State changed %u\n"), b); buttonPressedTime[b] = millis(); buttonPressedBefore[b] = !buttonPressedBefore[b]; } @@ -133,15 +133,15 @@ void handleSwitch(uint8_t b) if (buttonLongPressed[b] == buttonPressedBefore[b]) return; if (millis() - buttonPressedTime[b] > WLED_DEBOUNCE_THRESHOLD) { //fire edge event only after 50ms without change (debounce) - DEBUG_PRINT(F("Switch: Activating ")); DEBUG_PRINTLN(b); + DEBUG_PRINTF_P(PSTR("Switch: Activating %u\n"), b); if (!buttonPressedBefore[b]) { // on -> off - DEBUG_PRINT(F("Switch: On -> Off ")); DEBUG_PRINTLN(b); + DEBUG_PRINTF_P(PSTR("Switch: On -> Off (%u)\n"), b); if (macroButton[b]) applyPreset(macroButton[b], CALL_MODE_BUTTON_PRESET); else { //turn on if (!bri) {toggleOnOff(); stateUpdated(CALL_MODE_BUTTON);} } } else { // off -> on - DEBUG_PRINT(F("Switch: Off -> On ")); DEBUG_PRINTLN(b); + DEBUG_PRINTF_P(PSTR("Switch: Off -> On (%u)\n"), b); if (macroLongPress[b]) applyPreset(macroLongPress[b], CALL_MODE_BUTTON_PRESET); else { //turn off if (bri) {toggleOnOff(); stateUpdated(CALL_MODE_BUTTON);} @@ -173,7 +173,7 @@ void handleAnalog(uint8_t b) static float filteredReading[WLED_MAX_BUTTONS] = {0.0f}; unsigned rawReading; // raw value from analogRead, scaled to 12bit - DEBUG_PRINT(F("Analog: Reading button ")); DEBUG_PRINTLN(b); + DEBUG_PRINTF_P(PSTR("Analog: Reading button %u\n"), b); #ifdef ESP8266 rawReading = analogRead(A0) << 2; // convert 10bit read to 12bit @@ -193,8 +193,8 @@ void handleAnalog(uint8_t b) // remove noise & reduce frequency of UI updates if (abs(int(aRead) - int(oldRead[b])) <= POT_SENSITIVITY) return; // no significant change in reading - DEBUG_PRINT(F("Analog: Raw = ")); DEBUG_PRINT(rawReading); - DEBUG_PRINT(F(" Filtered = ")); DEBUG_PRINTLN(aRead); + DEBUG_PRINTF_P(PSTR("Analog: Raw = %u\n"), rawReading); + DEBUG_PRINTF_P(PSTR(" Filtered = %u\n"), aRead); // Unomment the next lines if you still see flickering related to potentiometer // This waits until strip finishes updating (why: strip was not updating at the start of handleButton() but may have started during analogRead()?) @@ -207,7 +207,7 @@ void handleAnalog(uint8_t b) // if no macro for "short press" and "long press" is defined use brightness control if (!macroButton[b] && !macroLongPress[b]) { - DEBUG_PRINT(F("Analog: Action = ")); DEBUG_PRINTLN(macroDoublePress[b]); + DEBUG_PRINTF_P(PSTR("Analog: Action = %u\n"), macroDoublePress[b]); // if "double press" macro defines which option to change if (macroDoublePress[b] >= 250) { // global brightness diff --git a/wled00/cfg.cpp b/wled00/cfg.cpp index 89076efab..a6c3ab74d 100644 --- a/wled00/cfg.cpp +++ b/wled00/cfg.cpp @@ -277,9 +277,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) { if ((buttonType[s] == BTN_TYPE_ANALOG) || (buttonType[s] == BTN_TYPE_ANALOG_INVERTED)) { if (digitalPinToAnalogChannel(btnPin[s]) < 0) { // not an ADC analog pin - DEBUG_PRINT(F("PIN ALLOC error: GPIO")); DEBUG_PRINT(btnPin[s]); - DEBUG_PRINT(F("for analog button #")); DEBUG_PRINT(s); - DEBUG_PRINTLN(F(" is not an analog pin!")); + DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for analog button #%d is not an analog pin!\n"), btnPin[s], s); btnPin[s] = -1; pinManager.deallocatePin(pin,PinOwner::Button); } else { @@ -290,7 +288,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) { { if (digitalPinToTouchChannel(btnPin[s]) < 0) { // not a touch pin - DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for touch button #%d is not an touch pin!\n"), btnPin[s], s); + DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for touch button #%d is not a touch pin!\n"), btnPin[s], s); btnPin[s] = -1; pinManager.deallocatePin(pin,PinOwner::Button); } diff --git a/wled00/e131.cpp b/wled00/e131.cpp index e28750db3..7c074759e 100644 --- a/wled00/e131.cpp +++ b/wled00/e131.cpp @@ -108,13 +108,7 @@ void handleE131Packet(e131_packet_t* p, IPAddress clientIP, byte protocol){ if (e131SkipOutOfSequence) if (seq < e131LastSequenceNumber[previousUniverses] && seq > 20 && e131LastSequenceNumber[previousUniverses] < 250){ - DEBUG_PRINT(F("skipping E1.31 frame (last seq=")); - DEBUG_PRINT(e131LastSequenceNumber[previousUniverses]); - DEBUG_PRINT(F(", current seq=")); - DEBUG_PRINT(seq); - DEBUG_PRINT(F(", universe=")); - DEBUG_PRINT(uni); - DEBUG_PRINTLN(")"); + DEBUG_PRINTF_P(PSTR("skipping E1.31 frame (last seq=%d, current seq=%d, universe=%d)\n"), e131LastSequenceNumber[previousUniverses], seq, uni); return; } e131LastSequenceNumber[previousUniverses] = seq; diff --git a/wled00/json.cpp b/wled00/json.cpp index 01acc7ba3..596bd780e 100644 --- a/wled00/json.cpp +++ b/wled00/json.cpp @@ -1144,11 +1144,8 @@ void serveJson(AsyncWebServerRequest* request) DEBUG_PRINTF_P(PSTR("JSON buffer size: %u for request: %d\n"), lDoc.memoryUsage(), subJson); - #ifdef WLED_DEBUG - size_t len = - #endif - response->setLength(); - DEBUG_PRINT(F("JSON content length: ")); DEBUG_PRINTLN(len); + [[maybe_unused]] size_t len = response->setLength(); + DEBUG_PRINTF_P(PSTR("JSON content length: %u\n"), len); request->send(response); } diff --git a/wled00/mqtt.cpp b/wled00/mqtt.cpp index 775a4fe58..833e6eb7d 100644 --- a/wled00/mqtt.cpp +++ b/wled00/mqtt.cpp @@ -55,8 +55,7 @@ static void onMqttConnect(bool sessionPresent) static void onMqttMessage(char* topic, char* payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total) { static char *payloadStr; - DEBUG_PRINT(F("MQTT msg: ")); - DEBUG_PRINTLN(topic); + DEBUG_PRINTF_P(PSTR("MQTT msg: %s\n"), topic); // paranoia check to avoid npe if no payload if (payload==nullptr) { diff --git a/wled00/ntp.cpp b/wled00/ntp.cpp index 056110a58..7b7dac96e 100644 --- a/wled00/ntp.cpp +++ b/wled00/ntp.cpp @@ -246,8 +246,7 @@ bool checkNTPResponse() } uint32_t ntpPacketReceivedTime = millis(); - DEBUG_PRINT(F("NTP recv, l=")); - DEBUG_PRINTLN(cb); + DEBUG_PRINTF_P(PSTR("NTP recv, l=%d\n"), cb); byte pbuf[NTP_PACKET_SIZE]; ntpUdp.read(pbuf, NTP_PACKET_SIZE); // read the packet into the buffer if (!isValidNtpResponse(pbuf)) return false; // verify we have a valid response to client @@ -493,7 +492,7 @@ void calculateSunriseAndSunset() { do { time_t theDay = localTime - retryCount * 86400; // one day back = 86400 seconds minUTC = getSunriseUTC(year(theDay), month(theDay), day(theDay), latitude, longitude, false); - DEBUG_PRINT(F("* sunrise (minutes from UTC) = ")); DEBUG_PRINTLN(minUTC); + DEBUG_PRINTF_P(PSTR("* sunrise (minutes from UTC) = %d\n"), minUTC); retryCount ++; } while ((abs(minUTC) > SUNSET_MAX) && (retryCount <= 3)); @@ -512,7 +511,7 @@ void calculateSunriseAndSunset() { do { time_t theDay = localTime - retryCount * 86400; // one day back = 86400 seconds minUTC = getSunriseUTC(year(theDay), month(theDay), day(theDay), latitude, longitude, true); - DEBUG_PRINT(F("* sunset (minutes from UTC) = ")); DEBUG_PRINTLN(minUTC); + DEBUG_PRINTF_P(PSTR("* sunset (minutes from UTC) = %d\n"), minUTC); retryCount ++; } while ((abs(minUTC) > SUNSET_MAX) && (retryCount <= 3)); diff --git a/wled00/presets.cpp b/wled00/presets.cpp index 2916d337a..20edfd91e 100644 --- a/wled00/presets.cpp +++ b/wled00/presets.cpp @@ -117,8 +117,7 @@ void initPresetsFile() bool applyPresetFromPlaylist(byte index) { - DEBUG_PRINT(F("Request to apply preset: ")); - DEBUG_PRINTLN(index); + DEBUG_PRINTF_P(PSTR("Request to apply preset: %d\n"), index); presetToApply = index; callModeToApply = CALL_MODE_DIRECT_CHANGE; return true; @@ -127,8 +126,7 @@ bool applyPresetFromPlaylist(byte index) bool applyPreset(byte index, byte callMode) { unloadPlaylist(); // applying a preset unloads the playlist (#3827) - DEBUG_PRINT(F("Request to apply preset: ")); - DEBUG_PRINTLN(index); + DEBUG_PRINTF_P(PSTR("Request to apply preset: %u\n"), index); presetToApply = index; callModeToApply = callMode; return true; @@ -163,8 +161,7 @@ void handlePresets() presetToApply = 0; //clear request for preset callModeToApply = 0; - DEBUG_PRINT(F("Applying preset: ")); - DEBUG_PRINTLN(tmpPreset); + DEBUG_PRINTF_P(PSTR("Applying preset: %u\n"), (unsigned)tmpPreset); #ifdef ARDUINO_ARCH_ESP32 if (tmpPreset==255 && tmpRAMbuffer!=nullptr) { @@ -222,7 +219,7 @@ void savePreset(byte index, const char* pname, JsonObject sObj) else sprintf_P(saveName, PSTR("Preset %d"), index); } - DEBUG_PRINT(F("Saving preset (")); DEBUG_PRINT(index); DEBUG_PRINT(F(") ")); DEBUG_PRINTLN(saveName); + DEBUG_PRINTF_P(PSTR("Saving preset (%d) %s\n"), index, saveName); presetToSave = index; playlistSave = false; diff --git a/wled00/remote.cpp b/wled00/remote.cpp index 9d8b94df0..9bc5430c0 100644 --- a/wled00/remote.cpp +++ b/wled00/remote.cpp @@ -186,8 +186,7 @@ void handleRemote(uint8_t *incomingData, size_t len) { } if (len != sizeof(message_structure_t)) { - DEBUG_PRINT(F("Unknown incoming ESP Now message received of length ")); - DEBUG_PRINTLN(len); + DEBUG_PRINTF_P(PSTR("Unknown incoming ESP Now message received of length %u\n"), len); return; } diff --git a/wled00/set.cpp b/wled00/set.cpp index 2811d7088..7814e55d9 100644 --- a/wled00/set.cpp +++ b/wled00/set.cpp @@ -157,8 +157,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage) char la[4] = "LA"; la[2] = offset+s; la[3] = 0; //LED mA char ma[4] = "MA"; ma[2] = offset+s; ma[3] = 0; //max mA if (!request->hasArg(lp)) { - DEBUG_PRINT(F("No data for ")); - DEBUG_PRINTLN(s); + DEBUG_PRINTF_P(PSTR("No data for %d\n"), s); break; } for (int i = 0; i < 5; i++) { @@ -729,7 +728,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage) else subObj[name].add(value.toInt()); // we may have an int j++; } - DEBUG_PRINT(F("[")); DEBUG_PRINT(j); DEBUG_PRINT(F("] = ")); DEBUG_PRINTLN(value); + DEBUG_PRINTF_P(PSTR("[%d] = %s\n"), j, value.c_str()); } else { // we are using a hidden field with the same name as our parameter (!before the actual parameter!) // to describe the type of parameter (text,float,int), for boolean parameters the first field contains "off" @@ -748,7 +747,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage) } else if (type == "int") subObj[name] = value.toInt(); else subObj[name] = value; // text fields } - DEBUG_PRINT(F(" = ")); DEBUG_PRINTLN(value); + DEBUG_PRINTF_P(PSTR(" = %s\n"), value.c_str()); } } usermods.readFromConfig(um); // force change of usermod parameters @@ -809,8 +808,7 @@ bool handleSet(AsyncWebServerRequest *request, const String& req, bool apply) if (!(req.indexOf("win") >= 0)) return false; int pos = 0; - DEBUG_PRINT(F("API req: ")); - DEBUG_PRINTLN(req); + DEBUG_PRINTF_P(PSTR("API req: %s\n"), req.c_str()); //segment select (sets main segment) pos = req.indexOf(F("SM=")); diff --git a/wled00/src/dependencies/toki/Toki.h b/wled00/src/dependencies/toki/Toki.h index e7f12a453..0e849d3c2 100644 --- a/wled00/src/dependencies/toki/Toki.h +++ b/wled00/src/dependencies/toki/Toki.h @@ -155,7 +155,7 @@ class Toki { return (tick == TickT::active); } - void printTime(const Time& t) { - Serial.printf_P(PSTR("%u,%03u\n"),t.sec,t.ms); + void printTime(const Time& t, Print &dest = Serial) { + dest.printf_P(PSTR("%u,%03u\n"),t.sec,t.ms); } }; \ No newline at end of file diff --git a/wled00/udp.cpp b/wled00/udp.cpp index c2221e2cf..d030b6655 100644 --- a/wled00/udp.cpp +++ b/wled00/udp.cpp @@ -213,7 +213,7 @@ void parseNotifyPacket(uint8_t *udpIn) { //compatibilityVersionByte: byte version = udpIn[11]; - DEBUG_PRINT(F("UDP packet version: ")); DEBUG_PRINTLN(version); + DEBUG_PRINTF_P(PSTR("UDP packet version: %d\n"), (int)version); // if we are not part of any sync group ignore message if (version < 9) { @@ -256,7 +256,7 @@ void parseNotifyPacket(uint8_t *udpIn) { if (applyEffects && currentPlaylist >= 0) unloadPlaylist(); if (version > 10 && (receiveSegmentOptions || receiveSegmentBounds)) { unsigned numSrcSegs = udpIn[39]; - DEBUG_PRINT(F("UDP segments: ")); DEBUG_PRINTLN(numSrcSegs); + DEBUG_PRINTF_P(PSTR("UDP segments: %d\n"), numSrcSegs); // are we syncing bounds and slave has more active segments than master? if (receiveSegmentBounds && numSrcSegs < strip.getActiveSegmentsNum()) { DEBUG_PRINTLN(F("Removing excessive segments.")); @@ -270,13 +270,13 @@ void parseNotifyPacket(uint8_t *udpIn) { for (size_t i = 0; i < numSrcSegs && i < strip.getMaxSegments(); i++) { unsigned ofs = 41 + i*udpIn[40]; //start of segment offset byte unsigned id = udpIn[0 +ofs]; - DEBUG_PRINT(F("UDP segment received: ")); DEBUG_PRINTLN(id); + DEBUG_PRINTF_P(PSTR("UDP segment received: %u\n"), id); if (id > strip.getSegmentsNum()) break; else if (id == strip.getSegmentsNum()) { if (receiveSegmentBounds && id < strip.getMaxSegments()) strip.appendSegment(); else break; } - DEBUG_PRINT(F("UDP segment check: ")); DEBUG_PRINTLN(id); + DEBUG_PRINTF_P(PSTR("UDP segment check: %u\n"), id); Segment& selseg = strip.getSegment(id); // if we are not syncing bounds skip unselected segments if (selseg.isActive() && !(selseg.isSelected() || receiveSegmentBounds)) continue; @@ -290,7 +290,7 @@ void parseNotifyPacket(uint8_t *udpIn) { id += inactiveSegs; // adjust id } } - DEBUG_PRINT(F("UDP segment processing: ")); DEBUG_PRINTLN(id); + DEBUG_PRINTF_P(PSTR("UDP segment processing: %u\n"), id); uint16_t start = (udpIn[1+ofs] << 8 | udpIn[2+ofs]); uint16_t stop = (udpIn[3+ofs] << 8 | udpIn[4+ofs]); @@ -307,14 +307,14 @@ void parseNotifyPacket(uint8_t *udpIn) { selseg.options = (selseg.options & 0x0071U) | (udpIn[9 +ofs] & 0x0E); // ignore selected, freeze, reset & transitional selseg.setOpacity(udpIn[10+ofs]); if (applyEffects) { - DEBUG_PRINT(F("Apply effect: ")); DEBUG_PRINTLN(id); + DEBUG_PRINTF_P(PSTR("Apply effect: %u\n"), id); selseg.setMode(udpIn[11+ofs]); selseg.speed = udpIn[12+ofs]; selseg.intensity = udpIn[13+ofs]; selseg.palette = udpIn[14+ofs]; } if (receiveNotificationColor || !someSel) { - DEBUG_PRINT(F("Apply color: ")); DEBUG_PRINTLN(id); + DEBUG_PRINTF_P(PSTR("Apply color: %u\n"), id); selseg.setColor(0, RGBW32(udpIn[15+ofs],udpIn[16+ofs],udpIn[17+ofs],udpIn[18+ofs])); selseg.setColor(1, RGBW32(udpIn[19+ofs],udpIn[20+ofs],udpIn[21+ofs],udpIn[22+ofs])); selseg.setColor(2, RGBW32(udpIn[23+ofs],udpIn[24+ofs],udpIn[25+ofs],udpIn[26+ofs])); @@ -324,10 +324,10 @@ void parseNotifyPacket(uint8_t *udpIn) { // when applying synced options ignore selected as it may be used as indicator of which segments to sync // freeze, reset should never be synced // LSB to MSB: select, reverse, on, mirror, freeze, reset, reverse_y, mirror_y, transpose, map1d2d (3), ssim (2), set (2) - DEBUG_PRINT(F("Apply options: ")); DEBUG_PRINTLN(id); + DEBUG_PRINTF_P(PSTR("Apply options: %u\n"), id); selseg.options = (selseg.options & 0b0000000000110001U) | (udpIn[28+ofs]<<8) | (udpIn[9 +ofs] & 0b11001110U); // ignore selected, freeze, reset if (applyEffects) { - DEBUG_PRINT(F("Apply sliders: ")); DEBUG_PRINTLN(id); + DEBUG_PRINTF_P(PSTR("Apply sliders: %u\n"), id); selseg.custom1 = udpIn[29+ofs]; selseg.custom2 = udpIn[30+ofs]; selseg.custom3 = udpIn[31+ofs] & 0x1F; @@ -561,7 +561,7 @@ void handleNotifications() //wled notifier, ignore if realtime packets active if (udpIn[0] == 0 && !realtimeMode && receiveGroups) { - DEBUG_PRINT(F("UDP notification from: ")); DEBUG_PRINTLN(notifierUdp.remoteIP()); + DEBUG_PRINTF_P(PSTR("UDP notification from: %d.%d.%d.%d\n"), notifierUdp.remoteIP()[0], notifierUdp.remoteIP()[1], notifierUdp.remoteIP()[2], notifierUdp.remoteIP()[3]); parseNotifyPacket(udpIn); return; } diff --git a/wled00/wled.cpp b/wled00/wled.cpp index a6143eee6..840c06bf7 100644 --- a/wled00/wled.cpp +++ b/wled00/wled.cpp @@ -159,7 +159,7 @@ void WLED::loop() if (millis() - heapTime > 15000) { uint32_t heap = ESP.getFreeHeap(); if (heap < MIN_HEAP_SIZE && lastHeap < MIN_HEAP_SIZE) { - DEBUG_PRINT(F("Heap too low! ")); DEBUG_PRINTLN(heap); + DEBUG_PRINTF_P(PSTR("Heap too low! %u\n"), heap); forceReconnect = true; strip.resetSegments(); // remove all but one segments from memory } else if (heap < MIN_HEAP_SIZE) { @@ -264,9 +264,9 @@ void WLED::loop() if (loopMillis > maxLoopMillis) maxLoopMillis = loopMillis; if (millis() - debugTime > 29999) { DEBUG_PRINTLN(F("---DEBUG INFO---")); - DEBUG_PRINT(F("Runtime: ")); DEBUG_PRINTLN(millis()); - DEBUG_PRINT(F("Unix time: ")); toki.printTime(toki.getTime()); - DEBUG_PRINT(F("Free heap: ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("Runtime: %u\n"), millis()); + DEBUG_PRINTF_P(PSTR("Unix time: %u,%03u\n"), toki.getTime().sec, toki.getTime().ms); + DEBUG_PRINTF_P(PSTR("Free heap: %u\n"), ESP.getFreeHeap()); #if defined(ARDUINO_ARCH_ESP32) if (psramFound()) { DEBUG_PRINTF_P(PSTR("PSRAM: %dkB/%dkB\n"), ESP.getFreePsram()/1024, ESP.getPsramSize()/1024); @@ -276,21 +276,21 @@ void WLED::loop() #endif DEBUG_PRINTF_P(PSTR("Wifi state: %d\n"), WiFi.status()); #ifndef WLED_DISABLE_ESPNOW - DEBUG_PRINT(F("ESP-NOW state: ")); DEBUG_PRINTLN(statusESPNow); + DEBUG_PRINTF_P(PSTR("ESP-NOW state: %u\n"), statusESPNow); #endif if (WiFi.status() != lastWifiState) { wifiStateChangedTime = millis(); } lastWifiState = WiFi.status(); - DEBUG_PRINT(F("State time: ")); DEBUG_PRINTLN(wifiStateChangedTime); - DEBUG_PRINT(F("NTP last sync: ")); DEBUG_PRINTLN(ntpLastSyncTime); - DEBUG_PRINT(F("Client IP: ")); DEBUG_PRINTLN(Network.localIP()); + DEBUG_PRINTF_P(PSTR("State time: %u\n"), wifiStateChangedTime); + DEBUG_PRINTF_P(PSTR("NTP last sync: %u\n"), ntpLastSyncTime); + DEBUG_PRINTF_P(PSTR("Client IP: %u.%u.%u.%u\n"), Network.localIP()[0], Network.localIP()[1], Network.localIP()[2], Network.localIP()[3]); if (loops > 0) { // avoid division by zero - DEBUG_PRINT(F("Loops/sec: ")); DEBUG_PRINTLN(loops / 30); - DEBUG_PRINT(F("Loop time[ms]: ")); DEBUG_PRINT(avgLoopMillis/loops); DEBUG_PRINT("/");DEBUG_PRINTLN(maxLoopMillis); - DEBUG_PRINT(F("UM time[ms]: ")); DEBUG_PRINT(avgUsermodMillis/loops); DEBUG_PRINT("/");DEBUG_PRINTLN(maxUsermodMillis); - DEBUG_PRINT(F("Strip time[ms]: ")); DEBUG_PRINT(avgStripMillis/loops); DEBUG_PRINT("/"); DEBUG_PRINTLN(maxStripMillis); + DEBUG_PRINTF_P(PSTR("Loops/sec: %u\n"), loops / 30); + DEBUG_PRINTF_P(PSTR("Loop time[ms]: %u/%u\n"), avgLoopMillis/loops, maxLoopMillis); + DEBUG_PRINTF_P(PSTR("UM time[ms]: %u/%u\n"), avgUsermodMillis/loops, maxUsermodMillis); + DEBUG_PRINTF_P(PSTR("Strip time[ms]:%u/%u\n"), avgStripMillis/loops, maxStripMillis); } strip.printSize(); loops = 0; @@ -358,45 +358,38 @@ void WLED::setup() Serial.setDebugOutput(false); // switch off kernel messages when using USBCDC #endif DEBUG_PRINTLN(); - DEBUG_PRINT(F("---WLED ")); - DEBUG_PRINT(versionString); - DEBUG_PRINT(F(" ")); - DEBUG_PRINT(VERSION); - DEBUG_PRINTLN(F(" INIT---")); + DEBUG_PRINTF_P(PSTR("---WLED %s %u INIT---\n"), versionString, VERSION); + DEBUG_PRINTLN(); #ifdef ARDUINO_ARCH_ESP32 - DEBUG_PRINT(F("esp32 ")); - DEBUG_PRINTLN(ESP.getSdkVersion()); + DEBUG_PRINTF_P(PSTR("esp32 %s\n"), ESP.getSdkVersion()); #if defined(ESP_ARDUINO_VERSION) - //DEBUG_PRINTF_P(PSTR("arduino-esp32 0x%06x\n"), ESP_ARDUINO_VERSION); - DEBUG_PRINTF_P(PSTR("arduino-esp32 v%d.%d.%d\n"), int(ESP_ARDUINO_VERSION_MAJOR), int(ESP_ARDUINO_VERSION_MINOR), int(ESP_ARDUINO_VERSION_PATCH)); // availeable since v2.0.0 + DEBUG_PRINTF_P(PSTR("arduino-esp32 v%d.%d.%d\n"), int(ESP_ARDUINO_VERSION_MAJOR), int(ESP_ARDUINO_VERSION_MINOR), int(ESP_ARDUINO_VERSION_PATCH)); // available since v2.0.0 #else DEBUG_PRINTLN(F("arduino-esp32 v1.0.x\n")); // we can't say in more detail. #endif - DEBUG_PRINT(F("CPU: ")); DEBUG_PRINT(ESP.getChipModel()); - DEBUG_PRINT(F(" rev.")); DEBUG_PRINT(ESP.getChipRevision()); - DEBUG_PRINT(F(", ")); DEBUG_PRINT(ESP.getChipCores()); DEBUG_PRINT(F(" core(s)")); - DEBUG_PRINT(F(", ")); DEBUG_PRINT(ESP.getCpuFreqMHz()); DEBUG_PRINTLN(F("MHz.")); - DEBUG_PRINT(F("FLASH: ")); DEBUG_PRINT((ESP.getFlashChipSize()/1024)/1024); - DEBUG_PRINT(F("MB, Mode ")); DEBUG_PRINT(ESP.getFlashChipMode()); + DEBUG_PRINTF_P(PSTR("CPU: "), ESP.getChipModel()); + DEBUG_PRINTF_P(PSTR(" rev."), ESP.getChipRevision()); + DEBUG_PRINTF_P(PSTR(", %d core(s)"), ESP.getChipCores()); + DEBUG_PRINTF_P(PSTR(", %d MHz.\n"), ESP.getCpuFreqMHz()); + DEBUG_PRINTF_P(PSTR("FLASH: %dMB, Mode %d "), (ESP.getFlashChipSize()/1024)/1024, ESP.getFlashChipMode()); #ifdef WLED_DEBUG switch (ESP.getFlashChipMode()) { // missing: Octal modes - case FM_QIO: DEBUG_PRINT(F(" (QIO)")); break; - case FM_QOUT: DEBUG_PRINT(F(" (QOUT)"));break; - case FM_DIO: DEBUG_PRINT(F(" (DIO)")); break; - case FM_DOUT: DEBUG_PRINT(F(" (DOUT)"));break; + case FM_QIO: DEBUG_PRINT(F("(QIO)")); break; + case FM_QOUT: DEBUG_PRINT(F("(QOUT)"));break; + case FM_DIO: DEBUG_PRINT(F("(DIO)")); break; + case FM_DOUT: DEBUG_PRINT(F("(DOUT)"));break; default: break; } #endif - DEBUG_PRINT(F(", speed ")); DEBUG_PRINT(ESP.getFlashChipSpeed()/1000000);DEBUG_PRINTLN(F("MHz.")); + DEBUG_PRINTF_P(PSTR(", speed %u MHz.\n"), ESP.getFlashChipSpeed()/1000000); #else - DEBUG_PRINT(F("esp8266 @ ")); DEBUG_PRINT(ESP.getCpuFreqMHz()); DEBUG_PRINT(F("MHz.\nCore: ")); - DEBUG_PRINTLN(ESP.getCoreVersion()); - DEBUG_PRINT(F("FLASH: ")); DEBUG_PRINT((ESP.getFlashChipSize()/1024)/1024); DEBUG_PRINTLN(F(" MB")); + DEBUG_PRINTF_P(PSTR("esp8266 @ %u MHz.\nCore: %s\n"), ESP.getCpuFreqMHz(), ESP.getCoreVersion()); + DEBUG_PRINTF_P(PSTR("FLASH: %u MB\n"), (ESP.getFlashChipSize()/1024)/1024); #endif - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); #if defined(ARDUINO_ARCH_ESP32) // BOARD_HAS_PSRAM also means that a compiler flag "-mfix-esp32-psram-cache-issue" was used and so PSRAM is safe to use on rev.1 ESP32 @@ -405,7 +398,7 @@ void WLED::setup() if (!psramSafe) DEBUG_PRINTLN(F("Not using PSRAM.")); #endif pDoc = new PSRAMDynamicJsonDocument((psramSafe && psramFound() ? 2 : 1)*JSON_BUFFER_SIZE); - DEBUG_PRINT(F("JSON buffer allocated: ")); DEBUG_PRINTLN((psramSafe && psramFound() ? 2 : 1)*JSON_BUFFER_SIZE); + DEBUG_PRINTF_P(PSTR("JSON buffer allocated: %u\n"), (psramSafe && psramFound() ? 2 : 1)*JSON_BUFFER_SIZE); // if the above fails requestJsonBufferLock() will always return false preventing crashes if (psramFound()) { DEBUG_PRINTF_P(PSTR("PSRAM: %dkB/%dkB\n"), ESP.getFreePsram()/1024, ESP.getPsramSize()/1024); @@ -427,7 +420,7 @@ void WLED::setup() DEBUG_PRINTLN(F("Registering usermods ...")); registerUsermods(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); bool fsinit = false; DEBUGFS_PRINTLN(F("Mount FS")); @@ -457,7 +450,7 @@ void WLED::setup() DEBUG_PRINTLN(F("Reading config")); deserializeConfigFromFS(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); #if defined(STATUSLED) && STATUSLED>=0 if (!pinManager.isPinAllocated(STATUSLED)) { @@ -469,12 +462,12 @@ void WLED::setup() DEBUG_PRINTLN(F("Initializing strip")); beginStrip(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); DEBUG_PRINTLN(F("Usermods setup")); userSetup(); usermods.setup(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); if (strcmp(multiWiFi[0].clientSSID, DEFAULT_CLIENT_SSID) == 0) showWelcomePage = true; @@ -537,13 +530,13 @@ void WLED::setup() // HTTP server page init DEBUG_PRINTLN(F("initServer")); initServer(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); #ifndef WLED_DISABLE_INFRARED // init IR DEBUG_PRINTLN(F("initIR")); initIR(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); #endif // Seed FastLED random functions with an esp random value, which already works properly at this point. @@ -654,11 +647,11 @@ bool WLED::initEthernet() return false; } if (ethernetType >= WLED_NUM_ETH_TYPES) { - DEBUG_PRINT(F("initE: Ignoring attempt for invalid ethernetType ")); DEBUG_PRINTLN(ethernetType); + DEBUG_PRINTF_P(PSTR("initE: Ignoring attempt for invalid ethernetType (%d)\n"), ethernetType); return false; } - DEBUG_PRINT(F("initE: Attempting ETH config: ")); DEBUG_PRINTLN(ethernetType); + DEBUG_PRINTF_P(PSTR("initE: Attempting ETH config: %d\n"), ethernetType); // Ethernet initialization should only succeed once -- else reboot required ethernet_settings es = ethernetBoards[ethernetType]; @@ -689,9 +682,7 @@ bool WLED::initEthernet() pinsToAllocate[9].pin = 17; pinsToAllocate[9].isOutput = true; } else { - DEBUG_PRINT(F("initE: Failing due to invalid eth_clk_mode (")); - DEBUG_PRINT(es.eth_clk_mode); - DEBUG_PRINTLN(")"); + DEBUG_PRINTF_P(PSTR("initE: Failing due to invalid eth_clk_mode (%d)\n"), es.eth_clk_mode); return false; } diff --git a/wled00/wled_server.cpp b/wled00/wled_server.cpp index d184e9878..291f6f5fc 100644 --- a/wled00/wled_server.cpp +++ b/wled00/wled_server.cpp @@ -163,8 +163,7 @@ static void handleUpload(AsyncWebServerRequest *request, const String& filename, } request->_tempFile = WLED_FS.open(finalname, "w"); - DEBUG_PRINT(F("Uploading ")); - DEBUG_PRINTLN(finalname); + DEBUG_PRINTF_P(PSTR("Uploading %s\n"), finalname.c_str()); if (finalname.equals(FPSTR(getPresetsFileName()))) presetsModifiedTime = toki.second(); } if (len) { @@ -466,7 +465,7 @@ void initServer() //called when the url is not defined here, ajax-in; get-settings server.onNotFound([](AsyncWebServerRequest *request){ - DEBUG_PRINT(F("Not-Found HTTP call: ")); DEBUG_PRINTLN(request->url()); + DEBUG_PRINTF_P(PSTR("Not-Found HTTP call: %s\n"), request->url().c_str()); if (captivePortal(request)) return; //make API CORS compatible diff --git a/wled00/ws.cpp b/wled00/ws.cpp index 3dec548f4..45640b68c 100644 --- a/wled00/ws.cpp +++ b/wled00/ws.cpp @@ -125,7 +125,7 @@ void sendDataWs(AsyncWebSocketClient * client) // the following may no longer be necessary as heap management has been fixed by @willmmiles in AWS size_t heap1 = ESP.getFreeHeap(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); #ifdef ESP8266 if (len>heap1) { DEBUG_PRINTLN(F("Out of memory (WS)!")); @@ -135,7 +135,7 @@ void sendDataWs(AsyncWebSocketClient * client) AsyncWebSocketBuffer buffer(len); #ifdef ESP8266 size_t heap2 = ESP.getFreeHeap(); - DEBUG_PRINT(F("heap ")); DEBUG_PRINTLN(ESP.getFreeHeap()); + DEBUG_PRINTF_P(PSTR("heap %u\n"), ESP.getFreeHeap()); #else size_t heap2 = 0; // ESP32 variants do not have the same issue and will work without checking heap allocation #endif @@ -150,11 +150,11 @@ void sendDataWs(AsyncWebSocketClient * client) DEBUG_PRINT(F("Sending WS data ")); if (client) { - client->text(std::move(buffer)); DEBUG_PRINTLN(F("to a single client.")); + client->text(std::move(buffer)); } else { - ws.textAll(std::move(buffer)); DEBUG_PRINTLN(F("to multiple clients.")); + ws.textAll(std::move(buffer)); } releaseJSONBufferLock(); diff --git a/wled00/xml.cpp b/wled00/xml.cpp index 25c0c6298..6c3ee83dc 100644 --- a/wled00/xml.cpp +++ b/wled00/xml.cpp @@ -224,8 +224,7 @@ void appendGPIOinfo() { void getSettingsJS(byte subPage, char* dest) { //0: menu 1: wifi 2: leds 3: ui 4: sync 5: time 6: sec - DEBUG_PRINT(F("settings resp")); - DEBUG_PRINTLN(subPage); + DEBUG_PRINTF_P(PSTR("settings resp %u\n"), (unsigned)subPage); obuf = dest; olen = 0; From fd00e5eaae9a587d3cf5950465f786a5f8ed60e0 Mon Sep 17 00:00:00 2001 From: Blaz Kristan Date: Tue, 10 Sep 2024 15:23:27 +0200 Subject: [PATCH 22/28] LED settings text update --- wled00/data/settings_leds.htm | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/wled00/data/settings_leds.htm b/wled00/data/settings_leds.htm index b7d2d18a7..06bcf3e6e 100644 --- a/wled00/data/settings_leds.htm +++ b/wled00/data/settings_leds.htm @@ -805,12 +805,13 @@ Swap: mA
Use per-output limiter:

Advanced

- Palette blending: + Palette wrapping: