OutputHardware.hpp

Go to the documentation of this file.

 
#pragma once
 
//---------------------------------------------------------------
// Imports
//---------------------------------------------------------------
 
#include "SimWheelTypes.hpp"
#include "driver/rmt_tx.h" // For rmt_channel_handle_t & rmt_encoder_handle_t
#include <vector>
#include <initializer_list>
 
//---------------------------------------------------------------
// Pixel vector
//---------------------------------------------------------------
 
struct PixelVectorHelper
{
public:
    using size_type = typename ::std::vector<Pixel>::size_type;
 
    using vector_type = typename ::std::vector<Pixel>;
 
    static void shift(
        vector_type &data,
        size_type from_index,
        size_type to_index,
        size_type shift = 1);
 
    static void shift_left(vector_type &data, size_type count) noexcept;
 
    static void shift_right(vector_type &data, size_type count) noexcept;
 
    static void fill(vector_type &data, const Pixel &color) noexcept;
 
    static void fill(
        vector_type &data,
        size_type fromIndex,
        size_type toIndex,
        const Pixel &color) noexcept;
 
}; // PixelVectorHelper
 
//---------------------------------------------------------------
// Led strip encoder
//---------------------------------------------------------------
 
class LEDStrip
{
public:
    using pixel_vector_type = typename ::std::vector<Pixel>;
 
    LEDStrip(
        OutputGPIO dataPin,
        uint8_t pixelCount,
        bool useLevelShift,
        PixelDriver driver = PixelDriver::WS2812,
        bool reverse_display = false);
 
    virtual ~LEDStrip();
 
    LEDStrip(LEDStrip &&other);
 
    LEDStrip &operator=(LEDStrip &&other);
 
    LEDStrip(const LEDStrip &other) = delete;
 
    LEDStrip &operator=(const LEDStrip &other) = delete;
 
    uint8_t getPixelCount() { return pixelCount; }
 
    void brightness(uint8_t value) { brightnessWeight = value + 1; }
 
    pixel_vector_type pixelVector(const Pixel &color = 0)
    {
        pixel_vector_type result(pixelCount, color);
        return result;
    }
 
    void clear()
    {
        show(pixelVector(0));
    }
 
    void show(const pixel_vector_type &pixels);
 
private:
    static constexpr uint32_t clockResolutionHz = 10000000;
    static constexpr size_t symbols_per_byte = 8;
    static constexpr size_t symbols_per_pixel =
        sizeof(Pixel) * symbols_per_byte;
 
    rmt_channel_handle_t rmtHandle = nullptr;
    rmt_encoder_handle_t pixel_encoder_handle = nullptr;
    rmt_bytes_encoder_config_t byte_enc_config{};
    uint8_t pixelCount;
    PixelFormat pixelFormat;
    uint16_t brightnessWeight = 128;
    uint32_t restTimeNs = 280000;
    bool reversed = false;
 
    static size_t pixels_rmt_encoder(
        const void *data,
        size_t data_size,
        size_t symbols_written,
        size_t symbols_free,
        rmt_symbol_word_t *symbols,
        bool *done,
        void *arg);
};
 
//---------------------------------------------------------------
// PCF8574 LED Driver
//---------------------------------------------------------------
 
class PCF8574LedDriver
{
public:
    PCF8574LedDriver(
        I2CBus bus,
        uint8_t address7bits);
 
    void setLed(uint8_t index, bool state);
 
    void shiftLeft();
 
    void shiftRight();
 
    void swap() { _state = ~_state; }
 
    void show() const;
 
    uint8_t getState() const { return _state; };
 
    void setState(uint8_t state) { _state = state; }
 
    ~PCF8574LedDriver()
    {
        setState(0);
        show();
    }
 
private:
    uint8_t _state = 0;
 
    void *device = nullptr;
};
 
//---------------------------------------------------------------
// Single LED
//---------------------------------------------------------------
 
class SingleLED
{
public:
    SingleLED(OutputGPIO pin);
 
