Arduino MIDI Library

https://fortyseveneffects.github.io/arduino_midi_library/
Admin
Arduino MIDI Library is a C++ library for Arduino boards that provides MIDI input and output...
Tokens:94,535
Snippets:919
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### MIDI Basic IO Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00071.html

Demonstrates fundamental MIDI input and output operations. No special setup is required.

```Arduino
#include <MIDI.h>

// Create a MIDI instance. 
// If you want to use the "real" MIDI ports, 
// you need to use the "real" MIDI library. 
// For example, for the Leonardo, you can use 
// MIDI_create_default_instance() which uses the 
// USB-MIDI interface.
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  // Initialize the MIDI library and start the serial port.
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.turnThruOff();
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);
}

void loop() {
  // Call the MIDI library's read() method to process incoming MIDI messages.
  MIDI.read();
}

// Callback function for Note On messages.
void handleNoteOn(byte channel, byte pitch, byte velocity) {
  // Print the received Note On message to the serial monitor.
  Serial.print("Note On, Channel: ");
  Serial.print(channel);
  Serial.print(", Pitch: ");
  Serial.print(pitch);
  Serial.print(", Velocity: ");
  Serial.println(velocity);

  // Send a Note Off message for the same note after a short delay.
  MIDI.sendNoteOff(pitch, 0, channel);
}

// Callback function for Note Off messages.
void handleNoteOff(byte channel, byte pitch, byte velocity) {
  // Print the received Note Off message to the serial monitor.
  Serial.print("Note Off, Channel: ");
  Serial.print(channel);
  Serial.print(", Pitch: ");
  Serial.print(pitch);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

```

--------------------------------

### MIDI Basic IO Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00075.html

Demonstrates basic MIDI input and output operations. This example is useful for understanding fundamental MIDI message handling.

```c++
#include <MIDI.h>

// Create a MIDI instance
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  // Initialize MIDI
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.turnThruOff();
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);

  // Start serial
  Serial.begin(115200);
  Serial.println("\nStarting MIDI Basic IO example...");
}

void loop() {
  // Read incoming MIDI messages
  MIDI.read();
}

// Callback for Note On messages
void handleNoteOn(byte channel, byte note, byte velocity) {
  Serial.print("Note On, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);

  // Echo back the note
  MIDI.sendNoteOn(note, velocity, channel);
}

// Callback for Note Off messages
void handleNoteOff(byte channel, byte note, byte velocity) {
  Serial.print("Note Off, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);

  // Echo back the note off
  MIDI.sendNoteOff(note, velocity, channel);
}

```

--------------------------------

### MIDI Simple Synth Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00075.html

A basic synthesizer example using the MIDI library. This demonstrates how to generate MIDI notes in response to input or internal logic.

```c++
#include <MIDI.h>

// Create a MIDI instance
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  // Initialize MIDI
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.turnThruOff();
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);

  // Start serial
  Serial.begin(115200);
  Serial.println("\nStarting MIDI Simple Synth example...");
}

void loop() {
  // Read incoming MIDI messages
  MIDI.read();

  // Example: Play a note every 5 seconds if no note is currently playing
  static unsigned long lastNoteTime = 0;
  if (millis() - lastNoteTime > 5000) {
    // Check if any notes are currently playing (simplified check)
    // In a real synth, you'd track active notes more robustly
    bool noteIsPlaying = false; // Assume no note is playing for this simple example
    if (!noteIsPlaying) {
      Serial.println("Playing a C4 note...");
      MIDI.sendNoteOn(60, 100, 1); // Note C4, Velocity 100, Channel 1
      lastNoteTime = millis();
      // In a real synth, you'd schedule a Note Off
      // MIDI.sendNoteOff(60, 0, 1); 
    }
  }
}

// Callback for Note On messages (to stop the synth from playing its own note)
void handleNoteOn(byte channel, byte note, byte velocity) {
  Serial.print("Received Note On, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
  // In a real synth, you might stop the currently playing note here
}

// Callback for Note Off messages
void handleNoteOff(byte channel, byte note, byte velocity) {
  Serial.print("Received Note Off, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

```

--------------------------------

### MIDI Benchmarking Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00071.html

Used for benchmarking the MIDI library's performance. Requires specific setup for accurate timing.

```Arduino
#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  MIDI.begin(MIDI_CHANNEL_OMNI);
}

void loop() {
  // Send a Note On message.
  MIDI.sendNoteOn(60, 127, 1);
  // Send a Note Off message.
  MIDI.sendNoteOff(60, 0, 1);
}

```

--------------------------------

### sendStart()

Source: https://fortyseveneffects.github.io/arduino_midi_library/functions.html

Sends a MIDI Start message.

```APIDOC
## sendStart()

### Description
Sends a MIDI Start message.

### Method
`MidiInterface< Transport, _Settings, _Platform >::sendStart()`
```

--------------------------------

### MIDI Simple Synth Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00071.html

A basic example of creating a simple synthesizer using the MIDI library. It responds to Note On/Off messages to play sounds.

```Arduino
#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);
  
  // Initialize audio output (e.g., PWM pin for a buzzer or DAC)
  // For simplicity, this example assumes a buzzer connected to pin 8
  pinMode(8, OUTPUT);
}

void loop() {
  MIDI.read();
}

void handleNoteOn(byte channel, byte pitch, byte velocity) {
  // Convert MIDI pitch to a frequency (simplified)
  // This is a very basic mapping and doesn't account for equal temperament
  float frequency = 440.0 * pow(2.0, (pitch - 69) / 12.0);
  
  // Play the note using PWM (buzzer)
  // The duration is controlled by the velocity (simplified)
  // A more advanced synth would use timers for precise duration and waveform generation
  if (velocity > 0) {
    tone(8, frequency, velocity * 10); // Play tone for a duration proportional to velocity
  }
}

void handleNoteOff(byte channel, byte pitch, byte velocity) {
  // Stop the note
  noTone(8);
}

```

