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

355 lines
14KB
Raw Blame History 

  1. #ifndef USBserial_h_

  2. #define USBserial_h_

  3. 

  4. #include <inttypes.h>

  5. 

  6. #include "Stream.h"

  7. 

  8. #define USB_MIDI_SYSEX_MAX 60  // maximum sysex length we can receive

  9. 

  10. /*

  11. These were originally meant to allow programs written for

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

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

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

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

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

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

  18. used together without conflict.

  19. #define NoteOff 0

  20. #define NoteOn 1

  21. #define AfterTouchPoly 2

  22. #define ControlChange 3

  23. #define ProgramChange 4

  24. #define AfterTouchChannel 5

  25. #define PitchBend 6

  26. #define SystemExclusive 7

  27. */

  28. 

  29. class usb_midi_class

  30. {

  31. public:

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

  33.         enum MidiType {

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

  35.                 NoteOff               = 0x80, // Note Off

  36.                 NoteOn                = 0x90, // Note On

  37.                 AfterTouchPoly        = 0xA0, // Polyphonic AfterTouch

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

  39.                 ProgramChange         = 0xC0, // Program Change

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

  41.                 PitchBend             = 0xE0, // Pitch Bend

  42.                 SystemExclusive       = 0xF0, // System Exclusive

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

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

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

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

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

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

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

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

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

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

  53.         };

  54.         void begin(void) { }

  55.         void end(void) { }

  56. 	void sendNoteOff(uint8_t note, uint8_t velocity, uint8_t channel, uint8_t cable=0) {

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

  58. 	}

  59. 	void sendNoteOn(uint8_t note, uint8_t velocity, uint8_t channel, uint8_t cable=0) {

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

  61. 	}

  62. 	void sendPolyPressure(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable=0) {

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

  64. 	}

  65. 	void sendAfterTouch(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable=0) {

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

  67. 	}

  68. 	void sendControlChange(uint8_t control, uint8_t value, uint8_t channel, uint8_t cable=0) {

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

  70. 	}

  71. 	void sendProgramChange(uint8_t program, uint8_t channel, uint8_t cable=0) {

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

  73. 	}

  74. 	void sendAfterTouch(uint8_t pressure, uint8_t channel, uint8_t cable=0) {

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

  76. 	}

  77. 	void sendPitchBend(uint16_t value, uint8_t channel, uint8_t cable=0) {

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

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

  80. 	}

  81. 	void sendSysEx(uint16_t length, const uint8_t *data, bool hasTerm=false, uint8_t cable=0) {

  82. 		if (cable > 0) return;

  83. 		if (hasTerm) {

  84. 			sendSysEx_BufferHasTerm(length, data);

  85. 		} else {

  86. 			sendSysEx_AddTermBytes(length, data);

  87. 		}

  88. 	}

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

  90.                 switch (type) {

  91.                         case 0xF8: // Clock

  92.                         case 0xFA: // Start

  93.                         case 0xFB: // Continue

  94.                         case 0xFC: // Stop

  95.                         case 0xFE: // ActiveSensing

  96.                         case 0xFF: // SystemReset

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

  98.                                 break;

  99.                         default: // Invalid Real Time marker

  100.                                 break;

  101.                 }

  102.         }

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

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

  105.         }

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

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

  108.         }

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

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

  111.         }

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

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

  114.         }

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

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

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

  118.         }

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

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

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

  122.         }

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

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

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

  126.         }

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

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

  129.         }

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

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

  132.         }

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

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

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

  136.         }

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

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

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

  140.         }

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

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

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

  144.         }

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

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

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

  148.         }

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

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

  151.         }

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

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

  154.         }

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

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

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

  158.         }

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

  160. 		if (cable > 0) return;

  161. 		if (type < 0xF0) {

  162. 			if (type < 0x80) return;

  163. 			send_raw(type >> 4, (type & 0xF0) | ((channel - 1) & 0x0F),

  164. 				data1 & 0x7F, data2 & 0x7F);

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

  166. 			send_raw(0x0F, type, 0, 0);

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

  168. 			send_raw(0x02, type, data1 & 0x7F, 0);

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

  170. 			send_raw(0x03, type, data1 & 0x7F, data2 & 0x7F);

  171. 		}

  172. 	}

  173. 	void send_now(void);

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

  175. 	bool read(uint8_t channel=0);

  176. 	inline uint8_t getType(void) {

  177. 		return msg_type;

  178. 	}

  179. 	uint8_t getCable(void) {

  180. 		return 0;

  181. 	}

  182. 	uint8_t getChannel(void) {

  183. 		return msg_channel;

  184. 	}

  185. 	uint8_t getData1(void) {

  186. 		return msg_data1;

  187. 	}

  188. 	uint8_t getData2(void) {

  189. 		return msg_data2;

  190. 	}

  191. 	uint8_t * getSysExArray(void) {

  192. 		return msg_sysex;

  193. 	}

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

  195. 		// type: 0x80  NoteOff

  196. 		handleNoteOff = fptr;

  197. 	}

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

  199. 		// type: 0x90  NoteOn

  200. 		handleNoteOn = fptr;

  201. 	}

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

  203. 		// type: 0xA0  AfterTouchPoly

  204. 		handleVelocityChange = fptr;

  205. 	}

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

  207. 		// type: 0xA0  AfterTouchPoly

  208. 		handleVelocityChange = fptr;

  209. 	}

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

  211. 		// type: 0xB0  ControlChange

  212. 		handleControlChange = fptr;

  213. 	}

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

  215. 		// type: 0xC0  ProgramChange

  216. 		handleProgramChange = fptr;

  217. 	}

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

  219. 		// type: 0xD0  AfterTouchChannel

  220. 		handleAfterTouch = fptr;

  221. 	}

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

  223. 		// type: 0xD0  AfterTouchChannel

  224. 		handleAfterTouch = fptr;

  225. 	}

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

  227. 		// type: 0xE0  PitchBend

  228. 		handlePitchChange = fptr;

  229. 	}

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

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

  232. 		handleSysExPartial = (void (*)(const uint8_t *, uint16_t, uint8_t))fptr;

  233. 	}

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

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

  236. 		handleSysExPartial = (void (*)(const uint8_t *, uint16_t, uint8_t))fptr;

  237. 	}

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

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

  240. 		handleSysExComplete = fptr;

  241. 	}

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

  243. 		// type: 0xF1  TimeCodeQuarterFrame

  244. 		handleTimeCodeQuarterFrame = fptr;

  245. 	}

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

  247. 		// type: 0xF2  SongPosition

  248. 		handleSongPosition = fptr;

  249. 	}

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

  251. 		// type: 0xF3  SongSelect

  252. 		handleSongSelect = fptr;

  253. 	}

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

  255. 		// type: 0xF6  TuneRequest

  256. 		handleTuneRequest = fptr;

  257. 	}

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

  259. 		// type: 0xF8  Clock

  260. 		handleClock = fptr;

  261. 	}

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

  263. 		// type: 0xFA  Start

  264. 		handleStart = fptr;

  265. 	}

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

  267. 		// type: 0xFB  Continue

  268. 		handleContinue = fptr;

  269. 	}

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

  271. 		// type: 0xFC  Stop

  272. 		handleStop = fptr;

  273. 	}

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

  275. 		// type: 0xFE  ActiveSensing

  276. 		handleActiveSensing = fptr;

  277. 	}

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

  279. 		// type: 0xFF  SystemReset

  280. 		handleSystemReset = fptr;

  281. 	}

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

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

  284. 		handleRealTimeSystem = fptr;

  285. 	}

  286. private:

  287. 	void send_raw(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3);

  288. 	void sendSysEx_BufferHasTerm(uint16_t length, const uint8_t *data);

  289. 	void sendSysEx_AddTermBytes(uint16_t length, const uint8_t *data);

  290. 	void read_sysex_byte(uint8_t b);

  291. 	uint8_t msg_channel;

  292. 	uint8_t msg_type;

  293. 	uint8_t msg_data1;

  294. 	uint8_t msg_data2;

  295. 	uint8_t msg_sysex[USB_MIDI_SYSEX_MAX];

  296. 	uint16_t msg_sysex_len;

  297. 	void (*handleNoteOff)(uint8_t ch, uint8_t note, uint8_t vel);

  298. 	void (*handleNoteOn)(uint8_t ch, uint8_t note, uint8_t vel);

  299. 	void (*handleVelocityChange)(uint8_t ch, uint8_t note, uint8_t vel);

  300. 	void (*handleControlChange)(uint8_t ch, uint8_t, uint8_t);

  301. 	void (*handleProgramChange)(uint8_t ch, uint8_t);

  302. 	void (*handleAfterTouch)(uint8_t ch, uint8_t);

  303. 	void (*handlePitchChange)(uint8_t ch, int pitch);

  304. 	void (*handleSysExPartial)(const uint8_t *data, uint16_t length, uint8_t complete);

  305. 	void (*handleSysExComplete)(uint8_t *data, unsigned int size);

  306. 	void (*handleTimeCodeQuarterFrame)(uint8_t data);

  307. 	void (*handleSongPosition)(uint16_t beats);

  308. 	void (*handleSongSelect)(uint8_t songnumber);

  309. 	void (*handleTuneRequest)(void);

  310. 	void (*handleClock)(void);

  311. 	void (*handleStart)(void);

  312. 	void (*handleContinue)(void);

  313. 	void (*handleStop)(void);

  314. 	void (*handleActiveSensing)(void);

  315. 	void (*handleSystemReset)(void);

  316. 	void (*handleRealTimeSystem)(uint8_t rtb);

  317. };

  318. 

  319. extern usb_midi_class usbMIDI;

  320. 

  321. 

  322. class usb_serial_class : public Stream

  323. {

  324. public:

  325. 	// standard Arduino functions

  326. 	void begin(long);

  327. 	void end();

  328. 	virtual int available();

  329. 	virtual int read();

  330. 	virtual int peek();

  331. 	virtual void flush();

  332. #if ARDUINO >= 100

  333. 	virtual size_t write(uint8_t);

  334. #else

  335. 	virtual void write(uint8_t);

  336. #endif

  337. 	using Print::write;

  338. 	operator bool();

  339. 	// Teensy extensions

  340. 	void send_now(void);

  341. 	uint32_t baud(void);

  342. 	uint8_t stopbits(void);

  343. 	uint8_t paritytype(void);

  344. 	uint8_t numbits(void);

  345. 	uint8_t dtr(void);

  346. 	uint8_t rts(void);

  347. private:

  348. 	uint8_t readnext(void);

  349. };

  350. 

  351. extern usb_serial_class Serial;

  352. 

  353. 

  354. #endif