Seich
/
arduino_midi_library
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed auto-instanciation

This commit is contained in:
Francois Best 2014-04-20 17:24:35 +02:00
parent 410e51c91a
commit f88012b38f
5 changed files with 45 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/MIDI.cpp
View File

@ -25,27 +25,6 @@
// -----------------------------------------------------------------------------
#if !(MIDI_BUILD_INPUT) && !(MIDI_BUILD_OUTPUT)
# error To use MIDI, you need to enable at least input or output.
#endif
#if MIDI_BUILD_THRU && !(MIDI_BUILD_OUTPUT)
# error For thru to work, you need to enable output.
#endif
#if MIDI_BUILD_THRU && !(MIDI_BUILD_INPUT)
# error For thru to work, you need to enable input.
#endif
// -----------------------------------------------------------------------------
#if MIDI_AUTO_INSTANCIATE && defined(ARDUINO)
MIDI_CREATE_INSTANCE(MIDI_DEFAULT_SERIAL_CLASS,
MIDI_DEFAULT_SERIAL_PORT,
MIDI);
#endif
// -----------------------------------------------------------------------------
BEGIN_MIDI_NAMESPACE
/*! \brief Encode System Exclusive messages.

63
src/MIDI.h
View File

@ -26,10 +26,6 @@
#include "midi_Settings.h"
#include "midi_Defs.h"
#ifdef FSE_AVR
#include <ak47.h>
#endif
// -----------------------------------------------------------------------------
BEGIN_MIDI_NAMESPACE
@ -44,8 +40,8 @@ template<class SerialPort, class Settings = DefaultSettings>
class MidiInterface
{
public:
MidiInterface(SerialPort& inSerial);
~MidiInterface();
inline MidiInterface(SerialPort& inSerial);
inline ~MidiInterface();
public:
void begin(Channel inChannel = 1);
@ -53,8 +49,6 @@ public:
// -------------------------------------------------------------------------
// MIDI Output
#if MIDI_BUILD_OUTPUT
public:
inline void sendNoteOn(DataByte inNoteNumber,
DataByte inVelocity,
@ -100,17 +94,9 @@ public:
DataByte inData2,
Channel inChannel);
private:
inline StatusByte getStatus(MidiType inType,
Channel inChannel) const;
#endif // MIDI_BUILD_OUTPUT
// -------------------------------------------------------------------------
// MIDI Input
#if MIDI_BUILD_INPUT
public:
inline bool read();
inline bool read(Channel inChannel);
@ -133,25 +119,10 @@ public:
static inline Channel getChannelFromStatusByte(byte inStatus);
static inline bool isChannelMessage(MidiType inType);
private:
bool parse();
inline void handleNullVelocityNoteOnAsNoteOff();
inline bool inputFilter(Channel inChannel);
inline void resetInput();
private:
StatusByte mRunningStatus_RX;
Channel mInputChannel;
byte mPendingMessage[3];
unsigned mPendingMessageExpectedLenght;
unsigned mPendingMessageIndex;
Message mMessage;
// -------------------------------------------------------------------------
// Input Callbacks
#if MIDI_USE_CALLBACKS
public:
inline void setHandleNoteOff(void (*fptr)(byte channel, byte note, byte velocity));
inline void setHandleNoteOn(void (*fptr)(byte channel, byte note, byte velocity));
@ -196,14 +167,9 @@ private:
void (*mActiveSensingCallback)(void);
void (*mSystemResetCallback)(void);
#endif // MIDI_USE_CALLBACKS
#endif // MIDI_BUILD_INPUT
// -------------------------------------------------------------------------
// MIDI Soft Thru
#if MIDI_BUILD_THRU
public:
inline MidiFilterMode getFilterMode() const;
inline bool getThruState() const;
@ -216,11 +182,28 @@ public:
private:
void thruFilter(byte inChannel);
private:
bool parse();
inline void handleNullVelocityNoteOnAsNoteOff();
inline bool inputFilter(Channel inChannel);
inline void resetInput();
private:
bool mThruActivated : 1;
MidiFilterMode mThruFilterMode : 7;
#endif // MIDI_BUILD_THRU
private:
StatusByte mRunningStatus_RX;
Channel mInputChannel;
byte mPendingMessage[3];
unsigned mPendingMessageExpectedLenght;
unsigned mPendingMessageIndex;
Message mMessage;
private:
inline StatusByte getStatus(MidiType inType,
Channel inChannel) const;
#if MIDI_USE_RUNNING_STATUS
@ -241,10 +224,4 @@ END_MIDI_NAMESPACE
// -----------------------------------------------------------------------------
#if MIDI_AUTO_INSTANCIATE && defined(ARDUINO)
extern MIDI_NAMESPACE::MidiInterface<MIDI_DEFAULT_SERIAL_CLASS> MIDI;
#endif
// -----------------------------------------------------------------------------
#include "MIDI.hpp"

43
src/MIDI.hpp
View File

@ -143,7 +143,7 @@ void MidiInterface<SerialPort, Settings>::send(MidiType inType,
// Then test if channel is valid
if (inChannel >= MIDI_CHANNEL_OFF ||
inChannel == MIDI_CHANNEL_OMNI ||
inType < NoteOff)
inType < 0x80)
{
if (Settings::UseRunningStatus)
{
@ -178,12 +178,14 @@ void MidiInterface<SerialPort, Settings>::send(MidiType inType,
// Then send data
mSerial.write(inData1);
if (inType != ProgramChange && inType != AfterTouchChannel)
{
mSerial.write(inData2);
return;
}
}
else if (inType >= TuneRequest && inType <= SystemReset)
{
sendRealTime(inType); // System Real-time and 1 byte.
}
}
// -----------------------------------------------------------------------------
@ -212,7 +214,7 @@ void MidiInterface<SerialPort, Settings>::sendNoteOn(DataByte inNoteNumber,
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. This method will always send a real NoteOff message.
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
*/
@ -492,24 +494,22 @@ inline bool MidiInterface<SerialPort, Settings>::read(Channel inChannel)
if (inChannel >= MIDI_CHANNEL_OFF)
return false; // MIDI Input disabled.
if (parse())
if (!parse())
return false;
handleNullVelocityNoteOnAsNoteOff();
const bool channelMatch = inputFilter(inChannel);
if (MIDI_USE_CALLBACKS && channelMatch)
{
handleNullVelocityNoteOnAsNoteOff();
if (inputFilter(inChannel))
{
#if (MIDI_BUILD_OUTPUT && MIDI_BUILD_THRU)
thruFilter(inChannel);
#endif
#if MIDI_USE_CALLBACKS
launchCallback();
#endif
return true;
}
launchCallback();
}
return false;
#if MIDI_BUILD_THRU
thruFilter(inChannel);
#endif
return channelMatch;
}
// -----------------------------------------------------------------------------
@ -802,7 +802,6 @@ inline void MidiInterface<SerialPort, Settings>::handleNullVelocityNoteOnAsNoteO
{
mMessage.type = NoteOff;
}
#endif
}
// Private method: check if the received message is on the listened channel
@ -953,10 +952,10 @@ MidiType MidiInterface<SerialPort, Settings>::getTypeFromStatusByte(byte inStatu
if (inStatus < 0xf0)
{
// Channel message, remove channel nibble.
return (MidiType)(inStatus & 0xf0);
return MidiType(inStatus & 0xf0);
}
return (MidiType)inStatus;
return MidiType(inStatus);
}
/*! \brief Returns channel in the range 1-16

8
src/midi_Defs.h
View File

@ -24,6 +24,7 @@
#pragma once
#include "midi_Namespace.h"
#include "midi_Settings.h"
#include <inttypes.h>
BEGIN_MIDI_NAMESPACE
@ -39,8 +40,7 @@ BEGIN_MIDI_NAMESPACE
// -----------------------------------------------------------------------------
// Type definitions
typedef uint8_t byte;
typedef uint8_t byte;
typedef byte StatusByte;
typedef byte DataByte;
typedef byte Channel;
@ -163,7 +163,6 @@ enum MidiControlChangeNumber
*/
struct Message
{
/*! The MIDI channel on which the message was recieved.
\n Value goes from 1 to 16.
*/
@ -196,13 +195,14 @@ struct Message
validity means the message respects the MIDI norm.
*/
bool valid;
};
// -----------------------------------------------------------------------------
/*! \brief Create an instance of the library attached to a serial port.
You can use HardwareSerial or SoftwareSerial for the serial port.
Example: MIDI_CREATE_INSTANCE(HardwareSerial, Serial2, midi2);
Then call midi2.begin(), midi2.read() etc..
*/
#define MIDI_CREATE_INSTANCE(Type, SerialPort, Name) \
midi::MidiInterface<Type> Name((Type&)SerialPort);

