Sending and receiving midi messages via ESPNOW

[devSarry]

Hey I was wondering what would be the process of trying to send an receive midi message wirelessly? The ESP32 supports it's own wifi communication protocol called ESP-NOW that I would like to use to link together multiple midi devices like buttons and have them all transmit their midi messages to one slave that is then connected to a PC.

[tttapa]

I have never used ESP-NOW, but if you have code to send binary data over it, it shouldn't be too hard to integrate with Control Surface.
Basically, you just have to implement the MIDI_Interface interface. You can use the StreamMIDI_Interface class as a starting point:

Control-Surface/src/MIDI_Interfaces/SerialMIDI_Interface.hpp

Lines 12 to 55 in a061a3a

	/**
	* @brief A class for MIDI interfaces sending and receiving MIDI messages
	* over a Stream.
	*
	* @ingroup MIDIInterfaces
	*/
	class StreamMIDI_Interface : public MIDI_Interface {
	public:
	/// Constructor.
	/// @param stream
	/// Reference to the Stream interface to read and send MIDI data
	/// from/to.
	StreamMIDI_Interface(Stream &stream) : stream(stream) {}
	/// Try reading and parsing a single incoming MIDI message.
	/// @return Returns the type of the read message, or
	/// `MIDIReadEvent::NO_MESSAGE` if no MIDI message was available.
	MIDIReadEvent read();
	/// Return the received channel voice message.
	ChannelMessage getChannelMessage() const;
	/// Return the received system common message.
	SysCommonMessage getSysCommonMessage() const;
	/// Return the received real-time message.
	RealTimeMessage getRealTimeMessage() const;
	/// Return the received system exclusive message.
	SysExMessage getSysExMessage() const;
	void update() override;
	protected:
	void sendChannelMessageImpl(ChannelMessage) override;
	void sendSysCommonImpl(SysCommonMessage) override { /* TODO */ }
	void sendSysExImpl(SysExMessage) override;
	void sendRealTimeImpl(RealTimeMessage) override;
	void sendNowImpl() override {}
	protected:
	void handleStall() override;
	protected:
	Stream &stream;
	SerialMIDI_Parser parser;
	};

As you can see, you just have to implement a method for reading MIDI data and a handful of methods to send MIDI messages.

Control-Surface/src/MIDI_Interfaces/SerialMIDI_Interface.cpp

Lines 8 to 16 in a061a3a

	// Reading MIDI
	MIDIReadEvent StreamMIDI_Interface::read() {
	return parser.pull(StreamPuller(stream));
	}
	void StreamMIDI_Interface::update() { MIDI_Interface::updateIncoming(this); }
	void StreamMIDI_Interface::handleStall() { MIDI_Interface::handleStall(this); }

Control-Surface/src/MIDI_Interfaces/SerialMIDI_Interface.cpp

Lines 40 to 55 in a061a3a

	// Sending MIDI
	void StreamMIDI_Interface::sendChannelMessageImpl(ChannelMessage msg) {
	stream.write(msg.header);
	stream.write(msg.data1);
	if (msg.hasTwoDataBytes())
	stream.write(msg.data2);
	}
	void StreamMIDI_Interface::sendSysExImpl(SysExMessage msg) {
	stream.write(msg.data, msg.length);
	}
	void StreamMIDI_Interface::sendRealTimeImpl(RealTimeMessage msg) {
	stream.write(msg.message);
	}

You'll have to implement your own “puller” class that returns the incoming data byte-by-byte. The StreamPuller class provides a good starting point:

Control-Surface/src/MIDI_Parsers/StreamPuller.hpp

Lines 17 to 26 in a061a3a

	/// Pull a byte out of the stream.
	/// @param[out] c
	/// A new character from the stream (if available).
	/// @return True if a character was available, false otherwise.
	bool pull(uint8_t &c) {
	int read = stream.read();
	if (read >= 0)
	c = read;
	return read >= 0;
	}

Alternatively, if you receive the data in a buffer already, you can just use the BufferPuller class:

Control-Surface/src/MIDI_Parsers/BufferPuller.hpp

Line 36 in a061a3a

BufferPuller_<T> BufferPuller(const T *buffer, size_t length) {

You can use the existing parser class, and the get{Channel,SysCommon,SysEx,RealTime}Message() methods can just call the corresponding methods of the parser.

I've linked to the files on the new-input branch, because that'll eventually become version 2.0 of the library this summer.

[devSarry]

Oh fantastic. I implemented something along these lines but in a much more hacky way. I ended up implementing the "ESPNOWMidiInterface" off the "Parsing_MIDI_Interface", but it's not quite working. I'll try your approach.

#pragma once

#include "EspNowInterface.hpp"
#include "MIDI_Interfaces/SerialMIDI_Interface.hpp"

#include <AH/Error/Error.hpp>

BEGIN_CS_NAMESPACE

uint8_t dataMessage;

static void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len)
{
  char macStr[18];
  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
          mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
  dataMessage = *data;
}

