SevenSegmentDisplay.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/STL/algorithm> // std::fill
#include <MIDI_Inputs/MIDIInputElement.hpp>
#include <MIDI_Inputs/MIDIInputElementMatchers.hpp>
#include <Print.h>
 
BEGIN_CS_NAMESPACE
 
namespace MCU {
 
template <uint8_t LENGTH>
class SevenSegmentDisplay
    : public MatchingMIDIInputElement<MIDIMessageType::ControlChange,
                                      TwoByteRangeMIDIMatcher>,
      public Printable {
  public:
    using Matcher = TwoByteRangeMIDIMatcher;
    using Parent =
        MatchingMIDIInputElement<MIDIMessageType::ControlChange, Matcher>;
 
    SevenSegmentDisplay(MIDIAddress address) : Parent({address, LENGTH}) {
        fillWithSpaces();
    }
 
    void reset() override {
        if (!ignoreReset) {
            fillWithSpaces();
            dirty = true;
        }
    }
 
  protected:
    void handleUpdate(typename Matcher::Result match) override {
        uint8_t index = LENGTH - 1 - match.index;
        // MIDI msg: character data → bits 0-5
        // MIDI msg: decimal point → bit 6 set, no decimal point → bit 6 not set
        // text:   decimal point → bit 7 set, no decimal point → bit 7 not set
        uint8_t decimalPt = (match.value & 0x40) << 1;
        uint8_t chardata = match.value & 0x3F;
        uint8_t character = chardata >= 0x20 ? chardata : chardata + 0x40;
        character |= decimalPt;
        dirty |= text[index] != character;
        text[index] = character;
    }
 
    void fillWithSpaces() { std::fill(std::begin(text), std::end(text), ' '); }
 
  public:
 
    void getText(char *buffer, uint8_t offset = 0,
                 uint8_t length = LENGTH) const {
        if (offset >= LENGTH)
            offset = LENGTH - 1;
        if (length > LENGTH - offset)
            length = LENGTH - offset;
        for (uint8_t i = 0; i < length; i++)
            buffer[i] = getCharacterAt(i + offset);
        buffer[length] = '\0';
    }
 
    char getCharacterAt(uint8_t index) const { return text[index] & 0x7F; }
 
    void getDecimalPoints(bool *buffer) const {
        for (uint8_t i = 0; i < LENGTH; i++)
            buffer[i] = getDecimalPointAt(i);
    }
 
    bool getDecimalPointAt(uint8_t index) const { return text[index] & 0x80; }
 
 
 
    size_t printTo(Print &printer) const override {
        size_t s = 0;
        for (uint8_t i = 0; i < LENGTH; i++) {
            s += printer.print(getCharacterAt(i));
            if (getDecimalPointAt(i))
                s += printer.print('.');
        }
        return s;
    }
 
 
 
    bool getDirty() const { return dirty; }
    void clearDirty() { dirty = false; }
 
 
  private:
    AH::Array<char, LENGTH> text; 
    bool dirty = true;
 
  public:
    bool ignoreReset = true;
};
 
} // namespace MCU
 
END_CS_NAMESPACE