Welcome to Renderbug’s documentation!

API Documentation

struct AnimatedNumber

#include <Animation.h>

Public Functions

inline void set(uint8_t v)

inline void set(uint8_t start, uint8_t end)

uint8_t value() const

inline void update()

inline void update(uint8_t speed)

inline bool isFinished() const

inline AnimatedNumber()

inline AnimatedNumber(uint8_t v)

inline AnimatedNumber &operator=(uint8_t v)

inline AnimatedNumber &operator+=(uint8_t v)

inline operator uint8_t() const

inline operator int() const

inline operator unsigned int() const

inline bool operator==(int other) const

inline uint8_t operator+(uint8_t other) const

inline int operator+(int other) const

Private Members

uint8_t m_idx = 255

uint8_t m_start = 0

uint8_t m_end = 0

struct AnimatedRGB

#include <Animation.h>

Public Functions

inline AnimatedRGB(const CRGB &color)

inline AnimatedRGB()

inline AnimatedRGB &operator=(const CRGB &rgb)

inline void update()

inline operator CRGB() const

Public Members

CRGB start

CRGB end

AnimatedNumber pos

class ArduinoOTAUpdater : public BufferedInputSource

#include <OTA.h>

Public Functions

ArduinoOTAUpdater()

virtual void loop() override

Called on every MainLoop tick

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

Private Members

bool m_online = false

Private Static Functions

static void s_onStart()

static void s_onProgress(unsigned int progress, unsigned int total)

struct AutoTaskRegistration : public Platform::TaskRegistration

#include <Static.h>

Public Functions

inline explicit AutoTaskRegistration(Task *task)

template<typename T, uint8_t Size = 8>
struct Averager

#include <MPU6050.h>

Public Functions

inline void add(const T &value)

inline T value() const

Public Members

std::array<T, Size> buf

unsigned int idx = 0

unsigned int count = 0

template<typename T, uint8_t Size = 8>
struct Averager

#include <BluetoothSerialTelemetry.h>

Public Functions

inline void add(const T &value)

inline T value() const

Public Members

std::array<T, Size> buf

unsigned int idx = 0

unsigned int count = 0

class Blob

#include <Blob.h>

Public Functions

inline Blob()

inline void setSaturation(uint8_t v)

inline void setPos(uint16_t p)

inline void setHue(uint8_t p)

inline void setBrightness(uint8_t p)

inline void setVelocity(int8_t v)

inline void update()

inline void render(Display *display) const

Private Members

uint8_t m_pos

int8_t m_velocity

uint8_t m_hue

int16_t m_brightness

uint8_t m_saturation

int8_t m_fadeDir

class BluetoothSerialTelemetry : public InputSource

#include <BluetoothSerialTelemetry.h>

Public Functions

BluetoothSerialTelemetry()

virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual InputEvent read() override

Private Members

BluetoothSerial m_serial

Ringbuf<char, 32> m_ringbuf

CRGB m_color

Averager<int16_t, 32> m_value

struct BootOptions

#include <BootOptions.h>

Public Functions

BootOptions()

void waitForRelease()

Public Members

bool isSetup = false

bool isSerial = false

bool isFlash = false

bool lastBootWasFlash = false

bool isSafeMode = false

uint8_t crashCount = 0

uint8_t resetReason = 0

Public Static Functions

static void initPins()

class Bounce

#include <Buttons.h>

Public Functions

inline void attach(int pin, int buttonPinMode)

inline void update()

inline void interval(uint8_t v)

inline bool fell() const

inline bool rose() const

inline bool held() const

Private Types

enum State

Values:

enumerator Ready

enumerator Started

enumerator Confirmed

enumerator Held

enumerator Released

Private Members

State m_state = Ready

unsigned int m_pin = 0

unsigned int m_downStart = 0

unsigned int m_interval = 10

class BPM : public InputSource, private ConfigTaskMixin

#include <BPM.h>

Public Functions

inline BPM()

inline virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

inline virtual void loop()

Called on every MainLoop tick

inline virtual void handleConfigChange(const Configuration &cfg) override

inline virtual InputEvent read() override

Private Functions

inline constexpr uint16_t msToBPM(float msPerBeat) const

inline void updateBPM()

Private Members

uint16_t m_msPerBeat = 60000

uint16_t m_nextBpm = 0

uint16_t m_nextLearn = 0

Ringbuf<uint16_t, 7> m_timings

class BufferedInputSource : public InputSource

#include <Input.h>

Subclassed by ArduinoOTAUpdater, ConfigInputTask, InputMapper, MQTTTelemetry

Public Functions

inline BufferedInputSource(const char *name)

virtual InputEvent read() override

Protected Functions

void setEvent(InputEvent &&evt)

void setEvent(InputEvent::Intent intent, Variant &&v)

Private Members

Ringbuf<InputEvent, 12> m_eventQueue

class Buttons : public InputSource

#include <Buttons.h>

Public Types

enum Chord

Values:

enumerator None

enumerator Circle

enumerator Triangle

enumerator Cross

enumerator CircleTriangle

enumerator CircleCross

enumerator TriangleCross

enumerator CircleTriangleCross

Public Functions

inline Buttons()

virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual InputEvent read() override

Private Members

Bounce m_buttons[3]

Chord m_buttonMap[3] = {Circle, Triangle, Cross}

bool m_wasChord[3] = {false, false, false}

template<int ChimeLength>
class Chime

#include <Chime.h>

Public Functions

inline Chime()

inline void setSaturation(uint8_t i)

inline void setSpeed(uint8_t i)

inline void setOffset(unsigned int i)

inline void setPos(uint8_t i)

inline void setHue(uint8_t i)

inline void setBrightness(uint8_t i)

inline void update()

inline void render(Display *dpy) const

Public Static Attributes

static const int Length = ChimeLength

Private Members

uint16_t m_pos

uint8_t m_speed

uint16_t m_hue

uint16_t m_saturation

uint16_t m_brightness

unsigned int m_offset

class ChimesAnimation : public Figment

#include <Chimes.h>

Public Functions

ChimesAnimation()

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void loop() override

Called on every MainLoop tick

virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Functions

void randomize()

Private Members

SpriteList<Chime<CHIME_LENGTH>, CHIME_COUNT> m_chimes

SpriteList<Blob, BLOB_COUNT> m_blobs

AnimatedRGB m_flashColor

AnimatedNumber m_flashBrightness

bool m_isRandom = false

class CircadianRhythm : public InputSource

#include <CircadianRhythm.h>

Public Functions

inline CircadianRhythm()

inline virtual void onStart()

Implement in a subclass to run when the task is started The default implementation does nothing.

inline uint8_t brightnessForTime(uint8_t hour, uint8_t minute) const

inline virtual InputEvent read()

Private Members

bool needsUpdate = true

struct ColorInfo

#include <colors.h>

Public Members

const char *name

CRGB rgb

template<int Period>
class ColorSequenceInput : public InputSource

#include <ColorCycle.h>

Public Functions

inline ColorSequenceInput(const std::vector<CRGB> &colors, const char *name)

inline virtual InputEvent read() override

inline virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

inline virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

Private Members

std::vector<CRGB> m_colors

unsigned int m_idx = 0

bool m_reset = true

class ConfigInputTask : public BufferedInputSource

#include <ConfigInput.h>

Public Functions

inline ConfigInputTask()

inline virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

Private Functions

inline void decrement()

inline void increment()

inline InputEvent::Intent nextIntent()

Private Members

InputEvent::Intent m_currentIntent = InputEvent::SetDisplayLength

struct ConfigService : public Task

#include <Config.h>

Public Functions

inline ConfigService()

virtual void onStart()

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual void loop() override

Called on every MainLoop tick

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

inline const CoordinateMapping *coordMap() const

const char *loadedProfile() const

void overrideProfile(const char *profileName)

const char *getConfigValue(const char *key) const

Private Functions

bool loadProfile(const char *name)

bool loadMap(const String &mapName)

Private Members

HardwareConfig m_config

JsonCoordinateMapping m_jsonMap

const char *m_overrideProfile = nullptr

class ConfigTaskMixin : public virtual Loopable

#include <Config.h>

Subclassed by BPM, MQTTTelemetry, Power

Public Functions

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

inline virtual void loop() override

Called on every MainLoop tick

inline virtual void handleConfigChange(const Configuration &config)

class Configuration

#include <Config.h>

Public Functions

Configuration(const JsonObject &data)

const char *get(const char *key, const char *defaultVal) const

int get(const char *key, int defaultVal) const

bool get(const char *key, bool defaultVal) const

Private Members

const JsonObject &m_json

struct CoordinateMapping

#include <Display.h>

Generic interface for converting between virtual and physical coordinates

Subclassed by JsonCoordinateMapping, LinearCoordinateMapping

Public Functions

virtual VirtualCoordinates physicalToVirtualCoords(const PhysicalCoordinates localCoords) const = 0

Maps physical coordinates to virtual coordinates. Virtual coordinates range from 0 to 255. Physical coordinates are hardware-dependent.

virtual PhysicalCoordinates virtualToPhysicalCoords(const VirtualCoordinates virtualCoords) const = 0

Maps virtual coordinates to physical (aka, hardware) coordinates. Virtual coordinates range from 0 to 255. Physical coordinates are hardware-dependent.

virtual int physicalCoordsToIndex(const PhysicalCoordinates localCoords) const = 0

Returns the index of the underlying FastLED array, i.e., the physical hardware pixel.

virtual unsigned int physicalPixelCount() const = 0

template<typename T>
struct Coordinates

#include <Geometry.h>

Public Functions

inline Coordinates(T _x, T _y)

Public Members

T x

T y

struct Data

#include <Config.h>

Public Members

char loadedProfile[16] = {0}

uint8_t lastRed = 255

uint8_t lastGreen = 255

uint8_t lastBlue = 255

char lastScene[16] = {0}

class Display

#include <Display.h>

The connection between the rendering engine and the physical hardware. Provides direct access to the underlying FastLED array.

Public Functions

inline Display(CRGB *pixels, int pixelCount, const CoordinateMapping *map)

CRGB &pixelAt(const PhysicalCoordinates coords)

Returns the physical pixel at the given physical coordinates

CRGB &pixelAt(const VirtualCoordinates coords)

Returns the physical pixel at the given virtual coordinates

CRGB &pixelAt(int idx)

Returns the physical pixel in the underlying FastLED array

int pixelCount() const

Returns how many pixels are in this display

CRGB *pixelBacking() const

Returns the raw underlying FastLED array

const CoordinateMapping *coordinateMapping() const

void clear()

Sets every pixel to (0, 0, 0)

void clear(const CRGB &color)

Sets every pixel to the given display

Private Members

CRGB *m_pixels

int m_pixelCount

const CoordinateMapping *m_coordMap

class DrainAnimation : public Figment

#include <Drain.h>

Public Functions

DrainAnimation()

virtual void loop() override

Called on every MainLoop tick

virtual void handleEvent(const InputEvent &event) override

Called by the MainLoop to process events

virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Functions

void fillRange(Display *dpy, const PhysicalCoordinates &start, const PhysicalCoordinates &end, const CHSV &baseColor) const

Private Members

AnimatedRGB m_fillColor

uint16_t m_pos

uint16_t m_burst

struct Figment : public Task

#include <Figment.h>

A Task with a graphical output

Subclassed by ChimesAnimation, DrainAnimation, FigmentFunc, Flashlight, InputBlip, Power, SolidAnimation, TestAnimation, UpdateStatus

Public Functions

inline Figment()

inline explicit Figment(const char *name)

virtual void render(Display *dpy) const = 0

Called when the Figment should render its output to a display

inline virtual bool isFigment() const override

A hacky way to determine if a task is a Figment subclass or not, without having to resort to RTTI

struct figment_iterator : public std::iterator<std::input_iterator_tag, Figment*>

#include <Platform.h>

Public Functions

inline explicit figment_iterator()

inline explicit figment_iterator(TaskRegistration *head)

inline figment_iterator &operator++()

inline figment_iterator operator++(int)

inline bool operator==(figment_iterator other) const

