visus
/
teensy-cores
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
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.
12 Commits
1 Branch
Tree: ee66b4f4a1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ee66b4f4a1'
${ noResults }
teensy-cores/usb_flightsim/usb_api.cpp

734 lines
16KB
Raw Blame History 

  1. /* USB API for Teensy USB Development Board

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

  3.  * Copyright (c) 2012 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. FlightSimCommand * FlightSimCommand::first = NULL;

  34. FlightSimCommand * FlightSimCommand::last = NULL;

  35. FlightSimInteger * FlightSimInteger::first = NULL;

  36. FlightSimInteger * FlightSimInteger::last = NULL;

  37. FlightSimFloat * FlightSimFloat::first = NULL;

  38. FlightSimFloat * FlightSimFloat::last = NULL;

  39. 

  40. uint8_t FlightSimClass::enabled = 0;

  41. uint8_t FlightSimClass::request_id_messages = 0;

  42. unsigned long FlightSimClass::frameCount = 0;

  43. elapsedMillis FlightSimClass::enableTimeout;

  44. 

  45. static unsigned int unassigned_id = 1;  // TODO: move into FlightSimClass

  46. 

  47. 

  48. 

  49. 

  50. 

  51. FlightSimCommand::FlightSimCommand()

  52. {

  53. 	id = unassigned_id++;

  54. 	if (!first) {

  55. 		first = this;

  56. 	} else {

  57. 		last->next = this;

  58. 	}

  59. 	last = this;

  60. 	name = NULL;

  61. 	next = NULL;

  62. 	FlightSimClass::request_id_messages = 1;

  63. }

  64. 

  65. void FlightSimCommand::identify(void)

  66. {

  67. 	uint8_t len, buf[6];

  68. 

  69. 	if (!FlightSim.enabled || !name) return;

  70. 	len = strlen_P((const prog_char*)name);

  71. 	buf[0] = len + 6;

  72. 	buf[1] = 1;

  73. 	buf[2] = id;

  74. 	buf[3] = id >> 8;

  75. 	buf[4] = 0;

  76. 	buf[5] = 0;

  77. 	FlightSimClass::xmit(buf, 6, name, len);

  78. }

  79. 

  80. void FlightSimCommand::sendcmd(uint8_t n)

  81. {

  82. 	uint8_t buf[4];

  83. 

  84. 	if (!FlightSim.enabled || !name) return;

  85. 	buf[0] = 4;

  86. 	buf[1] = n;

  87. 	buf[2] = id;

  88. 	buf[3] = id >> 8;

  89. 	FlightSimClass::xmit(buf, 4);

  90. }

  91. 

  92. 

  93. FlightSimInteger::FlightSimInteger()

  94. {

  95. 	id = unassigned_id++;

  96. 	if (!first) {

  97. 		first = this;

  98. 	} else {

  99. 		last->next = this;

  100. 	}

  101. 	last = this;

  102. 	name = NULL;

  103. 	next = NULL;

  104. 	value = 0;

  105. 	change_callback = NULL;

  106. 	FlightSimClass::request_id_messages = 1;

  107. }

  108. 

  109. void FlightSimInteger::identify(void)

  110. {

  111. 	uint8_t len, buf[6];

  112. 

  113. 	if (!FlightSim.enabled || !name) return;

  114. 	len = strlen_P((const prog_char*)name);

  115. 	buf[0] = len + 6;

  116. 	buf[1] = 1;

  117. 	buf[2] = id;

  118. 	buf[3] = id >> 8;

  119. 	buf[4] = 1;

  120. 	buf[5] = 0;

  121. 	FlightSimClass::xmit(buf, 6, name, len);

  122. }

  123. 

  124. void FlightSimInteger::write(long val)

  125. {

  126. 	uint8_t buf[6];

  127. 

  128. 	value = val;

  129. 	if (!FlightSim.enabled || !name) return; // TODO: mark as dirty

  130. 	buf[0] = 10;

  131. 	buf[1] = 2;

  132. 	buf[2] = id;

  133. 	buf[3] = id >> 8;

  134. 	buf[4] = 1;

  135. 	buf[5] = 0;

  136. 	FlightSimClass::xmit(buf, 6, (uint8_t *)&value, 4);

  137. }

  138. 

  139. void FlightSimInteger::update(long val)

  140. {

  141. 	value = val;

  142. 	if (change_callback) (*change_callback)(val);

  143. }

  144. 

  145. FlightSimInteger * FlightSimInteger::find(unsigned int n)

  146. {

  147. 	for (FlightSimInteger *p = first; p; p = p->next) {

  148. 		if (p->id == n) return p;

  149. 	}

  150. 	return NULL;

  151. }

  152. 

  153. 

  154. 

  155. 

  156. FlightSimFloat::FlightSimFloat()

  157. {

  158. 	id = unassigned_id++;

  159. 	if (!first) {

  160. 		first = this;

  161. 	} else {

  162. 		last->next = this;

  163. 	}

  164. 	last = this;

  165. 	name = NULL;

  166. 	next = NULL;

  167. 	value = 0;

  168. 	change_callback = NULL;

  169. 	FlightSimClass::request_id_messages = 1;

  170. }

  171. 

  172. void FlightSimFloat::identify(void)

  173. {

  174. 	uint8_t len, buf[6];

  175. 

  176. 	if (!FlightSim.enabled || !name) return;

  177. 	len = strlen_P((const prog_char*)name);

  178. 	buf[0] = len + 6;

  179. 	buf[1] = 1;

  180. 	buf[2] = id;

  181. 	buf[3] = id >> 8;

  182. 	buf[4] = 2;

  183. 	buf[5] = 0;

  184. 	FlightSimClass::xmit(buf, 6, name, len);

  185. }

  186. 

  187. void FlightSimFloat::write(float val)

  188. {

  189. 	uint8_t buf[6];

  190. 

  191. 	value = val;

  192. 	if (!FlightSim.enabled || !name) return; // TODO: mark as dirty

  193. 	buf[0] = 10;

  194. 	buf[1] = 2;

  195. 	buf[2] = id;

  196. 	buf[3] = id >> 8;

  197. 	buf[4] = 2;

  198. 	buf[5] = 0;

  199. 	FlightSimClass::xmit(buf, 6, (uint8_t *)&value, 4);

  200. }

  201. 

  202. void FlightSimFloat::update(float val)

  203. {

  204. 	value = val;

  205. 	if (change_callback) (*change_callback)(val);

  206. }

  207. 

  208. FlightSimFloat * FlightSimFloat::find(unsigned int n)

  209. {

  210. 	for (FlightSimFloat *p = first; p; p = p->next) {

  211. 		if (p->id == n) return p;

  212. 	}

  213. 	return NULL;

  214. }

  215. 

  216. 

  217. 

  218. 

  219. 

  220. 

  221. FlightSimClass::FlightSimClass()

  222. {

  223. }

  224. 

  225. void FlightSimClass::update(void)

  226. {

  227. 	uint8_t len, maxlen, type, buf[64], *p;

  228. 	uint16_t id;

  229. 

  230. 	while (recv(buf)) {

  231. 		p = buf;

  232. 		maxlen = 64;

  233. 		do {

  234. 			len = p[0];

  235. 			if (len < 2 || len > maxlen) break;

  236. 			switch (p[1]) {

  237. 			  case 0x02: // write data

  238. 				if (len < 10) break;

  239. 				id = p[2] | (p[3] << 8);

  240. 				type = p[4];

  241. 				if (type == 1) {

  242. 					FlightSimInteger *item = FlightSimInteger::find(id);

  243. 					if (!item) break;

  244. 					item->update(*(long *)(p + 6));

  245. 				} else if (type == 2) {

  246. 					FlightSimFloat *item = FlightSimFloat::find(id);

  247. 					if (!item) break;

  248. 					item->update(*(float *)(p + 6));

  249. 				}

  250. 				break;

  251. 			  case 0x03: // enable/disable

  252. 				if (len < 4) break;

  253. 				switch (p[2]) {

  254. 				  case 1:

  255. 					request_id_messages = 1;

  256. 				  case 2:

  257. 					enable();

  258. 					frameCount++;

  259. 					break;

  260. 				  case 3:

  261. 					disable();

  262. 				}

  263. 			}

  264. 			p += len;

  265. 			maxlen -= len;

  266. 		} while (p < buf + 64);

  267. 	}

  268. 	if (enabled && request_id_messages) {

  269. 		request_id_messages = 0;

  270. 		for (FlightSimCommand *p = FlightSimCommand::first; p; p = p->next) {

  271. 			p->identify();

  272. 		}

  273. 		for (FlightSimInteger *p = FlightSimInteger::first; p; p = p->next) {

  274. 			p->identify();

  275. 			// TODO: send any dirty data

  276. 		}

  277. 		for (FlightSimFloat *p = FlightSimFloat::first; p; p = p->next) {

  278. 			p->identify();

  279. 			// TODO: send any dirty data

  280. 		}

  281. 	}

  282. }

  283. 

  284. 

  285. bool FlightSimClass::isEnabled(void)

  286. {

  287.         if (!usb_configuration) return false;

  288.         if (!enabled) return false;

  289. 	if (enableTimeout > 1500) return false;

  290.         return true;

  291. }

  292. 

  293. 

  294. // receive a packet

  295. uint8_t FlightSimClass::recv(uint8_t *buffer)

  296. {

  297.         uint8_t intr_state;

  298. 

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

  300.         if (!usb_configuration) return 0;

  301.         intr_state = SREG;

  302.         cli();

  303.         UENUM = FLIGHTSIM_RX_ENDPOINT;

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

  305.         	SREG = intr_state;

  306. 		return 0;

  307. 	}

  308.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  309.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  310.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  311.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  312. 

  313.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  314.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  315.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  316.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  317. 

  318.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  319.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  320.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  321.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  322. 

  323.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  324.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  325.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  326.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  327. 

  328.         UEINTX = 0x6B;

  329.         SREG = intr_state;

  330.         return 1;

  331. }

  332. 

  333. 

  334. 

  335. 

  336. void FlightSimClass::xmit(const uint8_t *p1, uint8_t n1)

  337. {

  338. 	uint8_t intr_state, avail;

  339. 

  340. 	if (n1 > FLIGHTSIM_TX_SIZE) return;

  341. 	if (!enabled || !usb_configuration) return;

  342. 	intr_state = SREG;

  343. 	cli();

  344. 	UENUM = FLIGHTSIM_TX_ENDPOINT;

  345. 	avail = FLIGHTSIM_TX_SIZE - UEBCLX;

  346. 	if ((UEINTX & (1<<RWAL)) && (avail >= n1)) {

  347. 		goto send;

  348. 	} else {

  349. 		while (avail) {

  350. 			UEDATX = 0;

  351. 			avail--;

  352. 		}

  353. 		UEINTX = 0x3A;

  354. 		while (1) {

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

  356. 			SREG = intr_state;

  357. 			if (!enabled || !usb_configuration) return;

  358. 			intr_state = SREG;

  359. 			cli();

  360. 			UENUM = FLIGHTSIM_TX_ENDPOINT;

  361. 		}

  362. 	}

  363. send:

  364. 	do {

  365. 		UEDATX = *p1++;

  366. 	} while (--n1 > 0);

  367. 	if (UEBCLX == FLIGHTSIM_TX_SIZE) UEINTX = 0x3A;

  368. 	SREG = intr_state;

  369. }

  370. 

  371. 

  372. void FlightSimClass::xmit(const uint8_t *p1, uint8_t n1, const uint8_t *p2, uint8_t n2)

  373. {

  374. 	uint8_t intr_state, total, avail;

  375. 

  376. 	total = n1 + n2;

  377. 	if (total > FLIGHTSIM_TX_SIZE) return;

  378. 	if (!enabled || !usb_configuration) return;

  379. 	intr_state = SREG;

  380. 	cli();

  381. 	UENUM = FLIGHTSIM_TX_ENDPOINT;

  382. 	avail = FLIGHTSIM_TX_SIZE - UEBCLX;

  383. 	if ((UEINTX & (1<<RWAL)) && (avail >= total)) {

  384. 		goto send;

  385. 	} else {

  386. 		while (avail) {

  387. 			UEDATX = 0;

  388. 			avail--;

  389. 		}

  390. 		UEINTX = 0x3A;

  391. 		while (1) {

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

  393. 			SREG = intr_state;

  394. 			if (!enabled || !usb_configuration) return;

  395. 			intr_state = SREG;

  396. 			cli();

  397. 			UENUM = FLIGHTSIM_TX_ENDPOINT;

  398. 		}

  399. 	}

  400. send:

  401. 	do {

  402. 		UEDATX = *p1++;

  403. 	} while (--n1 > 0);

  404. 	do {

  405. 		UEDATX = *p2++;

  406. 	} while (--n2 > 0);

  407. 	if (UEBCLX == FLIGHTSIM_TX_SIZE) UEINTX = 0x3A;

  408. 	SREG = intr_state;

  409. }

  410. 

  411. 

  412. void FlightSimClass::xmit(const uint8_t *p1, uint8_t n1, const _XpRefStr_ *p2, uint8_t n2)

  413. {

  414. 	uint8_t intr_state, total, avail;

  415. 	const prog_char *s2 = (const prog_char *)p2;

  416. 

  417. 	total = n1 + n2;

  418. 	if (total > FLIGHTSIM_TX_SIZE) return;

  419. 	if (!enabled || !usb_configuration) return;

  420. 	intr_state = SREG;

  421. 	cli();

  422. 	UENUM = FLIGHTSIM_TX_ENDPOINT;

  423. 	avail = FLIGHTSIM_TX_SIZE - UEBCLX;

  424. 	if ((UEINTX & (1<<RWAL)) && (avail >= total)) {

  425. 		goto send;

  426. 	} else {

  427. 		while (avail) {

  428. 			UEDATX = 0;

  429. 			avail--;

  430. 		}

  431. 		UEINTX = 0x3A;

  432. 		while (1) {

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

  434. 			SREG = intr_state;

  435. 			if (!enabled || !usb_configuration) return;

  436. 			intr_state = SREG;

  437. 			cli();

  438. 			UENUM = FLIGHTSIM_TX_ENDPOINT;

  439. 		}

  440. 	}

  441. send:

  442. 	do {

  443. 		UEDATX = *p1++;

  444. 	} while (--n1 > 0);

  445. 	do {

  446. 		pgm_read_byte_postinc(UEDATX, s2);

  447. 	} while (--n2 > 0);

  448. 	if (UEBCLX == FLIGHTSIM_TX_SIZE) UEINTX = 0x3A;

  449. 	SREG = intr_state;

  450. }

  451. 

  452. 

  453. 

  454. FlightSimClass FlightSim;

  455. 

  456. 

  457. 

  458. 

  459. 

  460. 

  461. 

  462. 

  463. 

  464. static volatile uint8_t prev_byte=0;

  465. 

  466. void usb_serial_class::begin(long speed)

  467. {

  468. 	// make sure USB is initialized

  469. 	usb_init();

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

  471. 	while (1) {

  472. 		if (usb_configuration) {

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

  474. 			return;

  475. 		}

  476. 		if (usb_suspended) {

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

  478. 			while (usb_suspended) {

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

  480. 				// normal USB enumeration causes brief suspend

  481. 				// states, typically under 0.1 second

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

  483. 					return;

  484. 				}

  485. 			}

  486. 		}

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

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

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

  490. 	}

  491. 	prev_byte = 0;

  492. }

  493. 

  494. void usb_serial_class::end()

  495. {

  496. 	usb_shutdown();

  497. 	delay(25);

  498. }

  499. 

  500. 

  501. 

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

  503. int usb_serial_class::available()

  504. {

  505.         uint8_t c;

  506. 

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

  508. 	if (c) return 1;

  509. 	c = readnext();

  510. 	if (c) {

  511. 		prev_byte = c;

  512. 		return 1;

  513. 	}

  514. 	return 0;

  515. }

  516. 

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

  518. int usb_serial_class::read()

  519. {

  520. 	uint8_t c;

  521. 

  522. 	c = prev_byte;

  523. 	if (c) {

  524. 		prev_byte = 0;

  525. 		return c;

  526. 	}

  527. 	c = readnext();

  528. 	if (c) return c;

  529. 	return -1;

  530. }

  531. 

  532. int usb_serial_class::peek()

  533. {

  534. 	uint8_t c;

  535. 	

  536. 	c = prev_byte;

  537. 	if (c) return c;

  538. 	c = readnext();

  539. 	if (c) {

  540. 		prev_byte = c;

  541. 		return c;

  542. 	}

  543. 	return -1;

  544. }

  545. 

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

  547. uint8_t usb_serial_class::readnext(void)

  548. {

  549.         uint8_t c, intr_state;

  550. 

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

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

  553.         // even both in the same program!

  554.         intr_state = SREG;

  555.         cli();

  556.         if (!usb_configuration) {

  557.                 SREG = intr_state;

  558.                 return 0;

  559.         }

  560.         UENUM = DEBUG_RX_ENDPOINT;

  561. try_again:

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

  563.                 // no packet in buffer

  564.                 SREG = intr_state;

  565.                 return 0;

  566.         }

  567.         // take one byte out of the buffer

  568.         c = UEDATX;

  569. 	if (c == 0) {

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

  571. 		// discard the rest of this packet

  572. 		UEINTX = 0x6B;

  573. 		goto try_again;

  574. 	}

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

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

  577.         SREG = intr_state;

  578.         return c;

  579. }

  580. 

  581. // discard any buffered input

  582. void usb_serial_class::flush()

  583. {

  584.         uint8_t intr_state;

  585. 

  586.         if (usb_configuration) {

  587.                 intr_state = SREG;

  588.                 cli();

  589. 		UENUM = DEBUG_RX_ENDPOINT;

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

  591.                         UEINTX = 0x6B;

  592.                 }

  593.                 SREG = intr_state;

  594.         }

  595. 	prev_byte = 0;

  596. }

  597. 

  598. // transmit a character.

  599. #if ARDUINO >= 100

  600. size_t usb_serial_class::write(uint8_t c)

  601. #else

  602. void usb_serial_class::write(uint8_t c)

  603. #endif

  604. {

  605.         //static uint8_t previous_timeout=0;

  606.         uint8_t timeout, intr_state;

  607. 

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

  609.         if (!usb_configuration) goto error;

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

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

  612.         // even both in the same program!

  613.         intr_state = SREG;

  614.         cli();

  615.         UENUM = DEBUG_TX_ENDPOINT;

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

  617. #if 0

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

  619.         if (previous_timeout) {

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

  621.                         SREG = intr_state;

  622.                         return;

  623.                 }

  624.                 previous_timeout = 0;

  625.         }

  626. #endif

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

  628.         timeout = UDFNUML + TRANSMIT_TIMEOUT;

  629.         while (1) {

  630.                 // are we ready to transmit?

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

  632.                 SREG = intr_state;

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

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

  635.                 if (UDFNUML == timeout) {

  636.                         //previous_timeout = 1;

  637. 			goto error;

  638. 		}

  639.                 // has the USB gone offline?

  640.                 if (!usb_configuration) goto error;

  641.                 // get ready to try checking again

  642.                 intr_state = SREG;

  643.                 cli();

  644.                 UENUM = DEBUG_TX_ENDPOINT;

  645.         }

  646.         // actually write the byte into the FIFO

  647.         UEDATX = c;

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

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

  650. 		UEINTX = 0x3A;

  651.         	debug_flush_timer = 0;

  652. 	} else {

  653.         	debug_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  654. 	}

  655.         SREG = intr_state;

  656. #if ARDUINO >= 100

  657. 	return 1;

  658. #endif

  659. error:

  660. #if ARDUINO >= 100

  661. 	setWriteError();

  662. 	return 0;

  663. #else

  664. 	return;

  665. #endif

  666. }

  667. 

  668. 

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

  670. 

  671. // immediately transmit any buffered output.

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

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

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

  675. void usb_serial_class::send_now(void)

  676. {

  677.         uint8_t intr_state;

  678. 

  679.         intr_state = SREG;

  680.         cli();

  681.         if (debug_flush_timer) {

  682.                 UENUM = DEBUG_TX_ENDPOINT;

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

  684. 			UEDATX = 0;

  685. 		}

  686.                 UEINTX = 0x3A;

  687.                 debug_flush_timer = 0;

  688.         }

  689.         SREG = intr_state;

  690. }

  691. 

  692. uint32_t usb_serial_class::baud(void)

  693. {

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

  695. }

  696. 

  697. uint8_t usb_serial_class::stopbits(void)

  698. {

  699. 	return 1;

  700. }

  701. 

  702. uint8_t usb_serial_class::paritytype(void)

  703. {

  704. 	return 0;

  705. }

  706. 

  707. uint8_t usb_serial_class::numbits(void)

  708. {

  709. 	return 8;

  710. }

  711. 

  712. uint8_t usb_serial_class::dtr(void)

  713. {

  714. 	return 1;

  715. }

  716. 

  717. uint8_t usb_serial_class::rts(void)

  718. {

  719. 	return 1;

  720. }

  721. 

  722. usb_serial_class::operator bool()

  723. {

  724. 	if (usb_configuration) return true;

  725. 	return false;

  726. }

  727. 

  728. 

  729. 

  730. // Preinstantiate Objects //////////////////////////////////////////////////////

  731. 

  732. usb_serial_class	Serial = usb_serial_class();