MIDI Output

Functions
void	MidiInterface< Transport, _Settings, _Platform >::send (const MidiMessage &)
	Send a MIDI message. More...
void	MidiInterface< Transport, _Settings, _Platform >::send (MidiType inType, DataByte inData1, DataByte inData2, Channel inChannel)
	Generate and send a MIDI message from the values given. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendNoteOn (DataByte inNoteNumber, DataByte inVelocity, Channel inChannel)
	Send a Note On message. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendNoteOff (DataByte inNoteNumber, DataByte inVelocity, Channel inChannel)
	Send a Note Off message. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendProgramChange (DataByte inProgramNumber, Channel inChannel)
	Send a Program Change message. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendControlChange (DataByte inControlNumber, DataByte inControlValue, Channel inChannel)
	Send a Control Change message. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendPolyPressure (DataByte inNoteNumber, DataByte inPressure, Channel inChannel) __attribute__((deprecated))
	Send a Polyphonic AfterTouch message (applies to a specified note) More...
void	MidiInterface< Transport, _Settings, _Platform >::sendAfterTouch (DataByte inPressure, Channel inChannel)
	Send a MonoPhonic AfterTouch message (applies to all notes) More...
void	MidiInterface< Transport, _Settings, _Platform >::sendAfterTouch (DataByte inNoteNumber, DataByte inPressure, Channel inChannel)
	Send a Polyphonic AfterTouch message (applies to a specified note) More...
void	MidiInterface< Transport, _Settings, _Platform >::sendPitchBend (int inPitchValue, Channel inChannel)
	Send a Pitch Bend message using a signed integer value. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendPitchBend (double inPitchValue, Channel inChannel)
	Send a Pitch Bend message using a floating point value. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendSysEx (unsigned inLength, const byte *inArray, bool inArrayContainsBoundaries=false)
	Generate and send a System Exclusive frame. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendTuneRequest ()
	Send a Tune Request message. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendTimeCodeQuarterFrame (DataByte inTypeNibble, DataByte inValuesNibble)
	Send a MIDI Time Code Quarter Frame. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendTimeCodeQuarterFrame (DataByte inData)
	Send a MIDI Time Code Quarter Frame. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendSongPosition (unsigned inBeats)
	Send a Song Position Pointer message. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendSongSelect (DataByte inSongNumber)
	Send a Song Select message. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendCommon (MidiType inType, unsigned=0)
	Send a Common message. Common messages reset the running status. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendRealTime (MidiType inType)
	Send a Real Time (one byte) message. More...
void	MidiInterface< Transport, _Settings, _Platform >::beginRpn (unsigned inNumber, Channel inChannel)
	Start a Registered Parameter Number frame. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendRpnValue (unsigned inValue, Channel inChannel)
	Send a 14-bit value for the currently selected RPN number. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendRpnValue (byte inMsb, byte inLsb, Channel inChannel)
	Send separate MSB/LSB values for the currently selected RPN number. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendRpnIncrement (byte inAmount, Channel inChannel)
void	MidiInterface< Transport, _Settings, _Platform >::sendRpnDecrement (byte inAmount, Channel inChannel)
void	MidiInterface< Transport, _Settings, _Platform >::endRpn (Channel inChannel)
	Terminate an RPN frame. This will send a Null Function to deselect the currently selected RPN. More...
void	MidiInterface< Transport, _Settings, _Platform >::beginNrpn (unsigned inNumber, Channel inChannel)
	Start a Non-Registered Parameter Number frame. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendNrpnValue (unsigned inValue, Channel inChannel)
	Send a 14-bit value for the currently selected NRPN number. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendNrpnValue (byte inMsb, byte inLsb, Channel inChannel)
	Send separate MSB/LSB values for the currently selected NRPN number. More...
void	MidiInterface< Transport, _Settings, _Platform >::sendNrpnIncrement (byte inAmount, Channel inChannel)
void	MidiInterface< Transport, _Settings, _Platform >::sendNrpnDecrement (byte inAmount, Channel inChannel)
void	MidiInterface< Transport, _Settings, _Platform >::endNrpn (Channel inChannel)
	Terminate an NRPN frame. This will send a Null Function to deselect the currently selected NRPN. More...

Detailed Description

Function Documentation

beginNrpn()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::beginNrpn ( unsigned  inNumber, Channel  inChannel  )

inline

Start a Non-Registered Parameter Number frame.

Parameters

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

Definition at line 603 of file MIDI.hpp.

