jbwopreffects.h

Go to the documentation of this file.

 
#ifndef ARDUINO_WOPR_JBWOPREFFECTS_H
#define ARDUINO_WOPR_JBWOPREFFECTS_H
 
#include <Arduino.h>
#include <JBLogger.h>
#include "jbwoprhelpers.h"
#include <string>
#include <vector>
 
class JBWoprDevice;
 
// Note that effect names needs to fit in 12 characters.
#define JBWOPR_EFFECT_NAME_BASE             "Base"              
#define JBWOPR_EFFECT_NAME_TEXT             "Text"              
#define JBWOPR_EFFECT_NAME_SCROLLTEXT       "Scroll text"       
#define JBWOPR_EFFECT_NAME_TIME             "Time"              
#define JBWOPR_EFFECT_NAME_TIME_RAINBOW     "Time R"            
#define JBWOPR_EFFECT_NAME_DATE             "Date"              
#define JBWOPR_EFFECT_NAME_DATE_RAINBOW     "Date Time R"       
#define JBWOPR_EFFECT_NAME_DATETIME         "Date Time"         
#define JBWOPR_EFFECT_NAME_DATETIME_RAINBOW "Date Time R"       
#define JBWOPR_EFFECT_NAME_XMAS_SECONDS     "Xmas seconds"      
#define JBWOPR_EFFECT_NAME_CODE_SOLVE       "Code Solve"        
#define JBWOPR_EFFECT_NAME_DEFCON_RAINBOW   "Rainbow"           
#define JBWOPR_EFFECT_NAME_SONG             "Song"              
 
enum CodeSolveVariant {
    MOVIE,              
    RANDOM,             
    MESSAGE             
};
 
class JBWoprEffectBase {
public:
    explicit JBWoprEffectBase(JBWoprDevice *woprDevice,
                              uint32_t duration = -1,
                              std::string name = JBWOPR_EFFECT_NAME_BASE);
 
    virtual std::string getName();
 
    virtual void start();
 
    virtual void stop();
 
    virtual void loop();
 
    bool isRunning() const;
 
    uint32_t getDuration() const;
 
protected:
    JBWoprDevice *_woprDevice;          
    std::string _name;                  
    bool _isRunning = false;            
    bool _done = true;                  
    uint32_t _duration = -1;            
    uint32_t _startTime = 0;            
    uint32_t _nextTick = 0;             
 
    void _displayText(const std::string& text, JBTextAlignment alignment = JBTextAlignment::LEFT);
 
private:
    JBLogger _log {"effect" };  
};
 
class JBWoprTextDisplayEffect : public JBWoprEffectBase {
public:
    explicit JBWoprTextDisplayEffect(JBWoprDevice *woprDevice,
                                     const std::string& text,
                                     JBTextAlignment alignment = JBTextAlignment::LEFT,
                                     uint32_t duration = -1,
                                     const std::string& name=JBWOPR_EFFECT_NAME_TEXT);
 
    void start() override;
 
    void loop() override;
 
    virtual void setText(const std::string& text);
 
    virtual void setAlignment(JBTextAlignment alignment);
 
protected:
    std::string _text;                  
    JBTextAlignment _alignment;        
};
 
class JBWoprScrollTextDisplayEffect : public JBWoprEffectBase {
public:
    explicit JBWoprScrollTextDisplayEffect(JBWoprDevice *woprDevice,
                                           const std::string& text,
                                           uint32_t scrollSpeed = 200,
                                           uint32_t duration = -1,
                                           const std::string& name=JBWOPR_EFFECT_NAME_SCROLLTEXT);
 
    void start() override;
 
    void loop() override;
 
    virtual void setText(const std::string& text);
 
    void setScrollSpeed(uint32_t scrollSpeed);
 
protected:
    std::string _text;                  
    uint32_t _scrollSpeed = 200;        
    size_t _currentIndex = 0;           
    size_t _totalLength = 0;            
    size_t _endIndex = 0;               
 
private:
    JBLogger _log {"scroll" };  
};
 
