libraries/USB/src/USBMIDI.cpp

#if ARDUINO_USB_MODE

#warning This sketch should be used when USB is in OTG mode

void setup() {}

void loop() {}

#else

#include <math.h>

#include "USB.h"

#include "USBMIDI.h"

USBMIDI MIDI;

#define MIDI_NOTE_C4 64

#define MIDI_CC_CUTOFF 74

#define CONTROLLER_PIN 5

#define SMOOTHING_VALUE 1000

static double controllerInputValue = 0;

void updateControllerInputValue() {

controllerInputValue =

(controllerInputValue * (SMOOTHING_VALUE - 1) + analogRead(CONTROLLER_PIN)) / SMOOTHING_VALUE;

}

void primeControllerInputValue() {

for (int i = 0; i < SMOOTHING_VALUE; i++) {

updateControllerInputValue();

}

}

uint16_t readControllerValue() {

// Lower ADC input amplitude to get a stable value

return round(controllerInputValue / 12);

}

#define BUTTON_PIN 0

#define PRESSED 0xff00

#define RELEASED 0xfe1f

uint16_t getButtonEvent() {

static uint16_t state = 0;

state = (state << 1) | digitalRead(BUTTON_PIN) | 0xfe00;

return state;

}

void setup() {

Serial.begin(115200);

MIDI.begin();

USB.begin();

primeControllerInputValue();

}

void loop() {

uint16_t newControllerValue = readControllerValue();

static uint16_t lastControllerValue = 0;

// Auto-calibrate the controller range

static uint16_t maxControllerValue = 0;

static uint16_t minControllerValue = 0xFFFF;

if (newControllerValue < minControllerValue) {

minControllerValue = newControllerValue;

}

if (newControllerValue > maxControllerValue) {

maxControllerValue = newControllerValue;

}

// Send update if the controller value has changed

if (lastControllerValue != newControllerValue) {

lastControllerValue = newControllerValue;

// Can't map if the range is zero

if (minControllerValue != maxControllerValue) {

MIDI.controlChange(MIDI_CC_CUTOFF,

map(newControllerValue, minControllerValue, maxControllerValue, 0, 127));

}

}

updateControllerInputValue();

// Hook Button0 to a MIDI note so that we can observe

// the CC effect without the need for a MIDI keyboard.

switch (getButtonEvent()) {

case PRESSED:

MIDI.noteOn(MIDI_NOTE_C4, 64);

break;

case RELEASED:

MIDI.noteOff(MIDI_NOTE_C4, 0);

break;

default:

break;

}

}

#endif /* ARDUINO_USB_MODE */

#if ARDUINO_USB_MODE

#warning This sketch should be used when USB is in OTG mode

void setup() {}

void loop() {}

#else

#include "USB.h"

#include "USBMIDI.h"

USBMIDI MIDI;

#define MIDI_RX 39

#define MIDI_TX 40

void setup() {

// USBCDC Serial

Serial.begin(115200);

// HW UART Serial

Serial1.begin(31250, SERIAL_8N1, MIDI_RX, MIDI_TX);

MIDI.begin();

USB.begin();

}

void loop() {

// MIDI Serial 1.0 to USB MIDI 1.0

if (Serial1.available()) {

byte data = Serial1.read();

MIDI.write(data);

}

// USB MIDI 1.0 to MIDI Serial 1.0

midiEventPacket_t midi_packet_in = {0};

// See Chapter 4: USB-MIDI Event Packets (page 16) of the spec.

int8_t cin_to_midix_size[16] = {-1, -1, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1};

if (MIDI.readPacket(&midi_packet_in)) {

midi_code_index_number_t code_index_num = MIDI_EP_HEADER_CIN_GET(midi_packet_in.header);

int8_t midix_size = cin_to_midix_size[code_index_num];

// We skip Misc and Cable Events for simplicity

if (code_index_num >= 0x2) {

for (int i = 0; i < midix_size; i++) {

Serial1.write(((uint8_t *)&midi_packet_in)[i + 1]);

}

Serial1.flush();

}

}

}

#endif /* ARDUINO_USB_MODE */

#if ARDUINO_USB_MODE

#warning This sketch should be used when USB is in OTG mode

void setup() {}

void loop() {}

#else

#include "USB.h"

#include "USBMIDI.h"

USBMIDI MIDI;

#define END_OF_SONG 255

uint8_t notes[] = {END_OF_SONG, 71, 76, 79, 78, 76, 83, 81, 78, 76, 79, 78, 75, 77, 71};

uint8_t noteIndex = 0; // From 0 to sizeof(notes)

#define SONG_LENGTH (sizeof(notes) - 1) // END_OF_SONG does not attribute to the length.

#define BUTTON_PIN 0

