/Users/franky/DIY/Arduino/Arduino.app/Contents/Resources/Java/hardware/libraries/MIDI/MIDI.cpp

Go to the documentation of this file.

/*
 MIDI.cpp - Library for Arduino MIDI I/O communications.
 Created by Francois Best, January 2, 2009.
 Released into the public domain.
 Last update:   10/06/2009
*/ 


#ifdef __AVR_ATmega644P__
#undef UART
#define UART Serial1
#else

#undef UART
#define UART Serial
#endif



#include <inttypes.h> 
#include <stdlib.h>
#include "WConstants.h" 
#include "MIDI.h"

#include "HardwareSerial.h"
#define Channel_Refused 0

MIDI_Class MIDI;


MIDI_Class::MIDI_Class() { }
MIDI_Class::~MIDI_Class() { }


void MIDI_Class::begin(byte inChannel) {
        // All default values loaded
        UART.begin(MIDI_rate);                          
        delMsg();
        sysex_ID = MANUFACTURER_ID_H;                                           // Default ID = non commercial
        mInputChannel = inChannel;
        mThruActivated = true;
        mFilterMode = MIDI_FILTER_FULL;
        mRunningStatus_TX = Channel_Refused;
        mRunningStatus_RX = Channel_Refused;
        return;
}

byte MIDI_Class::genctrl(byte canal, byte type) {
        byte result = 128;
        result += ((type & 0x07)<<4) & 0x70;
        result += ((canal-1) & 0x0F);
        return result;
}


void MIDI_Class::send(byte type, byte data1, byte data2, byte channel) {
        //if (channel > 16) return; // Not cool, but handled by MIDI_CHANNEL_OFF
        data1 &= 0x7F;
        data2 &= 0x7F;
        if (channel >= MIDI_CHANNEL_OFF) {
                mRunningStatus_TX = Channel_Refused;
                return; // Don't send anything
        }
        if (mRunningStatus_TX == genctrl(channel,type)) {
                // Send only data bytes
                if (type == PC || type == ATCanal) {
                        UART.print(data1, BYTE);
                }
                else if (type == SysEx) {
                        // Use sendSysEx...
                }
                else {
                        UART.print(data1, BYTE);
                        UART.print(data2, BYTE);
                }
        }
        else {
                // New message
                if (type == PC || type == ATCanal) {
                        UART.print(genctrl(channel,type), BYTE);
                        UART.print(data1, BYTE);
                }
                else if (type == SysEx) {
                        UART.print(genctrl(channel,type));
                }
                else {
                        UART.print(genctrl(channel,type), BYTE);
                        UART.print(data1, BYTE);
                        UART.print(data2, BYTE);
                }
                mRunningStatus_TX = genctrl(channel,type);
        }
        return;
}

void MIDI_Class::sendNoteOn(byte NoteNumber,byte Velocity,byte Channel) { send(NoteOn,NoteNumber,Velocity,Channel); }
void MIDI_Class::sendNoteOff(byte NoteNumber,byte Velocity,byte Channel) { send(NoteOff,NoteNumber,Velocity,Channel); }
void MIDI_Class::sendProgramChange(byte ProgramNumber,byte Channel) { send(PC,ProgramNumber,0,Channel); }
void MIDI_Class::sendControlChange(byte ControlNumber, byte ControlValue,byte Channel) { send(CC,ControlNumber,ControlValue,Channel); }
void MIDI_Class::sendPolyPressure(byte NoteNumber,byte Pressure,byte Channel) { send(ATPoly,NoteNumber,Pressure,Channel); }
void MIDI_Class::sendAfterTouch(byte Pressure,byte Channel) { send(ATCanal,Pressure,0,Channel); }
void MIDI_Class::sendSysEx(byte length, byte * array) {
        UART.print(0xF0,BYTE);
        for (byte i=0;i<length;i++) UART.print(array[i],BYTE);
        UART.print(0xF7,BYTE);
}
/* Getters */
byte MIDI_Class::getType() { return mMessage.type; }
byte MIDI_Class::getChannel() { return mMessage.channel; }
byte MIDI_Class::getData1() { return mMessage.data1; }
byte MIDI_Class::getData2() { return mMessage.data2; }
byte * MIDI_Class::getSysExArray() { return mMessage.sysex_array; }
bool MIDI_Class::check() { return mMessage.OK; }

/* Setters */
void MIDI_Class::delMsg() {
        setChannel(0);
        setType(0);
        setData1(0);
        setData2(0);
        setStatus(false);
        delSysEx();
        return;
}
void MIDI_Class::delSysEx() { 
        for (int i=0;i<MIDI_SYSEX_ARRAY_SIZE;i++) mMessage.sysex_array[i] = 0;
}
void MIDI_Class::setDeviceID(byte sysID) { sysex_ID = sysID; }
void MIDI_Class::setInputChannel(byte channel) { mInputChannel = channel; }
void MIDI_Class::setFilter(byte filter) { mFilterMode = filter; }

void MIDI_Class::turnThruOn() { mThruActivated = true; }
void MIDI_Class::turnThruOff() { mThruActivated = false; }
void MIDI_Class::turnThru(bool val) { mThruActivated = val; }


void MIDI_Class::setType(byte type) { mMessage.type = type; }
void MIDI_Class::setChannel(byte channel) { mMessage.channel = channel; }
void MIDI_Class::setData1(byte D) { mMessage.data1 = D; }
void MIDI_Class::setData2(byte D) { mMessage.data2 = D; }
void MIDI_Class::setStatus(bool ok) { mMessage.OK = ok; }


