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.
380 Commits
1 Branch
Tree: 0d394a6e76
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0d394a6e76'
${ noResults }
teensy-cores/usb_flightsim/usb_api.cpp

797 lines
18KB
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. 	uint16_t len;

  68. 	uint8_t buf[6];

  69. 

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

  71. 	len = strlen_P((const char *)name);

  72. 	buf[0] = len + 6;

  73. 	buf[1] = 1;

  74. 	buf[2] = id;

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

  76. 	buf[4] = 0;

  77. 	buf[5] = 0;

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

  79. }

  80. 

  81. void FlightSimCommand::sendcmd(uint8_t n)

  82. {

  83. 	uint8_t buf[4];

  84. 

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

  86. 	buf[0] = 4;

  87. 	buf[1] = n;

  88. 	buf[2] = id;

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

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

  91. }

  92. 

  93. 

  94. FlightSimInteger::FlightSimInteger()

  95. {

  96. 	id = unassigned_id++;

  97. 	if (!first) {

  98. 		first = this;

  99. 	} else {

  100. 		last->next = this;

  101. 	}

  102. 	last = this;

  103. 	name = NULL;

  104. 	next = NULL;

  105. 	value = 0;

  106. 	change_callback = NULL;

  107. 	FlightSimClass::request_id_messages = 1;

  108. }

  109. 

  110. void FlightSimInteger::identify(void)

  111. {

  112. 	uint16_t len;

  113. 	uint8_t buf[6];

  114. 

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

  116. 	len = strlen_P((const char *)name);

  117. 	buf[0] = len + 6;

  118. 	buf[1] = 1;

  119. 	buf[2] = id;

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

  121. 	buf[4] = 1;

  122. 	buf[5] = 0;

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

  124. }

  125. 

  126. void FlightSimInteger::write(long val)

  127. {

  128. 	uint8_t buf[6];

  129. 

  130. 	value = val;

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

  132. 	buf[0] = 10;

  133. 	buf[1] = 2;

  134. 	buf[2] = id;

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

  136. 	buf[4] = 1;

  137. 	buf[5] = 0;

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

  139. }

  140. 

  141. void FlightSimInteger::update(long val)

  142. {

  143. 	value = val;

  144. 	if (change_callback) {

  145. 		if (!hasCallbackInfo) {

  146. 			(*change_callback)(val);

  147. 		} else {

  148. 			(*(void(*)(long,void*))change_callback)(val,callbackInfo);

  149. 		}

  150. 	}

  151. }

  152. 

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

  154. {

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

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

  157. 	}

  158. 	return NULL;

  159. }

  160. 

  161. 

  162. 

  163. 

  164. FlightSimFloat::FlightSimFloat()

  165. {

  166. 	id = unassigned_id++;

  167. 	if (!first) {

  168. 		first = this;

  169. 	} else {

  170. 		last->next = this;

  171. 	}

  172. 	last = this;

  173. 	name = NULL;

  174. 	next = NULL;

  175. 	value = 0;

  176. 	change_callback = NULL;

  177. 	FlightSimClass::request_id_messages = 1;

  178. }

  179. 

  180. void FlightSimFloat::identify(void)

  181. {

  182. 	uint16_t len;

  183. 	uint8_t buf[6];

  184. 

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

  186. 	len = strlen_P((const char *)name);

  187. 	buf[0] = len + 6;

  188. 	buf[1] = 1;

  189. 	buf[2] = id;

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

  191. 	buf[4] = 2;

  192. 	buf[5] = 0;

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

  194. }

  195. 

  196. void FlightSimFloat::write(float val)

  197. {

  198. 	uint8_t buf[6];

  199. 

  200. 	value = val;

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

  202. 	buf[0] = 10;

  203. 	buf[1] = 2;

  204. 	buf[2] = id;

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

  206. 	buf[4] = 2;

  207. 	buf[5] = 0;

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

  209. }

  210. 

  211. void FlightSimFloat::update(float val)

  212. {

  213. 	value = val;

  214. 	if (change_callback) {

  215. 		if (!hasCallbackInfo) {

  216. 			(*change_callback)(val);

  217. 		} else {

  218. 			(*(void(*)(long,void*))change_callback)(val,callbackInfo);

  219. 		}

  220. 	}

  221. }

  222. 

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

  224. {

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

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

  227. 	}

  228. 	return NULL;

  229. }

  230. 

  231. 

  232. 

  233. 

  234. 

  235. 

  236. FlightSimClass::FlightSimClass()

  237. {

  238. }

  239. 

  240. void FlightSimClass::update(void)

  241. {

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

  243. 	uint16_t id;

  244. 

  245. 	while (recv(buf)) {

  246. 		p = buf;

  247. 		maxlen = 64;

  248. 		do {

  249. 			len = p[0];

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

  251. 			switch (p[1]) {

  252. 			  case 0x02: // write data

  253. 				if (len < 10) break;

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

  255. 				type = p[4];

  256. 				if (type == 1) {

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

  258. 					if (!item) break;

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

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

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

  262. 					if (!item) break;

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

  264. 				}

  265. 				break;

  266. 			  case 0x03: // enable/disable

  267. 				if (len < 4) break;

  268. 				switch (p[2]) {

  269. 				  case 1:

  270. 					request_id_messages = 1;

  271. 				  case 2:

  272. 					enable();

  273. 					frameCount++;

  274. 					break;

  275. 				  case 3:

  276. 					disable();

  277. 				}

  278. 			}

  279. 			p += len;

  280. 			maxlen -= len;

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

  282. 	}

  283. 	if (enabled && request_id_messages) {

  284. 		request_id_messages = 0;

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

  286. 			p->identify();

  287. 		}

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

  289. 			p->identify();

  290. 			// TODO: send any dirty data

  291. 		}

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

  293. 			p->identify();

  294. 			// TODO: send any dirty data

  295. 		}

  296. 	}

  297. }

  298. 

  299. 

  300. bool FlightSimClass::isEnabled(void)

  301. {

  302.         if (!usb_configuration) return false;

  303.         if (!enabled) return false;

  304. 	if (enableTimeout > 1500) return false;

  305.         return true;

  306. }

  307. 

  308. 

  309. // receive a packet

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

  311. {

  312.         uint8_t intr_state;

  313. 

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

  315.         if (!usb_configuration) return 0;

  316.         intr_state = SREG;

  317.         cli();

  318.         UENUM = FLIGHTSIM_RX_ENDPOINT;

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

  320.         	SREG = intr_state;

  321. 		return 0;

  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.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  329.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  330.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  331.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  332. 

  333.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  334.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  335.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  336.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  337. 

  338.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  339.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  340.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  341.         *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX; *buffer++ = UEDATX;

  342. 

  343.         UEINTX = 0x6B;

  344.         SREG = intr_state;

  345.         return 1;

  346. }

  347. 

  348. 

  349. 

  350. 

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

  352. {

  353. 	uint8_t intr_state, avail;

  354. 

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

  356. 	intr_state = SREG;

  357. 	cli();

  358. 	UENUM = FLIGHTSIM_TX_ENDPOINT;

  359. 	avail = FLIGHTSIM_TX_SIZE - UEBCLX;

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

  361. 		goto send;

  362. 	} else {

  363. 		while (avail) {

  364. 			UEDATX = 0;

  365. 			avail--;

  366. 		}

  367. 		UEINTX = 0x3A;

  368. 		while (1) {

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

  370. 			SREG = intr_state;

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

  372. 			intr_state = SREG;

  373. 			cli();

  374. 			UENUM = FLIGHTSIM_TX_ENDPOINT;

  375. 		}

  376. 	}

  377. send:

  378. 	do {

  379. 		UEDATX = *p1++;

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

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

  382. 	SREG = intr_state;

  383. }

  384. 

  385. 

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

  387. {

  388. 	uint8_t intr_state, total, avail;

  389. 

  390. 	total = n1 + n2;

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

  392. 	intr_state = SREG;

  393. 	cli();

  394. 	UENUM = FLIGHTSIM_TX_ENDPOINT;

  395. 	avail = FLIGHTSIM_TX_SIZE - UEBCLX;

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

  397. 		goto send;

  398. 	} else {

  399. 		while (avail) {

  400. 			UEDATX = 0;

  401. 			avail--;

  402. 		}

  403. 		UEINTX = 0x3A;

  404. 		while (1) {

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

  406. 			SREG = intr_state;

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

  408. 			intr_state = SREG;

  409. 			cli();

  410. 			UENUM = FLIGHTSIM_TX_ENDPOINT;

  411. 		}

  412. 	}

  413. send:

  414. 	do {

  415. 		UEDATX = *p1++;

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

  417. 	do {

  418. 		UEDATX = *p2++;

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

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

  421. 	SREG = intr_state;

  422. }

  423. 

  424. 

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

  426. 	uint8_t intr_state, total, avail;

  427. 	const char * PROGMEM s2 = (const char *)p2;

  428. 

  429. 	total = n1 + n2;

  430. 	if (total > FLIGHTSIM_TX_SIZE) {

  431. 		xmit_big_packet(p1, n1, p2,  n2);

  432. 		return;

  433. 	}

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

  435. 	intr_state = SREG;

  436. 	cli();

  437. 	UENUM = FLIGHTSIM_TX_ENDPOINT;

  438. 	avail = FLIGHTSIM_TX_SIZE - UEBCLX;

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

  440. 		goto send;

  441. 	} else {

  442. 		while (avail) {

  443. 			UEDATX = 0;

  444. 			avail--;

  445. 		}

  446. 		UEINTX = 0x3A;

  447. 		while (1) {

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

  449. 			SREG = intr_state;

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

  451. 			intr_state = SREG;

  452. 			cli();

  453. 			UENUM = FLIGHTSIM_TX_ENDPOINT;

  454. 		}

  455. 	}

  456. send:

  457. 	do {

  458. 		UEDATX = *p1++;

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

  460. 	do {

  461. 		pgm_read_byte_postinc(UEDATX, s2);

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

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

  464. 	SREG = intr_state;

  465. }

  466. 

  467. void FlightSimClass::xmit_big_packet(const uint8_t *p1, uint8_t n1, const _XpRefStr_ *p2, uint16_t n2) {

  468. 	uint8_t intr_state, avail;

  469. 	uint16_t total;

  470. 

  471. 	bool part1 = true;

  472. 	const char * PROGMEM s2 = (const char *)p2;

  473. 	uint8_t packet_id = 1;

  474. 

  475. 	total = n1 + n2;

  476. 

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

  478. 	intr_state = SREG;

  479. 	cli();

  480. 	UENUM = FLIGHTSIM_TX_ENDPOINT;

  481. 	avail = FLIGHTSIM_TX_SIZE - UEBCLX;

  482. 

  483. 	while (total>0) {

  484. 		if (part1) {

  485. 			UEDATX = *p1++;

  486. 			part1 = (--n1 != 0);

  487. 		} else {

  488. 			pgm_read_byte_postinc(UEDATX, s2);

  489. 			n2--;

  490.  		}

  491. 		total--;

  492. 

  493. 		if (!--avail) {

  494. 			// transmit packet

  495. 			UEINTX = 0x3A;

  496. 			while (1) {

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

  498. 				SREG = intr_state;

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

  500. 				intr_state = SREG;

  501. 				cli();

  502. 				UENUM = FLIGHTSIM_TX_ENDPOINT;

  503. 			}

  504. 

  505. 			// start new fragment with length and fragment ID

  506. 			UEDATX = (total<(FLIGHTSIM_TX_SIZE-3) ? total+3 : FLIGHTSIM_TX_SIZE); // length byte

  507. 			UEDATX = 0xff;

  508. 			UEDATX = packet_id++;

  509. 			avail = FLIGHTSIM_TX_SIZE - 3;

  510. 		}

  511. 	}

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

  513. 	SREG = intr_state;

  514. }

  515. 

  516. 

  517. FlightSimClass FlightSim;

  518. 

  519. 

  520. 

  521. 

  522. 

  523. 

  524. 

  525. 

  526. 

  527. static volatile uint8_t prev_byte=0;

  528. 

  529. void usb_serial_class::begin(long speed)

  530. {

  531. 	// make sure USB is initialized

  532. 	usb_init();

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

  534. 	while (1) {

  535. 		if (usb_configuration) {

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

  537. 			return;

  538. 		}

  539. 		if (usb_suspended) {

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

  541. 			while (usb_suspended) {

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

  543. 				// normal USB enumeration causes brief suspend

  544. 				// states, typically under 0.1 second

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

  546. 					return;

  547. 				}

  548. 			}

  549. 		}

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

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

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

  553. 	}

  554. 	prev_byte = 0;

  555. }

  556. 

  557. void usb_serial_class::end()

  558. {

  559. 	usb_shutdown();

  560. 	delay(25);

  561. }

  562. 

  563. 

  564. 

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

  566. int usb_serial_class::available()

  567. {

  568.         uint8_t c;

  569. 

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

  571. 	if (c) return 1;

  572. 	c = readnext();

  573. 	if (c) {

  574. 		prev_byte = c;

  575. 		return 1;

  576. 	}

  577. 	return 0;

  578. }

  579. 

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

  581. int usb_serial_class::read()

  582. {

  583. 	uint8_t c;

  584. 

  585. 	c = prev_byte;

  586. 	if (c) {

  587. 		prev_byte = 0;

  588. 		return c;

  589. 	}

  590. 	c = readnext();

  591. 	if (c) return c;

  592. 	return -1;

  593. }

  594. 

  595. int usb_serial_class::peek()

  596. {

  597. 	uint8_t c;

  598. 	

  599. 	c = prev_byte;

  600. 	if (c) return c;

  601. 	c = readnext();

  602. 	if (c) {

  603. 		prev_byte = c;

  604. 		return c;

  605. 	}

  606. 	return -1;

  607. }

  608. 

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

  610. uint8_t usb_serial_class::readnext(void)

  611. {

  612.         uint8_t c, intr_state;

  613. 

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

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

  616.         // even both in the same program!

  617.         intr_state = SREG;

  618.         cli();

  619.         if (!usb_configuration) {

  620.                 SREG = intr_state;

  621.                 return 0;

  622.         }

  623.         UENUM = DEBUG_RX_ENDPOINT;

  624. try_again:

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

  626.                 // no packet in buffer

  627.                 SREG = intr_state;

  628.                 return 0;

  629.         }

  630.         // take one byte out of the buffer

  631.         c = UEDATX;

  632. 	if (c == 0) {

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

  634. 		// discard the rest of this packet

  635. 		UEINTX = 0x6B;

  636. 		goto try_again;

  637. 	}

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

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

  640.         SREG = intr_state;

  641.         return c;

  642. }

  643. 

  644. // discard any buffered input

  645. void usb_serial_class::flush()

  646. {

  647.         uint8_t intr_state;

  648. 

  649.         if (usb_configuration) {

  650.                 intr_state = SREG;

  651.                 cli();

  652. 		UENUM = DEBUG_RX_ENDPOINT;

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

  654.                         UEINTX = 0x6B;

  655.                 }

  656.                 SREG = intr_state;

  657.         }

  658. 	prev_byte = 0;

  659. }

  660. 

  661. // transmit a character.

  662. #if ARDUINO >= 100

  663. size_t usb_serial_class::write(uint8_t c)

  664. #else

  665. void usb_serial_class::write(uint8_t c)

  666. #endif

  667. {

  668.         //static uint8_t previous_timeout=0;

  669.         uint8_t timeout, intr_state;

  670. 

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

  672.         if (!usb_configuration) goto error;

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

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

  675.         // even both in the same program!

  676.         intr_state = SREG;

  677.         cli();

  678.         UENUM = DEBUG_TX_ENDPOINT;

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

  680. #if 0

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

  682.         if (previous_timeout) {

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

  684.                         SREG = intr_state;

  685.                         return;

  686.                 }

  687.                 previous_timeout = 0;

  688.         }

  689. #endif

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

  691.         timeout = UDFNUML + TRANSMIT_TIMEOUT;

  692.         while (1) {

  693.                 // are we ready to transmit?

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

  695.                 SREG = intr_state;

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

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

  698.                 if (UDFNUML == timeout) {

  699.                         //previous_timeout = 1;

  700. 			goto error;

  701. 		}

  702.                 // has the USB gone offline?

  703.                 if (!usb_configuration) goto error;

  704.                 // get ready to try checking again

  705.                 intr_state = SREG;

  706.                 cli();

  707.                 UENUM = DEBUG_TX_ENDPOINT;

  708.         }

  709.         // actually write the byte into the FIFO

  710.         UEDATX = c;

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

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

  713. 		UEINTX = 0x3A;

  714.         	debug_flush_timer = 0;

  715. 	} else {

  716.         	debug_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  717. 	}

  718.         SREG = intr_state;

  719. #if ARDUINO >= 100

  720. 	return 1;

  721. #endif

  722. error:

  723. #if ARDUINO >= 100

  724. 	setWriteError();

  725. 	return 0;

  726. #else

  727. 	return;

  728. #endif

  729. }

  730. 

  731. 

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

  733. 

  734. // immediately transmit any buffered output.

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

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

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

  738. void usb_serial_class::send_now(void)

  739. {

  740.         uint8_t intr_state;

  741. 

  742.         intr_state = SREG;

  743.         cli();

  744.         if (debug_flush_timer) {

  745.                 UENUM = DEBUG_TX_ENDPOINT;

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

  747. 			UEDATX = 0;

  748. 		}

  749.                 UEINTX = 0x3A;

  750.                 debug_flush_timer = 0;

  751.         }

  752.         SREG = intr_state;

  753. }

  754. 

  755. uint32_t usb_serial_class::baud(void)

  756. {

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

  758. }

  759. 

  760. uint8_t usb_serial_class::stopbits(void)

  761. {

  762. 	return 1;

  763. }

  764. 

  765. uint8_t usb_serial_class::paritytype(void)

  766. {

  767. 	return 0;

  768. }

  769. 

  770. uint8_t usb_serial_class::numbits(void)

  771. {

  772. 	return 8;

  773. }

  774. 

  775. uint8_t usb_serial_class::dtr(void)

  776. {

  777. 	return 1;

  778. }

  779. 

  780. uint8_t usb_serial_class::rts(void)

  781. {

  782. 	return 1;

  783. }

  784. 

  785. usb_serial_class::operator bool()

  786. {

  787. 	if (usb_configuration) return true;

  788. 	return false;

  789. }

  790. 

  791. 

  792. 

  793. // Preinstantiate Objects //////////////////////////////////////////////////////

  794. 

  795. usb_serial_class	Serial = usb_serial_class();