MIDI Output

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

Detailed Description

Function Documentation

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 543 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;
    }
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 463 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;
    }
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 609 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 529 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 134 of file MIDI.hpp.

{
    // Then test if channel is valid
    if (inChannel >= MIDI_CHANNEL_OFF  ||
        inChannel == MIDI_CHANNEL_OMNI ||
        inType < 0x80)
    {
        return; // Don't send anything
    }

    if (inType <= PitchBend)  // Channel messages
    {
        // Protection: remove MSBs on data
        inData1 &= 0x7f;
        inData2 &= 0x7f;

        const StatusByte status = getStatus(inType, inChannel);

        if (Settings::UseRunningStatus)
        {
            if (mRunningStatus_TX != status)
            {
                // New message, memorise and send header
                mRunningStatus_TX = status;
                mSerial.write(mRunningStatus_TX);
            }
        }
        else
        {
            // Don't care about running status, send the status byte.
            mSerial.write(status);
        }

        // Then send data
        mSerial.write(inData1);
        if (inType != ProgramChange && inType != AfterTouchChannel)
        {
            mSerial.write(inData2);
        }
    }
    else if (inType >= Clock && inType <= SystemReset)
    {
        sendRealTime(inType); // System Real-time and 1 byte.
    }
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 266 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 279 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 239 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 214 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 195 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

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

inline

Definition at line 598 of file MIDI.hpp.

{
    sendControlChange(DataDecrement, inAmount, inChannel);
}

template<class SerialPort , class Settings >

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

inline

Definition at line 588 of file MIDI.hpp.

{
    sendControlChange(DataIncrement, inAmount, inChannel);
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 561 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 576 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 293 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 308 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);
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 254 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 226 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 437 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:
            mSerial.write((byte)inType);
            break;
        default:
            // Invalid Real Time marker
            break;
    }
}

template<class SerialPort , class Settings >

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

inline

Definition at line 518 of file MIDI.hpp.

{
    sendControlChange(DataDecrement, inAmount, inChannel);
}

template<class SerialPort , class Settings >

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

inline

Definition at line 508 of file MIDI.hpp.

{
    sendControlChange(DataIncrement, inAmount, inChannel);
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 481 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 496 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 405 of file MIDI.hpp.

{
    mSerial.write((byte)SongPosition);
    mSerial.write(inBeats & 0x7f);
    mSerial.write((inBeats >> 7) & 0x7f);

    if (Settings::UseRunningStatus)
    {
        mRunningStatus_TX = InvalidType;
    }
}

template<class SerialPort , class Settings >

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

inline

Send a Song Select message.

Definition at line 419 of file MIDI.hpp.

{
    mSerial.write((byte)SongSelect);
    mSerial.write(inSongNumber & 0x7f);

    if (Settings::UseRunningStatus)
    {
        mRunningStatus_TX = InvalidType;
    }
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 326 of file MIDI.hpp.

{
    const bool writeBeginEndBytes = !inArrayContainsBoundaries;

    if (writeBeginEndBytes)
    {
        mSerial.write(0xf0);
    }

    for (unsigned i = 0; i < inLength; ++i)
    {
        mSerial.write(inArray[i]);
    }

    if (writeBeginEndBytes)
    {
        mSerial.write(0xf7);
    }

    if (Settings::UseRunningStatus)
    {
        mRunningStatus_TX = InvalidType;
    }
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 376 of file MIDI.hpp.

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

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 390 of file MIDI.hpp.

{
    mSerial.write((byte)TimeCodeQuarterFrame);
    mSerial.write(inData);

    if (Settings::UseRunningStatus)
    {
        mRunningStatus_TX = InvalidType;
    }
}

template<class SerialPort , class Settings >

void MidiInterface< SerialPort, Settings >::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 359 of file MIDI.hpp.

{
    mSerial.write(TuneRequest);

    if (Settings::UseRunningStatus)
    {
        mRunningStatus_TX = InvalidType;
    }
}