DebugMIDI_Interface.hpp

Go to the documentation of this file.

#pragma once
 
#include "MIDI_Interface.hpp"
#include <AH/Teensy/TeensyUSBTypes.hpp>
#include <MIDI_Parsers/HexPuller.hpp>
#include <MIDI_Parsers/SerialMIDI_Parser.hpp>
#include <MIDI_Parsers/StreamPuller.hpp>
#include <Settings/SettingsWrapper.hpp>
 
BEGIN_CS_NAMESPACE
 
class StreamDebugMIDI_Base {
  protected:
    void sendChannelMessageImpl(Stream &, ChannelMessage);
    void sendSysCommonImpl(Stream &, SysCommonMessage);
    void sendSysExImpl(Stream &, SysExMessage);
    void sendRealTimeImpl(Stream &, RealTimeMessage);
    void sendNowImpl(Stream &) {}
 
  public:
    StreamDebugMIDI_Base(const char *prefix) : prefix(prefix) {}
 
    void setPrefix(const char *prefix) { this->prefix = prefix; }
    const char *getPrefix() const { return prefix; }
 
  private:
    const char *prefix = nullptr;
};
 
class StreamDebugMIDI_Output : public StreamDebugMIDI_Base,
                               public MIDI_Sender<StreamDebugMIDI_Output>,
                               public TrueMIDI_Sink {
  public:
    StreamDebugMIDI_Output(Stream &stream, const char *prefix = nullptr)
        : StreamDebugMIDI_Base(prefix), stream(stream) {}
 
    Stream &getStream() const { return stream; }
 
  protected:
    void sendChannelMessageImpl(ChannelMessage);
    void sendSysCommonImpl(SysCommonMessage);
    void sendSysExImpl(SysExMessage);
    void sendRealTimeImpl(RealTimeMessage);
    void sendNowImpl();
 
    void sinkMIDIfromPipe(ChannelMessage m) override { send(m); }
    void sinkMIDIfromPipe(SysExMessage m) override { send(m); }
    void sinkMIDIfromPipe(SysCommonMessage m) override { send(m); }
    void sinkMIDIfromPipe(RealTimeMessage m) override { send(m); }
 
    Stream &stream;
 
    friend MIDI_Sender<StreamDebugMIDI_Output>;
};
 
class MIDIOutputOnly : public AH::UpdatableCRTP<MIDIOutputOnly> {
  public:
    virtual ~MIDIOutputOnly() = default;
    virtual void begin() = 0;
    static void beginAll() { applyToAll(&MIDIOutputOnly::begin); }
};
 
template <typename T>
class SerialDebugMIDI_Output : public MIDIOutputOnly,
                               public StreamDebugMIDI_Output {
  public:
    SerialDebugMIDI_Output(T &serial, unsigned long baud = AH::defaultBaudRate,
                           const char *prefix = nullptr)
        : StreamDebugMIDI_Output(serial, prefix), baud(baud) {}
    SerialDebugMIDI_Output(T &serial, const char *prefix)
        : SerialDebugMIDI_Output(serial, AH::defaultBaudRate, prefix) {}
 
    void begin() override { static_cast<T &>(getStream()).begin(baud); }
 
  private:
    const unsigned long baud;
};
 
class HardwareSerialDebugMIDI_Output
    : public SerialDebugMIDI_Output<HardwareSerial> {
  public:
    HardwareSerialDebugMIDI_Output(HardwareSerial &serial,
                                   unsigned long baud = AH::defaultBaudRate,
                                   const char *prefix = nullptr)
        : SerialDebugMIDI_Output(serial, baud, prefix) {}
    HardwareSerialDebugMIDI_Output(HardwareSerial &serial, const char *prefix)
        : SerialDebugMIDI_Output(serial, prefix) {}
};
 
class USBDebugMIDI_Output : public SerialDebugMIDI_Output<decltype(Serial)> {
  public:
    USBDebugMIDI_Output(unsigned long baud = AH::defaultBaudRate,
                        const char *prefix = nullptr)
        : SerialDebugMIDI_Output(Serial, baud, prefix) {}
    USBDebugMIDI_Output(const char *prefix)
        : SerialDebugMIDI_Output(Serial, prefix) {}
};
 
class StreamDebugMIDI_Interface : public StreamDebugMIDI_Base,
                                  public MIDI_Interface {
  public:
    StreamDebugMIDI_Interface(Stream &stream, const char *prefix = nullptr)
        : StreamDebugMIDI_Base(prefix), hexstream(stream) {}
 
    Stream &getStream() const { return hexstream.puller.stream; }
 
    MIDIReadEvent read();
 
    ChannelMessage getChannelMessage() const {
        return parser.getChannelMessage();
    }
    SysCommonMessage getSysCommonMessage() const {
        return parser.getSysCommonMessage();
    }
    RealTimeMessage getRealTimeMessage() const {
        return parser.getRealTimeMessage();
    }
    SysExMessage getSysExMessage() const { return parser.getSysExMessage(); }
 
    void update() override;
 
  protected:
    // MIDI send implementations
    void sendChannelMessageImpl(ChannelMessage) override;
    void sendSysCommonImpl(SysCommonMessage) override;
    void sendSysExImpl(SysExMessage) override;
    void sendRealTimeImpl(RealTimeMessage) override;
    void sendNowImpl() override;
 
  private:
    void handleStall() override;
 
  private:
    HexPuller<StreamPuller> hexstream;
    SerialMIDI_Parser parser;
};
 
template <typename T>
class SerialDebugMIDI_Interface : public StreamDebugMIDI_Interface {
  public:
    SerialDebugMIDI_Interface(T &serial,
                              unsigned long baud = AH::defaultBaudRate,
                              const char *prefix = nullptr)
        : StreamDebugMIDI_Interface(serial, prefix), baud(baud) {}
    SerialDebugMIDI_Interface(T &serial, const char *prefix)
        : SerialDebugMIDI_Interface(serial, AH::defaultBaudRate, prefix) {}
 
    void begin() override { static_cast<T &>(getStream()).begin(baud); }
 
  private:
    const unsigned long baud;
};
 
class HardwareSerialDebugMIDI_Interface
    : public SerialDebugMIDI_Interface<HardwareSerial> {
  public:
    HardwareSerialDebugMIDI_Interface(HardwareSerial &serial,
                                      unsigned long baud = AH::defaultBaudRate,
                                      const char *prefix = nullptr)
        : SerialDebugMIDI_Interface(serial, baud, prefix) {}
    HardwareSerialDebugMIDI_Interface(HardwareSerial &serial,
                                      const char *prefix)
        : SerialDebugMIDI_Interface(serial, prefix) {}
};
 
class USBDebugMIDI_Interface
    : public SerialDebugMIDI_Interface<decltype(Serial)> {
  public:
    USBDebugMIDI_Interface(unsigned long baud = AH::defaultBaudRate,
                           const char *prefix = nullptr)
        : SerialDebugMIDI_Interface(Serial, baud, prefix) {}
    USBDebugMIDI_Interface(const char *prefix)
        : SerialDebugMIDI_Interface(Serial, prefix) {}
};
 
END_CS_NAMESPACE