visus
/
teensy-core-4.1
Bevaka 1
Stjärnmärk 0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
Teensy 4.1 core updated for C++20
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
996 Incheckningar
2 Grenar
Träd: c4fe5e9303
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från 'c4fe5e9303'
${ noResults }
teensy-core-4.1/usb_midi/usb_api.cpp

716 lines
18KB
Rå Blame Historik 

  1. /* USB API for Teensy USB Development Board

  2.  * http://www.pjrc.com/teensy/teensyduino.html

  3.  * Copyright (c) 2008 PJRC.COM, LLC

  4.  * 

  5.  * Permission is hereby granted, free of charge, to any person obtaining a copy

  6.  * of this software and associated documentation files (the "Software"), to deal

  7.  * in the Software without restriction, including without limitation the rights

  8.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  9.  * copies of the Software, and to permit persons to whom the Software is

  10.  * furnished to do so, subject to the following conditions:

  11.  * 

  12.  * The above copyright notice and this permission notice shall be included in

  13.  * all copies or substantial portions of the Software.

  14.  * 

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  18.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  20.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  21.  * THE SOFTWARE.

  22.  */

  23. 

  24. #include <avr/io.h>

  25. #include <avr/pgmspace.h>

  26. #include <stdint.h>

  27. #include "usb_common.h"

  28. #include "usb_private.h"

  29. #include "usb_api.h"

  30. #include "wiring.h"

  31. 

  32. 

  33. void usb_midi_class::sendSysEx_BufferHasTerm(uint16_t length, const uint8_t *data)

  34. {

  35. 	while (length > 3) {

  36. 		send_raw(0x04, data[0], data[1], data[2]);

  37. 		data += 3;

  38. 		length -= 3;

  39. 	}

  40. 	if (length == 3) {

  41. 		send_raw(0x07, data[0], data[1], data[2]);

  42. 	} else if (length == 2) {

  43. 		send_raw(0x06, data[0], data[1], 0);

  44. 	} else if (length == 1) {

  45. 		send_raw(0x05, data[0], 0, 0);

  46. 	}

  47. }

  48. 

  49. void usb_midi_class::sendSysEx_AddTermBytes(uint16_t length, const uint8_t *data)

  50. {

  51. 	if (length == 0) {

  52. 		send_raw(0x06, 0xF0, 0xF7, 0);

  53. 		return;

  54. 	} else if (length == 1) {

  55. 		send_raw(0x07, 0xF0, data[0], 0xF7);

  56. 		return;

  57. 	} else {

  58. 		send_raw(0x04, 0xF0, data[0], data[1]);

  59. 		data += 2;

  60. 		length -= 2;

  61. 	}

  62. 	while (length >= 3) {

  63. 		send_raw(0x04, data[0], data[1], data[2]);

  64. 		data += 3;

  65. 		length -= 3;

  66. 	}

  67. 	if (length == 2) {

  68. 		send_raw(0x07, data[0], data[1], 0xF7);

  69. 	} else if (length == 1) {

  70. 		send_raw(0x06, data[0], 0xF7, 0);

  71. 	} else {

  72. 		send_raw(0x05, 0xF7, 0, 0);

  73. 	}

  74. }

  75. 

  76. void usb_midi_class::send_raw(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3)

  77. {

  78. 	uint8_t intr_state, timeout;

  79. 

  80. 	if (!usb_configuration) return;

  81. 	intr_state = SREG;

  82. 	cli();

  83. 	UENUM = MIDI_TX_ENDPOINT;

  84. 	timeout = UDFNUML + 2;

  85. 	while (1) {

  86. 		// are we ready to transmit?

  87. 		if (UEINTX & (1<<RWAL)) break;

  88. 		SREG = intr_state;

  89. 		if (UDFNUML == timeout) return;

  90. 		if (!usb_configuration) return;

  91. 		intr_state = SREG;

  92. 		cli();

  93. 		UENUM = MIDI_TX_ENDPOINT;

  94. 	}

  95. 	UEDATX = b0;

  96. 	UEDATX = b1;

  97. 	UEDATX = b2;

  98. 	UEDATX = b3;

  99. 	if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;

  100. 	SREG = intr_state;

  101. }

  102. 

  103. void usb_midi_class::send_now(void)

  104. {

  105. 	uint8_t intr_state;

  106. 

  107. 	if (!usb_configuration) return;

  108. 	intr_state = SREG;

  109. 	cli();

  110. 	UENUM = MIDI_TX_ENDPOINT;

  111. 	if (UEBCLX != MIDI_TX_SIZE) {

  112. 		UEINTX = 0x3A;

  113. 	}

  114. 	SREG = intr_state;

  115. }

  116. 

  117. 

  118. 

  119. // Convert 10 bit linear measurements to a logarthmic scale

  120. // suitable for sending as MIDI velocity numbers.  The

  121. // "range" parameter should be probably be between 30 to 60,

  122. // with 36 probably a good default.

  123. //

  124. // This function uses fast 16 bit unsigned integer math.  :-)

  125. //

  126. uint8_t usb_midi_class::analog2velocity(uint16_t val, uint8_t range)

  127. {

  128. #if 0

  129. 	if (val == 0) return 0;

  130. 	float scale = 1.0 + (20.0 / (float)range) * log10((float)val / 1023.0);

  131. 	if (scale < 0) return 0;

  132. 	return 127 * scale;

  133. #else

  134. 	uint8_t i, e, b;

  135. 	uint16_t s=0;

  136. 	static const uint8_t PROGMEM table[] = {225,124,65,34,17,9,4,2,1};

  137. 

  138. 	if (val == 0) return 0;

  139. 	if (val >= 1023) return 127;

  140. 	for (e=0; (val & 512) == 0; e++) val <<= 1;

  141. 	for (i=0; i<9; i++) {  // cordic algorithm

  142. 		uint16_t x = val + (val >> (i + 1));

  143. 		if (x < 1024) {

  144. 			val = x;

  145. 			s += pgm_read_byte(table + i);

  146. 		}

  147. 	}

  148. 	s += e * 385;

  149. 	s <<= 4;

  150. 	s += (range >> 1);

  151. 	s /= range;

  152. 	if (s >= 1024) return 0;

  153. 	s = 1024 - s;

  154. 	if (s > 511) {

  155. 		s -= 512;

  156. 		b = 64;

  157. 	} else if (s > 255) {

  158. 		s -= 256;

  159. 		b = 32;

  160. 	} else {

  161. 		b = 0;

  162. 	}

  163. 	return b + ((s * 127) >> 10);

  164. #endif

  165. }

  166. 

  167. 

  168. 

  169. 

  170. uint32_t usb_midi_class::midiusb_available()

  171. {

  172. 	uint8_t c, intr_state;

  173. 

  174. 	intr_state = SREG;

  175. 	cli();

  176. 	if (!usb_configuration) {

  177. 		SREG = intr_state;

  178. 		return 0;

  179. 	}

  180. 	UENUM = MIDI_RX_ENDPOINT;

  181. 	retry:

  182. 	c = UEINTX;

  183. 	if (!(c & (1<<RWAL))) {

  184. 		if (c & (1<<RXOUTI)) {

  185. 			UEINTX = 0x6B;

  186. 			goto retry;

  187. 		}

  188. 		SREG = intr_state;

  189. 		return 0;

  190. 	}

  191. 	SREG = intr_state;

  192. 	return 4;

  193. }

  194. 

  195. void usb_midi_class::midiusb_read(uint8_t *buf)

  196. {

  197. 	uint8_t c, intr_state;

  198. 

  199. 	intr_state = SREG;

  200. 	cli();

  201. 	if (!usb_configuration) {

  202. 		SREG = intr_state;

  203. 		buf[0] = 0;

  204. 		buf[1] = 0;

  205. 		buf[2] = 0;

  206. 		buf[3] = 0;

  207. 		return;

  208. 	}

  209. 	UENUM = MIDI_RX_ENDPOINT;

  210. 	retry:

  211. 	c = UEINTX;

  212. 	if (!(c & (1<<RWAL))) {

  213. 		if (c & (1<<RXOUTI)) {

  214. 			UEINTX = 0x6B;

  215. 			goto retry;

  216. 		}

  217. 		SREG = intr_state;

  218. 		buf[0] = 0;

  219. 		buf[1] = 0;

  220. 		buf[2] = 0;

  221. 		buf[3] = 0;

  222. 		return;

  223. 	}

  224. 	buf[0] = UEDATX;

  225. 	buf[1] = UEDATX;

  226. 	buf[2] = UEDATX;

  227. 	buf[3] = UEDATX;

  228. 	if (!(UEINTX & (1<<RWAL))) UEINTX = 0x6B;

  229. 	SREG = intr_state;

  230. }

  231. 

  232. 

  233. bool usb_midi_class::read(uint8_t channel)

  234. {

  235. 	uint8_t c, intr_state;

  236. 	uint8_t b0, b1, b2, b3, type1, type2;

  237. 

  238. 	intr_state = SREG;

  239. 	cli();

  240. 	if (!usb_configuration) {

  241. 		SREG = intr_state;

  242. 		return false;

  243. 	}

  244. 	UENUM = MIDI_RX_ENDPOINT;

  245. 	retry:

  246. 	c = UEINTX;

  247. 	if (!(c & (1<<RWAL))) {

  248. 		if (c & (1<<RXOUTI)) {

  249. 			UEINTX = 0x6B;

  250. 			goto retry;

  251. 		}

  252. 		SREG = intr_state;

  253. 		return false;

  254. 	}

  255. 	b0 = UEDATX;

  256. 	b1 = UEDATX;

  257. 	b2 = UEDATX;

  258. 	b3 = UEDATX;

  259. 	if (!(UEINTX & (1<<RWAL))) UEINTX = 0x6B;

  260. 	SREG = intr_state;

  261. 

  262. 	type1 = b0 & 0x0F;

  263. 	type2 = b1 & 0xF0;

  264. 	c = (b1 & 0x0F) + 1;

  265. 	if (type1 >= 0x08 && type1 <= 0x0E) {

  266. 		if (channel && channel != c) {

  267. 			// ignore other channels when user wants single channel read

  268. 			return false;

  269. 		}

  270. 		if (type1 == 0x08 && type2 == 0x80) {

  271. 			msg_type = 0x80;			// 0x80 = usbMIDI.NoteOff

  272. 			if (handleNoteOff) (*handleNoteOff)(c, b2, b3);

  273. 		} else

  274. 		if (type1 == 0x09 && type2 == 0x90) {

  275. 			if (b3) {

  276. 				msg_type = 0x90;		// 0x90 = usbMIDI.NoteOn

  277. 				if (handleNoteOn) (*handleNoteOn)(c, b2, b3);

  278. 			} else {

  279. 				msg_type = 0x80;		// 0x80 = usbMIDI.NoteOff

  280. 				if (handleNoteOff) (*handleNoteOff)(c, b2, b3);

  281. 			}

  282. 		} else

  283. 		if (type1 == 0x0A && type2 == 0xA0) {

  284. 			msg_type = 0xA0;			// 0xA0 = usbMIDI.AfterTouchPoly

  285. 			if (handleVelocityChange) (*handleVelocityChange)(c, b2, b3);

  286. 		} else

  287. 		if (type1 == 0x0B && type2 == 0xB0) {

  288. 			msg_type = 0xB0;			// 0xB0 = usbMIDI.ControlChange

  289. 			if (handleControlChange) (*handleControlChange)(c, b2, b3);

  290. 		} else

  291. 		if (type1 == 0x0C && type2 == 0xC0) {

  292. 			msg_type = 0xC0;			// 0xC0 = usbMIDI.ProgramChange

  293. 			if (handleProgramChange) (*handleProgramChange)(c, b2);

  294. 		} else

  295. 		if (type1 == 0x0D && type2 == 0xD0) {

  296. 			msg_type = 0xD0;			// 0xD0 = usbMIDI.AfterTouchChannel

  297. 			if (handleAfterTouch) (*handleAfterTouch)(c, b2);

  298. 		} else

  299. 		if (type1 == 0x0E && type2 == 0xE0) {

  300. 			msg_type = 0xE0;			// 0xE0 = usbMIDI.PitchBend

  301. 			if (handlePitchChange) {

  302. 				int value = (b2 & 0x7F) | ((int)(b3 & 0x7F) << 7);

  303. 				value -= 8192; // 0 to 16383 --> -8192 to +8191

  304. 				(*handlePitchChange)(c, value);

  305. 			}

  306. 		} else {

  307. 			return false;

  308. 		}

  309. 		return_message:

  310. 		// only update these when returning true for a parsed message

  311. 		// all other return cases will preserve these user-visible values

  312. 		msg_channel = c;

  313. 		msg_data1 = b2;

  314. 		msg_data2 = b3;

  315. 		return true;

  316. 	}

  317. 	if (type1 == 0x02 || type1 == 0x03 || (type1 == 0x05 && type2 == 0x0F)) {

  318. 		// system common or system realtime message

  319. 		system_common_or_realtime:

  320. 		switch (b1) {

  321.                   case 0xF1: // usbMIDI.TimeCodeQuarterFrame

  322.                         if (handleTimeCodeQuarterFrame) {

  323.                                 (*handleTimeCodeQuarterFrame)(b2);

  324.                         }

  325.                         break;

  326.                   case 0xF2: // usbMIDI.SongPosition

  327.                         if (handleSongPosition) {

  328.                                 (*handleSongPosition)(

  329. 				  (uint16_t)(b2 & 0x7F) | (uint16_t)(b3 & 0x7F) << 7);

  330.                         }

  331.                         break;

  332.                   case 0xF3: // usbMIDI.SongSelect

  333.                         if (handleSongSelect) {

  334.                                 (*handleSongSelect)(b2);

  335.                         }

  336.                         break;

  337.                   case 0xF6: // usbMIDI.TuneRequest

  338.                         if (handleTuneRequest) {

  339.                                 (*handleTuneRequest)();

  340.                         }

  341.                         break;

  342.                   case 0xF8: // usbMIDI.Clock

  343.                         if (handleClock) {

  344.                                 (*handleClock)();

  345.                         } else if (handleRealTimeSystem) {

  346.                                 (*handleRealTimeSystem)(0xF8);

  347.                         }

  348.                         break;

  349.                   case 0xFA: // usbMIDI.Start

  350.                         if (handleStart) {

  351.                                 (*handleStart)();

  352.                         } else if (handleRealTimeSystem) {

  353.                                 (*handleRealTimeSystem)(0xFA);

  354.                         }

  355.                         break;

  356.                   case 0xFB: // usbMIDI.Continue

  357.                         if (handleContinue) {

  358.                                 (*handleContinue)();

  359.                         } else if (handleRealTimeSystem) {

  360.                                 (*handleRealTimeSystem)(0xFB);

  361.                         }

  362.                         break;

  363.                   case 0xFC: // usbMIDI.Stop

  364.                         if (handleStop) {

  365.                                 (*handleStop)();

  366.                         } else if (handleRealTimeSystem) {

  367.                                 (*handleRealTimeSystem)(0xFC);

  368.                         }

  369.                         break;

  370.                   case 0xFE: // usbMIDI.ActiveSensing

  371.                         if (handleActiveSensing) {

  372.                                 (*handleActiveSensing)();

  373.                         } else if (handleRealTimeSystem) {

  374.                                 (*handleRealTimeSystem)(0xFE);

  375.                         }

  376.                         break;

  377.                   case 0xFF: // usbMIDI.SystemReset

  378.                         if (handleSystemReset) {

  379.                                 (*handleSystemReset)();

  380.                         } else if (handleRealTimeSystem) {

  381.                                 (*handleRealTimeSystem)(0xFF);

  382.                         }

  383.                         break;

  384.                   default:

  385.                         return false; // unknown message, ignore it

  386.                 }

  387. 		msg_type = b1;

  388. 		goto return_message;

  389. 	}

  390. 	if (type1 == 0x04) {

  391. 		read_sysex_byte(b1);

  392. 		read_sysex_byte(b2);

  393. 		read_sysex_byte(b3);

  394. 		return false;

  395. 	}

  396. 	if (type1 >= 0x05 && type1 <= 0x07) {

  397. 		read_sysex_byte(b1);

  398. 		if (type1 >= 0x06) read_sysex_byte(b2);

  399. 		if (type1 == 0x07) read_sysex_byte(b3);

  400. 		uint16_t len = msg_sysex_len;

  401. 		msg_data1 = len;

  402. 		msg_data2 = len >> 8;

  403. 		msg_sysex_len = 0;

  404. 		msg_type = 0xF0;			// 0xF0 = usbMIDI.SystemExclusive

  405.                 if (handleSysExPartial) {

  406.                         (*handleSysExPartial)(msg_sysex, len, 1);

  407.                 } else if (handleSysExComplete) {

  408.                         (*handleSysExComplete)(msg_sysex, len);

  409.                 }

  410. 		return true;

  411. 	}

  412. 	if (type1 == 0x0F) {

  413. 		if (b1 >= 0xF8) {

  414. 			// From Sebastian Tomczak, seb.tomczak at gmail.com

  415. 			// http://little-scale.blogspot.com/2011/08/usb-midi-game-boy-sync-for-16.html

  416. 			goto system_common_or_realtime;

  417. 		}

  418. 		if (msg_sysex_len > 0) {

  419. 			// From David Sorlien, dsorlien at gmail.com, http://axe4live.wordpress.com

  420. 			// OSX sometimes uses Single Byte Unparsed to

  421. 			// send bytes in the middle of a SYSEX message.

  422. 			read_sysex_byte(b1);

  423. 		}

  424. 	}

  425. 	return false;

  426. }

  427. 

  428. void usb_midi_class::read_sysex_byte(uint8_t b)

  429. {

  430. 	if (handleSysExPartial && msg_sysex_len >= USB_MIDI_SYSEX_MAX) {

  431. 		// when buffer is full, send another chunk to partial handler.

  432. 		(*handleSysExPartial)(msg_sysex, msg_sysex_len, 0);

  433. 		msg_sysex_len = 0;

  434. 	}

  435. 	if (msg_sysex_len < USB_MIDI_SYSEX_MAX) {

  436. 		msg_sysex[msg_sysex_len++] = b;

  437. 	}

  438. }

  439. 

  440. 

  441. 

  442. 

  443. 

  444. static volatile uint8_t prev_byte=0;

  445. 

  446. void usb_serial_class::begin(long speed)

  447. {

  448. 	// make sure USB is initialized

  449. 	usb_init();

  450. 	uint16_t begin_wait = (uint16_t)millis();

  451. 	while (1) {

  452. 		if (usb_configuration) {

  453. 			delay(200);  // a little time for host to load a driver

  454. 			return;

  455. 		}

  456. 		if (usb_suspended) {

  457. 			uint16_t begin_suspend = (uint16_t)millis();

  458. 			while (usb_suspended) {

  459. 				// must remain suspended for a while, because

  460. 				// normal USB enumeration causes brief suspend

  461. 				// states, typically under 0.1 second

  462. 				if ((uint16_t)millis() - begin_suspend > 250) {

  463. 					return;

  464. 				}

  465. 			}

  466. 		}

  467. 		// ... or a timout (powered by a USB power adaptor that

  468. 		// wiggles the data lines to keep a USB device charging)

  469. 		if ((uint16_t)millis() - begin_wait > 2500) return;

  470. 	}

  471. 	prev_byte = 0;

  472. }

  473. 

  474. void usb_serial_class::end()

  475. {

  476. 	usb_shutdown();

  477. 	delay(25);

  478. }

  479. 

  480. 

  481. 

  482. // number of bytes available in the receive buffer

  483. int usb_serial_class::available()

  484. {

  485.         uint8_t c;

  486. 

  487. 	c = prev_byte;  // assume 1 byte static volatile access is atomic

  488. 	if (c) return 1;

  489. 	c = readnext();

  490. 	if (c) {

  491. 		prev_byte = c;

  492. 		return 1;

  493. 	}

  494. 	return 0;

  495. }

  496. 

  497. // get the next character, or -1 if nothing received

  498. int usb_serial_class::read()

  499. {

  500. 	uint8_t c;

  501. 

  502. 	c = prev_byte;

  503. 	if (c) {

  504. 		prev_byte = 0;

  505. 		return c;

  506. 	}

  507. 	c = readnext();

  508. 	if (c) return c;

  509. 	return -1;

  510. }

  511. 

  512. int usb_serial_class::peek()

  513. {

  514. 	uint8_t c;

  515. 

  516. 	c = prev_byte;

  517. 	if (c) return c;

  518. 	c = readnext();

  519. 	if (c) {

  520. 		prev_byte = c;

  521. 		return c;

  522. 	}

  523. 	return -1;

  524. }

  525. 

  526. // get the next character, or 0 if nothing

  527. uint8_t usb_serial_class::readnext(void)

  528. {

  529.         uint8_t c, intr_state;

  530. 

  531.         // interrupts are disabled so these functions can be

  532.         // used from the main program or interrupt context,

  533.         // even both in the same program!

  534.         intr_state = SREG;

  535.         cli();

  536.         if (!usb_configuration) {

  537.                 SREG = intr_state;

  538.                 return 0;

  539.         }

  540.         UENUM = DEBUG_RX_ENDPOINT;

  541. try_again:

  542.         if (!(UEINTX & (1<<RWAL))) {

  543.                 // no packet in buffer

  544.                 SREG = intr_state;

  545.                 return 0;

  546.         }

  547.         // take one byte out of the buffer

  548.         c = UEDATX;

  549. 	if (c == 0) {

  550. 		// if we see a zero, discard it and

  551. 		// discard the rest of this packet

  552. 		UEINTX = 0x6B;

  553. 		goto try_again;

  554. 	}

  555.         // if this drained the buffer, release it

  556.         if (!(UEINTX & (1<<RWAL))) UEINTX = 0x6B;

  557.         SREG = intr_state;

  558.         return c;

  559. }

  560. 

  561. // discard any buffered input

  562. void usb_serial_class::flush()

  563. {

  564.         uint8_t intr_state;

  565. 

  566.         if (usb_configuration) {

  567.                 intr_state = SREG;

  568.                 cli();

  569. 		UENUM = DEBUG_RX_ENDPOINT;

  570.                 while ((UEINTX & (1<<RWAL))) {

  571.                         UEINTX = 0x6B;

  572.                 }

  573.                 SREG = intr_state;

  574.         }

  575. 	prev_byte = 0;

  576. }

  577. 

  578. // transmit a character.

  579. #if ARDUINO >= 100

  580. size_t usb_serial_class::write(uint8_t c)

  581. #else

  582. #define setWriteError() 

  583. void usb_serial_class::write(uint8_t c)

  584. #endif

  585. {

  586.         //static uint8_t previous_timeout=0;

  587.         uint8_t timeout, intr_state;

  588. 

  589.         // if we're not online (enumerated and configured), error

  590.         if (!usb_configuration) goto error;

  591.         // interrupts are disabled so these functions can be

  592.         // used from the main program or interrupt context,

  593.         // even both in the same program!

  594.         intr_state = SREG;

  595.         cli();

  596.         UENUM = DEBUG_TX_ENDPOINT;

  597.         // if we gave up due to timeout before, don't wait again

  598. #if 0

  599. 	// this seems to be causig a lockup... why????

  600.         if (previous_timeout) {

  601.                 if (!(UEINTX & (1<<RWAL))) {

  602.                         SREG = intr_state;

  603.                         return;

  604.                 }

  605.                 previous_timeout = 0;

  606.         }

  607. #endif

  608.         // wait for the FIFO to be ready to accept data

  609.         timeout = UDFNUML + TRANSMIT_TIMEOUT;

  610.         while (1) {

  611.                 // are we ready to transmit?

  612.                 if (UEINTX & (1<<RWAL)) break;

  613.                 SREG = intr_state;

  614.                 // have we waited too long?  This happens if the user

  615.                 // is not running an application that is listening

  616.                 if (UDFNUML == timeout) {

  617.                         //previous_timeout = 1;

  618.                         goto error;

  619.                 }

  620.                 // has the USB gone offline?

  621.                 if (!usb_configuration) goto error;

  622.                 // get ready to try checking again

  623.                 intr_state = SREG;

  624.                 cli();

  625.                 UENUM = DEBUG_TX_ENDPOINT;

  626.         }

  627.         // actually write the byte into the FIFO

  628.         UEDATX = c;

  629.         // if this completed a packet, transmit it now!

  630.         if (!(UEINTX & (1<<RWAL))) {

  631. 		UEINTX = 0x3A;

  632.         	debug_flush_timer = 0;

  633. 	} else {

  634.         	debug_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  635. 	}

  636.         SREG = intr_state;

  637. #if ARDUINO >= 100

  638.         return 1;

  639. #endif

  640. error:

  641. #if ARDUINO >= 100

  642.         setWriteError();

  643.         return 0;

  644. #else

  645. 	return;

  646. #endif

  647. }

  648. 

  649. 

  650. // These are Teensy-specific extensions to the Serial object

  651. 

  652. // immediately transmit any buffered output.

  653. // This doesn't actually transmit the data - that is impossible!

  654. // USB devices only transmit when the host allows, so the best

  655. // we can do is release the FIFO buffer for when the host wants it

  656. void usb_serial_class::send_now(void)

  657. {

  658.         uint8_t intr_state;

  659. 

  660.         intr_state = SREG;

  661.         cli();

  662.         if (debug_flush_timer) {

  663.                 UENUM = DEBUG_TX_ENDPOINT;

  664. 		while ((UEINTX & (1<<RWAL))) {

  665. 			UEDATX = 0;

  666. 		}

  667.                 UEINTX = 0x3A;

  668.                 debug_flush_timer = 0;

  669.         }

  670.         SREG = intr_state;

  671. }

  672. 

  673. uint32_t usb_serial_class::baud(void)

  674. {

  675. 	return ((uint32_t)DEBUG_TX_SIZE * 10000 / DEBUG_TX_INTERVAL);

  676. }

  677. 

  678. uint8_t usb_serial_class::stopbits(void)

  679. {

  680. 	return 1;

  681. }

  682. 

  683. uint8_t usb_serial_class::paritytype(void)

  684. {

  685. 	return 0;

  686. }

  687. 

  688. uint8_t usb_serial_class::numbits(void)

  689. {

  690. 	return 8;

  691. }

  692. 

  693. uint8_t usb_serial_class::dtr(void)

  694. {

  695. 	return 1;

  696. }

  697. 

  698. uint8_t usb_serial_class::rts(void)

  699. {

  700. 	return 1;

  701. }

  702. 

  703. usb_serial_class::operator bool()

  704. {

  705. 	if (usb_configuration) return true;

  706. 	return false;

  707. }

  708. 

  709. 

  710. 

  711. // Preinstantiate Objects //////////////////////////////////////////////////////

  712. 

  713. usb_serial_class	Serial = usb_serial_class();

  714. usb_midi_class		usbMIDI = usb_midi_class();