visus
/
framework-arduinoteensy-cxx20
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
4 Révisions
1 Branche
Aborescence: 16a0c39090
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '16a0c39090'
${ noResults }
framework-arduinoteensy-cxx20/cores/teensy3/usb_midi.h

392 lines
16KB
Brut Annotations Historique 

  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. // Quick-dirty way to transmit MIDI sysex:

  111. //     echo -n -e '\xF0abcd\xF7' > /dev/midi2

  112. 

  113. // C++ interface

  114. #ifdef __cplusplus

  115. class usb_midi_class

  116. {

  117.         public:

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

  119. 	enum MidiType {

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

  121. 		NoteOff               = 0x80, // Note Off

  122. 		NoteOn                = 0x90, // Note On

  123. 		AfterTouchPoly        = 0xA0, // Polyphonic AfterTouch

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

  125. 		ProgramChange         = 0xC0, // Program Change

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

  127. 		PitchBend             = 0xE0, // Pitch Bend

  128. 		SystemExclusive       = 0xF0, // System Exclusive

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

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

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

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

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

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

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

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

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

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

  139. 	};

  140.         void begin(void) { }

  141.         void end(void) { }

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

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

  144. 	}

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

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

  147. 	}

  148.         void sendPolyPressure(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 sendAfterTouchPoly(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

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

  153. 	}

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

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

  156. 	}

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

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

  159. 	}

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

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

  162. 	}

  163.         void sendPitchBend(int value, uint8_t channel, uint8_t cable=0) __attribute__((always_inline)) {

  164. 		if (value < -8192) {

  165. 			value = -8192;

  166. 		} else if (value > 8191) {

  167. 			value = 8191;

  168. 		}

  169. 		value += 8192;

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

  171. 	}

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

  173. 		if (cable >= MIDI_NUM_CABLES) return;

  174. 		if (hasTerm) {

  175. 			usb_midi_send_sysex_buffer_has_term(data, length, cable);

  176. 		} else {

  177. 			usb_midi_send_sysex_add_term_bytes(data, length, cable);

  178. 		}

  179. 	}

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

  181. 		switch (type) {

  182. 			case 0xF8: // Clock

  183. 			case 0xFA: // Start

  184. 			case 0xFB: // Continue

  185. 			case 0xFC: // Stop

  186. 			case 0xFE: // ActiveSensing

  187. 			case 0xFF: // SystemReset

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

  189. 				break;

  190. 			default: // Invalid Real Time marker

  191. 				break;

  192. 		}

  193. 	}

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

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

  196. 	}

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

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

  199. 	}

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

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

  202. 	}

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

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

  205. 	}

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

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

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

  209. 	}

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

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

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

  213. 	}

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

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

  216. 	}

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

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

  219. 	}

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

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

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

  223. 	}

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

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

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

  227. 	}

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

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

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

  231. 	}

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

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

  234. 	}

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

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

  237. 	}

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

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

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

  241. 	}

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

  243. 		if (cable >= MIDI_NUM_CABLES) return;

  244. 		if (type < 0xF0) {

  245. 			if (type < 0x80) return;

  246. 			type &= 0xF0;

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

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

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

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

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

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

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

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

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

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

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

  258. 		}

  259. 	}

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

  261. 		usb_midi_flush_output();

  262. 	}

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

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

  265. 		return usb_midi_read(channel);

  266. 	}

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

  268.                 return usb_midi_msg_type;

  269.         }

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

  271.                 return usb_midi_msg_cable;

  272.         }

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

  274.                 return usb_midi_msg_channel;

  275.         }

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

  277.                 return usb_midi_msg_data1;

  278.         }

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

  280.                 return usb_midi_msg_data2;

  281.         }

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

  283.                 return usb_midi_msg_sysex;

  284.         }

  285. 	uint16_t getSysExArrayLength(void) __attribute__((always_inline)) {

  286.                 return usb_midi_msg_data2 << 8 | usb_midi_msg_data1;

  287.         }

  288. 	

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

  290. 		// type: 0x80  NoteOff

  291.                 usb_midi_handleNoteOff = fptr;

  292.         }

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

  294. 		// type: 0x90  NoteOn

  295.                 usb_midi_handleNoteOn = fptr;

  296.         }

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

  298. 		// type: 0xA0  AfterTouchPoly

  299.                 usb_midi_handleVelocityChange = fptr;

  300.         }

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

  302. 		// type: 0xA0  AfterTouchPoly

  303.                 usb_midi_handleVelocityChange = fptr;

  304.         }

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

  306. 		// type: 0xB0  ControlChange

  307.                 usb_midi_handleControlChange = fptr;

  308.         }

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

  310. 		// type: 0xC0  ProgramChange

  311.                 usb_midi_handleProgramChange = fptr;

  312.         }

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

  314. 		// type: 0xD0  AfterTouchChannel

  315.                 usb_midi_handleAfterTouch = fptr;

  316.         }

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

  318. 		// type: 0xD0  AfterTouchChannel

  319.                 usb_midi_handleAfterTouch = fptr;

  320.         }

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

  322. 		// type: 0xE0  PitchBend

  323.                 usb_midi_handlePitchChange = fptr;

  324.         }

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

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

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

  328.         }

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

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

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

  332.         }

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

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

  335. 		usb_midi_handleSysExComplete = fptr;

  336. 	}

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

  338. 		// type: 0xF1  TimeCodeQuarterFrame

  339.                 usb_midi_handleTimeCodeQuarterFrame = fptr;

  340.         }

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

  342. 		// type: 0xF2  SongPosition

  343. 		usb_midi_handleSongPosition = fptr;

  344. 	}

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

  346. 		// type: 0xF3  SongSelect

  347. 		usb_midi_handleSongSelect = fptr;

  348. 	}

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

  350. 		// type: 0xF6  TuneRequest

  351. 		usb_midi_handleTuneRequest = fptr;

  352. 	}

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

  354. 		// type: 0xF8  Clock

  355. 		usb_midi_handleClock = fptr;

  356. 	}

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

  358. 		// type: 0xFA  Start

  359. 		usb_midi_handleStart = fptr;

  360. 	}

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

  362. 		// type: 0xFB  Continue

  363. 		usb_midi_handleContinue = fptr;

  364. 	}

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

  366. 		// type: 0xFC  Stop

  367. 		usb_midi_handleStop = fptr;

  368. 	}

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

  370. 		// type: 0xFE  ActiveSensing

  371. 		usb_midi_handleActiveSensing = fptr;

  372. 	}

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

  374. 		// type: 0xFF  SystemReset

  375. 		usb_midi_handleSystemReset = fptr;

  376. 	}

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

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

  379.                 usb_midi_handleRealTimeSystem = fptr;

  380.         };

  381. };

  382. 

  383. extern usb_midi_class usbMIDI;

  384. 

  385. 

  386. #endif // __cplusplus

  387. 

  388. #endif // MIDI_INTERFACE

  389. 

  390. #endif // USBmidi_h_