class JBWoprTimeDisplayEffect : public JBWoprEffectBase {
public:
    explicit JBWoprTimeDisplayEffect(JBWoprDevice *woprDevice,
                                     std::string  timeFormat = "",
                                     uint32_t duration = -1,
                                     const std::string& name=JBWOPR_EFFECT_NAME_TIME);
 
    void start() override;
 
    void loop() override;
 
    virtual void setTimeFormat(const std::string& timeFormat);
 
protected:
    virtual std::string _getOddTimeFormat(const std::string& format);
 
    bool _evenFormat = false;           
    std::string _rawTimeFormat;         
    std::string _timeFormatEven;        
    std::string _timeFormatOdd;         
 
private:
    JBLogger _log {"time" };            
};
 
class JBWoprTimeDisplayRainbowEffect : public JBWoprTimeDisplayEffect {
public:
    explicit JBWoprTimeDisplayRainbowEffect(JBWoprDevice *woprDevice,
                                     std::string  timeFormat = "",
                                     uint32_t duration = -1,
                                     const std::string& name=JBWOPR_EFFECT_NAME_TIME_RAINBOW);
 
    void loop() override;
 
protected:
    uint64_t _nextLedTick = 0;          
    uint16_t _pixelHue = 0;             
 
private:
    JBLogger _log {"time" };            
};
 
class JBWoprDateDisplayEffect : public JBWoprEffectBase {
public:
    explicit JBWoprDateDisplayEffect(JBWoprDevice *woprDevice,
                                     std::string  dateFormat = "",
                                     uint32_t duration = -1,
                                     const std::string& name=JBWOPR_EFFECT_NAME_DATE);
 
    void start() override;
 
    void loop() override;
 
    void setDateFormat(const std::string& dateFormat);
 
protected:
    std::string _rawTimeFormat;         
    std::string _timeFormatEven;        
    std::string _timeFormatOdd;         
    std::string _rawDateFormat;         
    std::string _dateFormat;            
 
private:
    JBLogger _log {"date" };    
};
 
class JBWoprDateDisplayRainbowEffect : public JBWoprDateDisplayEffect {
public:
    explicit JBWoprDateDisplayRainbowEffect(JBWoprDevice *woprDevice,
                                     std::string  dateFormat = "",
                                     uint32_t duration = -1,
                                     const std::string& name=JBWOPR_EFFECT_NAME_DATE_RAINBOW);
 
    void loop() override;
 
protected:
    uint64_t _nextLedTick = 0;          
    uint16_t _pixelHue = 0;             
 
private:
    JBLogger _log {"date" };    
};
 
class JBWoprDateTimeDisplayEffect : public JBWoprEffectBase {
public:
    explicit JBWoprDateTimeDisplayEffect(JBWoprDevice *woprDevice,
                                         std::string  timeFormat = "",
                                         std::string  dateFormat = "",
                                         uint32_t duration = -1,
                                         const std::string& name=JBWOPR_EFFECT_NAME_DATETIME);
 
    void start() override;
 
    void loop() override;
 
    virtual void setTimeFormat(const std::string& timeFormat);
 
    void setDateFormat(const std::string& dateFormat);
 
protected:
    uint32_t _displayCounter = 0;       
    std::string _rawDateFormat;         
    std::string _rawTimeFormat;         
    std::string _dateFormat;            
    bool _evenFormat = false;           
    std::string _timeFormatEven;        
    std::string _timeFormatOdd;         
//  uint64_t _nextLedTick = 0;          ///< Next LED tick
//  uint16_t _pixelHue = 0;             ///< Pixel hue
private:
    JBLogger _log {"datetime" };        
 
    virtual std::string _getOddTimeFormat(const std::string& format);
};
 