bool MIDI_Class::parse(byte inChannelFilter) {
        if (inChannelFilter >= MIDI_CHANNEL_OFF) return false;  // MIDI input disabled
        byte tStatus=0,tChannel=0,tType=0,tData1=0,tData2=0;
        delMsg();       // Cleanup
        if (UART.available() == 128) { UART.flush(); }; 
        if (UART.available() > 0) { // do we have something to read?
                tStatus = UART.read();
                if (tStatus > 127) {
                        tChannel = (tStatus&0x0F)+1;
                        tType = ((tStatus&0x70)>>4)&0x07;
                        if (tChannel == inChannelFilter || inChannelFilter == MIDI_CHANNEL_OMNI || tType == SysEx) {
                                if (tType == PC || tType == ATCanal) {
                                        // 2 bytes long message
                                        if(UART.available() > 0) {
                                                tData1 = UART.read();
                                                if (tData1 < 128) {
                                                        // Saving to struct
                                                        setChannel(tChannel);
                                                        setType(tType);
                                                        setData1(tData1);
                                                        setData2(0);
                                                        setStatus(true);
                                                        mRunningStatus_RX = tStatus;
                                                }
                                        }
                                        else {
                                                // Data on next turn
                                                mRunningStatus_RX = tStatus;
                                                return false;
                                        }
                                }
                                else if (tType == SysEx) { // Handle all system messages
                                        mMessage.sysex_array[0] = tStatus;
                                        unsigned length;
                                        for (length=1;length<MIDI_SYSEX_ARRAY_SIZE;length++) {
                                                while(!UART.available()) {};
                                                tData1 = UART.read();
                                                mMessage.sysex_array[length] = tData1;
                                                if (tData1 == 0xF7) {
                                                        length++;
                                                        break;
                                                }
                                        }
                                        for (unsigned i=0;i<length;i++) { Serial.print(mMessage.sysex_array[i],HEX); Serial << " "; }
                                        setType(SysEx);
                                        setData1(length);
                                        setStatus(true);
                                        mRunningStatus_RX = Channel_Refused; // No running status with SysEx
                                }
                                else {
                                        // 3 bytes message
                                        if(UART.available() > 0) {
                                                tData1 = UART.read();
                                                if (tData1 < 128) {
                                                        // Wait for the third byte
                                                        while(!UART.available()) {};
                                                        if(UART.available() > 0) {
                                                                tData2 = UART.read();
                                                                if (tData2 < 128) {
                                                                        // Saving
                                                                        setChannel(tChannel);
                                                                        setType(tType);
                                                                        setData1(tData1);
                                                                        setData2(tData2);
                                                                        setStatus(true);
                                                                        mRunningStatus_RX = tStatus;
                                                                }
                                                        }
                                                }
                                                else {
                                                        // We were expecting for a data byte
                                                        return false;
                                                }
                                        }
                                        else {
                                                // Data on next turn
                                                mRunningStatus_RX = tStatus;
                                                return false;
                                        }
                                }
                        }
                        else {
                                // Channel refused
                                mRunningStatus_RX = Channel_Refused;
                                return false;
                        }
                }
                else {
                        // Running status?
                        // data matching the previous control byte
                        if (mRunningStatus_RX == Channel_Refused) {
                                return false;
                        }
                        else {
                                tChannel = (mRunningStatus_RX&0x0F)+1;
                                tType = ((mRunningStatus_RX&0x70)>>4)&0x07;
                                if (tType == PC || tType == ATCanal) {
                                        // Saving       
                                        setChannel(tChannel);
                                        setType(tType);
                                        setData1(tStatus);
                                        setData2(0);
                                        setStatus(true);
                                }
                                else if (tType == SysEx) {
                                        // Normally not possible (as we don't recognize SysEx as a Running Status
                                        mRunningStatus_RX = Channel_Refused;
                                }
                                else {
                                        // 3 bytes
                                        while(!UART.available()) {};
                                        if(UART.available() > 0) {
                                                tData2 = UART.read();
                                                if (tData2 < 128) {
                                                        // Saving
                                                        setChannel(tChannel);
                                                        setType(tType);
                                                        setData1(tStatus);
                                                        setData2(tData2);
                                                        setStatus(true);
                                                }
                                        }
                                }
                        }
                }
        }
        else return false;
        return check();
}


bool MIDI_Class::read() {
        return read(mInputChannel);
}
bool MIDI_Class::read(byte channel) {
        if (parse(MIDI_CHANNEL_OMNI)) {
                if (channel >= MIDI_CHANNEL_OFF && getType() != SysEx) { // Input disabled
                        delMsg(); 
                        return false; 
                } 
                if (mThruActivated) filter(channel); // Filter and send (if thru enabled)
                if (getChannel() == channel || channel == MIDI_CHANNEL_OMNI || getType() == SysEx)      return true;
                else { 
                        delMsg(); 
                        return false; 
                }
        }
        else return false;
}

void MIDI_Class::filter(byte channel) { // Mirroring filter
        // MIDI message validity already checked by thru
        switch (mFilterMode) {
                case MIDI_FILTER_FULL:
                        // All pass
                        send(getType(),getData1(),getData2(),getChannel());
                        break;
                case MIDI_FILTER_CANAL:
                        // Same channel
                        if (channel >= MIDI_CHANNEL_OFF) return;
                        if (getChannel() == channel || channel == MIDI_CHANNEL_OMNI) send(getType(),getData1(),getData2(),getChannel());
                        break;
                case MIDI_FILTER_ANTICANAL:
                        // Different channel
                        if (channel == MIDI_CHANNEL_OMNI) return;
                        if (getChannel() != channel || channel >= MIDI_CHANNEL_OFF) send(getType(),getData1(),getData2(),getChannel());
                        break;
                default:
                        break;
        }
        return;
}
        

---