inline bool operator!=(figment_iterator other) const

inline Figment *operator*() const

Public Members

TaskRegistration *cur

struct FigmentFunc : public Figment

#include <Figment.h>

Functional lambda interface for creating Figments

Public Functions

inline FigmentFunc(std::function<void(Display*)> func)

inline virtual void loop() override

Called on every MainLoop tick

inline virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Public Members

std::function<void(Display*)> func

class Flashlight : public Figment

#include <Flashlight.h>

Public Functions

Flashlight()

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void loop() override

Called on every MainLoop tick

virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Members

SpriteList<Blob, blobCount> m_blobs

Private Static Attributes

static constexpr int blobCount = 30

struct HardwareConfig

#include <Config.h>

Public Functions

void save()

bool isValid() const

Public Members

uint8_t version = 3

uint8_t checksum = 0

Data data

Public Static Functions

static HardwareConfig load()

Public Static Attributes

static constexpr uint16_t MAX_LED_NUM = 255

Private Functions

uint8_t getCRC() const

Private Static Attributes

static constexpr uint8_t CRC7_POLY = 0x91

class InputBlip : public Figment

#include <InputBlip.h>

Public Functions

InputBlip()

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void loop() override

Called on every MainLoop tick

virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Members

uint8_t m_time = 0

struct InputEvent : public Variant

#include <Input.h>

Public Types

enum Intent

Values:

enumerator None

enumerator UserInput

enumerator ButtonPress

enumerator Acceleration

enumerator NetworkStatus

enumerator NetworkActivity

enumerator PowerToggle

enumerator SetPower

enumerator SetBrightness

enumerator PreviousPattern

enumerator NextPattern

enumerator SetPattern

enumerator PreviousScene

enumerator NextScene

enumerator SetScene

enumerator ScheduleChange

enumerator Beat

enumerator BeatDetect

enumerator StartThing

enumerator StopThing

enumerator SetDisplayOffset

enumerator SetDisplayLength

enumerator LoadConfigurationByName

enumerator SetColor

enumerator SaveConfigurationRequest

enumerator ConfigurationChanged

enumerator FirmwareUpdate

enumerator ReadyToRoll

Public Functions

template<typename Value>
inline InputEvent(Intent s, Value v)

inline InputEvent(Intent s)

inline InputEvent()

Public Members

Intent intent

class InputFunc : public InputSource

#include <Input.h>

Public Functions

inline InputFunc(std::function<InputEvent(void)> f)

inline InputFunc(std::function<InputEvent(void)> f, const char *name)

inline virtual InputEvent read() override

Private Members

std::function<InputEvent(void)> m_func

class InputMapper : public BufferedInputSource

#include <Input.h>

Public Functions

inline InputMapper(std::function<InputEvent(const InputEvent)> f, const char *name)

inline virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

Private Members

std::function<InputEvent(const InputEvent)> m_func

class InputSource : public Task

#include <Input.h>

Subclassed by BluetoothSerialTelemetry, BPM, BufferedInputSource, Buttons, CircadianRhythm, ColorSequenceInput< Period >, InputFunc, MPU5060, SerialInput, WiFiTask

Public Functions

inline InputSource()

inline explicit InputSource(const char *name)

virtual void loop() override

Called on every MainLoop tick

virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual InputEvent read() = 0

Private Functions

void init()

struct iterator : public std::iterator<std::input_iterator_tag, Task*>

#include <MainLoop.h>

Public Functions

inline explicit iterator(Scheduler &queue)

inline iterator(Scheduler &queue, int start)

inline iterator &operator++()

inline int nextEnabled(int start) const

inline iterator operator++(int)

inline bool operator==(iterator other) const

inline bool operator!=(iterator other) const

inline Task *operator*() const

Public Members

Scheduler &queue

int idx = 0

struct JsonCoordinateMapping : public CoordinateMapping

#include <JsonCoordinateMapping.h>

Public Functions

void load(const JsonArray &strides)

void loadDefault()

virtual VirtualCoordinates physicalToVirtualCoords(const PhysicalCoordinates localCoords) const override

Maps physical coordinates to virtual coordinates. Virtual coordinates range from 0 to 255. Physical coordinates are hardware-dependent.

virtual PhysicalCoordinates virtualToPhysicalCoords(const VirtualCoordinates virtualCoords) const override

Maps virtual coordinates to physical (aka, hardware) coordinates. Virtual coordinates range from 0 to 255. Physical coordinates are hardware-dependent.

virtual int physicalCoordsToIndex(const PhysicalCoordinates localCoords) const override

Returns the index of the underlying FastLED array, i.e., the physical hardware pixel.

virtual unsigned int physicalPixelCount() const override

Public Members

Span displayMap[32]

int strideCount = 0

int maxStrideSize = 0

struct LinearCoordinateMapping : public CoordinateMapping

#include <Display.h>

Basic mapping for a contiguous 1-d linear display, eg, an LED strip.

X value ranges from 0 to 255; all Y values are flattened to Y=0

Public Functions

inline LinearCoordinateMapping()

inline LinearCoordinateMapping(unsigned int count, unsigned int start)

inline virtual VirtualCoordinates physicalToVirtualCoords(const PhysicalCoordinates localCoords) const override

Maps physical coordinates to virtual coordinates. Virtual coordinates range from 0 to 255. Physical coordinates are hardware-dependent.

inline virtual PhysicalCoordinates virtualToPhysicalCoords(const VirtualCoordinates virtualCoords) const override

Maps virtual coordinates to physical (aka, hardware) coordinates. Virtual coordinates range from 0 to 255. Physical coordinates are hardware-dependent.

inline virtual int physicalCoordsToIndex(const PhysicalCoordinates localCoords) const override

Returns the index of the underlying FastLED array, i.e., the physical hardware pixel.

inline virtual unsigned int physicalPixelCount() const override

Public Members

unsigned int pixelCount = 1

unsigned int startPixel = 0

class LogPrinter : public Print

#include <MQTTTelemetry.h>

Public Functions

inline LogPrinter(MQTTTelemetry *telemetry)

inline size_t write(uint8_t byte)

Private Members

