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

336 lines
13KB
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. class usb_midi_class

  11. {

  12. public:

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

  14.         enum MidiType {

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

  16.                 NoteOff               = 0x80, // Note Off

  17.                 NoteOn                = 0x90, // Note On

  18.                 AfterTouchPoly        = 0xA0, // Polyphonic AfterTouch

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

  20.                 ProgramChange         = 0xC0, // Program Change

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

  22.                 PitchBend             = 0xE0, // Pitch Bend

  23.                 SystemExclusive       = 0xF0, // System Exclusive

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

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

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

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

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

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

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

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

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

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

  34.         };

  35.         void begin(void) { }

  36.         void end(void) { }

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

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

  39. 	}

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

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

  42. 	}

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

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

  45. 	}

  46. 	void sendAfterTouchPoly(uint8_t note, uint8_t pressure, uint8_t channel, uint8_t cable=0) {

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

  48. 	}

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

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

  51. 	}

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

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

  54. 	}

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

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

  57. 	}

  58. 	void sendPitchBend(int value, uint8_t channel, uint8_t cable=0) {

  59. 		if (value < -8192) {

  60. 			value = -8192;

  61. 		} else if (value > 8191) {

  62. 			value = 8191;

  63. 		}

  64. 		value += 8192;

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

  66. 	}

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

  68. 		if (cable > 0) return;

  69. 		if (hasTerm) {

  70. 			sendSysEx_BufferHasTerm(length, data);

  71. 		} else {

  72. 			sendSysEx_AddTermBytes(length, data);

  73. 		}

  74. 	}

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

  76.                 switch (type) {

  77.                         case 0xF8: // Clock

  78.                         case 0xFA: // Start

  79.                         case 0xFB: // Continue

  80.                         case 0xFC: // Stop

  81.                         case 0xFE: // ActiveSensing

  82.                         case 0xFF: // SystemReset

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

  84.                                 break;

  85.                         default: // Invalid Real Time marker

  86.                                 break;

  87.                 }

  88.         }

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

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

  91.         }

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

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

  94.         }

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

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

  97.         }

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

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

  100.         }

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

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

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

  104.         }

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

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

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

  108.         }

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

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

  111.         }

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

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

  114.         }

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

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

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

  118.         }

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

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

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

  122.         }

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

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

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

  126.         }

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

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

  129.         }

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

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

  132.         }

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

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

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

  136.         }

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

  138. 		if (cable > 0) return;

  139. 		if (type < 0xF0) {

  140. 			if (type < 0x80) return;

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

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

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

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

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

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

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

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

  149. 		}

  150. 	}

  151. 	void send_now(void);

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

  153. 	bool read(uint8_t channel=0);

  154. 	inline uint8_t getType(void) {

  155. 		return msg_type;

  156. 	}

  157. 	uint8_t getCable(void) {

  158. 		return 0;

  159. 	}

  160. 	uint8_t getChannel(void) {

  161. 		return msg_channel;

  162. 	}

  163. 	uint8_t getData1(void) {

  164. 		return msg_data1;

  165. 	}

  166. 	uint8_t getData2(void) {

  167. 		return msg_data2;

  168. 	}

  169. 	uint8_t * getSysExArray(void) {

  170. 		return msg_sysex;

  171. 	}

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

  173. 		// type: 0x80  NoteOff

  174. 		handleNoteOff = fptr;

  175. 	}

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

  177. 		// type: 0x90  NoteOn

  178. 		handleNoteOn = fptr;

  179. 	}

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

  181. 		// type: 0xA0  AfterTouchPoly

  182. 		handleVelocityChange = fptr;

  183. 	}

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

  185. 		// type: 0xA0  AfterTouchPoly

  186. 		handleVelocityChange = fptr;

  187. 	}

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

  189. 		// type: 0xB0  ControlChange

  190. 		handleControlChange = fptr;

  191. 	}

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

  193. 		// type: 0xC0  ProgramChange

  194. 		handleProgramChange = fptr;

  195. 	}

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

  197. 		// type: 0xD0  AfterTouchChannel

  198. 		handleAfterTouch = fptr;

  199. 	}

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

  201. 		// type: 0xD0  AfterTouchChannel

  202. 		handleAfterTouch = fptr;

  203. 	}

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

  205. 		// type: 0xE0  PitchBend

  206. 		handlePitchChange = fptr;

  207. 	}

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

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

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

  211. 	}

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

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

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

  215. 	}

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

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

  218. 		handleSysExComplete = fptr;

  219. 	}

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

  221. 		// type: 0xF1  TimeCodeQuarterFrame

  222. 		handleTimeCodeQuarterFrame = fptr;

  223. 	}

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

  225. 		// type: 0xF2  SongPosition

  226. 		handleSongPosition = fptr;

  227. 	}

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

  229. 		// type: 0xF3  SongSelect

  230. 		handleSongSelect = fptr;

  231. 	}

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

  233. 		// type: 0xF6  TuneRequest

  234. 		handleTuneRequest = fptr;

  235. 	}

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

  237. 		// type: 0xF8  Clock

  238. 		handleClock = fptr;

  239. 	}

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

  241. 		// type: 0xFA  Start

  242. 		handleStart = fptr;

  243. 	}

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

  245. 		// type: 0xFB  Continue

  246. 		handleContinue = fptr;

  247. 	}

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

  249. 		// type: 0xFC  Stop

  250. 		handleStop = fptr;

  251. 	}

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

  253. 		// type: 0xFE  ActiveSensing

  254. 		handleActiveSensing = fptr;

  255. 	}

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

  257. 		// type: 0xFF  SystemReset

  258. 		handleSystemReset = fptr;

  259. 	}

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

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

  262. 		handleRealTimeSystem = fptr;

  263. 	}

  264. private:

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

  266. 	uint32_t midiusb_available();

  267. 	void midiusb_read(uint8_t *buf);

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

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

  270. 	void read_sysex_byte(uint8_t b);

  271. 	uint8_t msg_channel;

  272. 	uint8_t msg_type;

  273. 	uint8_t msg_data1;

  274. 	uint8_t msg_data2;

  275. 	uint8_t msg_sysex[USB_MIDI_SYSEX_MAX];

  276. 	uint16_t msg_sysex_len;

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

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

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

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

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

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

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

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

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

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

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

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

  289. 	void (*handleTuneRequest)(void);

  290. 	void (*handleClock)(void);

  291. 	void (*handleStart)(void);

  292. 	void (*handleContinue)(void);

  293. 	void (*handleStop)(void);

  294. 	void (*handleActiveSensing)(void);

  295. 	void (*handleSystemReset)(void);

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

  297. 	friend class MIDI_;

  298. };

  299. 

  300. extern usb_midi_class usbMIDI;

  301. 

  302. 

  303. class usb_serial_class : public Stream

  304. {

  305. public:

  306. 	// standard Arduino functions

  307. 	void begin(long);

  308. 	void end();

  309. 	virtual int available();

  310. 	virtual int read();

  311. 	virtual int peek();

  312. 	virtual void flush();

  313. #if ARDUINO >= 100

  314. 	virtual size_t write(uint8_t);

  315. #else

  316. 	virtual void write(uint8_t);

  317. #endif

  318. 	using Print::write;

  319. 	operator bool();

  320. 	// Teensy extensions

  321. 	void send_now(void);

  322. 	uint32_t baud(void);

  323. 	uint8_t stopbits(void);

  324. 	uint8_t paritytype(void);

  325. 	uint8_t numbits(void);

  326. 	uint8_t dtr(void);

  327. 	uint8_t rts(void);

  328. private:

  329. 	uint8_t readnext(void);

  330. };

  331. 

  332. extern usb_serial_class Serial;

  333. 

  334. 

  335. #endif