{
    if (mCurrentNrpnNumber != inNumber)
    {
        const byte numMsb = 0x7f & (inNumber >> 7);
        const byte numLsb = 0x7f & inNumber;
        sendControlChange(NRPNLSB, numLsb, inChannel);
        sendControlChange(NRPNMSB, numMsb, inChannel);
        mCurrentNrpnNumber = inNumber;
    }
}

beginRpn()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::beginRpn ( unsigned  inNumber, Channel  inChannel  )

inline

Start a Registered Parameter Number frame.

Parameters

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

Definition at line 523 of file MIDI.hpp.

{
    if (mCurrentRpnNumber != inNumber)
    {
        const byte numMsb = 0x7f & (inNumber >> 7);
        const byte numLsb = 0x7f & inNumber;
        sendControlChange(RPNLSB, numLsb, inChannel);
        sendControlChange(RPNMSB, numMsb, inChannel);
        mCurrentRpnNumber = inNumber;
    }
}

endNrpn()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::endNrpn ( Channel  inChannel )

inline

Terminate an NRPN frame. This will send a Null Function to deselect the currently selected NRPN.

Parameters

inChannel

The channel on which the message will be sent (1 to 16).

Definition at line 669 of file MIDI.hpp.

{
    sendControlChange(NRPNLSB, 0x7f, inChannel);
    sendControlChange(NRPNMSB, 0x7f, inChannel);
    mCurrentNrpnNumber = 0xffff;
}

endRpn()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::endRpn ( Channel  inChannel )

inline

Terminate an RPN frame. This will send a Null Function to deselect the currently selected RPN.

Parameters

inChannel

The channel on which the message will be sent (1 to 16).

Definition at line 589 of file MIDI.hpp.

{
    sendControlChange(RPNLSB, 0x7f, inChannel);
    sendControlChange(RPNMSB, 0x7f, inChannel);
    mCurrentRpnNumber = 0xffff;
}