MQTTTelemetry *telemetry

Ringbuf<char, 512> buf

class LogService : public Task

#include <LogService.h>

Public Functions

inline LogService()

virtual void handleEvent(const InputEvent &event) override

Called by the MainLoop to process events

inline virtual void loop() override

Called on every MainLoop tick

Public Static Functions

static const char *intentName(InputEvent::Intent intent)

static const char *eventValue(const InputEvent &evt)

Private Members

uint16_t m_duplicateEvents = 0

InputEvent m_lastEvent

Private Static Attributes

static char s_valueBuf[255]

struct Loopable

#include <Figment.h>

A generic interface for anything that can be executed and respond to events.

Subclassed by ConfigTaskMixin, OnlineTaskMixin, Task

Public Functions

inline virtual void handleEvent(const InputEvent &event)

Called by the MainLoop to process events

virtual void loop() = 0

Called on every MainLoop tick

struct MainLoop

#include <MainLoop.h>

Public Functions

inline MainLoop(std::vector<Task*> &&tasks)

void start()

void loop()

void dispatch(const InputEvent &event)

void dispatchSync(const InputEvent &event)

Public Members

Scheduler scheduler

Public Static Functions

static inline MainLoop *instance()

static const char *lastTaskName()

Private Members

Ringbuf<InputEvent, 32> m_eventBuf

Private Static Attributes

static MainLoop *s_instance

class MPU5060 : public InputSource

#include <MPU6050.h>

Public Functions

MPU5060()

virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual void onStop() override

Implement in a subclass to run when the task is stopped. The default implementation does nothing.

virtual InputEvent read() override

Public Members

Averager<int16_t, 32> m_value

Private Members

const int ACCEL_XOUT_HIGH = 0x3B

const int ACCEL_XOUT_LOW = 0x3C

const int ACCEL_YOUT_HIGH = 0x3D

const int ACCEL_YOUT_LOW = 0x3E

const int ACCEL_ZOUT_HIGH = 0x3F

const int ACCEL_ZOUT_LOW = 0x40

const int I2C_ADDRESS = 0x68

const int PWR_MGMT_1 = 0x6B

const int CONFIG_REG = 0x1A

const int ACCEL_CONFIG_REG = 0x1C

struct MQTTDevice

Public Functions

inline void toJson(const JsonObject &json) const

Public Members

const String id

const String name

const String model

const String softwareVersion

const String manufacturer

const String availabilityTopic

struct MQTTEntity

Public Functions

inline MQTTEntity(const String &domain, const MQTTDevice &device, const String &name)

inline String configTopic() const

inline String commandTopic() const

inline String heartbeatTopic() const

inline String statTopic() const

inline bool isCommandTopic(const char *topic) const

inline void toJson(JsonDocument &jsonBuf, bool isInteractive = true) const

Public Members

const MQTTDevice &device

String name

String entityId

String rootTopic

class MQTTTelemetry : public BufferedInputSource, private OnlineTaskMixin, private ConfigTaskMixin

#include <MQTTTelemetry.h>

Public Functions

MQTTTelemetry()

inline void setSequencer(Sequencer *seq)

inline Print *logPrinter()

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void handleEventOnline(const InputEvent &evt) override

virtual void handleConfigChange(const Configuration &cfg) override

virtual void loop() override

Called on every MainLoop tick

virtual void loopOnline() override

virtual void onOnline() override

virtual void onOffline() override

Private Functions

void callback(char *topic, const char *payload)

void publishDoc(const char *topic)

void publishDoc(const char *topic, bool retain)

Private Members

String m_rootTopic

String m_debugTopic

char m_patternBuf[48]

bool m_needHeartbeat = false

bool m_isOn = true

char m_hostBuf[15]

Sequencer *m_sequencer = 0

WiFiClient m_wifi

PubSubClient m_mqtt

LogPrinter m_logPrinter

Private Static Functions

static void s_callback(char *topic, byte *payload, unsigned int length)

Private Static Attributes

static char s_topicBuf[128] = {0}

static char s_payloadBuf[512] = {0}

class OnlineTaskMixin : public virtual Loopable

#include <Input.h>

Subclassed by MQTTTelemetry

Public Functions

inline virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

inline virtual void onOnline()

inline virtual void onOffline()

inline virtual void handleEventOnline(const InputEvent &evt)

inline virtual void loop() override

Called on every MainLoop tick

inline virtual void loopOnline()

Private Members

bool m_online = false

struct PerfCounter

#include <Perfcounter.h>

Public Functions

inline PerfCounter(const char *name)

inline ~PerfCounter()

Public Members

uint16_t start

const char *name

struct PhysicalCoordinates : public Coordinates<uint16_t>

#include <Geometry.h>

Public Functions

inline PhysicalCoordinates(uint16_t _x, uint16_t _y)

class Platform : public Task

#include <Platform.h>

Public Functions

inline Platform()

virtual void loop() override

Called on every MainLoop tick

Public Static Functions

static inline void setTimezone(int tz)

static inline int getTimezone()

static void addLEDs(CRGB *leds, unsigned int ledCount)

static const char *name()

static const char *version()

static const String model()

static inline const String deviceName()

static void preSetup()

static void bootSplash()

static void setup()

static bool getLocalTime(struct tm *timedata)

static const char *deviceID()

static int freeRam()

static inline void registerTask(TaskRegistration *reg)

static inline figment_iterator beginFigments()

static inline figment_iterator endFigments()

static inline task_iterator beginTasks()

static inline task_iterator endTasks()

static void restart()

Public Static Attributes

static BootOptions bootopts

static TaskRegistration *firstTask = NULL

static TaskRegistration *lastTask = NULL

Private Static Attributes

static int s_timezone = 0

static char s_deviceID[15]

class Power : public Figment, private ConfigTaskMixin

#include <Power.h>

Public Functions

inline Power()

inline virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void handleConfigChange(const Configuration &config) override

inline virtual void loop() override

Called on every MainLoop tick

inline virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Members

AnimatedNumber m_powerState = 255

AnimatedNumber m_brightness = 255

AnimatedNumber m_beatDecay = 255