--------------------------------

### MIDI Bench Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00075.html

A benchmarking example for the MIDI library. Use this to test the performance and throughput of MIDI communication.

```c++
#include <MIDI.h>

// Create a MIDI instance
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  // Initialize MIDI
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.turnThruOff();
  MIDI.setHandleRealTimeSystem(handleRealTimeSystem);

  // Start serial
  Serial.begin(115200);
  Serial.println("\nStarting MIDI Bench example...");
}

void loop() {
  // Read incoming MIDI messages
  MIDI.read();
}

// Callback for Real Time System messages
void handleRealTimeSystem(SevenBitNumber system_byte) {
  // Handle Real Time System messages if needed
}

```

--------------------------------

### begin()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00039.html

Initializes the MIDI interface. This should be called in the setup() function of your Arduino sketch.

```APIDOC
## begin()

### Description
Call the begin method in the setup() function of the Arduino. Initializes the MIDI interface.

### Method
void begin (Channel inChannel=1)

### Endpoint
N/A (Method Call)

### Parameters
#### Query Parameters
- **inChannel** (Channel) - Optional - The MIDI channel to use (defaults to 1).
```

--------------------------------

### MidiInterface::begin

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00002_source.html

Initializes the MIDI library. Should be called in the setup() function of the Arduino sketch.

```APIDOC
## MidiInterface::begin

### Description
Call the begin method in the setup() function of the Arduino.

### Method
void begin(Channel inChannel=1)

### Parameters
- **inChannel** (Channel) - The MIDI channel to use. Defaults to 1.
```

--------------------------------

### MidiInterface::sendStart

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00002_source.html

Sends a MIDI Start message.

```APIDOC
## MidiInterface::sendStart

### Description
Sends a MIDI Start message.

### Method
void sendStart()

### Endpoint
N/A (Function Call)

### Parameters
None

### Request Example
```cpp
midiInterface.sendStart();
```

### Response
None
```

--------------------------------

### setHandleStart

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00039.html

Sets a callback function to be executed when a Start MIDI message is received.

```APIDOC
## setHandleStart()

### Description
Sets a callback function to be executed when a Start MIDI message is received.

### Method
`void MidiInterface< Transport, _Settings, _Platform >::setHandleStart(StartCallback _fptr)`

### Parameters
*   **_fptr** (StartCallback) - The callback function to set for Start events.
```

--------------------------------

### MidiInterface::beginRpn

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00002_source.html

Starts a Registered Parameter Number (RPN) frame.

```APIDOC
## MidiInterface::beginRpn

### Description
Start a Registered Parameter Number frame.

### Method
void

### Parameters
- **inNumber** (unsigned) - The RPN number.
- **inChannel** (Channel) - The MIDI channel.
```

--------------------------------

### MidiInterface::begin() Method

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00039.html

Initializes the MidiInterface and the transport layer. This should be called in the Arduino setup() function. The input channel defaults to 1 if not specified.

```cpp
template<class Transport , class Settings , class Platform >
void MidiInterface< Transport, Settings, Platform >::begin(Channel _inChannel_ = 1)
{
    // Initialise the Transport layer
    mTransport.begin();

    mInputChannel = inChannel;
    mRunningStatus_TX = InvalidType;
    mRunningStatus_RX = InvalidType;

    mPendingMessageIndex = 0;
    mPendingMessageExpectedLength = 0;

    mCurrentRpnNumber = 0xffff;
    mCurrentNrpnNumber = 0xffff;

    mLastMessageSentTime = Platform::now();

    mMessage.valid = false;
    mMessage.type = InvalidType;
    mMessage.channel = 0;
    mMessage.data1 = 0;
    mMessage.data2 = 0;
    mMessage.length = 0;

    mThruFilterMode = Thru::Full;
    mThruActivated = mTransport.thruActivated;
}
```

--------------------------------

### MidiInterface::setHandleStart

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00002_source.html

Sets a callback function to handle MIDI Start messages.

```APIDOC
## MidiInterface::setHandleStart

### Description
Set a callback function to handle MIDI Start messages.

### Method
void setHandleStart(StartCallback fptr)

### Parameters
- **fptr** (StartCallback) - A pointer to the Start callback function.
```

--------------------------------

### Begin RPN

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00032.html

Starts a Registered Parameter Number (RPN) frame.

```APIDOC
## MidiInterface< Transport, _Settings, _Platform >::beginRpn (unsigned inNumber, Channel inChannel)

### Description
Start a Registered Parameter Number frame.

### Method
void

### Parameters
- **inNumber** (unsigned) - The RPN number.
- **inChannel** (Channel) - The MIDI channel.
```

--------------------------------

### MIDI Callbacks Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00071.html

Illustrates using callback functions for handling different MIDI message types, simplifying input processing.

