LCD.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Debug/Debug.hpp>
#include <AH/Math/MinMaxFix.hpp>
#include <MIDI_Inputs/MIDIInputElement.hpp>
#include <string.h> // memcpy
 
#ifndef ARDUINO
#include <cassert>
#endif
 
BEGIN_CS_NAMESPACE
 
using AH::max;
using AH::min;
 
namespace MCU {

class LCDCounter {
  public:
    LCDCounter() { instances++; }
    ~LCDCounter() { instances--; }
 
    static uint8_t getInstances() { return instances; }
 
  private:
    static uint8_t instances;
};

template <uint8_t BufferSize = 112>
class LCD : public MIDIInputElementSysEx, private LCDCounter {
  public:
    LCD(uint8_t offset = 0, Cable cable = Cable_1)
        : offset(offset), cable(cable) {
        // Null-terminate the buffer
        buffer[BufferSize] = '\0';
        // Fill the buffer with spaces
        for (uint8_t i = 0; i < BufferSize; i++) buffer[i] = ' ';
    }
 
  protected:
    bool updateWith(SysExMessage midimsg) override {
        // If this message is meant for a different cable than ours, return:
        if (midimsg.getCable() != this->cable)
            return false;
 
        // We can't handle chunked SysEx data (yet), and it wouldn't make a ton
        // of sense, since the default SysEx buffer size is the same size as the
        // SysEx message we expect, so it shouldn't arrive in chunks.
        if (!midimsg.isCompleteMessage())
            return false;
 
        // Format:
        // F0 mm mm mm nn 12 oo yy... F7
        // mm = manufacturer ID (00 00 66 for Mackie)
        // nn = model number (10 for Logic Control, 11 for Logic Control XT)
        // oo = offset [0x00, 0x6F]
        // yy... = ASCII data
        if (midimsg.data[5] != 0x12)
            return false;
 
        const uint8_t midiOffset = midimsg.data[6];
        const uint8_t midiLength = midimsg.length - 8;
        const uint8_t *text = midimsg.data + 7;
        const uint8_t midiBufferEnd = midiOffset + midiLength;
 
        const uint8_t bufferEnd = this->offset + BufferSize;
 
        // If there's no overlap between incoming range and the range that we're
        // listening for, return:
        if (midiOffset >= bufferEnd || this->offset >= midiBufferEnd)
            // If there are other instances, maybe it'll match one of those,
            // otherwise, stop handling this message:
            return getInstances() == 1;
 
        // Find the ranges that overlap between the text data in the message
        // (src) and the range of characters we're listening for (dst):
        uint8_t srcStart = max(0, this->offset - midiOffset);
        uint8_t dstStart = max(0, midiOffset - this->offset);
        uint8_t length = midiBufferEnd - midiOffset -
                         max(0, this->offset - midiOffset) -
                         max(0, midiBufferEnd - bufferEnd);
 
        // Copy the interesting part to our buffer:
#ifdef ARDUINO
        memcpy(&buffer[dstStart], &text[srcStart], length);
#else // Tests
        for (uint8_t i = 0; i < length; ++i) {
            buffer[dstStart + i] = text[srcStart + i];
            assert(dstStart + i < BufferSize);
            assert(srcStart + i < midiLength);
        }
#endif
 
        markDirty();
 
        // If this is the only instance, the others don't have to be updated
        // anymore, so we return true to break the loop:
        return getInstances() == 1;
    }
 
  public:
    void begin() override { markDirty(); }


    const char *getText() const { return buffer.data; }



    bool getDirty() const { return dirty > 0; }
    void clearDirty() {
        if (dirty > 0)
            --dirty;
    }

    void markDirty() { dirty = num_subscribers > 0 ? num_subscribers : 1; }
    void addSubscriber() { ++num_subscribers; }
    void removeSubscriber() { --num_subscribers; }

 
  private:
    Array<char, BufferSize + 1> buffer;
    uint8_t offset;
    Cable cable;
    uint8_t dirty = 0;
    uint8_t num_subscribers = 0;
};
 
} // namespace MCU
 
END_CS_NAMESPACE