send() [1/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::send ( const MidiMessage &  inMessage )

inline

Send a MIDI message.

Parameters

inMessage

The message

This method is used when you want to send a Message that has not been constructed by the library, but by an external source. This method does not check against any of the constraints. Typically this function is use by MIDI Bridges taking MIDI messages and passing them thru.

Definition at line 118 of file MIDI.hpp.

{
    if (!inMessage.valid)
        return;
 
    if (mTransport.beginTransmission(inMessage.type))
    {
        const StatusByte status = getStatus(inMessage.type, inMessage.channel);
        mTransport.write(status);
 
        if (inMessage.type != MidiType::SystemExclusive)
        {
            if (inMessage.length > 1) mTransport.write(inMessage.data1);
            if (inMessage.length > 2) mTransport.write(inMessage.data2);
        } else
        {
            // sysexArray does not contain the start and end tags
            mTransport.write(MidiType::SystemExclusiveStart);
 
            for (size_t i = 0; i < inMessage.getSysExSize(); i++)
                mTransport.write(inMessage.sysexArray[i]);
 
            mTransport.write(MidiType::SystemExclusiveEnd);
        }
    }
    mTransport.endTransmission();
    UpdateLastSentTime();
}

send() [2/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::send	(	MidiType	inType,
		DataByte	inData1,
		DataByte	inData2,
		Channel	inChannel
	)

Generate and send a MIDI message from the values given.

Parameters

inType	The message type (see type defines for reference)
inData1	The first data byte.
inData2	The second data byte (if the message contains only 1 data byte, set this one to 0).
inChannel	The output channel on which the message will be sent (values from 1 to 16). Note: you cannot send to OMNI.

This is an internal method, use it only if you need to send raw data from your code, at your own risks.

Definition at line 160 of file MIDI.hpp.

{
    if (inType <= PitchBend)  // Channel messages
    {
        // Then test if channel is valid
        if (inChannel >= MIDI_CHANNEL_OFF  ||
            inChannel == MIDI_CHANNEL_OMNI ||
            inType < 0x80)
        {
            return; // Don't send anything
        }
        // Protection: remove MSBs on data
        inData1 &= 0x7f;
        inData2 &= 0x7f;
 
        const StatusByte status = getStatus(inType, inChannel);
 
        if (mTransport.beginTransmission(inType))
        {
            if (Settings::UseRunningStatus)
            {
                if (mRunningStatus_TX != status)
                {
                    // New message, memorise and send header
                    mRunningStatus_TX = status;
                    mTransport.write(mRunningStatus_TX);
                }
            }
            else
            {
                // Don't care about running status, send the status byte.
                mTransport.write(status);
            }
 
            // Then send data
            mTransport.write(inData1);
            if (inType != ProgramChange && inType != AfterTouchChannel)
            {
                mTransport.write(inData2);
            }
 
            mTransport.endTransmission();
            UpdateLastSentTime();
        }
    }
    else if (inType >= Clock && inType <= SystemReset)
    {
        sendRealTime(inType); // System Real-time and 1 byte.
    }
}

sendAfterTouch() [1/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendAfterTouch ( DataByte  inNoteNumber, DataByte  inPressure, Channel  inChannel  )

inline

Send a Polyphonic AfterTouch message (applies to a specified note)

Parameters

inNoteNumber	The note to apply AfterTouch to (0 to 127).
inPressure	The amount of AfterTouch to apply (0 to 127).
inChannel	The channel on which the message will be sent (1 to 16).

See also

Replaces sendPolyPressure (which is now deprecated).

Definition at line 310 of file MIDI.hpp.

{
    send(AfterTouchPoly, inNoteNumber, inPressure, inChannel);
}

sendAfterTouch() [2/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendAfterTouch ( DataByte  inPressure, Channel  inChannel  )

inline

Send a MonoPhonic AfterTouch message (applies to all notes)

Parameters

inPressure	The amount of AfterTouch to apply to all notes.
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 297 of file MIDI.hpp.

{
    send(AfterTouchChannel, inPressure, 0, inChannel);
}

sendCommon()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendCommon ( MidiType  inType, unsigned  inData1 = 0  )

inline

Send a Common message. Common messages reset the running status.

Parameters

inType

The available Common types are: TimeCodeQuarterFrame, SongPosition, SongSelect and TuneRequest.

See also

MidiType

Parameters

inData1

The byte that goes with the common message.

Definition at line 443 of file MIDI.hpp.

{
    switch (inType)
    {
        case TimeCodeQuarterFrame:
        case SongPosition:
        case SongSelect:
        case TuneRequest:
            break;
        default:
            // Invalid Common marker
            return;
    }
 
    if (mTransport.beginTransmission(inType))
    {
            mTransport.write((byte)inType);
            switch (inType)
            {
            case TimeCodeQuarterFrame:
                mTransport.write(inData1);
                break;
            case SongPosition:
                mTransport.write(inData1 & 0x7f);
                mTransport.write((inData1 >> 7) & 0x7f);
                break;
            case SongSelect:
                mTransport.write(inData1 & 0x7f);
                break;
            case TuneRequest:
                break;
            default:
                break; // LCOV_EXCL_LINE - Coverage blind spot
        }
        mTransport.endTransmission();
        UpdateLastSentTime();
    }
 
    if (Settings::UseRunningStatus)
        mRunningStatus_TX = InvalidType;
}

sendControlChange()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendControlChange ( DataByte  inControlNumber, DataByte  inControlValue, Channel  inChannel  )

inline

Send a Control Change message.

Parameters

inControlNumber	The controller number (0 to 127).
inControlValue	The value for the specified controller (0 to 127).
inChannel	The channel on which the message will be sent (1 to 16).

See also

MidiControlChangeNumber

Definition at line 270 of file MIDI.hpp.

{
    send(ControlChange, inControlNumber, inControlValue, inChannel);
}

sendNoteOff()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendNoteOff ( DataByte  inNoteNumber, DataByte  inVelocity, Channel  inChannel  )

inline

Send a Note Off message.

Parameters

inNoteNumber	Pitch value in the MIDI format (0 to 127).
inVelocity	Release velocity (0 to 127).
inChannel	The channel on which the message will be sent (1 to 16).

Note: you can send NoteOn with zero velocity to make a NoteOff, this is based on the Running Status principle, to avoid sending status messages and thus sending only NoteOn data. sendNoteOff will always send a real NoteOff message. Take a look at the values, names and frequencies of notes here: http://www.phys.unsw.edu.au/jw/notes.html

Definition at line 245 of file MIDI.hpp.

{
    send(NoteOff, inNoteNumber, inVelocity, inChannel);
}

sendNoteOn()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendNoteOn ( DataByte  inNoteNumber, DataByte  inVelocity, Channel  inChannel  )

inline

Send a Note On message.

Parameters

inNoteNumber	Pitch value in the MIDI format (0 to 127).
inVelocity	Note attack velocity (0 to 127). A NoteOn with 0 velocity is considered as a NoteOff.
inChannel	The channel on which the message will be sent (1 to 16).

Take a look at the values, names and frequencies of notes here: http://www.phys.unsw.edu.au/jw/notes.html

Definition at line 226 of file MIDI.hpp.

{
    send(NoteOn, inNoteNumber, inVelocity, inChannel);
}

sendNrpnDecrement()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendNrpnDecrement ( byte  inAmount, Channel  inChannel  )

inline

Definition at line 658 of file MIDI.hpp.

{
    sendControlChange(DataDecrement, inAmount, inChannel);
}

sendNrpnIncrement()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendNrpnIncrement ( byte  inAmount, Channel  inChannel  )

inline

Definition at line 648 of file MIDI.hpp.

{
    sendControlChange(DataIncrement, inAmount, inChannel);
}

sendNrpnValue() [1/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendNrpnValue ( byte  inMsb, byte  inLsb, Channel  inChannel  )

inline

Send separate MSB/LSB values for the currently selected NRPN number.

Parameters

inMsb	The MSB part of the value to send. Meaning depends on NRPN number.
inLsb	The LSB part of the value to send. Meaning depends on NRPN number.
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 636 of file MIDI.hpp.

{
    sendControlChange(DataEntryMSB, inMsb, inChannel);
    sendControlChange(DataEntryLSB, inLsb, inChannel);
}

sendNrpnValue() [2/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendNrpnValue ( unsigned  inValue, Channel  inChannel  )

inline

Send a 14-bit value for the currently selected NRPN number.

Parameters

inValue	The 14-bit value of the selected NRPN.
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 621 of file MIDI.hpp.

{;
    const byte valMsb = 0x7f & (inValue >> 7);
    const byte valLsb = 0x7f & inValue;
    sendControlChange(DataEntryMSB, valMsb, inChannel);
    sendControlChange(DataEntryLSB, valLsb, inChannel);
}

sendPitchBend() [1/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendPitchBend ( double  inPitchValue, Channel  inChannel  )

inline

Send a Pitch Bend message using a floating point value.

Parameters

inPitchValue	The amount of bend to send (in a floating point format), between -1.0f (maximum downwards bend) and +1.0f (max upwards bend), center value is 0.0f.
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 339 of file MIDI.hpp.

{
    const int scale = inPitchValue > 0.0 ? MIDI_PITCHBEND_MAX : MIDI_PITCHBEND_MIN;
    const int value = int(inPitchValue * double(scale));
    sendPitchBend(value, inChannel);
}

sendPitchBend() [2/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendPitchBend ( int  inPitchValue, Channel  inChannel  )

inline

Send a Pitch Bend message using a signed integer value.

Parameters

inPitchValue	The amount of bend to send (in a signed integer format), between MIDI_PITCHBEND_MIN and MIDI_PITCHBEND_MAX, center value is 0.
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 324 of file MIDI.hpp.

{
    const unsigned bend = unsigned(inPitchValue - int(MIDI_PITCHBEND_MIN));
    send(PitchBend, (bend & 0x7f), (bend >> 7) & 0x7f, inChannel);
}

sendPolyPressure()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendPolyPressure ( DataByte  inNoteNumber, DataByte  inPressure, Channel  inChannel  )

inline

Send a Polyphonic AfterTouch message (applies to a specified note)

Parameters

inNoteNumber	The note to apply AfterTouch to (0 to 127).
inPressure	The amount of AfterTouch to apply (0 to 127).
inChannel	The channel on which the message will be sent (1 to 16). Note: this method is deprecated and will be removed in a future revision of the library,

See also

sendAfterTouch to send polyphonic and monophonic AfterTouch messages.

Definition at line 285 of file MIDI.hpp.

{
    send(AfterTouchPoly, inNoteNumber, inPressure, inChannel);
}

sendProgramChange()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendProgramChange ( DataByte  inProgramNumber, Channel  inChannel  )

inline

Send a Program Change message.

Parameters

inProgramNumber	The Program to select (0 to 127).
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 257 of file MIDI.hpp.

{
    send(ProgramChange, inProgramNumber, 0, inChannel);
}

sendRealTime()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendRealTime ( MidiType  inType )

inline

Send a Real Time (one byte) message.

Parameters

inType

The available Real Time types are: Start, Stop, Continue, Clock, ActiveSensing and SystemReset.

See also

MidiType

Definition at line 492 of file MIDI.hpp.

{
    // Do not invalidate Running Status for real-time messages
    // as they can be interleaved within any message.
 
    switch (inType)
    {
        case Clock:
        case Start:
        case Stop:
        case Continue:
        case ActiveSensing:
        case SystemReset:
            if (mTransport.beginTransmission(inType))
            {
                mTransport.write((byte)inType);
                mTransport.endTransmission();
                UpdateLastSentTime();
            }
            break;
        default:
            // Invalid Real Time marker
            break;
    }
}

sendRpnDecrement()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendRpnDecrement ( byte  inAmount, Channel  inChannel  )

inline

Definition at line 578 of file MIDI.hpp.

{
    sendControlChange(DataDecrement, inAmount, inChannel);
}

sendRpnIncrement()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendRpnIncrement ( byte  inAmount, Channel  inChannel  )

inline

Definition at line 568 of file MIDI.hpp.

{
    sendControlChange(DataIncrement, inAmount, inChannel);
}

sendRpnValue() [1/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendRpnValue ( byte  inMsb, byte  inLsb, Channel  inChannel  )

inline

Send separate MSB/LSB values for the currently selected RPN number.

Parameters

inMsb	The MSB part of the value to send. Meaning depends on RPN number.
inLsb	The LSB part of the value to send. Meaning depends on RPN number.
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 556 of file MIDI.hpp.

{
    sendControlChange(DataEntryMSB, inMsb, inChannel);
    sendControlChange(DataEntryLSB, inLsb, inChannel);
}

sendRpnValue() [2/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendRpnValue ( unsigned  inValue, Channel  inChannel  )

inline

Send a 14-bit value for the currently selected RPN number.

Parameters

inValue	The 14-bit value of the selected RPN.
inChannel	The channel on which the message will be sent (1 to 16).

Definition at line 541 of file MIDI.hpp.

{;
    const byte valMsb = 0x7f & (inValue >> 7);
    const byte valLsb = 0x7f & inValue;
    sendControlChange(DataEntryMSB, valMsb, inChannel);
    sendControlChange(DataEntryLSB, valLsb, inChannel);
}

sendSongPosition()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendSongPosition ( unsigned  inBeats )

inline

Send a Song Position Pointer message.

Parameters

inBeats

The number of beats since the start of the song.

Definition at line 423 of file MIDI.hpp.

{
    sendCommon(SongPosition, inBeats);
}

sendSongSelect()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendSongSelect ( DataByte  inSongNumber )

inline

Send a Song Select message.

Definition at line 430 of file MIDI.hpp.

{
    sendCommon(SongSelect, inSongNumber);
}

sendSysEx()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendSysEx ( unsigned  inLength, const byte *  inArray, bool  inArrayContainsBoundaries = false  )

inline

Generate and send a System Exclusive frame.

Parameters

inLength	The size of the array to send
inArray	The byte array containing the data to send
inArrayContainsBoundaries	When set to 'true', 0xf0 & 0xf7 bytes (start & stop SysEx) will NOT be sent (and therefore must be included in the array). default value for ArrayContainsBoundaries is set to 'false' for compatibility with previous versions of the library.

Definition at line 357 of file MIDI.hpp.

{
    const bool writeBeginEndBytes = !inArrayContainsBoundaries;
 
    if (mTransport.beginTransmission(MidiType::SystemExclusiveStart))
    {
        if (writeBeginEndBytes)
            mTransport.write(MidiType::SystemExclusiveStart);
 
        for (unsigned i = 0; i < inLength; ++i)
            mTransport.write(inArray[i]);
 
        if (writeBeginEndBytes)
            mTransport.write(MidiType::SystemExclusiveEnd);
 
        mTransport.endTransmission();
        UpdateLastSentTime();
   }
 
    if (Settings::UseRunningStatus)
        mRunningStatus_TX = InvalidType;
}

sendTimeCodeQuarterFrame() [1/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendTimeCodeQuarterFrame ( DataByte  inData )

inline

Send a MIDI Time Code Quarter Frame.

See MIDI Specification for more information.

Parameters

inData

if you want to encode directly the nibbles in your program, you can send the byte here.

Definition at line 414 of file MIDI.hpp.

{
    sendCommon(TimeCodeQuarterFrame, inData);
}

sendTimeCodeQuarterFrame() [2/2]

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendTimeCodeQuarterFrame ( DataByte  inTypeNibble, DataByte  inValuesNibble  )

inline

Send a MIDI Time Code Quarter Frame.

Parameters

inTypeNibble	MTC type
inValuesNibble	MTC data See MIDI Specification for more information.

Definition at line 400 of file MIDI.hpp.

{
    const byte data = byte((((inTypeNibble & 0x07) << 4) | (inValuesNibble & 0x0f)));
    sendTimeCodeQuarterFrame(data);
}

sendTuneRequest()

template<class Transport , class Settings , class Platform >

void MidiInterface< Transport, Settings, Platform >::sendTuneRequest

inline

Send a Tune Request message.

When a MIDI unit receives this message, it should tune its oscillators (if equipped with any).

Definition at line 388 of file MIDI.hpp.

{
    sendCommon(TuneRequest);
}