```Arduino
#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);
  MIDI.setHandleControlChange(handleControlChange);
  MIDI.setHandleProgramChange(handleProgramChange);
  MIDI.setHandlePitchBend(handlePitchBend);
  MIDI.setHandleAfterTouch(handleAfterTouch);
  MIDI.setHandleSystemExclusive(handleSystemExclusive);
  MIDI.setHandleTimeCodeQuarterFrame(handleTimeCodeQuarterFrame);
  MIDI.setHandleSongPosition(handleSongPosition);
  MIDI.setHandleSongSelect(handleSongSelect);
  MIDI.setHandleTuneRequest(handleTuneRequest);
  MIDI.setHandleClock(handleClock);
  MIDI.setHandleStart(handleStart);
  MIDI.setHandleContinue(handleContinue);
  MIDI.setHandleStop(handleStop);
  MIDI.setHandleReset(handleReset);
}

void loop() {
  MIDI.read();
}

void handleNoteOn(byte channel, byte pitch, byte velocity) {
  Serial.print("Note On, Channel ");
  Serial.print(channel);
  Serial.print(", Pitch ");
  Serial.print(pitch);
  Serial.print(", Velocity ");
  Serial.println(velocity);
}

void handleNoteOff(byte channel, byte pitch, byte velocity) {
  Serial.print("Note Off, Channel ");
  Serial.print(channel);
  Serial.print(", Pitch ");
  Serial.print(pitch);
  Serial.print(", Velocity ");
  Serial.println(velocity);
}

void handleControlChange(byte channel, byte control, byte value) {
  Serial.print("Control Change, Channel ");
  Serial.print(channel);
  Serial.print(", Control ");
  Serial.print(control);
  Serial.print(", Value ");
  Serial.println(value);
}

void handleProgramChange(byte channel, byte program) {
  Serial.print("Program Change, Channel ");
  Serial.print(channel);
  Serial.print(", Program ");
  Serial.println(program);
}

void handlePitchBend(byte channel, byte lsb, byte msb) {
  Serial.print("Pitch Bend, Channel ");
  Serial.print(channel);
  Serial.print(", LSB ");
  Serial.print(lsb);
  Serial.print(", MSB ");
  Serial.println(msb);
}

void handleAfterTouch(byte channel, byte attribute, byte value) {
  Serial.print("After Touch, Channel ");
  Serial.print(channel);
  Serial.print(", Attribute ");
  Serial.print(attribute);
  Serial.print(", Value ");
  Serial.println(value);
}

void handleSystemExclusive(byte* message, unsigned size, bool has_eos) {
  Serial.print("System Exclusive, Size ");
  Serial.println(size);
}

void handleTimeCodeQuarterFrame(byte frame_斦, byte time_code) {
  Serial.print("Time Code Quarter Frame, Frame ");
  Serial.print(frame_斦);
  Serial.print(", Time Code ");
  Serial.println(time_code);
}

void handleSongPosition(unsigned pulse) {
  Serial.print("Song Position, Pulse ");
  Serial.println(pulse);
}

void handleSongSelect(byte song) {
  Serial.print("Song Select, Song ");
  Serial.println(song);
}

void handleTuneRequest() {
  Serial.println("Tune Request");
}

void handleClock() {
  Serial.println("Clock");
}

void handleStart() {
  Serial.println("Start");
}

void handleContinue() {
  Serial.println("Continue");
}

void handleStop() {
  Serial.println("Stop");
}

void handleReset() {
  Serial.println("Reset");
}

```

--------------------------------

### MIDI Callbacks Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00075.html

Illustrates how to use callback functions for various MIDI events. This is essential for event-driven MIDI processing.

```c++
#include <MIDI.h>

// Create a MIDI instance
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  // Initialize MIDI
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.turnThruOff();
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);
  MIDI.setHandleControlChange(handleControlChange);
  MIDI.setHandleProgramChange(handleProgramChange);
  MIDI.setHandlePitchBend(handlePitchBend);
  MIDI.setHandleAfterTouch(handleAfterTouch);
  MIDI.setHandleAfterTouchPoly(handleAfterTouchPoly);
  MIDI.setHandleSystemExclusive(handleSystemExclusive);
  MIDI.setHandleTimeCodeQuarterFrame(handleTimeCodeQuarterFrame);
  MIDI.setHandleSongPosition(handleSongPosition);
  MIDI.setHandleSongSelect(handleSongSelect);
  MIDI.setHandleTuneRequest(handleTuneRequest);
  MIDI.setHandleClock(handleClock);
  MIDI.setHandleStart(handleStart);
  MIDI.setHandleContinue(handleContinue);
  MIDI.setHandleStop(handleStop);
  MIDI.setHandleReset(handleReset);

  // Start serial
  Serial.begin(115200);
  Serial.println("\nStarting MIDI Callbacks example...");
}

void loop() {
  // Read incoming MIDI messages
  MIDI.read();
}

// Callback for Note On messages
void handleNoteOn(byte channel, byte note, byte velocity) {
  Serial.print("Note On, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

// Callback for Note Off messages
void handleNoteOff(byte channel, byte note, byte velocity) {
  Serial.print("Note Off, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

// Callback for Control Change messages
void handleControlChange(byte channel, byte control, byte value) {
  Serial.print("Control Change, Channel: ");
  Serial.print(channel);
  Serial.print(", Control: ");
  Serial.print(control);
  Serial.print(", Value: ");
  Serial.println(value);
}

// Callback for Program Change messages
void handleProgramChange(byte channel, byte program) {
  Serial.print("Program Change, Channel: ");
  Serial.print(channel);
  Serial.print(", Program: ");
  Serial.println(program);
}

// Callback for Pitch Bend messages
void handlePitchBend(byte channel, byte pitchLow, byte pitchHigh) {
  Serial.print("Pitch Bend, Channel: ");
  Serial.print(channel);
  Serial.print(", Value: ");
  Serial.print(pitchLow + (pitchHigh << 7));
  Serial.println();
}

// Callback for After Touch messages
void handleAfterTouch(byte channel, byte note, byte value) {
  Serial.print("After Touch, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Value: ");
  Serial.println(value);
}

// Callback for Polyphonic After Touch messages
void handleAfterTouchPoly(byte channel, byte note, byte value) {
  Serial.print("Polyphonic After Touch, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Value: ");
  Serial.println(value);
}

// Callback for System Exclusive messages
void handleSystemExclusive(byte* message, unsigned int length, byte cable) {
  Serial.print("System Exclusive, Cable: ");
  Serial.print(cable);
  Serial.print(", Length: ");
  Serial.println(length);
}

// Callback for Time Code Quarter Frame messages
void handleTimeCodeQuarterFrame(byte data) {
  Serial.print("Time Code Quarter Frame, Data: ");
  Serial.println(data);
}

// Callback for Song Position messages
void handleSongPosition(unsigned int beats) {
  Serial.print("Song Position, Beats: ");
  Serial.println(beats);
}

// Callback for Song Select messages
void handleSongSelect(byte song) {
  Serial.print("Song Select, Song: ");
  Serial.println(song);
}

// Callback for Tune Request messages
void handleTuneRequest() {
  Serial.println("Tune Request");
}

// Callback for Clock messages
void handleClock() {
  Serial.println("Clock");
}

// Callback for Start messages
void handleStart() {
  Serial.println("Start");
}

// Callback for Continue messages
void handleContinue() {
  Serial.println("Continue");
}

// Callback for Stop messages
void handleStop() {
  Serial.println("Stop");
}

// Callback for Reset messages
void handleReset() {
  Serial.println("Reset");
}

```

