MIDI Input

Modules
	Callbacks

Functions
bool	MidiInterface< Transport, _Settings, _Platform >::read ()
	Read messages from the serial port using the main input channel. More...
bool	MidiInterface< Transport, _Settings, _Platform >::read (Channel inChannel)
	Read messages on a specified channel. More...
MidiType	MidiInterface< Transport, _Settings, _Platform >::getType () const
	Get the last received message's type. More...
Channel	MidiInterface< Transport, _Settings, _Platform >::getChannel () const
	Get the channel of the message stored in the structure. More...
DataByte	MidiInterface< Transport, _Settings, _Platform >::getData1 () const
	Get the first data byte of the last received message. More...
DataByte	MidiInterface< Transport, _Settings, _Platform >::getData2 () const
	Get the second data byte of the last received message. More...
const byte *	MidiInterface< Transport, _Settings, _Platform >::getSysExArray () const
	Get the System Exclusive byte array. More...
unsigned	MidiInterface< Transport, _Settings, _Platform >::getSysExArrayLength () const
	Get the length of the System Exclusive array. More...
bool	MidiInterface< Transport, _Settings, _Platform >::check () const
	Check if a valid message is stored in the structure. More...
Channel	MidiInterface< Transport, _Settings, _Platform >::getInputChannel () const
void	MidiInterface< Transport, _Settings, _Platform >::setInputChannel (Channel inChannel)
	Set the value for the input MIDI channel. More...
static MidiType	MidiInterface< Transport, _Settings, _Platform >::getTypeFromStatusByte (byte inStatus)
	Extract an enumerated MIDI type from a status byte. More...
static Channel	MidiInterface< Transport, _Settings, _Platform >::getChannelFromStatusByte (byte inStatus)
	Returns channel in the range 1-16. More...
static bool	MidiInterface< Transport, _Settings, _Platform >::isChannelMessage (MidiType inType)
void	MidiInterface< Transport, _Settings, _Platform >::disconnectCallbackFromType (MidiType inType)
	Detach an external function from the given type. More...

Detailed Description

Function Documentation

check()

template<class Transport , class Settings , class Platform >

bool MidiInterface< Transport, Settings, Platform >::check

inline

Check if a valid message is stored in the structure.

Definition at line 1187 of file MIDI.hpp.

{
    return mMessage.valid;
}

disconnectCallbackFromType()

template<class Transport , class Settings , class Platform >

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

inline

Detach an external function from the given type.

Use this method to cancel the effects of setHandle********.

Parameters

inType

The type of message to unbind. When a message of this type is received, no function will be called.

Definition at line 1262 of file MIDI.hpp.

{
    switch (inType)
    {
        case NoteOff:               mNoteOffCallback                = nullptr; break;
        case NoteOn:                mNoteOnCallback                 = nullptr; break;
        case AfterTouchPoly:        mAfterTouchPolyCallback         = nullptr; break;
        case ControlChange:         mControlChangeCallback          = nullptr; break;
        case ProgramChange:         mProgramChangeCallback          = nullptr; break;
        case AfterTouchChannel:     mAfterTouchChannelCallback      = nullptr; break;
        case PitchBend:             mPitchBendCallback              = nullptr; break;
        case SystemExclusive:       mSystemExclusiveCallback        = nullptr; break;
        case TimeCodeQuarterFrame:  mTimeCodeQuarterFrameCallback   = nullptr; break;
        case SongPosition:          mSongPositionCallback           = nullptr; break;
        case SongSelect:            mSongSelectCallback             = nullptr; break;
        case TuneRequest:           mTuneRequestCallback            = nullptr; break;
        case Clock:                 mClockCallback                  = nullptr; break;
        case Start:                 mStartCallback                  = nullptr; break;
        case Tick:                  mTickCallback                   = nullptr; break;
        case Continue:              mContinueCallback               = nullptr; break;
        case Stop:                  mStopCallback                   = nullptr; break;
        case ActiveSensing:         mActiveSensingCallback          = nullptr; break;
        case SystemReset:           mSystemResetCallback            = nullptr; break;
        default:
            break;
    }
}

getChannel()

template<class Transport , class Settings , class Platform >

Channel MidiInterface< Transport, Settings, Platform >::getChannel

inline

Get the channel of the message stored in the structure.

Returns

Channel range is 1 to 16. For non-channel messages, this will return 0.

Definition at line 1145 of file MIDI.hpp.

{
    return mMessage.channel;
}

getChannelFromStatusByte()

template<class Transport , class Settings , class Platform >

Channel MidiInterface< Transport, Settings, Platform >::getChannelFromStatusByte ( byte  inStatus )

inlinestatic

Returns channel in the range 1-16.

Definition at line 1236 of file MIDI.hpp.

{
    return Channel((inStatus & 0x0f) + 1);
}

getData1()

template<class Transport , class Settings , class Platform >

DataByte MidiInterface< Transport, Settings, Platform >::getData1

inline

Get the first data byte of the last received message.

Definition at line 1152 of file MIDI.hpp.

{
    return mMessage.data1;
}

getData2()

template<class Transport , class Settings , class Platform >

DataByte MidiInterface< Transport, Settings, Platform >::getData2

inline

Get the second data byte of the last received message.

Definition at line 1159 of file MIDI.hpp.

{
    return mMessage.data2;
}

getInputChannel()

template<class Transport , class Settings , class Platform >

Channel MidiInterface< Transport, Settings, Platform >::getInputChannel

inline

Definition at line 1195 of file MIDI.hpp.

{
    return mInputChannel;
}

getSysExArray()

template<class Transport , class Settings , class Platform >

const byte * MidiInterface< Transport, Settings, Platform >::getSysExArray

inline