uint8_t m_voltage = 5

uint16_t m_milliamps = 500

bool m_valid = true

bool m_useBPM = false

struct Renderer : public Task

#include <Renderer.h>

Public Functions

inline Renderer(std::vector<Display*> &&displays, const std::vector<Figment*> &figments)

virtual void loop() override

Called on every MainLoop tick

virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

Private Members

const std::vector<Figment*> m_figments

const std::vector<Display*> m_displays

template<typename T, int Size>
struct Ringbuf

#include <Ringbuf.h>

A simple ring buffer structure

Public Functions

inline Ringbuf()

inline void clear()

Clears the buffer’s contents

inline T peek(int offset) const

Returns the value of the next available item, if available

inline bool take(T &dest)

Removes and returns the next available item, if any.

Returns

false if no data is available, true otherwise

inline void insert(const T &src)

Inserts an item into the buffer. If the buffer is full, the oldest item is overwritten.

inline size_t write(T (&dest)[Size])

Consumes the entire buffer and writes it to the given array.

inline size_t write(Print &stream)

Consumes the entire buffer and writes it to the given output

inline size_t size()

Returns how many items are available in the buffer

Private Members

int m_head = 0

int m_tail = 0

std::array<T, Size> m_items

class SafeMode

#include <SafeMode.h>

Public Static Attributes

static MainLoop safeModeApp = {{Static<Platform>::instance(), Static<LogService>::instance(), &safeModeNag,}}

class Scene

#include <Sequencer.h>

Public Functions

void start()

void stop()

Public Members

const char *name

std::vector<const char*> patterns

struct ScheduleEntry

#include <CircadianRhythm.h>

Public Members

uint8_t hour

uint8_t brightness

struct Scheduler

#include <MainLoop.h>

Public Functions

inline bool operator==(const Scheduler &other) const

inline Scheduler(std::vector<Task*> &&tasks)

inline iterator begin()

inline iterator end()

Public Members

std::vector<Task*> tasks

class Sequencer : public Task

#include <Sequencer.h>

Public Functions

Sequencer()

virtual void loop() override

Called on every MainLoop tick

virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

void setScenes(std::vector<Scene> &&scenes)

const char *currentSceneName()

const std::vector<Scene> scenes() const

Private Members

int m_idx

std::vector<Scene> m_scenes

class SerialInput : public InputSource

#include <Serial.h>

Public Functions

inline virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual InputEvent read()

Private Functions

void doCommand()

Private Members

String m_buf

class SolidAnimation : public Figment

#include <SolidAnimation.h>

Public Functions

SolidAnimation()

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void loop() override

Called on every MainLoop tick

virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Functions

void randomize()

Private Members

AnimatedNumber m_red

AnimatedNumber m_green

AnimatedNumber m_blue

AnimatedNumber m_changePct

CRGB m_curColor

CRGB m_prevColor

SpriteList<Blob, blobCount> m_blobs

bool m_isRandom = false

bool m_horizontal = false

Private Static Attributes

static constexpr int blobCount = 20

struct Span

#include <JsonCoordinateMapping.h>

Public Functions

inline Span()

inline Span(int length, int x, int y)

Public Members

int length = 0

int x = 0

int y = 0

template<typename T, int Size>
struct SpriteList

#include <Animation.h>

Public Types

using Type = T

Public Functions

inline void update()

inline void render(Display *dpy) const

inline void forEach(std::function<void(T&)> func)

inline void forEach(std::function<void(const T&)> func) const

inline void disable()

inline void enable()

inline void toggle()

inline T &operator[](int idx)

Public Members

T animations[Size]

bool m_enabled = true

Public Static Attributes

static constexpr int size = Size

template<typename T>
class Static

#include <Static.h>

Public Static Functions

static inline T *instance()

Private Static Attributes

static T *s_instance

template<typename T>
struct StaticTaskRegistration : public Platform::TaskRegistration

#include <Static.h>

Public Functions

inline StaticTaskRegistration()

class Surface

#include <Surface.h>

A high performance and hardware-independent rendering surface which represents a full 2d display ranging from (0,0) to (255, 255), that may be rotated.

Simple brushes and complex shaders may be applied to a Surface using and . The Surface will only execute each shader or brush once for each physical pixel in the display, allowing you to design display-independent graphics.

Public Types

using Shader = std::function<void(CRGB&, const VirtualCoordinates &virtPos, const PhysicalCoordinates &realPos, const VirtualCoordinates &surfacePos)>

A lambda function that maps coordinates to colors.

using BrushFunc = std::function<void(CRGB&)>

A simple lambda that is called for every pixel in a surface. Commonly used for solid fills; if you want to map pixel coordinates to colors or textures, you probably want to use a Shader instead.

Public Functions

Surface(Display *dpy, const VirtualCoordinates &start, const VirtualCoordinates &end)

Surface(Display *dpy, const VirtualCoordinates &start, const VirtualCoordinates &end, uint8_t rotation)

Surface &operator=(const CRGB &color)

Sets the entire surface to one solid color

Surface &operator+=(const CRGB &color)

Adds the given color to every pixel on the surface

template<typename T>
inline Surface &operator|=(const T &val)

OR operation that applies the given color to every pixel on the surface

void paintWith(BrushFunc func)

Applies the given BrushFunc to every physical pixel in the surface

void paintShader(Shader shader)

Applies the given Shader to every physical pixel in the surface

Public Members

const PhysicalCoordinates start

const PhysicalCoordinates end

const VirtualCoordinates virtStart

const VirtualCoordinates virtEnd

Private Members

Display *m_display

uint8_t m_rotation = 0

struct Task : public virtual Loopable

#include <Figment.h>

A Loopable that can be named and may be started or stopped in a MainLoop.

Subclassed by ConfigService, Figment, InputSource, LogService, Platform, Renderer, Sequencer, TaskFunc, U8Display

Public Types

enum State

Values:

enumerator Running

enumerator Stopped

Public Functions

inline virtual void onStart()

Implement in a subclass to run when the task is started The default implementation does nothing.

inline virtual void onStop()

Implement in a subclass to run when the task is stopped. The default implementation does nothing.