--------------------------------

### MidiInterface::begin()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00039.html

Initializes the MIDI interface. This method should be called in the setup() function of your Arduino sketch. It sets the input channel and configures thru mirroring.

```APIDOC
## begin(Channel _inChannel = 1)

### Description
Call the begin method in the setup() function of the Arduino.
All parameters are set to their default values:
  * Input channel set to 1 if no value is specified
  * Full thru mirroring

### Parameters
- **_inChannel** (Channel) - Optional. The MIDI channel to listen on. Defaults to 1.
```

--------------------------------

### MIDI Input Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00071.html

Focuses on receiving and processing MIDI messages. Demonstrates basic parsing of incoming data.

```Arduino
#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);
}

void loop() {
  MIDI.read();
}

void handleNoteOn(byte channel, byte pitch, byte velocity) {
  Serial.print("Note On, Channel: ");
  Serial.print(channel);
  Serial.print(", Pitch: ");
  Serial.print(pitch);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

void handleNoteOff(byte channel, byte pitch, byte velocity) {
  Serial.print("Note Off, Channel: ");
  Serial.print(channel);
  Serial.print(", Pitch: ");
  Serial.print(pitch);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

```

--------------------------------

### Begin NRPN

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00032.html

Starts a Non-Registered Parameter Number (NRPN) frame.

```APIDOC
## MidiInterface< Transport, _Settings, _Platform >::beginNrpn (unsigned inNumber, Channel inChannel)

### Description
Start a Non-Registered Parameter Number frame.

### Method
void

### Parameters
- **inNumber** (unsigned) - The NRPN number.
- **inChannel** (Channel) - The MIDI channel.
```

--------------------------------

### MIDI Dual Merger Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00075.html

Demonstrates merging MIDI input from two sources into a single output. Useful for combining multiple MIDI devices.

```c++
#include <MIDI.h>

// Create MIDI instances for two input ports
MIDI_CREATE_INSTANCE(HardwareSerial, Serial, MIDI_PORT_1);
MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI_PORT_2);

void setup() {
  // Initialize MIDI ports
  MIDI_PORT_1.begin(MIDI_CHANNEL_OMNI);
  MIDI_PORT_2.begin(MIDI_CHANNEL_OMNI);
  MIDI_PORT_1.turnThruOff();
  MIDI_PORT_2.turnThruOff();

  // Set callbacks to merge messages
  MIDI_PORT_1.setHandleNoteOn(handleNoteOn);
  MIDI_PORT_1.setHandleNoteOff(handleNoteOff);
  MIDI_PORT_2.setHandleNoteOn(handleNoteOn);
  MIDI_PORT_2.setHandleNoteOff(handleNoteOff);

  // Start serial for debugging
  Serial.begin(115200);
  Serial.println("\nStarting MIDI Dual Merger example...");
}

void loop() {
  // Read from both MIDI ports
  MIDI_PORT_1.read();
  MIDI_PORT_2.read();
}

// Callback for Note On messages (from either port)
void handleNoteOn(byte channel, byte note, byte velocity) {
  Serial.print("Note On, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);

  // Send the note on message to the default output
  MIDI.sendNoteOn(note, velocity, channel);
}

// Callback for Note Off messages (from either port)
void handleNoteOff(byte channel, byte note, byte velocity) {
  Serial.print("Note Off, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);

  // Send the note off message to the default output
  MIDI.sendNoteOff(note, velocity, channel);
}

```

--------------------------------

### MidiInterface::beginNrpn

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00002_source.html

Starts a Non-Registered Parameter Number (NRPN) frame.

```APIDOC
## MidiInterface::beginNrpn

### Description
Start a Non-Registered Parameter Number frame.

### Method
void beginNrpn(unsigned inNumber, Channel inChannel)

### Parameters
- **inNumber** (unsigned) - The NRPN number.
- **inChannel** (Channel) - The MIDI channel.
```

--------------------------------

### Start New MIDI Message - Running Status Check

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00005_source.html

Starts a new pending MIDI message. Checks for running status if the extracted byte is not a status byte.