30
src/midi_Settings.h
View File

@ -44,36 +44,6 @@
#define MIDI_USE_CALLBACKS 1
// -----------------------------------------------------------------------------
// Create a MIDI object automatically on the port defined with MIDI_SERIAL_PORT.
#ifndef MIDI_AUTO_INSTANCIATE
# ifdef ARDUINO
# define MIDI_AUTO_INSTANCIATE 1
# else
# define MIDI_AUTO_INSTANCIATE 0 ///< @see MIDI_CREATE_INSTANCE
# endif
#endif
// -----------------------------------------------------------------------------
// Default serial port configuration (if MIDI_AUTO_INSTANCIATE is set)
// Set the default port to use for MIDI.
#if MIDI_AUTO_INSTANCIATE
# ifdef ARDUINO
# include "Arduino.h"
# ifdef USBCON
# define MIDI_DEFAULT_SERIAL_PORT Serial1 // For Leonardo
# else
# define MIDI_DEFAULT_SERIAL_PORT Serial // For other Arduinos
# endif
# define MIDI_DEFAULT_SERIAL_CLASS HardwareSerial
# include "HardwareSerial.h"
# else
# error Auto-instanciation disabled. Use MIDI_CREATE_INSTANCE macro.
# endif
#endif
// -----------------------------------------------------------------------------
// Misc. options