25template<
typename AllModes>
static constexpr bool verifyGroup()
27 constexpr bool inheritsFromBasicMode = details::allOf<AllModes>::inheritsFromBasicMode;
28 static_assert(inheritsFromBasicMode,
"All modes must inherit from modes::BasicMode!");
30 constexpr bool stateDefaultConstructible = details::allOf<AllModes>::stateDefaultConstructible;
31 static_assert(stateDefaultConstructible,
"All states must be default constructible!");
34 acc |= !inheritsFromBasicMode;
35 acc |= !stateDefaultConstructible;
40template<typename AllModes, bool earlyFail = verifyGroup<AllModes>()>
struct GroupTy
43 using SelfTy = GroupTy<AllModes>;
44 using AllModesTy = AllModes;
45 using AllStatesTy = details::StateTyFrom<AllModes>;
46 static constexpr uint8_t nbModes {std::tuple_size_v<AllModesTy>};
49 static_assert(nbModes < 32,
"Maximum of 31 modes has been exceeded.");
51 template<u
int8_t Idx>
using ModeAtRaw = std::tuple_element_t<Idx, AllModesTy>;
52 template<u
int8_t Idx>
using ModeAt = std::conditional_t<!earlyFail, ModeAtRaw<Idx>, BasicMode>;
55 using HasAnyMode = details::anyOf<AllModesTy, earlyFail>;
56 static constexpr bool hasSunsetAnimation = HasAnyMode::hasSunsetAnimation;
57 static constexpr bool hasSunriseAnimation = HasAnyMode::hasSunriseAnimation;
58 static constexpr bool hasBrightCallback = HasAnyMode::hasBrightCallback;
59 static constexpr bool hasSystemCallbacks = HasAnyMode::hasSystemCallbacks;
60 static constexpr bool requireUserThread = HasAnyMode::requireUserThread;
61 static constexpr bool hasCustomRamp = HasAnyMode::hasCustomRamp;
62 static constexpr bool hasButtonCustomUI = HasAnyMode::hasButtonCustomUI;
65 static constexpr auto everySunsetCallback = HasAnyMode::everySunsetCallback;
66 static constexpr auto everySunriseCallback = HasAnyMode::everySunriseCallback;
67 static constexpr auto everyBrightCallback = HasAnyMode::everyBrightCallback;
68 static constexpr auto everySystemCallbacks = HasAnyMode::everySystemCallbacks;
69 static constexpr auto everyRequireUserThread = HasAnyMode::everyRequireUserThread;
70 static constexpr auto everyCustomRamp = HasAnyMode::everyCustomRamp;
71 static constexpr auto everyButtonCustomUI = HasAnyMode::everyButtonCustomUI;
75 GroupTy(
const GroupTy&) =
delete;
76 GroupTy& operator=(
const GroupTy&) =
delete;
79 template<
typename CallBack>
static void LMBD_INLINE dispatch_mode(
auto& ctx, CallBack&& cb)
81 uint8_t modeId = ctx.get_active_mode(nbModes);
83 details::unroll<nbModes>([&](
auto Idx) LMBD_INLINE {
92 template<
bool systemCallbacksOnly,
typename CallBack>
static void LMBD_INLINE foreach_mode(
auto& ctx, CallBack&& cb)
94 if constexpr (systemCallbacksOnly)
96 details::unroll<nbModes>([&](
auto Idx) LMBD_INLINE {
97 if constexpr (ModeAt<Idx>::hasSystemCallbacks)
105 details::unroll<nbModes>([&](
auto Idx) LMBD_INLINE {
112 template<
bool systemCallbacksOnly,
typename CallBack>
static void LMBD_INLINE iterate_mode(
auto& ctx, CallBack&& cb)
114 if constexpr (systemCallbacksOnly)
116 details::unroll<nbModes>([&](
auto Idx) LMBD_INLINE {
117 if constexpr (ModeAt<Idx>::hasSystemCallbacks)
125 details::unroll<nbModes>([&](
auto Idx) LMBD_INLINE {
136 enum class Store : uint16_t
142 static constexpr uint32_t storeId = modes::store::derivateStoreId<modes::store::hash(
"GroupTyStoreId"), AllModesTy>;
157 assert(modeId < nbModes);
158 if constexpr (ctx.hasCustomRamp)
160 ctx.state.customRampMemory[modeId] = ctx.get_active_custom_ramp();
161 ctx.state.customIndexMemory[modeId] = ctx.get_active_custom_index();
168 assert(modeId < nbModes);
169 if constexpr (ctx.hasCustomRamp)
171 ctx.set_active_custom_ramp(ctx.state.customRampMemory[modeId]);
172 ctx.set_active_custom_index(ctx.state.customIndexMemory[modeId]);
178 template<
typename Mode>
static auto* LMBD_INLINE getStateOf(
auto& manager)
180 using StateTy =
typename Mode::StateTy;
181 using OptionalTy = std::optional<StateTy>;
183 StateTy* substate =
nullptr;
184 details::unroll<nbModes>([&](
auto Idx) LMBD_INLINE {
185 using ModeHere = ModeAt<Idx>;
186 constexpr bool isHere = std::is_same_v<ModeHere, Mode>;
188 if constexpr (isHere)
190 auto* state = manager.template getStateGroupOf<SelfTy>();
193 OptionalTy& opt = std::get<OptionalTy>(state->modeStates);
194 if (!opt.has_value())
199 StateTy& stateHere = *opt;
200 substate = &stateHere;
205 assert(substate !=
nullptr &&
"this should not have happened!");
214 static constexpr bool isGroupManager =
false;
216 static constexpr bool isModeManager =
true;
219 static void next_mode(
auto& ctx)
221 uint8_t modeIdBefore = ctx.get_active_mode(nbModes);
222 ctx.set_active_mode(modeIdBefore + 1, nbModes);
226 static void enter_mode(
auto& ctx)
230 ctx.lamp.align_internal_to_system_brightness();
234 uint8_t modeIdAfter = ctx.get_active_mode(nbModes);
235 ctx.state.load_ramps(ctx, modeIdAfter);
238 dispatch_mode(ctx, [](
auto mode) {
239 mode.on_enter_mode();
244 static void quit_mode(
auto& ctx)
247 if (not ctx.is_in_favorite_group())
250 uint8_t modeIdBefore = ctx.get_active_mode(nbModes);
253 ctx.state.save_ramps(ctx, modeIdBefore);
257 dispatch_mode(ctx, [](
auto mode) {
267 static void loop(
auto& ctx)
269 dispatch_mode(ctx, [](
auto mode) {
275 static void sunset_update(
auto& ctx,
float progress)
277 dispatch_mode(ctx, [&](
auto mode) {
278 mode.sunset_update(progress);
283 static void sunrise_update(
auto& ctx,
float progress)
285 dispatch_mode(ctx, [&](
auto mode) {
286 mode.sunrise_update(progress);
293 dispatch_mode(ctx, [&](
auto mode) {
294 mode.brightness_update(brightness);
299 static void custom_ramp_update(
auto& ctx, uint8_t rampValue)
301 dispatch_mode(ctx, [&](
auto mode) {
302 mode.custom_ramp_update(rampValue);
307 static bool custom_click(
auto& ctx, uint8_t nbClick)
310 dispatch_mode(ctx, [&](
auto mode) {
311 retVal = mode.custom_click(nbClick);
317 static bool custom_hold(
auto& ctx, uint8_t nbClickAndHold,
bool isEndOfHoldEvent, uint32_t holdDuration)
320 dispatch_mode(ctx, [&](
auto mode) {
321 retVal = mode.custom_hold(nbClickAndHold, isEndOfHoldEvent, holdDuration);
326 static std::array<uint8_t, nbModes> get_custom_ramp_default_value(
auto& ctx)
328 std::array<uint8_t, nbModes> defaultValues;
329 defaultValues.fill(0);
331 iterate_mode<false>(ctx, [&defaultValues](
auto mode,
const size_t index) {
332 if constexpr (mode.hasCustomRamp)
334 defaultValues[index] = mode.get_custom_ramp_default_value();
337 return defaultValues;
343 foreach_mode<true>(ctx, [](
auto mode) {
344 mode.power_on_sequence();
351 foreach_mode<true>(ctx, [](
auto mode) {
352 mode.power_off_sequence();
359 foreach_mode<true>(ctx, [](
auto mode) {
360 mode.write_parameters();
367 foreach_mode<true>(ctx, [](
auto mode) {
368 mode.read_parameters();
375 dispatch_mode(ctx, [](
auto mode) {
386template<
typename... Modes>
using GroupFor = GroupTy<std::tuple<Modes...>>;
Define assertions helpers.
ContextTy and associated definitions.
modes::ManagerFor and associated definitions
Basic interface types to implement custom user modes.
brightness_t get_scaled_saved_brightness()
Return the saved brightness level, with the user brightness scale applied. This is the level that the...
Definition: brightness_handle.cpp:71
Contains basic interface types to implement custom user modes.
Definition: control_fixed_modes.hpp:14
GroupTy< std::tuple< Modes... > > GroupFor
Group together many different modes::BasicMode.
Definition: group_type.hpp:386
static auto context_as(auto &ctx)
Bind provided context to another modes::BasicMode.
Definition: context_type.hpp:25
void brightness_update(const brightness_t brightness)
Called when the system changes the LED strip brightness.
Definition: default_behavior.hpp:64
void user_thread()
Called at each tick of the secondary thread.
Definition: default_behavior.hpp:199
void read_parameters()
Called when system wants to read parameters from filesystem.
Definition: default_behavior.hpp:94
void power_on_sequence()
Called when the system powers on (must be non blocking function!)
Definition: default_behavior.hpp:39
void write_parameters()
Called when system wants to write parameters to filesystem.
Definition: default_behavior.hpp:88
void power_off_sequence()
Called when the system powers off (must be non blocking function!)
Definition: default_behavior.hpp:50
void loop()
Called at each tick of the main loop.
Definition: default_behavior.hpp:179
uint16_t brightness_t
Define the type of the brightness parameters.
Definition: constants.h:151
Definition: group_type.hpp:149
std::array< uint8_t, nbModes > customIndexMemory
Store the active index for each mode.
Definition: group_type.hpp:152
std::array< uint8_t, nbModes > customRampMemory
Store the ramp value for each mode.
Definition: group_type.hpp:151
AllStatesTy modeStates
Store the current group state.
Definition: group_type.hpp:150
void LMBD_INLINE save_ramps(auto &ctx, uint8_t modeId)
If a mode signaled that it has a ramp, save it.
Definition: group_type.hpp:155
void LMBD_INLINE load_ramps(auto &ctx, uint8_t modeId)
If a mode signaled that it has a ramp, load it.
Definition: group_type.hpp:166