```cpp
mPendingMessage[0] = extracted;

// Check for running status first
if (isChannelMessage(getTypeFromStatusByte(mRunningStatus_RX)))
{
  // Only these types allow Running Status

  // If the status byte is not received, prepend it
  // to the pending message
  if (extracted < 0x80)
  {
    mPendingMessage[0] = mRunningStatus_RX;
    mPendingMessage[1] = extracted;
    mPendingMessageIndex = 1;
  }
  // Else: well, we received another status byte,
  // so the running status does not apply here.
  // It will be updated upon completion of this message.
}
```

--------------------------------

### MIDI Dual Merger Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00071.html

Shows how to merge MIDI input from two different sources into a single output stream. Useful for combining controllers.

```Arduino
#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.turnThruOff();
  MIDI.setHandleRealTimeSystem(MIDI.sendRealTimeSystem);
}

void loop() {
  MIDI.read();
}

```

--------------------------------

### BEGIN_MIDI_NAMESPACE Macro

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00020_source.html

Defines the start of the MIDI library's namespace. This helps prevent naming conflicts with other libraries.

```cpp
#define BEGIN_MIDI_NAMESPACE

```

--------------------------------

### MIDI Input Example

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00075.html

Focuses on receiving and processing MIDI input. This is fundamental for any MIDI-based project that needs to react to external MIDI signals.

```c++
#include <MIDI.h>

// Create a MIDI instance
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  // Initialize MIDI
  MIDI.begin(MIDI_CHANNEL_OMNI);
  MIDI.turnThruOff();
  MIDI.setHandleNoteOn(handleNoteOn);
  MIDI.setHandleNoteOff(handleNoteOff);

  // Start serial
  Serial.begin(115200);
  Serial.println("\nStarting MIDI Input example...");
}

void loop() {
  // Read incoming MIDI messages
  MIDI.read();
}

// Callback for Note On messages
void handleNoteOn(byte channel, byte note, byte velocity) {
  Serial.print("Note On, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

// Callback for Note Off messages
void handleNoteOff(byte channel, byte note, byte velocity) {
  Serial.print("Note Off, Channel: ");
  Serial.print(channel);
  Serial.print(", Note: ");
  Serial.print(note);
  Serial.print(", Velocity: ");
  Serial.println(velocity);
}

```

--------------------------------

### beginRpn()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00032.html

Starts a Registered Parameter Number (RPN) frame by sending the appropriate Control Change messages for the given number and channel.

```APIDOC
## beginRpn()

### Description
Starts a Registered Parameter Number frame.

### Parameters
- **inNumber** (unsigned) - The 14-bit number of the RPN you want to select.
- **inChannel** (Channel) - The channel on which the message will be sent (1 to 16).

### Definition
```cpp
template<class Transport , class Settings , class Platform >
void MidiInterface< Transport, Settings, Platform >::beginRpn(unsigned inNumber, Channel inChannel)
```
```

--------------------------------

### MIDI_CREATE_INSTANCE

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00023.html

Creates an instance of the MIDI library attached to a serial port. This macro simplifies the setup process for using MIDI with hardware or software serial ports.

