visus
/
teensy-core-4.1
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Teensy 4.1 core updated for C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
742 Commits
2 Branches
Tree: 6d49f67650
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6d49f67650'
${ noResults }
teensy-core-4.1/teensy3/usb_midi.h

315 lines
13KB
Raw Blame History 

  1. /* Teensyduino Core Library

  2.  * http://www.pjrc.com/teensy/

  3.  * Copyright (c) 2017 PJRC.COM, LLC.

  4.  *

  5.  * Permission is hereby granted, free of charge, to any person obtaining

  6.  * a copy of this software and associated documentation files (the

  7.  * "Software"), to deal in the Software without restriction, including

  8.  * without limitation the rights to use, copy, modify, merge, publish,

  9.  * distribute, sublicense, and/or sell copies of the Software, and to

  10.  * permit persons to whom the Software is furnished to do so, subject to

  11.  * the following conditions:

  12.  *

  13.  * 1. The above copyright notice and this permission notice shall be

  14.  * included in all copies or substantial portions of the Software.

  15.  *

  16.  * 2. If the Software is incorporated into a build system that allows

  17.  * selection among a list of target devices, then similar target

  18.  * devices manufactured by PJRC.COM must be included in the list of

  19.  * target devices and selectable in the same manner.

  20.  *

  21.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  22.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  23.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  24.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  25.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  26.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  28.  * SOFTWARE.

  29.  */

  30. 

  31. #ifndef USBmidi_h_

  32. #define USBmidi_h_

  33. 

  34. #include "usb_desc.h"

  35. 

  36. #if defined(MIDI_INTERFACE)

  37. 

  38. #include <inttypes.h>

  39. 

  40. /*

  41. These were originally meant to allow programs written for

  42. Francois Best's MIDI library to be easily used with

  43. Teensy's usbMIDI which implements the same API.  However,

  44. the MIDI library definitions have changed, so these names

  45. now conflict.  They've never been documented (the PJRC web

  46. page documents usbMIDI.getType() in numbers) so they are

  47. now commented out so usbMIDI and the MIDI library can be

  48. used together without conflict.

  49. #define NoteOff 0

  50. #define NoteOn 1

  51. #define AfterTouchPoly 2

  52. #define ControlChange 3

  53. #define ProgramChange 4

  54. #define AfterTouchChannel 5

  55. #define PitchBend 6

  56. #define SystemExclusive 7

  57. */

  58. 

  59. // maximum sysex length we can receive

  60. #if defined(__MKL26Z64__) || defined(__MK20DX128__)

  61. #define USB_MIDI_SYSEX_MAX  60

  62. #else

  63. #define USB_MIDI_SYSEX_MAX 290

  64. #endif

  65. 

  66. // C language implementation

  67. #ifdef __cplusplus

  68. extern "C" {

  69. #endif

  70. void usb_midi_write_packed(uint32_t n);

  71. void usb_midi_send_sysex(const uint8_t *data, uint32_t length, uint8_t cable);

  72. void usb_midi_flush_output(void);

  73. int usb_midi_read(uint32_t channel);

  74. uint32_t usb_midi_available(void);

  75. uint32_t usb_midi_read_message(void);

  76. extern uint8_t usb_midi_msg_cable;

  77. extern uint8_t usb_midi_msg_channel;

  78. extern uint8_t usb_midi_msg_type;

  79. extern uint8_t usb_midi_msg_data1;

  80. extern uint8_t usb_midi_msg_data2;

  81. extern uint8_t usb_midi_msg_sysex[USB_MIDI_SYSEX_MAX];

  82. extern uint16_t usb_midi_msg_sysex_len;

  83. extern void (*usb_midi_handleNoteOff)(uint8_t ch, uint8_t note, uint8_t vel);

  84. extern void (*usb_midi_handleNoteOn)(uint8_t ch, uint8_t note, uint8_t vel);

  85. extern void (*usb_midi_handleVelocityChange)(uint8_t ch, uint8_t note, uint8_t vel);

  86. extern void (*usb_midi_handleControlChange)(uint8_t ch, uint8_t control, uint8_t value);

  87. extern void (*usb_midi_handleProgramChange)(uint8_t ch, uint8_t program);

  88. extern void (*usb_midi_handleAfterTouch)(uint8_t ch, uint8_t pressure);

  89. extern void (*usb_midi_handlePitchChange)(uint8_t ch, int pitch);

  90. extern void (*usb_midi_handleSysEx)(const uint8_t *data, uint16_t length, uint8_t complete);

  91. extern void (*usb_midi_handleRealTimeSystem)(uint8_t rtb);

  92. extern void (*usb_midi_handleTimeCodeQuarterFrame)(uint16_t data);

  93. 

  94. #ifdef __cplusplus

  95. }

  96. #endif

  97. 

  98. // To test receiving on Linux, run "aseqdump -l" to list sequencer devices.

  99. //

  100. //    Port    Client name                      Port name

  101. //     0:0    System                           Timer

  102. //     0:1    System                           Announce

  103. //    14:0    Midi Through                     Midi Through Port-0

  104. //    24:0    Teensy MIDI                      Teensy MIDI MIDI 1

  105. //    28:0    AKM320                           AKM320 MIDI 1

  106. //

  107. // Then run "aseqdump -p 24:0" to view the MIDI messages.

  108. //

  109. //    Waiting for data. Press Ctrl+C to end.

  110. //    Source  Event                  Ch  Data

  111. //     24:0   Note on                 0, note 61, velocity 99

  112. //     24:0   Note off                0, note 61, velocity 0

  113. //     24:0   Note on                 0, note 62, velocity 99

  114. //     24:0   Note off                0, note 62, velocity 0

  115. //     24:0   Note on                 0, note 64, velocity 99

  116. //     24:0   Note off                0, note 64, velocity 0

  117. 

  118. // C++ interface

  119. #ifdef __cplusplus

  120. class usb_midi_class

  121. {

  122.         public:

  123.         void begin(void) { }

  124.         void end(void) { }

  125.         void sendNoteOff(uint8_t note, uint8_t velocity, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  126. 		send(0x80, note, velocity, channel, cable);

  127. 	};

  128.         void sendNoteOn(uint8_t note, uint8_t velocity, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  129. 		send(0x90, note, velocity, channel, cable);

  130. 	};

  131.         void sendPolyPressure(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  132. 		send(0xA0, note, pressure, channel, cable);

  133. 	};

  134. 	void sendAfterTouch(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  135. 		send(0xA0, note, pressure, channel, cable);

  136. 	};

  137.         void sendControlChange(uint8_t control, uint8_t value, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  138. 		send(0xB0, control, value, channel, cable);

  139. 	};

  140.         void sendProgramChange(uint8_t program, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  141. 		send(0xC0, program, 0, channel, cable);

  142. 	};

  143.         void sendAfterTouch(uint8_t pressure, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  144. 		send(0xD0, pressure, 0, channel, cable);

  145. 	};

  146.         void sendPitchBend(uint16_t value, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  147. 		// MIDI 4.3 takes -8192 to +8191.  We take 0 to 16383

  148. 		// MIDI 4.3 also has version that takes float -1.0 to +1.0

  149. 		send(0xE0, value, value >> 7, channel, cable);

  150. 	};

  151.         void sendSysEx(uint32_t length, const uint8_t *data, bool hasTerm=false, uint8_t cable=0) __attribute__((always_inline)) {

  152. 		if (cable >= MIDI_NUM_CABLES) return;

  153. 		if (hasTerm) {

  154. 			if (length > 2) {

  155. 				usb_midi_send_sysex(data + 1, length - 2, cable);

  156. 			}

  157. 		} else {

  158. 			usb_midi_send_sysex(data, length, cable);

  159. 		}

  160. 	};

  161. 	void sendRealTime(uint8_t type, uint8_t cable=0) __attribute__((always_inline)) __attribute__((always_inline)) {

  162. 		switch (type) {

  163. 			case 0xF8: // Clock

  164. 			case 0xFA: // Start

  165. 			case 0xFB: // Continue

  166. 			case 0xFC: // Stop

  167. 			case 0xFE: // ActiveSensing

  168. 			case 0xFF: // SystemReset

  169. 				send(type, 0, 0, 0, cable);

  170. 				break;

  171. 			default: // Invalid Real Time marker

  172. 				break;

  173. 		}

  174. 	};

  175. 	void sendTimeCodeQuarterFrame(uint8_t type, uint8_t value, uint8_t cable=0) __attribute__((always_inline)) __attribute__((always_inline)) {

  176. 		send(0xF1, ((type & 0x07) << 4) | (value & 0x0F), 0, 0, cable);

  177. 	};

  178.         //void sendTimeCodeQuarterFrame(uint8_t data, uint8_t cable=0) __attribute__((always_inline)) {

  179. 		// MIDI 4.3 has this, but we can't implement with cable param

  180. 		//send(0xF1, data, 0, 0, cable);

  181. 	//};

  182. 	void sendSongPosition(uint16_t beats, uint8_t cable=0) __attribute__((always_inline)) {

  183. 		send(0xF2, beats, beats >> 7, 0, cable);

  184. 	};

  185. 	void sendSongSelect(uint8_t song, uint8_t cable=0) __attribute__((always_inline)) {

  186. 		send(0xF4, song, 0, 0, cable);

  187. 	};

  188. 	void sendTuneRequest(uint8_t cable=0) __attribute__((always_inline)) {

  189. 		send(0xF6, 0, 0, 0, cable);

  190. 	};

  191. 	void beginRpn(uint16_t number, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  192. 		sendControlChange(101, number >> 7, channel, cable);

  193. 		sendControlChange(100, number, channel, cable);

  194. 	};

  195. 	void sendRpnValue(uint16_t value, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  196. 		sendControlChange(6, value >> 7, channel, cable);

  197. 		sendControlChange(38, value, channel, cable);

  198. 	};

  199. 	void sendRpnValue(uint8_t msb, uint8_t lsb, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  200. 		sendControlChange(6, msb, channel, cable);

  201. 		sendControlChange(38, lsb, channel, cable);

  202. 	};

  203. 	void sendRpnIncrement(uint8_t amount, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  204. 		sendControlChange(96, amount, channel, cable);

  205. 	};

  206. 	void sendRpnDecrement(uint8_t amount, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  207. 		sendControlChange(97, amount, channel, cable);

  208. 	};

  209. 	void endRpn(uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  210. 		sendControlChange(101, 0x7F, channel, cable);

  211. 		sendControlChange(100, 0x7F, channel, cable);

  212. 	};

  213. 	void beginNrpn(uint16_t number, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  214. 		sendControlChange(99, number >> 7, channel, cable);

  215. 		sendControlChange(98, number, channel, cable);

  216. 	}

  217. 	void sendNrpnValue(uint16_t value, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  218. 		sendControlChange(6, value >> 7, channel, cable);

  219. 		sendControlChange(38, value, channel, cable);

  220. 	}

  221. 	void sendNrpnValue(uint8_t msb, uint8_t lsb, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  222. 		sendControlChange(6, msb, channel, cable);

  223. 		sendControlChange(38, lsb, channel, cable);

  224. 	}

  225. 	void sendNrpnIncrement(uint8_t amount, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  226. 		sendControlChange(96, amount, channel, cable);

  227. 	}

  228. 	void sendNrpnDecrement(uint8_t amount, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  229. 		sendControlChange(97, amount, channel, cable);

  230. 	}

  231. 	void endNrpn(uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  232. 		sendControlChange(99, 0x7F, channel, cable);

  233. 		sendControlChange(98, 0x7F, channel, cable);

  234. 	}

  235. 	void send(uint8_t type, uint8_t data1, uint8_t data2, uint8_t channel, uint8_t cable) __attribute__((always_inline)) {

  236. 		if (cable >= MIDI_NUM_CABLES) return;

  237. 		if (type < 0xF0) {

  238. 			if (type < 0x80) return;

  239. 			type &= 0xF0;

  240. 			usb_midi_write_packed((type << 8) | (type >> 4) | ((cable & 0x0F) << 4)

  241. 			  | (((channel - 1) & 0x0F) << 8) | ((data1 & 0x7F) << 16)

  242. 			  | ((data2 & 0x7F) << 24));

  243. 		} else {

  244. 			usb_midi_write_packed((type << 8) | 0x0F | ((cable & 0x0F) << 4)

  245. 			  | ((data1 & 0x7F) << 16) | ((data2 & 0x7F) << 24));

  246. 		}

  247. 	};

  248.         void send_now(void) __attribute__((always_inline)) {

  249. 		usb_midi_flush_output();

  250. 	};

  251.         uint8_t analog2velocity(uint16_t val, uint8_t range);

  252.         bool read(uint8_t channel=0) __attribute__((always_inline)) {

  253. 		return usb_midi_read(channel);

  254. 	};

  255.         inline uint8_t getType(void) __attribute__((always_inline)) {

  256.                 return usb_midi_msg_type;

  257.         };

  258.         inline uint8_t getCable(void) __attribute__((always_inline)) {

  259.                 return usb_midi_msg_cable;

  260.         };

  261.         inline uint8_t getChannel(void) __attribute__((always_inline)) {

  262.                 return usb_midi_msg_channel;

  263.         };

  264.         inline uint8_t getData1(void) __attribute__((always_inline)) {

  265.                 return usb_midi_msg_data1;

  266.         };

  267.         inline uint8_t getData2(void) __attribute__((always_inline)) {

  268.                 return usb_midi_msg_data2;

  269.         };

  270.         inline uint8_t * getSysExArray(void) __attribute__((always_inline)) {

  271.                 return usb_midi_msg_sysex;

  272.         };

  273.         inline void setHandleNoteOff(void (*fptr)(uint8_t channel, uint8_t note, uint8_t velocity)) {

  274.                 usb_midi_handleNoteOff = fptr;

  275.         };

  276.         inline void setHandleNoteOn(void (*fptr)(uint8_t channel, uint8_t note, uint8_t velocity)) {

  277.                 usb_midi_handleNoteOn = fptr;

  278.         };

  279.         inline void setHandleVelocityChange(void (*fptr)(uint8_t channel, uint8_t note, uint8_t velocity)) {

  280.                 usb_midi_handleVelocityChange = fptr;

  281.         };

  282.         inline void setHandleControlChange(void (*fptr)(uint8_t channel, uint8_t control, uint8_t value)) {

  283.                 usb_midi_handleControlChange = fptr;

  284.         };

  285.         inline void setHandleProgramChange(void (*fptr)(uint8_t channel, uint8_t program)) {

  286.                 usb_midi_handleProgramChange = fptr;

  287.         };

  288.         inline void setHandleAfterTouch(void (*fptr)(uint8_t channel, uint8_t pressure)) {

  289.                 usb_midi_handleAfterTouch = fptr;

  290.         };

  291.         inline void setHandlePitchChange(void (*fptr)(uint8_t channel, int pitch)) {

  292.                 usb_midi_handlePitchChange = fptr;

  293.         };

  294.         inline void setHandleSysEx(void (*fptr)(const uint8_t *data, uint16_t length, bool complete)) {

  295.                 usb_midi_handleSysEx = (void (*)(const uint8_t *, uint16_t, uint8_t))fptr;

  296.         }

  297.         inline void setHandleRealTimeSystem(void (*fptr)(uint8_t realtimebyte)) {

  298.                 usb_midi_handleRealTimeSystem = fptr;

  299.         };

  300.         inline void setHandleTimeCodeQuarterFrame(void (*fptr)(uint16_t data)) {

  301.                 usb_midi_handleTimeCodeQuarterFrame = fptr;

  302.         };

  303. 	private:

  304. };

  305. 

  306. extern usb_midi_class usbMIDI;

  307. 

  308. 

  309. #endif // __cplusplus

  310. 

  311. #endif // MIDI_INTERFACE

  312. 

  313. #endif // USBmidi_h_