inline Task()

inline explicit Task(const char *name)

inline void start()

Starts the task and makes it schedulable

inline void stop()

Stops the task and makes it unschedulable

inline virtual bool isFigment() const

A hacky way to determine if a task is a Figment subclass or not, without having to resort to RTTI

Public Members

const char *name = ""

State state = Stopped

struct task_iterator : public std::iterator<std::input_iterator_tag, Task*>

#include <Platform.h>

Public Functions

inline explicit task_iterator()

inline explicit task_iterator(TaskRegistration *head)

inline task_iterator &operator++()

inline task_iterator operator++(int)

inline bool operator==(task_iterator other) const

inline bool operator!=(task_iterator other) const

inline Task *operator*() const

Public Members

TaskRegistration *cur

struct TaskFunc : public Task

#include <Figment.h>

Functional lambda interface for creating Tasks

Public Functions

inline TaskFunc(std::function<void()> func)

inline virtual void loop() override

Called on every MainLoop tick

Public Members

std::function<void()> func

struct TaskRegistration

#include <Platform.h>

Subclassed by AutoTaskRegistration, StaticTaskRegistration< T >

Public Functions

inline TaskRegistration(Task *task)

Public Members

Task *task = 0

TaskRegistration *next = 0

class TestAnimation : public Figment

#include <TestAnimation.h>

Public Functions

const char *name() const

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void loop() override

Called on every MainLoop tick

virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Members

AnimatedNumber m_hue

AnimatedNumber m_saturation

AnimatedNumber m_brightness

uint8_t m_x

uint8_t m_y

class U8Display : public Task

Public Types

enum ScreenState

Values:

enumerator BootSplash

enumerator Running

enumerator Message

enumerator Idle

Public Functions

inline U8Display()

inline virtual void onStart()

Implement in a subclass to run when the task is started The default implementation does nothing.

inline virtual void onStop()

Implement in a subclass to run when the task is stopped. The default implementation does nothing.

inline virtual void handleEvent(const InputEvent &evt)

Called by the MainLoop to process events

inline void drawSplash()

inline void drawMessage()

inline void drawTime()

inline void drawState(ScreenState state)

inline virtual void loop()

Called on every MainLoop tick

Private Functions

inline void redraw()

Private Members

ScreenState m_state = BootSplash

ScreenState m_nextState = BootSplash

uint8_t m_transitionFrame = 0

uint8_t m_screenStartTime = 0

InputEvent m_lastEvent

String m_message

TaskHandle_t m_renderTask

Private Static Functions

static inline void redrawTask(void *data)

class UpdateStatus : public Figment

#include <UpdateStatus.h>

Public Functions

inline UpdateStatus()

virtual void handleEvent(const InputEvent &evt) override

Called by the MainLoop to process events

virtual void loop() override

Called on every MainLoop tick

virtual void render(Display *dpy) const override

Called when the Figment should render its output to a display

Private Members

bool m_updateReady = false

uint8_t m_pos = 0

struct Variant

#include <Input.h>

Subclassed by InputEvent

Public Types

enum Type

Values:

enumerator Null

enumerator Integer

enumerator String

enumerator Color

enumerator Pointer

Public Functions

inline Variant(int v)

inline Variant(const char *v)

inline Variant(const CRGB &v)

inline Variant(void *p)

inline Variant()

const char *asString() const

CRGB asRGB() const

int asInt() const

bool asBool() const

template<typename T>
inline const T *as() const

Public Members

Type type

int asInt

const char *asString

uint8_t asRGB[3]

void *asPointer

Private Members

union Variant::[anonymous] m_value

template<typename T>
struct Vector3d

#include <Geometry.h>

Public Functions

inline Vector3d(T _x, T _y, T _z)

inline Vector3d()

inline T magnitude() const

inline Vector3d<T> operator-(const Vector3d<T> &other) const

inline Vector3d<T> absolute() const

Public Members

T x

T y

T z

struct VirtualCoordinates : public Coordinates<uint8_t>

#include <Geometry.h>

Public Functions

inline VirtualCoordinates(uint8_t _x, uint8_t _y)

class WiFiTask : public InputSource

#include <WiFiTask.h>

Public Functions

WiFiTask()

virtual void onStart() override

Implement in a subclass to run when the task is started The default implementation does nothing.

virtual InputEvent read() override

Private Members

uint8_t m_lastStatus

file Animation.cpp

#include “./Animation.h”

#include “./Input.h”

#include “./Display.h”

#include <algorithm>

file Animation.h

#include <FastLED.h>

#include “./Figment.h”

file Display.cpp

#include “Display.h”

#include <math.h>

file Display.h

#include <FastLED.h>

#include “Geometry.h”

file Figment.h

#include <Arduino.h>

#include <functional>

#include <ArduinoLog.h>

Defines

F_LIKELY(x)

F_UNLIKELY(x)

file Figments.h

#include “./Display.h”

#include “./Input.h”

#include “./Figment.h”

#include “./Animation.h”

#include “./MainLoop.h”

#include “./Renderer.h”

#include “./Surface.h”

file Geometry.h

#include <stdint.h>

Typedefs

typedef Vector3d<uint8_t> Vec3

file Input.cpp

#include <Arduino.h>

#include “./Input.h”

#include “./MainLoop.h”

file Input.h

#include <Arduino.h>

#include “./Geometry.h”

#include “./Figment.h”

#include “./Ringbuf.h”

#include <FastLED.h>

Typedefs

typedef Vector3d<int> MotionVec

file MainLoop.cpp

#include “./MainLoop.h”

#include “./Input.h”

#include “./Figment.h”

#include <ArduinoLog.h>

Defines

__NOINIT_ATTR

Variables

__NOINIT_ATTR const char * s_lastTaskName

file MainLoop.h

#include <vector>

#include <algorithm>

#include “./Input.h”

#include “./Ringbuf.h”

file Perfcounter.h

#include <ArduinoLog.h>

file Renderer.cpp

#include “./Renderer.h”

#include “./Display.h”

#include <ArduinoLog.h>

file Renderer.h

#include “./Figment.h”

#include <vector>

file Ringbuf.h