```APIDOC
## MIDI_CREATE_INSTANCE

### Description
Creates an instance of the library attached to a serial port. You can use HardwareSerial or SoftwareSerial for the serial port.

### Syntax
```c
MIDI_CREATE_INSTANCE(Type, SerialPort, Name)
```

### Parameters
*   **Type**: The type of serial port (e.g., `HardwareSerial`, `SoftwareSerial`).
*   **SerialPort**: The specific serial port instance (e.g., `Serial`, `Serial2`).
*   **Name**: The name to assign to the MIDI interface instance.

### Value
```c
MIDI_NAMESPACE::SerialMIDI<Type> serial##Name(SerialPort);
MIDI_NAMESPACE::MidiInterface<MIDI_NAMESPACE::SerialMIDI<Type>> Name((MIDI_NAMESPACE::SerialMIDI<Type>&)serial##Name);
```

### Example
```c
MIDI_CREATE_INSTANCE(HardwareSerial, Serial2, midi2);
midi2.begin();
midi2.read();
```

Definition at line 100 of file serialMIDI.h.
```

--------------------------------

### Channel Management

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00039.html

Functions to get and set the input MIDI channel.

```APIDOC
## Channel Management

### getInputChannel

Gets the current input MIDI channel.

### setInputChannel

Sets the input MIDI channel.

- **inChannel** (Channel) - The MIDI channel to set.
```

--------------------------------

### SerialMIDI beginTransmission() Function

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00067.html

Indicates the start of a MIDI transmission. This function currently always returns true and does not perform any specific actions.

```cpp
template<class SerialPort , class _Settings = DefaultSerialSettings>
inline 
bool SerialMIDI< SerialPort, _Settings >::beginTransmission( MidiType)
{
    return true;
};
```

--------------------------------

### beginNrpn()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00032.html

Starts a Non-Registered Parameter Number (NRPN) frame by sending the appropriate Control Change messages for the given number and channel.

```APIDOC
## beginNrpn()

### Description
Starts a Non-Registered Parameter Number frame.

### Parameters
- **inNumber** (unsigned) - The 14-bit number of the NRPN you want to select.
- **inChannel** (Channel) - The channel on which the message will be sent (1 to 16).

### Definition
```cpp
template<class Transport , class Settings , class Platform >
void MidiInterface< Transport, Settings, Platform >::beginNrpn(unsigned inNumber, Channel inChannel)
```
```

--------------------------------

### Input Channel Management

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00002_source.html

Functions to get and set the input MIDI channel.

```APIDOC
## getInputChannel

### Description
Gets the currently configured input MIDI channel.

### Method
`inline Channel getInputChannel() const`

### Returns
`Channel` - The input MIDI channel.
```

```APIDOC
## setInputChannel

### Description
Sets the input MIDI channel to listen on.

### Method
`inline void setInputChannel(Channel inChannel)`

### Parameters
- **inChannel** (Channel) - The MIDI channel to set as the input channel.
```

--------------------------------

### Begin MIDI Namespace Block

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00014.html

Starts a namespace block using the defined MIDI_NAMESPACE. This is typically used to enclose library code within its designated namespace.

```c++
#define BEGIN_MIDI_NAMESPACE namespace MIDI_NAMESPACE {
```

--------------------------------

### begin()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00067.html

Initializes the serial port for MIDI communication with the configured baud rate.

```APIDOC
## begin()

### Description
Initializes the serial port for MIDI communication with the configured baud rate.

### Signature
`void begin()`

### Definition
`serialMIDI.h:56`
```

--------------------------------

### begin()

Source: https://fortyseveneffects.github.io/arduino_midi_library/functions_func.html

Initializes the MIDI interface. This function can be overloaded for different transport and settings.

```APIDOC
## begin()

### Description
Initializes the MIDI interface. This function can be overloaded for different transport and settings.

### Method
`MidiInterface< Transport, _Settings, _Platform >::begin()`
`SerialMIDI< SerialPort, _Settings >::begin()`
```

--------------------------------

### begin

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00005_source.html

Initializes the MIDI interface with a specified channel and resets internal states.

```APIDOC
## begin

### Description
Initializes the MIDI interface with a specified channel and resets internal states.

### Method
void begin(Channel inChannel)

### Parameters
- **inChannel** (Channel) - The MIDI channel to use for input.
```

--------------------------------

### endTransmission()

Source: https://fortyseveneffects.github.io/arduino_midi_library/functions.html

Completes and sends the MIDI transmission that was started with `beginTransmission()`.

```APIDOC
## endTransmission()

### Description
Completes and sends the MIDI transmission that was started with `beginTransmission()`.

### Method
`SerialMIDI< SerialPort, _Settings >::endTransmission()`
```

--------------------------------

### MidiInterface Begin Method

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00005_source.html

Initializes the MIDI interface with a specified input channel. This method sets up the transport layer, resets internal states, and prepares the interface for MIDI communication.

```cpp
template<class Transport, class Settings, class Platform>
void MidiInterface<Transport, Settings, Platform>::begin(Channel inChannel)
{
// Initialise the Transport layer
mTransport.begin();

mInputChannel = inChannel;
mRunningStatus_TX = InvalidType;
mRunningStatus_RX = InvalidType;

mPendingMessageIndex = 0;
mPendingMessageExpectedLength = 0;

mCurrentRpnNumber = 0xffff;
mCurrentNrpnNumber = 0xffff;

mLastMessageSentTime = Platform::now();

mMessage.valid = false;
mMessage.type = InvalidType;
mMessage.channel = 0;
mMessage.data1 = 0;
mMessage.data2 = 0;
mMessage.length = 0;

mThruFilterMode = Thru::Full;
mThruActivated = mTransport.thruActivated;
}
```

--------------------------------

### MidiInterface::getInputChannel()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00033.html

Gets the current input MIDI channel.

```APIDOC
## MidiInterface::getInputChannel()

### Description
Get the input MIDI channel.

### Method
```cpp
Channel getInputChannel ()
```

### Parameters
None

### Response
- **Channel**: The current input MIDI channel.
```

--------------------------------

### System Common and Real-Time Callbacks

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00008.html

Defines callback function types for MIDI System Common messages like Song Position and Song Select, as well as real-time messages like Start, Stop, and Tick.

```APIDOC
## ◆ SongPositionCallback
using SongPositionCallback = void (*)(unsigned beats)

## ◆ SongSelectCallback
using SongSelectCallback = void (*)(byte songnumber)

## ◆ StartCallback
using StartCallback = void (*)(void)

## ◆ StopCallback
using StopCallback = void (*)(void)

## ◆ TickCallback
using TickCallback = void (*)(void)
```

--------------------------------

### MidiInterface::getSysExArrayLength()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00033.html

Gets the length of the System Exclusive array.

```APIDOC
## MidiInterface::getSysExArrayLength()

### Description
Get the length of the System Exclusive array.

### Method
```cpp
unsigned getSysExArrayLength () const
```

### Parameters
None

### Response
- **unsigned**: The length of the System Exclusive array.
```

--------------------------------

### MidiInterface::getSysExArray()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00033.html

Gets the System Exclusive byte array.

```APIDOC
## MidiInterface::getSysExArray()

### Description
Get the System Exclusive byte array.

### Method
```cpp
const byte * getSysExArray () const
```

### Parameters
None

### Response
- **const byte***: A pointer to the System Exclusive byte array.
```

--------------------------------

### sendNoteOn

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00005_source.html

Sends a Note On message. This indicates that a note has started playing.

```APIDOC
## sendNoteOn

### Description
Sends a Note On message, indicating a note has started playing.

### Method Signature
`void sendNoteOn(DataByte inNoteNumber, DataByte inVelocity, Channel inChannel)`

### Parameters
- **inNoteNumber** (DataByte) - The MIDI note number (0-127).
- **inVelocity** (DataByte) - The velocity of the note (0-127). A velocity of 0 typically means Note Off.
- **inChannel** (Channel) - The MIDI channel (1-16) to send the message on.
```

--------------------------------

### SerialMIDI begin() Function

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00067.html

Initializes the serial port with the baud rate specified in the _Settings. It uses conditional compilation for different AVR platforms.

```cpp
template<class SerialPort , class _Settings = DefaultSerialSettings>
inline 
void SerialMIDI< SerialPort, _Settings >::begin()
{
    // Initialise the Serial port
    #if defined(AVR_CAKE)
    mSerial. template open<Settings::BaudRate>();
    #else
    mSerial.begin(Settings::BaudRate);
    #endif
}
```

--------------------------------

### Transport Control

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00039.html

Function to get a pointer to the transport control object.

```APIDOC
## Transport Control

### getTransport

Returns a pointer to the transport control object, allowing for control over MIDI transport functions.

Returns:
- (Transport *) A pointer to the Transport object.
```

--------------------------------

### MIDI Instance Creation Macros

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00023_source.html

Macros to create MIDI instances, either custom or default.

```APIDOC
## MIDI Instance Creation Macros

### `MIDI_CREATE_INSTANCE(Type, SerialPort, Name)`
Creates a custom MIDI interface instance.

- **Type**: The type of the serial port (e.g., `HardwareSerial`).
- **SerialPort**: The serial port object to use.
- **Name**: The name for the created MIDI interface instance.

Example:
```cpp
MIDI_CREATE_INSTANCE(HardwareSerial, Serial, MyMIDI);
```

### `MIDI_CREATE_DEFAULT_INSTANCE()`
Creates a default MIDI interface instance. It automatically selects the appropriate serial port based on the target board (e.g., `Serial1` for Leonardo/Due, `Serial` for others).
```

--------------------------------

### getFilterMode()

Source: https://fortyseveneffects.github.io/arduino_midi_library/functions_func.html

Gets the current filter mode for incoming MIDI messages.

```APIDOC
## getFilterMode()

### Description
Gets the current filter mode for incoming MIDI messages.

### Method
`MidiInterface< Transport, _Settings, _Platform >::getFilterMode()`
```

--------------------------------

### MidiInterface::getChannel()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00033.html

Gets the channel of the last received MIDI message.

```APIDOC
## MidiInterface::getChannel()

### Description
Get the channel of the message stored in the structure.

### Method
```cpp
Channel getChannel () const
```

### Parameters
None

### Response
- **Channel**: The channel of the last received message.
```

--------------------------------

### MidiInterface::getType()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00033.html

Gets the type of the last received MIDI message.

```APIDOC
## MidiInterface::getType()

### Description
Get the last received message's type.

### Method
```cpp
MidiType getType () const
```

### Parameters
None

### Response
- **MidiType**: The type of the last received message.
```

--------------------------------

### Setting Up MIDI Message Handlers

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00036.html

Methods for registering callback functions to handle specific incoming MIDI messages.

```APIDOC
## setHandleActiveSensing

### Description
Registers a callback function to handle Active Sensing MIDI messages.

### Method
`setHandleActiveSensing(ActiveSensingCallback fptr)`

## setHandleAfterTouchChannel

### Description
Registers a callback function to handle Channel Aftertouch MIDI messages.

### Method
`setHandleAfterTouchChannel(AfterTouchChannelCallback fptr)`

## setHandleAfterTouchPoly

### Description
Registers a callback function to handle Polyphonic Aftertouch MIDI messages.

### Method
`setHandleAfterTouchPoly(AfterTouchPolyCallback fptr)`

## setHandleClock

### Description
Registers a callback function to handle MIDI Clock messages.

### Method
`setHandleClock(ClockCallback fptr)`

## setHandleContinue

### Description
Registers a callback function to handle MIDI Continue messages.

### Method
`setHandleContinue(ContinueCallback fptr)`

## setHandleControlChange

### Description
Registers a callback function to handle Control Change MIDI messages.

### Method
`setHandleControlChange(ControlChangeCallback fptr)`

## setHandleError

### Description
Registers a callback function to handle MIDI errors.

### Method
`setHandleError(ErrorCallback fptr)`

## setHandleMessage

### Description
Registers a general callback function to handle any incoming MIDI message.

### Method
`setHandleMessage(void(*fptr)(const MidiMessage &))`

## setHandleNoteOff

### Description
Registers a callback function to handle Note Off MIDI messages.

### Method
`setHandleNoteOff(NoteOffCallback fptr)`

## setHandleNoteOn

### Description
Registers a callback function to handle Note On MIDI messages.

### Method
`setHandleNoteOn(NoteOnCallback fptr)`

## setHandlePitchBend

### Description
Registers a callback function to handle Pitch Bend MIDI messages.

### Method
`setHandlePitchBend(PitchBendCallback fptr)`

## setHandleProgramChange

### Description
Registers a callback function to handle Program Change MIDI messages.

### Method
`setHandleProgramChange(ProgramChangeCallback fptr)`

## setHandleSongPosition

### Description
Registers a callback function to handle Song Position Pointer MIDI messages.

### Method
`setHandleSongPosition(SongPositionCallback fptr)`

## setHandleSongSelect

### Description
Registers a callback function to handle Song Select MIDI messages.

### Method
`setHandleSongSelect(SongSelectCallback fptr)`

## setHandleStart

### Description
Registers a callback function to handle MIDI Start messages.

### Method
`setHandleStart(StartCallback fptr)`

## setHandleStop

### Description
Registers a callback function to handle MIDI Stop messages.

### Method
`setHandleStop(StopCallback fptr)`

## setHandleSystemExclusive

### Description
Registers a callback function to handle System Exclusive (SysEx) MIDI messages.

### Method
`setHandleSystemExclusive(SystemExclusiveCallback fptr)`

## setHandleSystemReset

### Description
Registers a callback function to handle System Reset MIDI messages.

### Method
`setHandleSystemReset(SystemResetCallback fptr)`

## setHandleTick

### Description
Registers a callback function to handle MIDI Clock Tick messages.

### Method
`setHandleTick(TickCallback fptr)`

## setHandleTimeCodeQuarterFrame

### Description
Registers a callback function to handle Time Code Quarter Frame MIDI messages.

### Method
`setHandleTimeCodeQuarterFrame(TimeCodeQuarterFrameCallback fptr)`

## setHandleTuneRequest

### Description
Registers a callback function to handle Tune Request MIDI messages.

### Method
`setHandleTuneRequest(TuneRequestCallback fptr)`
```

--------------------------------

### getSysExArrayLength()

Source: https://fortyseveneffects.github.io/arduino_midi_library/functions.html

Gets the number of bytes in the current System Exclusive (SysEx) message.

```APIDOC
## getSysExArrayLength()

### Description
Gets the number of bytes in the current System Exclusive (SysEx) message.

### Method
`MidiInterface< Transport, _Settings, _Platform >::getSysExArrayLength()`
```

--------------------------------

### getFilterMode()

Source: https://fortyseveneffects.github.io/arduino_midi_library/functions.html

Gets the current filter mode, which determines which MIDI messages are processed.

```APIDOC
## getFilterMode()

### Description
Gets the current filter mode, which determines which MIDI messages are processed.

### Method
`MidiInterface< Transport, _Settings, _Platform >::getFilterMode()`
```

--------------------------------

### BEGIN_MIDI_NAMESPACE

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00011_source.html

Opens the namespace for MIDI library components.

```APIDOC
## BEGIN_MIDI_NAMESPACE

### Description
This macro marks the beginning of the namespace used by the Arduino MIDI Library.

### Definition
`#define BEGIN_MIDI_NAMESPACE`

### File
midi_Namespace.h
```

--------------------------------

### MIDI_CREATE_DEFAULT_INSTANCE

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00023.html

Creates an instance of the library with default name, serial port, and settings. This is useful for compatibility with older sketches or when custom configurations are not needed.

```APIDOC
## Macro Definition Documentation
## ◆ MIDI_CREATE_DEFAULT_INSTANCE
#define MIDI_CREATE_DEFAULT_INSTANCE | ( | | ) |  MIDI_CREATE_INSTANCE(HardwareSerial, Serial, MIDI);
---|---|---|---|---
Create an instance of the library with default name, serial port and settings, for compatibility with sketches written with pre-v4.2 MIDI Lib, or if you don't bother using custom names, serial port or settings. 
Definition at line 113 of file serialMIDI.h.
```

--------------------------------

### Get Thru Filter Mode

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00005_source.html

Retrieves the current Thru filter mode setting.

```C++
template<class Transport, class Settings, class Platform>
inline Thru::Mode MidiInterface<Transport, Settings, Platform>::getFilterMode() const
{
return mThruFilterMode;
}
```

--------------------------------

### Get MIDI Message Properties

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00002_source.html

Retrieves properties of the currently read MIDI message.

```APIDOC
## getType

### Description
Gets the type of the current MIDI message.

### Method
`inline MidiType getType() const`

### Returns
`MidiType` - The type of the MIDI message.
```

```APIDOC
## getChannel

### Description
Gets the channel of the current MIDI message.

### Method
`inline Channel getChannel() const`

### Returns
`Channel` - The MIDI channel of the message.
```

```APIDOC
## getData1

### Description
Gets the first data byte of the current MIDI message.

### Method
`inline DataByte getData1() const`

### Returns
`DataByte` - The first data byte.
```

```APIDOC
## getData2

### Description
Gets the second data byte of the current MIDI message.

### Method
`inline DataByte getData2() const`

### Returns
`DataByte` - The second data byte.
```

```APIDOC
## getSysExArray

### Description
Gets the byte array for a System Exclusive message.

### Method
`inline const byte* getSysExArray() const`

### Returns
`const byte*` - Pointer to the System Exclusive data.
```

```APIDOC
## getSysExArrayLength

### Description
Gets the length of the System Exclusive message byte array.

### Method
`inline unsigned getSysExArrayLength() const`

### Returns
`unsigned` - The length of the System Exclusive data.
```

```APIDOC
## check

### Description
Checks if the current MIDI message is valid.

### Method
`inline bool check() const`

### Returns
`bool` - True if the message is valid, false otherwise.
```

--------------------------------

### Create MIDI Instance with Serial Port

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00023.html

Use this macro to create a MIDI library instance connected to a serial port. You can then use standard MIDI methods like begin(), read(), etc. on the created instance.

```c++
#define MIDI_CREATE_INSTANCE | ( |  | Type,   
---|---|---|---
|  |  | SerialPort,   
|  |  | Name   
| ) | |   
**Value:**
MIDI_NAMESPACE::SerialMIDI<Type> serial##Name(SerialPort);
MIDI_NAMESPACE::MidiInterface<MIDI_NAMESPACE::SerialMIDI<Type>> Name((MIDI_NAMESPACE::SerialMIDI<Type>&)serial##Name);
```

```c++
MIDI_CREATE_INSTANCE(HardwareSerial, Serial2, midi2);
```

--------------------------------

### MidiInterface::getData2()

Source: https://fortyseveneffects.github.io/arduino_midi_library/a00033.html

Gets the second data byte of the last received MIDI message.

```APIDOC
## MidiInterface::getData2()

### Description
Get the second data byte of the last received message.

### Method
```cpp
DataByte getData2 () const
```

### Parameters
None

### Response
- **DataByte**: The second data byte of the last received message.
```
Tokens:
Raw