class JBWoprDateTimeDisplayRainbowEffect : public JBWoprDateTimeDisplayEffect {
public:
    explicit JBWoprDateTimeDisplayRainbowEffect(JBWoprDevice *woprDevice,
                                                std::string  timeFormat = "",
                                                std::string  dateFormat = "",
                                                uint32_t duration = -1,
                                                const std::string& name=JBWOPR_EFFECT_NAME_DATETIME_RAINBOW);
 
    void loop() override;
 
protected:
    uint64_t _nextLedTick = 0;                      
    uint16_t _pixelHue = 0;                         
 
private:
    JBLogger _log {"datetime" };        
};
 
class JBWoprXmasSecondsDisplayEffect: public JBWoprScrollTextDisplayEffect {
public:
    explicit JBWoprXmasSecondsDisplayEffect(JBWoprDevice *woprBoard,
                                            uint32_t scrollSpeed = 200,
                                            uint32_t duration = -1,
                                            const std::string& name=JBWOPR_EFFECT_NAME_XMAS_SECONDS);
 
    void start() override;
 
private:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
    void setText(std::string& text);
#pragma GCC diagnostic pop
 
    JBLogger _log {"xmas" };    
};
 
class JBWoprMissileCodeSolveEffect : public JBWoprEffectBase {
public:
    explicit JBWoprMissileCodeSolveEffect(JBWoprDevice *woprBoard,
                                          CodeSolveVariant solveVariant = CodeSolveVariant::MOVIE,
                                          uint32_t duration = -1,
                                          const std::string& name=JBWOPR_EFFECT_NAME_CODE_SOLVE);
 
    void start() override;
 
    void loop() override;
 
    void setCodeSolveVariant(CodeSolveVariant solveVariant);
 
private:
    void _displayCurrentGuess();
 
    void _displaySolvedCharacters();
 
    void _displayBlinkingSolution();
 
    void _displayBlinkingLaunching();
 
    std::string _getSolution();
 
    std::string _getStartingGuess();
 
    std::vector<uint32_t> _getSolveOrder();
 
    std::string _getRandomCode();
 
    static char _getRandomChar();
 
    uint32_t _getNextSolveTicks() const;
 
    CodeSolveVariant _solveVariant = CodeSolveVariant::MOVIE; 
    uint32_t _currentSolveStep = 0;                          
    uint32_t _nextSolveTick = 0;                             
    int32_t _defconValue = -1;                               
    std::string _currentSolution;                            
    std::string _currentGuess;                               
    std::vector<uint32_t> _codeSolveOrder;                   
    const uint32_t _minSolveTicks = 1300;                    
    const uint32_t _maxSolveTicks = 2500;                    
};
 
class JBWoprDefconRainbowEffect : public JBWoprEffectBase {
public:
    explicit JBWoprDefconRainbowEffect(JBWoprDevice *woprBoard,
                                       uint32_t duration = -1,
                                       const std::string& name=JBWOPR_EFFECT_NAME_DEFCON_RAINBOW);
 
    void loop() override;
 
private:
    uint16_t _pixelHue = 0;     
};
 
class JBWoprSongEffect: public JBWoprEffectBase {
public:
    struct Note {
        uint16_t note;          
        uint16_t octave;        
        int16_t duration;       
        std::string text;       
    };
 
    explicit JBWoprSongEffect(JBWoprDevice *woprBoard,
                              const std::vector<Note>* song,
                              uint32_t tempo = 114,
                              uint32_t duration = -1,
                              const std::string& name=JBWOPR_EFFECT_NAME_SONG);
 
    void start() override;
 
    void loop() override;
 
    virtual void setSong(const std::vector<Note>* song);
 
    virtual void setTempo(uint32_t tempo);
 
protected:
    const std::vector<Note>*_song = nullptr;        
    uint32_t _step = 0;                             
    uint32_t _tempo = 114;                          
    uint32_t _wholeNote = (60000 * 4) / _tempo;     
    bool _done = false;                             
 
private:
    JBLogger _log {"song" };    
};
 
 
 
 
#endif//ARDUINO_WOPR_JBWOPREFFECTS_H