MIDI_CC_to_NOTEs.ino

/* Receive Incoming USB Host MIDI using functions.  As usbMIDI
   reads incoming messages, handler functions are run.
   See the InputRead example for the non-function alterative.

   This very long example demonstrates all possible handler
   functions.  Most applications need only some of these.
   This example is meant to allow easy copy-and-paste of the
   desired functions.

   Use the Arduino Serial Monitor to view the messages
   as Teensy receives them by USB MIDI

   You must select MIDI from the "Tools > USB Type" menu

   This example code is in the public domain.
*/


// Need this file and also the name.c file in the folder.  You can change the name.c file to reflect the usb midi name that appears

// need to upload this to a teensy in serial + MIDI mode so the teensy appears as a usb midi device when plugged into a console/computer


#include <USBHost_t36.h>

USBHost myusb;
USBHub hub1(myusb);
USBHub hub2(myusb);
MIDIDevice midi1(myusb);

int programm = 0;
int programmold = 0;
int programnew = 0;

void setup() {
  Serial.begin(115200);

  // Wait 1.5 seconds before turning on USB Host.  If connected USB devices
  // use too much power, Teensy at least completes USB enumeration, which
  // makes isolating the power issue easier.
  delay(500);
  Serial.println("USB Host CC to Notes");
  delay(10);
  myusb.begin();

  //  midi1.setHandleNoteOn(myNoteOn);
  //  midi1.setHandleNoteOff(myNoteOff);
  //  midi1.setHandleAfterTouchPoly(myAfterTouchPoly);
  midi1.setHandleControlChange(myControlChange);
  //midi1.setHandleProgramChange(myProgramChange);
  //  midi1.setHandleAfterTouchChannel(myAfterTouchChannel);
  //  midi1.setHandlePitchChange(myPitchChange);
  // Only one of these System Exclusive handlers will actually be
  // used.  See the comments below for the difference between them.
  //  midi1.setHandleSystemExclusive(mySystemExclusiveChunk);
  //  midi1.setHandleSystemExclusive(mySystemExclusive);
  //  midi1.setHandleTimeCodeQuarterFrame(myTimeCodeQuarterFrame);
  //  midi1.setHandleSongPosition(mySongPosition);
  //  midi1.setHandleSongSelect(mySongSelect);
  //  midi1.setHandleTuneRequest(myTuneRequest);
  //  midi1.setHandleClock(myClock);
  //  midi1.setHandleStart(myStart);
  //  midi1.setHandleContinue(myContinue);
  //  midi1.setHandleStop(myStop);
  //  midi1.setHandleActiveSensing(myActiveSensing);
  //  midi1.setHandleSystemReset(mySystemReset);
  // This generic System Real Time handler is only used if the
  // more specific ones are not set.
  //  midi1.setHandleRealTimeSystem(myRealTimeSystem);
}

void loop() {
  // The handler functions are called when midi1 reads data.  They
  // will not be called automatically.  You must call midi1.read()
  // regularly from loop() for midi1 to actually read incoming
  // data and run the handler functions as messages arrive.
  myusb.Task();
  midi1.read();
}

