jeans/WLED
jeans/WLED
1
0
Fork 0
mirror of https://github.com/wled/WLED.git synced 2025-04-23 14:27:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #4093 from axlan/pixel-dice-usermod

Browse Source 
Added a usermod for interacting with BLE Pixels Dice.
This commit is contained in:
Blaž Kristan 2024-08-19 05:39:35 +02:00 committed by GitHub
commit 8a1df1e700
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
21 changed files with 2122 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

254
usermods/pixels_dice_tray/README.md Normal file
View File

@ -0,0 +1,254 @@
# 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 <https://www.robopenguins.com/pixels-dice-box/> 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 <https://axlan.github.io/WLED-WebInstaller/> for 8MB ESP32-S3 boards.
## Table of Contents
<!-- TOC start (generated with https://github.com/derlin/bitdowntoc) -->
* [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)
<!-- TOC end -->
<!-- TOC --><a name="demos"></a>
## Demos
<!-- TOC --><a name="tft-gui"></a>
### TFT GUI
[![Watch the video](https://img.youtube.com/vi/VNsHq1TbiW8/0.jpg)](https://youtu.be/VNsHq1TbiW8)
<!-- TOC --><a name="multiple-die-controlling-different-segments"></a>
### Multiple Die Controlling Different Segments
[![Watch the video](https://img.youtube.com/vi/oCDr44C-qwM/0.jpg)](https://youtu.be/oCDr44C-qwM)
<!-- TOC --><a name="hardware"></a>
## 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.
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.
<!-- TOC --><a name="library-used"></a>
## Library used
[axlan/pixels-dice-interface](https://github.com/axlan/arduino-pixels-dice)
Optional: [Bodmer/TFT_eSPI](https://github.com/Bodmer/TFT_eSPI)
<!-- TOC --><a name="compiling"></a>
## Compiling
<!-- TOC --><a name="platformio_overrideini"></a>
### 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.
<!-- TOC --><a name="manual-platformioini-changes"></a>
### 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.
<!-- TOC --><a name="configuration"></a>
## 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
<!-- TOC --><a name="controlling-dice-connections"></a>
### 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.
<!-- TOC --><a name="controlling-effects"></a>
### Controlling Effects
The die effects for rolls take advantage of most of the normal WLED effect features: <https://kno.wled.ge/features/effects/>.
If you have different segments, they can have different effects driven by the same die, or different dice.
<!-- TOC --><a name="diesimple"></a>
#### 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.
<!-- TOC --><a name="diepulse"></a>
#### 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.
<!-- TOC --><a name="diecheck"></a>
#### 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.
<!-- TOC --><a name="tft-gui-1"></a>
## 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).
<!-- TOC --><a name="status"></a>
### Status
<img src="images/status.webp" alt="Status Menu" width="200"/>
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.
<!-- TOC --><a name="effect-menu"></a>
### Effect Menu
<img src="images/effect.webp" alt="Effect Menu" width="200"/>
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.
<!-- TOC --><a name="roll-info"></a>
### Roll Info
<img src="images/info.webp" alt="Roll Info Menu" width="200"/>
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.
<!-- TOC --><a name="mqtt"></a>
## MQTT
See <https://kno.wled.ge/interfaces/mqtt/> 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`.
<img src="images/roll_plot.png" alt="Roll Plot"/>
<!-- TOC --><a name="potential-modifications-and-additional-features"></a>
## 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.
<!-- TOC --><a name="esp32-issues"></a>
## 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 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.
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).

6
usermods/pixels_dice_tray/WLED_ESP32_4MB_64KB_FS.csv Normal file
View File

@ -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,
1 # Name Type SubType Offset Size Flags
2 nvs data nvs 0x9000 0x5000
3 otadata data ota 0xe000 0x2000
4 app0 app ota_0 0x10000 0x1F0000
5 app1 app ota_1 0x200000 0x1F0000
6 spiffs data spiffs 0x3F0000 0x10000

76
usermods/pixels_dice_tray/dice_state.h Normal file
View File

@ -0,0 +1,76 @@
/**
* Structs for passing around usermod state
*/
#pragma once
#include <pixels_dice_interface.h> // 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<pixels::PixelsDieID> 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<pixels::PixelsDieID, MAX_NUM_DICE> 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<std::string, MAX_NUM_DICE> 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<pixels::RollEvent, MAX_NUM_DICE> 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 <typename C, typename T>
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<uint8_t, 3> DIE_LED_MODES = {0xFF, 0xFF, 0xFF};

230
usermods/pixels_dice_tray/generate_roll_info.py Normal file
View File

@ -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()

BIN
usermods/pixels_dice_tray/images/effect.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

BIN
usermods/pixels_dice_tray/images/info.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

BIN
usermods/pixels_dice_tray/images/roll_plot.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 9.8 KiB

BIN
usermods/pixels_dice_tray/images/status.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

124
usermods/pixels_dice_tray/led_effects.h Normal file
View File

@ -0,0 +1,124 @@
/**
* The LED effects influenced by dice rolls.
*/
#pragma once
#include "wled.h"
#include "dice_state.h"
// Reuse FX display functions.
extern uint16_t mode_breath();
extern uint16_t mode_blends();
extern uint16_t mode_glitter();
extern uint16_t mode_gravcenter();
static constexpr uint8_t USER_ANY_DIE = 0xFF;
/**
* Two custom effect parameters are used.
* c1 - Source Die. Sets which die from [0 - MAX_NUM_DICE) controls this effect.
* If this is set to 0xFF, use the latest event regardless of which die it
* came from.
* c2 - Target Roll. Sets the "success" criteria for a roll to >= 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";

104
usermods/pixels_dice_tray/mqtt_client/mqtt_logger.py Normal file
View File

@ -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()

69
usermods/pixels_dice_tray/mqtt_client/mqtt_plotter.py Normal file
View File

@ -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()

2
usermods/pixels_dice_tray/mqtt_client/requirements.txt Normal file
View File

@ -0,0 +1,2 @@
plotly-express
paho-mqtt

535
usermods/pixels_dice_tray/pixels_dice_tray.h Normal file
View File

@ -0,0 +1,535 @@
#pragma once
#include <pixels_dice_interface.h> // 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<const std::string, MAX_NUM_DICE>& 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<bool, MAX_NUM_DICE> 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
// <input type="hidden" name="DiceTray:die_0" value="text">
// <input type="text" name="DiceTray:die_0" value="*" style="width:250px;" oninput="check(this,'DiceTray')">
// ```
// 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,'<br><br><i>Set to \"*\" to "
"connect to any die.<br>Leave Blank to disable.</i><br><i "
"class=\"warn\">Saving will replace \"*\" with die names.</i>','');"));
#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,'<br><i class=\"warn\">DO NOT CHANGE "
"SPI PINS.</i><br><i class=\"warn\">CHANGES ARE IGNORED.</i>','');"));
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<const std::string, MAX_NUM_DICE> 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!
};

115
usermods/pixels_dice_tray/platformio_override.ini.sample Normal file
View File

@ -0,0 +1,115 @@
[platformio]
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_dice]
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_dice]
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_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
; 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

107
usermods/pixels_dice_tray/roll_info.h Normal file
View File

@ -0,0 +1,107 @@
#pragma once
#include <TFT_eSPI.h>
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;

479
usermods/pixels_dice_tray/tft_menu.h Normal file
View File

@ -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 <TFT_eSPI.h>
#include <pixels_dice_interface.h> // 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<long, MAX_NUM_DICE> last_update{0, 0};
std::array<pixels::PixelsDieID, MAX_NUM_DICE> last_die_ids{0, 0};
std::array<bool, MAX_NUM_DICE> die_updated{false, false};
std::array<pixels::BatteryEvent, MAX_NUM_DICE> die_battery = {
pixels::BatteryEvent{INVALID_BATTERY, false},
pixels::BatteryEvent{INVALID_BATTERY, false}};
std::array<RollCountWidget, MAX_NUM_DICE> 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<uint8_t, 3> 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<uint8_t, 3> 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<MenuBase*, 3> menu_ptrs = {&status_menu, &effect_menu,
&info_menu};
};
#endif

11
wled00/FX.cpp
View File

@ -7805,18 +7805,23 @@ 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;
} else {
return id;
} 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() - 1;
} else {
return 255; // The vector is full so return 255
}
}

4
wled00/FX.h
View File

@ -786,7 +786,6 @@ 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
inline void restartRuntime() { for (Segment &seg : _segments) seg.markForReset(); }
@ -822,7 +821,8 @@ class WS2812FX { // 96 bytes
getActiveSegmentsNum(void) const,
getFirstSelectedSegId(void) const,
getLastActiveSegmentId(void) const,
getActiveSegsLightCapabilities(bool selectedOnly = false) const;
getActiveSegsLightCapabilities(bool selectedOnly = false) const,
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) const { return _brightness; } // returns current strip brightness
inline uint8_t getMaxSegments(void) const { return MAX_NUM_SEGMENTS; } // returns maximum number of supported segments (fixed value)

1
wled00/const.h
View File

@ -201,6 +201,7 @@
#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"
#define USERMOD_ID_PIXELS_DICE_TRAY 54 //Usermod "pixels_dice_tray.h"
//Access point behavior
#define AP_BEHAVIOR_BOOT_NO_CONN 0 //Open AP when no connection after boot

3
wled00/pin_manager.h
View File

@ -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<uint8_t>(PinOwner::None), "PinOwner::None must be zero, so default array initialization works as expected");

8
wled00/usermods_list.cpp
View File

@ -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
@ -335,6 +339,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