bool isButtonPressed() {

static uint16_t state = 0;

state = (state << 1) | digitalRead(BUTTON_PIN) | 0xfe00;

return (state == 0xff00);

}

void setup() {

Serial.begin(115200);

// Make the BUTTON_PIN an input:

pinMode(BUTTON_PIN, INPUT_PULLUP);

MIDI.begin();

USB.begin();

}

void loop() {

if (isButtonPressed()) {

// Stop current note

MIDI.noteOff(notes[noteIndex]);

// Play next note

noteIndex = noteIndex < SONG_LENGTH ? noteIndex + 1 : 0;

if (notes[noteIndex] != END_OF_SONG) {

MIDI.noteOn(notes[noteIndex], 64);

}

}

}

#endif /* ARDUINO_USB_MODE */

#if ARDUINO_USB_MODE

#warning This sketch should be used when USB is in OTG mode

void setup() {}

void loop() {}

#else

#include "USB.h"

#include "USBMIDI.h"

USBMIDI MIDI;

void setup() {

Serial.begin(115200);

MIDI.begin();

USB.begin();

}

void loop() {

midiEventPacket_t midi_packet_in = {0};

if (MIDI.readPacket(&midi_packet_in)) {

printDetails(midi_packet_in);

}

}

void printDetails(midiEventPacket_t &midi_packet_in) {

// See Chapter 4: USB-MIDI Event Packets (page 16) of the spec.

uint8_t cable_num = MIDI_EP_HEADER_CN_GET(midi_packet_in.header);

midi_code_index_number_t code_index_num = MIDI_EP_HEADER_CIN_GET(midi_packet_in.header);

Serial.println("Received a USB MIDI packet:");

Serial.println(".----.-----.--------.--------.--------.");

Serial.println("| CN | CIN | STATUS | DATA 0 | DATA 1 |");

Serial.println("+----+-----+--------+--------+--------+");

Serial.printf("| %d | %X | %X | %X | %X |\n", cable_num, code_index_num,

midi_packet_in.byte1, midi_packet_in.byte2, midi_packet_in.byte3);

Serial.println("'----'-----'--------.--------'--------'\n");

Serial.print("Description: ");

switch (code_index_num) {

case MIDI_CIN_MISC:

Serial.println("This a Miscellaneous event");

break;

case MIDI_CIN_CABLE_EVENT:

Serial.println("This a Cable event");

break;

case MIDI_CIN_SYSCOM_2BYTE: // 2 byte system common message e.g MTC, SongSelect

case MIDI_CIN_SYSCOM_3BYTE: // 3 byte system common message e.g SPP

Serial.println("This a System Common (SysCom) event");

break;

case MIDI_CIN_SYSEX_START: // SysEx starts or continue

case MIDI_CIN_SYSEX_END_1BYTE: // SysEx ends with 1 data, or 1 byte system common message

case MIDI_CIN_SYSEX_END_2BYTE: // SysEx ends with 2 data

case MIDI_CIN_SYSEX_END_3BYTE: // SysEx ends with 3 data

Serial.println("This a system exclusive (SysEx) event");

break;

case MIDI_CIN_NOTE_ON:

Serial.printf("This a Note-On event of Note %d with a Velocity of %d\n",

midi_packet_in.byte2, midi_packet_in.byte3);

break;

case MIDI_CIN_NOTE_OFF:

Serial.printf("This a Note-Off event of Note %d with a Velocity of %d\n",

midi_packet_in.byte2, midi_packet_in.byte3);

break;

case MIDI_CIN_POLY_KEYPRESS:

Serial.printf("This a Poly Aftertouch event for Note %d and Value %d\n",

midi_packet_in.byte2, midi_packet_in.byte3);

break;

case MIDI_CIN_CONTROL_CHANGE:

Serial.printf("This a Control Change/Continuous Controller (CC) event of Controller %d "

"with a Value of %d\n",

midi_packet_in.byte2, midi_packet_in.byte3);

break;

case MIDI_CIN_PROGRAM_CHANGE:

Serial.printf("This a Program Change event with a Value of %d\n", midi_packet_in.byte2);

break;

case MIDI_CIN_CHANNEL_PRESSURE:

Serial.printf("This a Channel Pressure event with a Value of %d\n", midi_packet_in.byte2);

break;

case MIDI_CIN_PITCH_BEND_CHANGE:

Serial.printf("This a Pitch Bend Change event with a Value of %d\n",

((uint16_t)midi_packet_in.byte2) << 7 | midi_packet_in.byte3);

break;

case MIDI_CIN_1BYTE_DATA:

Serial.printf("This an embedded Serial MIDI event byte with Value %X\n",

midi_packet_in.byte1);

break;

}

Serial.println();

}

#endif /* ARDUINO_USB_MODE */