    void set(bool state) { _state = state; }
 
    bool get() { return _state; }
 
    void swap() { _state = !_state; }
 
    void show();
 
    ~SingleLED() { _pin.grant(); }
 
private:
    OutputGPIO _pin;
    bool _state = false;
};
 
//------------------------------------------------------------------------------
// Monochrome OLED
//------------------------------------------------------------------------------
 
struct OLEDParameters
{
    bool flip_horizontal = false;
    bool flip_vertical = false;
    bool inverted_display = false;
    uint8_t screen_width = 128;
    uint8_t screen_height = 64;
    uint8_t start_row = 0;
    uint8_t start_col = 0;
    uint8_t display_offset = 0;
    uint8_t contrast = 127;
    uint8_t COMpins = 0x12;
    uint8_t oscillator_frequency = 0x80;
 
public:
    static OLEDParameters for132x64()
    {
        OLEDParameters result;
        result.start_col = 2;
        return result;
    }
 
    static OLEDParameters withResolution(
        uint8_t width,
        uint8_t height,
        const OLEDParameters &params)
    {
        OLEDParameters result{params};
        result.screen_width = width;
        result.screen_height = height;
        return result;
    }
};
 
struct OLEDBase
{
    enum class Controller : uint8_t
    {
        SSD1306,
        SH1107,
        SH1106,
        UNKNOWN
    };
 
    Controller guess_controller() const noexcept;
 
    bool available() const noexcept { return (device); }
 
protected:
    constexpr OLEDBase() noexcept : device{nullptr} {}
 
    OLEDBase(
        ::std::initializer_list<uint8_t> &&try_addresses,
        I2CBus bus) noexcept;
 
    virtual ~OLEDBase() noexcept;
 
    OLEDBase(const OLEDBase &other) noexcept = delete;
 
    OLEDBase(OLEDBase &&other) noexcept;
 
    OLEDBase &operator=(const OLEDBase &other) noexcept = delete;
 
    OLEDBase &operator=(OLEDBase &&other) noexcept;
 
    bool write(const uint8_t *buffer, ::std::size_t size) const noexcept;
 
    bool write_cmd(uint8_t command) const noexcept;
 
    bool write_cmd(uint8_t command, uint8_t arg) const noexcept;
 
    bool write_cmd(uint8_t command, uint8_t arg1, uint8_t arg2) const noexcept;
 
    bool write_gdd_ram(
        const uint8_t *buffer,
        ::std::size_t size) const noexcept;
 
    bool read_status(uint8_t &status) const noexcept;
 
private:
    void *device = nullptr;
};
 
struct OLED : public OLEDBase
{
 
    constexpr OLED() : OLEDBase(), _params{}, width_b{0}, height_b{0}
    {
        _params.screen_width = 0;
        _params.screen_height = 0;
    }
 
    OLED(
        const OLEDParameters &params,
        I2CBus bus);
 
    OLED(
        const OLEDParameters &params,
        uint8_t address7bits,
        I2CBus bus);
 
    OLED(const OLED &other) noexcept = delete;
 
    OLED(OLED &&other) noexcept = default;
 
    OLED &operator=(const OLED &other) noexcept = delete;
 
    OLED &operator=(OLED &&other) noexcept = default;
 
    OLEDParameters parameters() const noexcept { return _params; }
 
    ::std::size_t frame_size() const noexcept
    {
        return width_b * height_b * 8;
    }
 
    void contrast(uint8_t value);
 
    void enable_display(bool yesOrNo);
 
    void turn(bool onOrOff);
 
    void inverse_display(bool yesOrNo);
 
    void clear(bool inverted = false);
 
    void show(const uint8_t *frame);
 
protected:
    OLEDParameters _params;
    uint8_t width_b;
    uint8_t height_b;
 
    void init();
 
    void locate(uint8_t x, uint8_t page);
 
    inline uint8_t row2col(
        uint8_t bit_index,
        const uint8_t *from,
        uint8_t row_count);
};