#include <array>

file Service.h

file Surface.cpp

#include “./Surface.h”

#include “./Display.h”

#include <ArduinoLog.h>

#include “Perfcounter.h”

file Surface.h

#include <FastLED.h>

#include “./Geometry.h”

#include <functional>

file Chimes.cpp

#include “Chimes.h”

#include “../Static.h”

Functions

STATIC_ALLOC(ChimesAnimation)

STATIC_TASK(ChimesAnimation)

file Chimes.h

#include “../Figments/Figments.h”

#include “../sprites/Chime.h”

#include “../sprites/Blob.h”

Defines

CHIME_LENGTH

CHIME_COUNT

BLOB_COUNT

file Drain.cpp

#include “Drain.h”

#include “../Static.h”

Functions

STATIC_ALLOC(DrainAnimation)

STATIC_TASK(DrainAnimation)

file Drain.h

#include <Figments.h>

#include <ArduinoLog.h>

file Flashlight.cpp

#include “Flashlight.h”

#include “../Static.h”

Functions

STATIC_ALLOC(Flashlight)

STATIC_TASK(Flashlight)

file Flashlight.h

#include <Figments.h>

#include “../sprites/Blob.h”

file InputBlip.cpp

#include “InputBlip.h”

Functions

STATIC_ALLOC(InputBlip)

STATIC_TASK(InputBlip)

file InputBlip.h

#include “../Figments/Figments.h”

#include “../Static.h”

file Power.cpp

#include “./Power.h”

#include “../Static.h”

#include <ArduinoJson.h>

Functions

STATIC_ALLOC(Power)

STATIC_TASK(Power)

file Power.h

#include <Figments.h>

#include “../Config.h”

file SolidAnimation.cpp

#include “SolidAnimation.h”

#include “../Static.h”

#include <Perfcounter.h>

Functions

STATIC_ALLOC(SolidAnimation)

STATIC_TASK(SolidAnimation)

file SolidAnimation.h

#include <Figments.h>

#include “../sprites/Blob.h”

file TestAnimation.cpp

#include “./TestAnimation.h”

#include <FastLED.h>

file TestAnimation.h

#include <Figments.h>

file UpdateStatus.cpp

#include “./UpdateStatus.h”

#include <FastLED.h>

#include “../Static.h”

Functions

STATIC_ALLOC(UpdateStatus)

STATIC_TASK(UpdateStatus)

file UpdateStatus.h

#include <Figments.h>

file BootOptions.cpp

#include “BootOptions.h”

#include “Config.h”

#include <EEPROM.h>

file BootOptions.h

#include <Arduino.h>

file colors.cpp

#include “colors.h”

Functions

ColorInfo colorForName(const char *name)

const ColorInfo *allColors()

Variables

const ColorInfo color_data[]

file colors.h

#include <FastLED.h>

Typedefs

typedef struct ColorInfo ColorInfo

Functions

ColorInfo colorForName(const char *name)

const ColorInfo *allColors()

file Config.cpp

#include “./Config.h”

#include “./Static.h”

#include “./Sequencer.h”

#include <ArduinoLog.h>

#include <ArduinoJson.h>

#include <EEPROM.h>

#include <LittleFS.h>

#include <vector>

Functions

STATIC_ALLOC(ConfigService)

STATIC_TASK(ConfigService)

Variables

StaticJsonDocument<1024> jsonConfig

file Config.h

#include <Figments.h>

#include “JsonCoordinateMapping.h”

#include <ArduinoJson.h>

file BPM.cpp

#include “./BPM.h”

#include “../Static.h”

Functions

STATIC_ALLOC(BPM)

STATIC_TASK(BPM)

file BPM.h

#include <Figments.h>

#include <ArduinoJson.h>

#include “../Config.h”

file Buttons.cpp

#include “./Buttons.h”

#include “../Static.h”

Functions

STATIC_ALLOC(Buttons)

STATIC_TASK(Buttons)

file Buttons.h

#include <Input.h>

file CircadianRhythm.cpp

#include “./CircadianRhythm.h”

#include “../Static.h”

Functions

STATIC_ALLOC(CircadianRhythm)

STATIC_TASK(CircadianRhythm)

file CircadianRhythm.h

#include <Figments.h>

Variables

std::array<ScheduleEntry, 10> schedule{{{0, 0}, {5, 0}, {6, 0}, {7, 10}, {8, 80}, {11, 120}, {18, 200}, {19, 255}, {22, 120}, {23, 20}}}

file ColorCycle.cpp

file ColorCycle.h

#include <Figments.h>

#include <ArduinoLog.h>

file ConfigInput.cpp

#include “./ConfigInput.h”

#include “./Static.h”

Functions

STATIC_ALLOC(ConfigInput)

STATIC_TASK(ConfigInput)

file ConfigInput.h

#include <Figments.h>

file DMX.cpp

file MPU6050.cpp

#include “MPU6050.h”

#include <Wire.h>

#include “../Config.h”

#include “../Static.h”

Functions

STATIC_ALLOC(MPU5060)

STATIC_TASK(MPU5060)

file MPU6050.h

#include <Figments.h>

file Serial.cpp

#include “Serial.h”

Functions

STATIC_ALLOC(SerialInput)

STATIC_TASK(SerialInput)

file Serial.h

#include “../Figments/Figments.h”

file JsonCoordinateMapping.cpp

#include “./JsonCoordinateMapping.h”

file JsonCoordinateMapping.h

#include <Figments.h>

#include <ArduinoJson.h>

file LogService.cpp

#include “LogService.h”

#include “Static.h”

#include <ArduinoLog.h>

Functions

static const char *eventValue(const InputEvent &evt)

STATIC_ALLOC(LogService)

STATIC_TASK(LogService)

file LogService.h

#include <Figments.h>

file main.cpp

#include “Arduino.h”

#include <FastLED.h>

#include <Figments.h>

#include <ArduinoLog.h>

#include “Platform.h”

#include “Static.h”

#include “Config.h”

#include “LogService.h”

#include <time.h>

#include “inputs/ColorCycle.h”

#include “inputs/Buttons.h”

#include “SafeMode.h”

