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

328 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(uint16_t value, uint8_t channel, uint8_t cable=0) {

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

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

  61. 	}

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

  63. 		if (cable > 0) return;

  64. 		if (hasTerm) {

  65. 			sendSysEx_BufferHasTerm(length, data);

  66. 		} else {

  67. 			sendSysEx_AddTermBytes(length, data);

  68. 		}

  69. 	}

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

  71.                 switch (type) {

  72.                         case 0xF8: // Clock

  73.                         case 0xFA: // Start

  74.                         case 0xFB: // Continue

  75.                         case 0xFC: // Stop

  76.                         case 0xFE: // ActiveSensing

  77.                         case 0xFF: // SystemReset

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

  79.                                 break;

  80.                         default: // Invalid Real Time marker

  81.                                 break;

  82.                 }

  83.         }

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

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

  86.         }

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

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

  89.         }

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

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

  92.         }

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

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

  95.         }

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

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

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

  99.         }

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

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

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

  103.         }

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

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

  106.         }

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

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

  109.         }

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

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

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

  113.         }

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

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

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

  117.         }

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

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

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

  121.         }

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

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

  124.         }

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

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

  127.         }

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

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

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

  131.         }

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

  133. 		if (cable > 0) return;

  134. 		if (type < 0xF0) {

  135. 			if (type < 0x80) return;

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

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

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

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

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

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

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

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

  144. 		}

  145. 	}

  146. 	void send_now(void);

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

  148. 	bool read(uint8_t channel=0);

  149. 	inline uint8_t getType(void) {

  150. 		return msg_type;

  151. 	}

  152. 	uint8_t getCable(void) {

  153. 		return 0;

  154. 	}

  155. 	uint8_t getChannel(void) {

  156. 		return msg_channel;

  157. 	}

  158. 	uint8_t getData1(void) {

  159. 		return msg_data1;

  160. 	}

  161. 	uint8_t getData2(void) {

  162. 		return msg_data2;

  163. 	}

  164. 	uint8_t * getSysExArray(void) {

  165. 		return msg_sysex;

  166. 	}

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

  168. 		// type: 0x80  NoteOff

  169. 		handleNoteOff = fptr;

  170. 	}

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

  172. 		// type: 0x90  NoteOn

  173. 		handleNoteOn = fptr;

  174. 	}

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

  176. 		// type: 0xA0  AfterTouchPoly

  177. 		handleVelocityChange = fptr;

  178. 	}

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

  180. 		// type: 0xA0  AfterTouchPoly

  181. 		handleVelocityChange = fptr;

  182. 	}

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

  184. 		// type: 0xB0  ControlChange

  185. 		handleControlChange = fptr;

  186. 	}

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

  188. 		// type: 0xC0  ProgramChange

  189. 		handleProgramChange = fptr;

  190. 	}

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

  192. 		// type: 0xD0  AfterTouchChannel

  193. 		handleAfterTouch = fptr;

  194. 	}

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

  196. 		// type: 0xD0  AfterTouchChannel

  197. 		handleAfterTouch = fptr;

  198. 	}

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

  200. 		// type: 0xE0  PitchBend

  201. 		handlePitchChange = fptr;

  202. 	}

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

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

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

  206. 	}

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

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

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

  210. 	}

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

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

  213. 		handleSysExComplete = fptr;

  214. 	}

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

  216. 		// type: 0xF1  TimeCodeQuarterFrame

  217. 		handleTimeCodeQuarterFrame = fptr;

  218. 	}

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

  220. 		// type: 0xF2  SongPosition

  221. 		handleSongPosition = fptr;

  222. 	}

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

  224. 		// type: 0xF3  SongSelect

  225. 		handleSongSelect = fptr;

  226. 	}

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

  228. 		// type: 0xF6  TuneRequest

  229. 		handleTuneRequest = fptr;

  230. 	}

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

  232. 		// type: 0xF8  Clock

  233. 		handleClock = fptr;

  234. 	}

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

  236. 		// type: 0xFA  Start

  237. 		handleStart = fptr;

  238. 	}

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

  240. 		// type: 0xFB  Continue

  241. 		handleContinue = fptr;

  242. 	}

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

  244. 		// type: 0xFC  Stop

  245. 		handleStop = fptr;

  246. 	}

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

  248. 		// type: 0xFE  ActiveSensing

  249. 		handleActiveSensing = fptr;

  250. 	}

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

  252. 		// type: 0xFF  SystemReset

  253. 		handleSystemReset = fptr;

  254. 	}

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

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

  257. 		handleRealTimeSystem = fptr;

  258. 	}

  259. private:

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

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

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

  263. 	void read_sysex_byte(uint8_t b);

  264. 	uint8_t msg_channel;

  265. 	uint8_t msg_type;

  266. 	uint8_t msg_data1;

  267. 	uint8_t msg_data2;

  268. 	uint8_t msg_sysex[USB_MIDI_SYSEX_MAX];

  269. 	uint16_t msg_sysex_len;

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

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

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

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

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

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

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

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

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

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

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

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

  282. 	void (*handleTuneRequest)(void);

  283. 	void (*handleClock)(void);

  284. 	void (*handleStart)(void);

  285. 	void (*handleContinue)(void);

  286. 	void (*handleStop)(void);

  287. 	void (*handleActiveSensing)(void);

  288. 	void (*handleSystemReset)(void);

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

  290. };

  291. 

  292. extern usb_midi_class usbMIDI;

  293. 

  294. 

  295. class usb_serial_class : public Stream

  296. {

  297. public:

  298. 	// standard Arduino functions

  299. 	void begin(long);

  300. 	void end();

  301. 	virtual int available();

  302. 	virtual int read();

  303. 	virtual int peek();

  304. 	virtual void flush();

  305. #if ARDUINO >= 100

  306. 	virtual size_t write(uint8_t);

  307. #else

  308. 	virtual void write(uint8_t);

  309. #endif

  310. 	using Print::write;

  311. 	operator bool();

  312. 	// Teensy extensions

  313. 	void send_now(void);

  314. 	uint32_t baud(void);

  315. 	uint8_t stopbits(void);

  316. 	uint8_t paritytype(void);

  317. 	uint8_t numbits(void);

  318. 	uint8_t dtr(void);

  319. 	uint8_t rts(void);

  320. private:

  321. 	uint8_t readnext(void);

  322. };

  323. 

  324. extern usb_serial_class Serial;

  325. 

  326. 

  327. #endif