/**
 * @brief   Bluetooth Low Energy MIDI Interface for the ESP32.
 * 
 * @ingroup MIDIInterfaces
 */
class   EspNowMidiInterface : public Parsing_MIDI_Interface
{

  constexpr static unsigned long MAX_MESSAGE_TIME = 10000; // microseconds

  unsigned long startTime = 0;

  constexpr static size_t BUFFER_LENGTH = 1024;

  uint8_t buffer[BUFFER_LENGTH] = {};
  uint8_t inputBuffer[BUFFER_LENGTH] = {};
  size_t index = 0;

  SerialMIDI_Parser parser;

  EspNowInterface espNowInterface;

  uint8_t connected = 0;

  bool hasSpaceFor(size_t bytes) { return bytes <= BUFFER_LENGTH - index; }

public:
  EspNowMidiInterface() : Parsing_MIDI_Interface(parser) {
    
  }

  void begin() override {
    
     espNowInterface.begin(OnDataRecv); }

  void publish()
  {
    if (index == 0)
      return;
    espNowInterface.notifyValue(buffer, index);
    index = 0;
  }

  MIDIReadEvent read() override
  {
      // uint8_t midiByte = stream.read();
      MIDIReadEvent parseResult = parser.parse(dataMessage);
      if (parseResult != MIDIReadEvent::NO_MESSAGE)
        return parseResult;

    return MIDIReadEvent::NO_MESSAGE; // TODO
  }


  template <size_t N>
  void addToBuffer(const uint8_t (&data)[N])
  {
    addToBuffer(&data[0], N);
  }

  void addToBuffer(const uint8_t *data, size_t len)
  {
    bool first = index == 0;
    if (!hasSpaceFor(len + 1 + first))
    { // TODO
      DEBUGFN("Buffer full");
      publish();
      if (!hasSpaceFor(len + 1 + first))
      { // TODO
        DEBUGFN("Message is larger than buffer");
        return;
      }
    }

    if (first)
      startTime = micros();

    if (first)
      buffer[index++] = 0x80; // header / timestamp msb
    buffer[index++] = 0x80;   // timestamp lsb
    memcpy(&buffer[index], data, len);
    index += len;

    update();
  }

  void addToInputBuffer(const uint8_t *data, size_t len)
  {
    bool first = index == 0;
    if (!hasSpaceFor(len + 1 + first))
    { // TODO
      DEBUGFN("Buffer full");
      publish();
      if (!hasSpaceFor(len + 1 + first))
      { // TODO
        DEBUGFN("Message is larger than buffer");
        return;
      }
    }

    if (first)
      startTime = micros();

    if (first)
      inputBuffer[index++] = 0x80; // header / timestamp msb
    inputBuffer[index++] = 0x80;   // timestamp lsb
    memcpy(&inputBuffer[index], data, len);
    index += len;

    update();
  }

  void update() override
  {
    if (micros() - startTime >= MAX_MESSAGE_TIME)
      publish();
  }

  void sendImpl(uint8_t header, uint8_t d1, uint8_t d2, uint8_t cn) override
  {
    (void)cn;
    uint8_t msg[3] = {header, d1, d2};
    addToBuffer(msg);
  }
  void sendImpl(uint8_t header, uint8_t d1, uint8_t cn) override
  {
    (void)cn;
    uint8_t msg[2] = {header, d1};
    addToBuffer(msg);
  }

  void sendImpl(const uint8_t *data, size_t length, uint8_t cn) override
  {
    (void)data;
    (void)length;
    (void)cn; // TODO
  }

  void sendImpl(uint8_t rt, uint8_t cn) override
  {
    (void)rt;
    (void)cn; // TODO
  }

  void parse(const uint8_t *const data, const size_t len)
  {
    // TODO: documentation and link to BLE MIDI spec
    if (len <= 1)
      return;
    if (MIDI_Parser::isData(data[0]))
      return;
    if (MIDI_Parser::isData(data[1]))
      parse(data[1]);
    bool prevWasTimestamp = true;
    for (const uint8_t *d = data + 2; d < data + len; d++)
    {
      if (MIDI_Parser::isData(*d))
      {
        parse(*d);
        prevWasTimestamp = false;
      }
      else
      {
        if (prevWasTimestamp)
          parse(*d);
        prevWasTimestamp = !prevWasTimestamp;
      }
    }
  }

  void parse(uint8_t data)
  {
    event = parser.parse(data);
    // Best we can do is just retry until the pipe is no longer in exclusive
    // mode.
    // Keep in mind that this is executed in the callback of the BLE stack,
    // I don't know what happens to the Bluetooth connection if we let it
    // wait for longer than the communication interval.
    //
    // TODO: If this causes problems, we could buffer the data until the
    //       pipe is available for writing again.
    while (!dispatchMIDIEvent(event))
#ifdef ARDUINO
      delay(1);
#else
      usleep(1e3);
#endif
  }


  EspNowInterface &getBLEMIDI() { return espNowInterface; }
};




END_CS_NAMESPACE```