Functions

Display dpy(leds, HardwareConfig::MAX_LED_NUM, Static<ConfigService>::instance() -> coordMap())

REGISTER_TASK(keyMap)

REGISTER_TASK(idleCycle)

REGISTER_TASK(rainbowCycle)

void setup()

void loop()

Variables

CRGB leds[HardwareConfig::MAX_LED_NUM]

InputMapper keyMap ([](const InputEvent &evt) { if(evt.intent==InputEvent::UserInput) { Buttons::Chord chord=(Buttons::Chord) evt.asInt();switch(chord) { case Buttons::Circle:return InputEvent::PowerToggle;break;case Buttons::Triangle:return InputEvent::NextPattern;break;case Buttons::Cross:return InputEvent::UserInput;break;default:break;} } return InputEvent::None;}, "Keymap")

ColorSequenceInput<9> idleCycle{{CRGB(0, 123, 167), CRGB(80, 200, 120), CRGB(207, 113, 175), CRGB(128, 0, 128), CRGB(255, 255, 255), CRGB(0, 255, 255),}, "IdleColors"}

ColorSequenceInput<7> rainbowCycle{{CRGB(255, 0, 0), CRGB(255, 127, 0), CRGB(0, 255, 0), CRGB(0, 0, 255), CRGB(128, 0, 128),}, "Rainbow"}

MainLoop *runner = &SafeMode::safeModeApp

file Platform.cpp

#include “Platform.h”

#include <ArduinoLog.h>

#include “Static.h”

#include <time.h>

Functions

void printNewline(Print *logOutput, int logLevel)

int printEspLog(const char *fmt, va_list args)

STATIC_ALLOC(Platform)

STATIC_TASK(Platform)

file Platform.h

#include <FastLED.h>

#include <Figments.h>

#include “BootOptions.h”

file BluetoothSerialTelemetry.cpp

#include “BluetoothSerialTelemetry.h”

#include “../../Static.h”

#include “../../Platform.h”

#include <ArduinoLog.h>

#include “../../inputs/Buttons.h”

#include <cstdlib>

Functions

STATIC_ALLOC(BluetoothSerialTelemetry)

STATIC_TASK(BluetoothSerialTelemetry)

file BluetoothSerialTelemetry.h

#include <Figments.h>

#include <BluetoothSerial.h>

#include <Ringbuf.h>

file MQTTTelemetry.cpp

#include “MQTTTelemetry.h”

#include <ArduinoJson.h>

#include “../../Static.h”

#include “../../Config.h”

#include “../../Platform.h”

Functions

STATIC_ALLOC(MQTTTelemetry)

STATIC_TASK(MQTTTelemetry)

Variables

StaticJsonDocument<1024> m_json

const String availTopic = String("renderbug/") + Platform::deviceID() + "/availability"

const MQTTDevice Device = {Platform::deviceID(), Platform::deviceName(), Platform::model(), "", "Phong Robotics", availTopic}

const MQTTEntity Lightswitch{"light", Device, "lightswitch"}

const MQTTEntity flashlightSwitch{"switch", Device, "flashlight"}

const MQTTEntity FPSSensor{"sensor", Device, "fps"}

file MQTTTelemetry.h

#include <Figments.h>

#include <Ringbuf.h>

#include <PubSubClient.h>

#include <ArduinoLog.h>

#include “../../Config.h”

#include “../../Sequencer.h”

file OTA.cpp

#include “OTA.h”

#include “../../Static.h”

Functions

STATIC_ALLOC(ArduinoOTAUpdater)

STATIC_TASK(ArduinoOTAUpdater)

file OTA.h

#include <ArduinoOTA.h>

#include <Figments.h>

file U8Display.cpp

#include <Figments.h>

#include <U8g2lib.h>

#include “../../Static.h”

#include <ArduinoLog.h>

#include “../../LogService.h”

Functions

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2 (U8G2_R0, 16, 15, 4)

STATIC_ALLOC(U8Display)

STATIC_TASK(U8Display)

file WiFiTask.cpp

#include <Input.h>

#include <ArduinoLog.h>

#include “Static.h”

#include “WiFiTask.h”

Functions

STATIC_ALLOC(WiFiTask)

STATIC_TASK(WiFiTask)

file WiFiTask.h

#include <Input.h>

#include “Static.h”

file SafeMode.cpp

#include “./SafeMode.h”

#include “./LogService.h”

#include “./Platform.h”

#include “./Static.h”

#include “./Config.h”

Variables

TaskFunc safeModeNag ([]{ static uint8_t frame=0;static CRGB *leds=FastLED.leds();EVERY_N_SECONDS(30) { Log.fatal("I am running in safe mode!");} EVERY_N_MILLISECONDS(16) { frame++;for(int i=0;i< HardwareConfig::MAX_LED_NUM;i++) { leds[i]=CRGB(0, 0, 0);} for(int idx=0;idx< 3;idx++) { uint8_t length=beatsin8(5, 3, HardwareConfig::MAX_LED_NUM, 0, idx *5);for(int i=0;i< length;i++) { leds[i]+=CRGB(scale8(5, beatsin8(5+i *7, 0, 255, 0, i *3)), 0, 0);} } FastLED.show();} })

file SafeMode.h

#include <Figments.h>

file Sequencer.cpp

#include “Sequencer.h”

#include <MainLoop.h>

#include “Static.h”

Functions

STATIC_ALLOC(Sequencer)

STATIC_TASK(Sequencer)

file Sequencer.h

#include <Figment.h>

#include <vector>

file Blob.h

#include <Figments.h>

#include <ArduinoLog.h>

#include <Perfcounter.h>

file Chime.h

file Static.h

#include “Platform.h”

Defines

NAMED_STATIC_ALLOC(Cls, StaticName)

STATIC_ALLOC(Cls)

NAMED_STATIC_TASK(Cls, StaticName)

STATIC_TASK(Cls)

REGISTER_TASK(TaskName)

dir src/animations

dir src/platform/arduino

dir lib/Figments

dir src/inputs

dir lib

dir src/platform

dir src/sprites

dir src

Indices and tables

• Index

• Module Index

• Search Page