/*
  void myNoteOn(byte channel, byte note, byte velocity) {
  // When a USB device with multiple virtual cables is used,
  // midi1.getCable() can be used to read which of the virtual
  // MIDI cables received this message.
  Serial.print("Note On, ch=");
  Serial.print(channel, DEC);
  Serial.print(", note=");
  Serial.print(note, DEC);
  Serial.print(", velocity=");
  Serial.println(velocity, DEC);
  }

  void myNoteOff(byte channel, byte note, byte velocity) {
  Serial.print("Note Off, ch=");
  Serial.print(channel, DEC);
  Serial.print(", note=");
  Serial.print(note, DEC);
  Serial.print(", velocity=");
  Serial.println(velocity, DEC);
  }

  void myAfterTouchPoly(byte channel, byte note, byte velocity) {
  Serial.print("AfterTouch Change, ch=");
  Serial.print(channel, DEC);
  Serial.print(", note=");
  Serial.print(note, DEC);
  Serial.print(", velocity=");
  Serial.println(velocity, DEC);
  }
*/
void myControlChange(byte channel, byte control, byte value) {
  Serial.print("Control Change, ch=");
  Serial.print(channel, DEC);
  Serial.print(", control=");
  Serial.print(control, DEC);
  Serial.print(", value=");
  Serial.println(value, DEC);
  usbMIDI.sendNoteOn(control, value, channel);
}
/*
void myProgramChange(byte channel, byte program) {
  Serial.print("Program Change, ch=");
  Serial.print(channel, DEC);
  Serial.print(", program=");
  Serial.println(program);
  programm = program;
  if (programm < programmold)
  {
    Serial.println("Lesser");
      Serial.println(programmold, DEC);
  Serial.println(programm, DEC);
  Serial.println(programnew, DEC);
    programnew = 0;
  }
  if (programm > programmold)
  {
    Serial.println("Greater");
      Serial.println(programmold, DEC);
  Serial.println(programm, DEC);
  Serial.println(programnew, DEC);
    programnew = 1;
  }

  Serial.println(programmold, DEC);
  Serial.println(programm, DEC);
  Serial.println(programnew, DEC);
  programmold = programm;

  usbMIDI.sendNoteOn(51, programnew,  channel);

}
/*
  void myAfterTouchChannel(byte channel, byte pressure) {
  Serial.print("After Touch, ch=");
  Serial.print(channel, DEC);
  Serial.print(", pressure=");
  Serial.println(pressure, DEC);
  }

  void myPitchChange(byte channel, int pitch) {
  Serial.print("Pitch Change, ch=");
  Serial.print(channel, DEC);
  Serial.print(", pitch=");
  Serial.println(pitch, DEC);
  }


  // This 3-input System Exclusive function is more complex, but allows you to
  // process very large messages which do not fully fit within the midi1's
  // internal buffer.  Large messages are given to you in chunks, with the
  // 3rd parameter to tell you which is the last chunk.  This function is
  // a Teensy extension, not available in the Arduino MIDI library.
  //
  void mySystemExclusiveChunk(const byte *data, uint16_t length, bool last) {
  Serial.print("SysEx Message: ");
  printBytes(data, length);
  if (last) {
    Serial.println(" (end)");
  } else {
    Serial.println(" (to be continued)");
  }
  }

  // This simpler 2-input System Exclusive function can only receive messages
  // up to the size of the internal buffer.  Larger messages are truncated, with
  // no way to receive the data which did not fit in the buffer.  If both types
  // of SysEx functions are set, the 3-input version will be called by midi1.
  //
  void mySystemExclusive(byte *data, unsigned int length) {
  Serial.print("SysEx Message: ");
  printBytes(data, length);
  Serial.println();
  }

  void myTimeCodeQuarterFrame(byte data) {
  static char SMPTE[8]={'0','0','0','0','0','0','0','0'};
  static byte fps=0;
  byte index = data >> 4;
  byte number = data & 15;
  if (index == 7) {
    fps = (number >> 1) & 3;
    number = number & 1;
  }
  if (index < 8 || number < 10) {
    SMPTE[index] = number + '0';
    Serial.print("TimeCode: ");  // perhaps only print when index == 7
    Serial.print(SMPTE[7]);
    Serial.print(SMPTE[6]);
    Serial.print(':');
    Serial.print(SMPTE[5]);
    Serial.print(SMPTE[4]);
    Serial.print(':');
    Serial.print(SMPTE[3]);
    Serial.print(SMPTE[2]);
    Serial.print('.');
    Serial.print(SMPTE[1]);  // perhaps add 2 to compensate for MIDI latency?
    Serial.print(SMPTE[0]);
    switch (fps) {
      case 0: Serial.println(" 24 fps"); break;
      case 1: Serial.println(" 25 fps"); break;
      case 2: Serial.println(" 29.97 fps"); break;
      case 3: Serial.println(" 30 fps"); break;
    }
  } else {
    Serial.print("TimeCode: invalid data = ");
    Serial.println(data, HEX);
  }
  }

  void mySongPosition(uint16_t beats) {
  Serial.print("Song Position, beat=");
  Serial.println(beats);
  }

  void mySongSelect(byte songNumber) {
  Serial.print("Song Select, song=");
  Serial.println(songNumber, DEC);
  }

  void myTuneRequest() {
  Serial.println("Tune Request");
  }

  void myClock() {
  Serial.println("Clock");
  }

  void myStart() {
  Serial.println("Start");
  }

  void myContinue() {
  Serial.println("Continue");
  }

  void myStop() {
  Serial.println("Stop");
  }

  void myActiveSensing() {
  Serial.println("Actvice Sensing");
  }

  void mySystemReset() {
  Serial.println("System Reset");
  }

  void myRealTimeSystem(uint8_t realtimebyte) {
  Serial.print("Real Time Message, code=");
  Serial.println(realtimebyte, HEX);
  }

*/

void printBytes(const byte *data, unsigned int size) {
  while (size > 0) {
    byte b = *data++;
    if (b < 16) Serial.print('0');
    Serial.print(b, HEX);
    if (size > 1) Serial.print(' ');
    size = size - 1;
  }
}