Get the System Exclusive byte array.

See also

getSysExArrayLength to get the array's length in bytes.

Definition at line 1169 of file MIDI.hpp.

{
    return mMessage.sysexArray;
}

getSysExArrayLength()

template<class Transport , class Settings , class Platform >

unsigned MidiInterface< Transport, Settings, Platform >::getSysExArrayLength

inline

Get the length of the System Exclusive array.

It is coded using data1 as LSB and data2 as MSB.

Returns

The array's length, in bytes.

Definition at line 1180 of file MIDI.hpp.

{
    return mMessage.getSysExSize();
}

getType()

template<class Transport , class Settings , class Platform >

MidiType MidiInterface< Transport, Settings, Platform >::getType

inline

Get the last received message's type.

Returns an enumerated type.

See also

MidiType

Definition at line 1134 of file MIDI.hpp.

{
    return mMessage.type;
}

getTypeFromStatusByte()

template<class Transport , class Settings , class Platform >

MidiType MidiInterface< Transport, Settings, Platform >::getTypeFromStatusByte ( byte  inStatus )

inlinestatic

Extract an enumerated MIDI type from a status byte.

This is a utility static method, used internally, made public so you can handle MidiTypes more easily.

Definition at line 1218 of file MIDI.hpp.

{
    if ((inStatus  < 0x80) ||
        (inStatus == Undefined_F4) ||
        (inStatus == Undefined_F5) ||
        (inStatus == Undefined_FD))
        return InvalidType; // Data bytes and undefined.
 
    if (inStatus < 0xf0)
        // Channel message, remove channel nibble.
        return MidiType(inStatus & 0xf0);
 
    return MidiType(inStatus);
}

isChannelMessage()

template<class Transport , class Settings , class Platform >

bool MidiInterface< Transport, Settings, Platform >::isChannelMessage ( MidiType  inType )

inlinestatic

Definition at line 1242 of file MIDI.hpp.

{
    return (inType == NoteOff           ||
            inType == NoteOn            ||
            inType == ControlChange     ||
            inType == AfterTouchPoly    ||
            inType == AfterTouchChannel ||
            inType == PitchBend         ||
            inType == ProgramChange);
}

read() [1/2]

template<class Transport , class Settings , class Platform >

bool MidiInterface< Transport, Settings, Platform >::read

inline

Read messages from the serial port using the main input channel.

Returns

True if a valid message has been stored in the structure, false if not. A valid message is a message that matches the input channel.

If the Thru is enabled and the message matches the filter, it is sent back on the MIDI output.

See also

see setInputChannel()

Definition at line 704 of file MIDI.hpp.

{
    return read(mInputChannel);
}

read() [2/2]

template<class Transport , class Settings , class Platform >

bool MidiInterface< Transport, Settings, Platform >::read ( Channel  inChannel )

inline

Read messages on a specified channel.

Definition at line 712 of file MIDI.hpp.

{
    #ifndef RegionActiveSending
    // Active Sensing. This message is intended to be sent
    // repeatedly to tell the receiver that a connection is alive. Use
    // of this message is optional. When initially received, the
    // receiver will expect to receive another Active Sensing
    // message each 300ms (max), and if it does not then it will
    // assume that the connection has been terminated. At
    // termination, the receiver will turn off all voices and return to
    // normal (non- active sensing) operation.
    if (Settings::UseSenderActiveSensing && (mSenderActiveSensingPeriodicity > 0) && (Platform::now() - mLastMessageSentTime) > mSenderActiveSensingPeriodicity)
    {
        sendActiveSensing();
        mLastMessageSentTime = Platform::now();
    }
 
    if (Settings::UseReceiverActiveSensing && mReceiverActiveSensingActivated && (mLastMessageReceivedTime + ActiveSensingTimeout < Platform::now()))
    {
        mReceiverActiveSensingActivated = false;
 
        mLastError |= 1UL << ErrorActiveSensingTimeout; // set the ErrorActiveSensingTimeout bit
        if (mErrorCallback)
            mErrorCallback(mLastError);
    }
    #endif
 
    if (inChannel >= MIDI_CHANNEL_OFF)
        return false; // MIDI Input disabled.
 
    if (!parse())
        return false;
 
    #ifndef RegionActiveSending
 
    if (Settings::UseReceiverActiveSensing && mMessage.type == ActiveSensing)
    {
        // When an ActiveSensing message is received, the time keeping is activated.
        // When a timeout occurs, an error message is send and time keeping ends.
        mReceiverActiveSensingActivated = true;
 
        // is ErrorActiveSensingTimeout bit in mLastError on
        if (mLastError & (1 << (ErrorActiveSensingTimeout - 1)))
        {
            mLastError &= ~(1UL << ErrorActiveSensingTimeout); // clear the ErrorActiveSensingTimeout bit
            if (mErrorCallback)
                mErrorCallback(mLastError);
        }
    }
 
    // Keep the time of the last received message, so we can check for the timeout
    if (Settings::UseReceiverActiveSensing && mReceiverActiveSensingActivated)
        mLastMessageReceivedTime = Platform::now();
 
    #endif
 
    handleNullVelocityNoteOnAsNoteOff();
 
    const bool channelMatch = inputFilter(inChannel);
    if (channelMatch)
        launchCallback();
 
    thruFilter(inChannel);
 
    return channelMatch;
}

setInputChannel()

template<class Transport , class Settings , class Platform >

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

inline

Set the value for the input MIDI channel.

Parameters

inChannel

the channel value. Valid values are 1 to 16, MIDI_CHANNEL_OMNI if you want to listen to all channels, and MIDI_CHANNEL_OFF to disable input.

Definition at line 1205 of file MIDI.hpp.

{
    mInputChannel = inChannel;
}