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.
748 Commits
2 Branches
Tree: 8c6655f312
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8c6655f312'
${ noResults }
teensy-core-4.1/teensy3/usb_midi.h

393 lines
17KB
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. // maximum sysex length we can receive

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

  42. #define USB_MIDI_SYSEX_MAX  60

  43. #else

  44. #define USB_MIDI_SYSEX_MAX 290

  45. #endif

  46. 

  47. // C language implementation

  48. #ifdef __cplusplus

  49. extern "C" {

  50. #endif

  51. void usb_midi_write_packed(uint32_t n);

  52. void usb_midi_send_sysex_buffer_has_term(const uint8_t *data, uint32_t length, uint8_t cable);

  53. void usb_midi_send_sysex_add_term_bytes(const uint8_t *data, uint32_t length, uint8_t cable);

  54. void usb_midi_flush_output(void);

  55. int usb_midi_read(uint32_t channel);

  56. uint32_t usb_midi_available(void);

  57. uint32_t usb_midi_read_message(void);

  58. extern uint8_t usb_midi_msg_cable;

  59. extern uint8_t usb_midi_msg_channel;

  60. extern uint8_t usb_midi_msg_type;

  61. extern uint8_t usb_midi_msg_data1;

  62. extern uint8_t usb_midi_msg_data2;

  63. extern uint8_t usb_midi_msg_sysex[USB_MIDI_SYSEX_MAX];

  64. extern uint16_t usb_midi_msg_sysex_len;

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

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

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

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

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

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

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

  72. extern void (*usb_midi_handleSysExPartial)(const uint8_t *data, uint16_t length, uint8_t complete);

  73. extern void (*usb_midi_handleSysExComplete)(uint8_t *data, unsigned int size);

  74. extern void (*usb_midi_handleTimeCodeQuarterFrame)(uint8_t data);

  75. extern void (*usb_midi_handleSongPosition)(uint16_t beats);

  76. extern void (*usb_midi_handleSongSelect)(uint8_t songnumber);

  77. extern void (*usb_midi_handleTuneRequest)(void);

  78. extern void (*usb_midi_handleClock)(void);

  79. extern void (*usb_midi_handleStart)(void);

  80. extern void (*usb_midi_handleContinue)(void);

  81. extern void (*usb_midi_handleStop)(void);

  82. extern void (*usb_midi_handleActiveSensing)(void);

  83. extern void (*usb_midi_handleSystemReset)(void);

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

  85. 

  86. #ifdef __cplusplus

  87. }

  88. #endif

  89. 

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

  91. //

  92. //    Port    Client name                      Port name

  93. //     0:0    System                           Timer

  94. //     0:1    System                           Announce

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

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

  97. //    28:0    AKM320                           AKM320 MIDI 1

  98. //

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

  100. //

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

  102. //    Source  Event                  Ch  Data

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

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

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

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

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

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

  109. 

  110. // C++ interface

  111. #ifdef __cplusplus

  112. class usb_midi_class

  113. {

  114.         public:

  115. 	// Message type names for compatibility with Arduino MIDI library 4.3.1

  116. 	enum MidiType {

  117. 		InvalidType           = 0x00, // For notifying errors

  118. 		NoteOff               = 0x80, // Note Off

  119. 		NoteOn                = 0x90, // Note On

  120. 		AfterTouchPoly        = 0xA0, // Polyphonic AfterTouch

  121. 		ControlChange         = 0xB0, // Control Change / Channel Mode

  122. 		ProgramChange         = 0xC0, // Program Change

  123. 		AfterTouchChannel     = 0xD0, // Channel (monophonic) AfterTouch

  124. 		PitchBend             = 0xE0, // Pitch Bend

  125. 		SystemExclusive       = 0xF0, // System Exclusive

  126. 		TimeCodeQuarterFrame  = 0xF1, // System Common - MIDI Time Code Quarter Frame

  127. 		SongPosition          = 0xF2, // System Common - Song Position Pointer

  128. 		SongSelect            = 0xF3, // System Common - Song Select

  129. 		TuneRequest           = 0xF6, // System Common - Tune Request

  130. 		Clock                 = 0xF8, // System Real Time - Timing Clock

  131. 		Start                 = 0xFA, // System Real Time - Start

  132. 		Continue              = 0xFB, // System Real Time - Continue

  133. 		Stop                  = 0xFC, // System Real Time - Stop

  134. 		ActiveSensing         = 0xFE, // System Real Time - Active Sensing

  135. 		SystemReset           = 0xFF, // System Real Time - System Reset

  136. 	};

  137.         void begin(void) { }

  138.         void end(void) { }

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

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

  141. 	}

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

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

  144. 	}

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

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

  147. 	}

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

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

  150. 	}

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

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

  153. 	}

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

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

  156. 	}

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

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

  159. 	}

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

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

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

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

  164. 	}

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

  166. 		if (cable >= MIDI_NUM_CABLES) return;

  167. 		if (hasTerm) {

  168. 			usb_midi_send_sysex_buffer_has_term(data, length, cable);

  169. 		} else {

  170. 			usb_midi_send_sysex_add_term_bytes(data, length, cable);

  171. 		}

  172. 	}

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

  174. 		switch (type) {

  175. 			case 0xF8: // Clock

  176. 			case 0xFA: // Start

  177. 			case 0xFB: // Continue

  178. 			case 0xFC: // Stop

  179. 			case 0xFE: // ActiveSensing

  180. 			case 0xFF: // SystemReset

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

  182. 				break;

  183. 			default: // Invalid Real Time marker

  184. 				break;

  185. 		}

  186. 	}

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

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

  189. 	}

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

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

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

  193. 	//}

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

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

  196. 	}

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

  198. 		send(0xF3, song, 0, 0, cable);

  199. 	}

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

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

  202. 	}

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

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

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

  206. 	}

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

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

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

  210. 	}

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

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

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

  214. 	}

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

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

  217. 	}

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

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

  220. 	}

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

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

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

  224. 	}

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

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

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

  228. 	}

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

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

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

  232. 	}

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

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

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

  236. 	}

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

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

  239. 	}

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

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

  242. 	}

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

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

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

  246. 	}

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

  248. 		if (cable >= MIDI_NUM_CABLES) return;

  249. 		if (type < 0xF0) {

  250. 			if (type < 0x80) return;

  251. 			type &= 0xF0;

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

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

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

  255. 		} else if (type >= 0xF8 || type == 0xF6) {

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

  257. 		} else if (type == 0xF1 || type == 0xF3) {

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

  259. 			  | ((data1 & 0x7F) << 16));

  260. 		} else if (type == 0xF2) {

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

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

  263. 		}

  264. 	}

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

  266. 		usb_midi_flush_output();

  267. 	}

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

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

  270. 		return usb_midi_read(channel);

  271. 	}

  272.         uint8_t getType(void) __attribute__((always_inline)) {

  273.                 return usb_midi_msg_type;

  274.         }

  275.         uint8_t getCable(void) __attribute__((always_inline)) {

  276.                 return usb_midi_msg_cable;

  277.         }

  278.         uint8_t getChannel(void) __attribute__((always_inline)) {

  279.                 return usb_midi_msg_channel;

  280.         }

  281.         uint8_t getData1(void) __attribute__((always_inline)) {

  282.                 return usb_midi_msg_data1;

  283.         }

  284.         uint8_t getData2(void) __attribute__((always_inline)) {

  285.                 return usb_midi_msg_data2;

  286.         }

  287.         uint8_t * getSysExArray(void) __attribute__((always_inline)) {

  288.                 return usb_midi_msg_sysex;

  289.         }

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

  291. 		// type: 0x80  NoteOff

  292.                 usb_midi_handleNoteOff = fptr;

  293.         }

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

  295. 		// type: 0x90  NoteOn

  296.                 usb_midi_handleNoteOn = fptr;

  297.         }

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

  299. 		// type: 0xA0  AfterTouchPoly

  300.                 usb_midi_handleVelocityChange = fptr;

  301.         }

  302. 	void setHandleAfterTouchPoly(void (*fptr)(uint8_t channel, uint8_t note, uint8_t pressure)) {

  303. 		// type: 0xA0  AfterTouchPoly

  304.                 usb_midi_handleVelocityChange = fptr;

  305.         }

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

  307. 		// type: 0xB0  ControlChange

  308.                 usb_midi_handleControlChange = fptr;

  309.         }

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

  311. 		// type: 0xC0  ProgramChange

  312.                 usb_midi_handleProgramChange = fptr;

  313.         }

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

  315. 		// type: 0xD0  AfterTouchChannel

  316.                 usb_midi_handleAfterTouch = fptr;

  317.         }

  318.         void setHandleAfterTouchChannel(void (*fptr)(uint8_t channel, uint8_t pressure)) {

  319. 		// type: 0xD0  AfterTouchChannel

  320.                 usb_midi_handleAfterTouch = fptr;

  321.         }

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

  323. 		// type: 0xE0  PitchBend

  324.                 usb_midi_handlePitchChange = fptr;

  325.         }

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

  327. 		// type: 0xF0  SystemExclusive - multiple calls for message bigger than buffer

  328.                 usb_midi_handleSysExPartial = (void (*)(const uint8_t *, uint16_t, uint8_t))fptr;

  329.         }

  330.         void setHandleSystemExclusive(void (*fptr)(const uint8_t *data, uint16_t length, bool complete)) {

  331. 		// type: 0xF0  SystemExclusive - multiple calls for message bigger than buffer

  332.                 usb_midi_handleSysExPartial = (void (*)(const uint8_t *, uint16_t, uint8_t))fptr;

  333.         }

  334. 	void setHandleSystemExclusive(void (*fptr)(uint8_t *data, unsigned int size)) {

  335. 		// type: 0xF0  SystemExclusive - single call, message larger than buffer is truncated

  336. 		usb_midi_handleSysExComplete = fptr;

  337. 	}

  338.         void setHandleTimeCodeQuarterFrame(void (*fptr)(uint8_t data)) {

  339. 		// type: 0xF1  TimeCodeQuarterFrame

  340.                 usb_midi_handleTimeCodeQuarterFrame = fptr;

  341.         }

  342. 	void setHandleSongPosition(void (*fptr)(uint16_t beats)) {

  343. 		// type: 0xF2  SongPosition

  344. 		usb_midi_handleSongPosition = fptr;

  345. 	}

  346. 	void setHandleSongSelect(void (*fptr)(uint8_t songnumber)) {

  347. 		// type: 0xF3  SongSelect

  348. 		usb_midi_handleSongSelect = fptr;

  349. 	}

  350. 	void setHandleTuneRequest(void (*fptr)(void)) {

  351. 		// type: 0xF6  TuneRequest

  352. 		usb_midi_handleTuneRequest = fptr;

  353. 	}

  354. 	void setHandleClock(void (*fptr)(void)) {

  355. 		// type: 0xF8  Clock

  356. 		usb_midi_handleClock = fptr;

  357. 	}

  358. 	void setHandleStart(void (*fptr)(void)) {

  359. 		// type: 0xFA  Start

  360. 		usb_midi_handleStart = fptr;

  361. 	}

  362. 	void setHandleContinue(void (*fptr)(void)) {

  363. 		// type: 0xFB  Continue

  364. 		usb_midi_handleContinue = fptr;

  365. 	}

  366. 	void setHandleStop(void (*fptr)(void)) {

  367. 		// type: 0xFC  Stop

  368. 		usb_midi_handleStop = fptr;

  369. 	}

  370. 	void setHandleActiveSensing(void (*fptr)(void)) {

  371. 		// type: 0xFE  ActiveSensing

  372. 		usb_midi_handleActiveSensing = fptr;

  373. 	}

  374. 	void setHandleSystemReset(void (*fptr)(void)) {

  375. 		// type: 0xFF  SystemReset

  376. 		usb_midi_handleSystemReset = fptr;

  377. 	}

  378.         void setHandleRealTimeSystem(void (*fptr)(uint8_t realtimebyte)) {

  379. 		// type: 0xF8-0xFF - if more specific handler not configured

  380.                 usb_midi_handleRealTimeSystem = fptr;

  381.         };

  382. };

  383. 

  384. extern usb_midi_class usbMIDI;

  385. 

  386. 

  387. #endif // __cplusplus

  388. 

  389. #endif // MIDI_INTERFACE

  390. 

  391. #endif // USBmidi_h_