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.
374 Commits
2 Branches
Tree: 12c5d4972d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '12c5d4972d'
${ noResults }
teensy-core-4.1/usb_hid/usb_api.cpp

928 lines
23KB
Raw Blame History 

  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. 

  34. // Step #1, decode UTF8 to Unicode code points

  35. //

  36. size_t usb_keyboard_class::write(uint8_t c)

  37. {

  38. 	if (c < 0x80) {

  39. 		// single byte encoded, 0x00 to 0x7F

  40. 		utf8_state = 0;

  41. 		write_unicode(c);

  42. 	} else if (c < 0xC0) {

  43. 		// 2nd, 3rd or 4th byte, 0x80 to 0xBF

  44. 		c &= 0x3F;

  45. 		if (utf8_state == 1) {

  46. 			utf8_state = 0;

  47. 			write_unicode(unicode_wchar | c);

  48. 		} else if (utf8_state == 2) {

  49. 			unicode_wchar |= ((uint16_t)c << 6);

  50. 			utf8_state = 1;

  51. 		}

  52. 	} else if (c < 0xE0) {

  53. 		// begin 2 byte sequence, 0xC2 to 0xDF

  54. 		// or illegal 2 byte sequence, 0xC0 to 0xC1

  55. 		unicode_wchar = (uint16_t)(c & 0x1F) << 6;

  56. 		utf8_state = 1;

  57. 	} else if (c < 0xF0) {

  58. 		// begin 3 byte sequence, 0xE0 to 0xEF

  59. 		unicode_wchar = (uint16_t)(c & 0x0F) << 12;

  60. 		utf8_state = 2;

  61. 	} else {

  62. 		// begin 4 byte sequence (not supported), 0xF0 to 0xF4

  63. 		// or illegal, 0xF5 to 0xFF

  64. 		utf8_state = 255;

  65. 	}

  66. 	return 1;

  67. }

  68. 

  69. 

  70. // Step #2: translate Unicode code point to keystroke sequence

  71. //

  72. KEYCODE_TYPE usb_keyboard_class::unicode_to_keycode(uint16_t cpoint)

  73. {

  74. 	// Unicode code points beyond U+FFFF are not supported

  75. 	// technically this input should probably be called UCS-2

  76. 	if (cpoint < 32) {

  77. 		if (cpoint == 10) return KEY_ENTER & KEYCODE_MASK;

  78. 		if (cpoint == 11) return KEY_TAB & KEYCODE_MASK;

  79. 		return 0;

  80. 	}

  81. 	if (cpoint < 128) {

  82. 		if (sizeof(KEYCODE_TYPE) == 1) {

  83. 			return pgm_read_byte(keycodes_ascii + (cpoint - 0x20));

  84. 		} else if (sizeof(KEYCODE_TYPE) == 2) {

  85. 			return pgm_read_word(keycodes_ascii + (cpoint - 0x20));

  86. 		}

  87. 		return 0;

  88. 	}

  89. 	#ifdef ISO_8859_1_A0

  90. 	if (cpoint <= 0xA0) return 0;

  91. 	if (cpoint < 0x100) {

  92. 		if (sizeof(KEYCODE_TYPE) == 1) {

  93. 			return pgm_read_byte(keycodes_iso_8859_1 + (cpoint - 0xA0));

  94. 		} else if (sizeof(KEYCODE_TYPE) == 2) {

  95. 			return pgm_read_word(keycodes_iso_8859_1 + (cpoint - 0xA0));

  96. 		}

  97. 		return 0;

  98. 	}

  99. 	#endif

  100. 	//#ifdef UNICODE_20AC

  101. 	//if (cpoint == 0x20AC) return UNICODE_20AC & 0x3FFF;

  102. 	//#endif

  103. 	#ifdef KEYCODE_EXTRA00

  104. 	if (cpoint == UNICODE_EXTRA00) return KEYCODE_EXTRA00 & 0x3FFF;

  105. 	#endif

  106. 	#ifdef KEYCODE_EXTRA01

  107. 	if (cpoint == UNICODE_EXTRA01) return KEYCODE_EXTRA01 & 0x3FFF;

  108. 	#endif

  109. 	#ifdef KEYCODE_EXTRA02

  110. 	if (cpoint == UNICODE_EXTRA02) return KEYCODE_EXTRA02 & 0x3FFF;

  111. 	#endif

  112. 	#ifdef KEYCODE_EXTRA03

  113. 	if (cpoint == UNICODE_EXTRA03) return KEYCODE_EXTRA03 & 0x3FFF;

  114. 	#endif

  115. 	#ifdef KEYCODE_EXTRA04

  116. 	if (cpoint == UNICODE_EXTRA04) return KEYCODE_EXTRA04 & 0x3FFF;

  117. 	#endif

  118. 	#ifdef KEYCODE_EXTRA05

  119. 	if (cpoint == UNICODE_EXTRA05) return KEYCODE_EXTRA05 & 0x3FFF;

  120. 	#endif

  121. 	#ifdef KEYCODE_EXTRA06

  122. 	if (cpoint == UNICODE_EXTRA06) return KEYCODE_EXTRA06 & 0x3FFF;

  123. 	#endif

  124. 	#ifdef KEYCODE_EXTRA07

  125. 	if (cpoint == UNICODE_EXTRA07) return KEYCODE_EXTRA07 & 0x3FFF;

  126. 	#endif

  127. 	#ifdef KEYCODE_EXTRA08

  128. 	if (cpoint == UNICODE_EXTRA08) return KEYCODE_EXTRA08 & 0x3FFF;

  129. 	#endif

  130. 	#ifdef KEYCODE_EXTRA09

  131. 	if (cpoint == UNICODE_EXTRA09) return KEYCODE_EXTRA09 & 0x3FFF;

  132. 	#endif

  133. 	return 0;

  134. }

  135. 

  136. // Step #3: execute keystroke sequence

  137. //

  138. void usb_keyboard_class::write_keycode(KEYCODE_TYPE keycode)

  139. {

  140. 	if (!keycode) return;

  141. 	#ifdef DEADKEYS_MASK

  142. 	KEYCODE_TYPE deadkeycode = deadkey_to_keycode(keycode);

  143. 	if (deadkeycode) write_key(deadkeycode);

  144. 	#endif

  145. 	write_key(keycode);

  146. }

  147. 

  148. KEYCODE_TYPE usb_keyboard_class::deadkey_to_keycode(KEYCODE_TYPE keycode)

  149. {

  150. 	#ifdef DEADKEYS_MASK

  151. 	keycode &= DEADKEYS_MASK;

  152. 	if (keycode == 0) return 0;

  153. 	#ifdef ACUTE_ACCENT_BITS

  154. 	if (keycode == ACUTE_ACCENT_BITS) return DEADKEY_ACUTE_ACCENT;

  155. 	#endif

  156. 	#ifdef CEDILLA_BITS

  157. 	if (keycode == CEDILLA_BITS) return DEADKEY_CEDILLA;

  158. 	#endif

  159. 	#ifdef CIRCUMFLEX_BITS

  160. 	if (keycode == CIRCUMFLEX_BITS) return DEADKEY_CIRCUMFLEX;

  161. 	#endif

  162. 	#ifdef DIAERESIS_BITS

  163. 	if (keycode == DIAERESIS_BITS) return DEADKEY_DIAERESIS;

  164. 	#endif

  165. 	#ifdef GRAVE_ACCENT_BITS

  166. 	if (keycode == GRAVE_ACCENT_BITS) return DEADKEY_GRAVE_ACCENT;

  167. 	#endif

  168. 	#ifdef TILDE_BITS

  169. 	if (keycode == TILDE_BITS) return DEADKEY_TILDE;

  170. 	#endif

  171. 	#ifdef RING_ABOVE_BITS

  172. 	if (keycode == RING_ABOVE_BITS) return DEADKEY_RING_ABOVE;

  173. 	#endif

  174. 	#endif // DEADKEYS_MASK

  175. 	return 0;

  176. }

  177. 

  178. // Step #4: do each keystroke

  179. //

  180. void usb_keyboard_class::write_key(KEYCODE_TYPE keycode)

  181. {

  182. 	keyboard_report_data[0] = keycode_to_modifier(keycode);

  183. 	keyboard_report_data[1] = 0;

  184. 	keyboard_report_data[2] = keycode_to_key(keycode);

  185. 	keyboard_report_data[3] = 0;

  186. 	keyboard_report_data[4] = 0;

  187. 	keyboard_report_data[5] = 0;

  188. 	keyboard_report_data[6] = 0;

  189. 	keyboard_report_data[7] = 0;

  190. 	send_now();

  191. 	keyboard_report_data[0] = 0;

  192. 	keyboard_report_data[2] = 0;

  193. 	send_now();

  194. }

  195. 

  196. uint8_t usb_keyboard_class::keycode_to_modifier(KEYCODE_TYPE keycode)

  197. {

  198. 	uint8_t modifier=0;

  199. 

  200. 	#ifdef SHIFT_MASK

  201. 	if (keycode & SHIFT_MASK) modifier |= MODIFIERKEY_SHIFT;

  202. 	#endif

  203. 	#ifdef ALTGR_MASK

  204. 	if (keycode & ALTGR_MASK) modifier |= MODIFIERKEY_RIGHT_ALT;

  205. 	#endif

  206. 	#ifdef RCTRL_MASK

  207. 	if (keycode & RCTRL_MASK) modifier |= MODIFIERKEY_RIGHT_CTRL;

  208. 	#endif

  209. 	return modifier;

  210. }

  211. 

  212. uint8_t usb_keyboard_class::keycode_to_key(KEYCODE_TYPE keycode)

  213. {

  214. 	uint8_t key = keycode & 0x3F;

  215. 	#ifdef KEY_NON_US_100

  216. 	if (key == KEY_NON_US_100) key = 100;

  217. 	#endif

  218. 	return key;

  219. }

  220. 

  221. 

  222. 

  223. void usb_keyboard_class::set_modifier(uint8_t c)

  224. {

  225. 	keyboard_report_data[0] = c;

  226. }

  227. void usb_keyboard_class::set_key1(uint8_t c)

  228. {

  229. 	keyboard_report_data[2] = c;

  230. }

  231. void usb_keyboard_class::set_key2(uint8_t c)

  232. {

  233. 	keyboard_report_data[3] = c;

  234. }

  235. void usb_keyboard_class::set_key3(uint8_t c)

  236. {

  237. 	keyboard_report_data[4] = c;

  238. }

  239. void usb_keyboard_class::set_key4(uint8_t c)

  240. {

  241. 	keyboard_report_data[5] = c;

  242. }

  243. void usb_keyboard_class::set_key5(uint8_t c)

  244. {

  245. 	keyboard_report_data[6] = c;

  246. }

  247. void usb_keyboard_class::set_key6(uint8_t c)

  248. {

  249. 	keyboard_report_data[7] = c;

  250. }

  251. 

  252. 

  253. void usb_keyboard_class::send_now(void)

  254. {

  255.         uint8_t intr_state, timeout;

  256. 

  257.         if (!usb_configuration) return;

  258.         intr_state = SREG;

  259.         cli();

  260.         UENUM = KEYBOARD_ENDPOINT;

  261.         timeout = UDFNUML + 50;

  262.         while (1) {

  263.                 // are we ready to transmit?

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

  265.                 SREG = intr_state;

  266.                 // has the USB gone offline?

  267.                 if (!usb_configuration) return;

  268.                 // have we waited too long?

  269.                 if (UDFNUML == timeout) return;

  270.                 // get ready to try checking again

  271.                 intr_state = SREG;

  272.                 cli();

  273.                 UENUM = KEYBOARD_ENDPOINT;

  274.         }

  275.         UEDATX = keyboard_report_data[0];

  276.         UEDATX = keyboard_report_data[1];

  277.         UEDATX = keyboard_report_data[2];

  278.         UEDATX = keyboard_report_data[3];

  279.         UEDATX = keyboard_report_data[4];

  280.         UEDATX = keyboard_report_data[5];

  281.         UEDATX = keyboard_report_data[6];

  282.         UEDATX = keyboard_report_data[7];

  283.         UEINTX = 0x3A;

  284.         keyboard_idle_count = 0;

  285.         SREG = intr_state;

  286. }

  287. 

  288. 

  289. void usb_keyboard_class::press(uint16_t n)

  290. {

  291. 	uint8_t key, mod, msb, modrestore=0;

  292. 

  293. 	msb = n >> 8;

  294. 	if (msb >= 0xC2) {

  295. 		if (msb <= 0xDF) {

  296. 			n = (n & 0x3F) | ((uint16_t)(msb & 0x1F) << 6);

  297. 		} else if (msb == 0xF0) {

  298. 			presskey(n, 0);

  299. 			return;

  300. 		} else if (msb == 0xE0) {

  301. 			presskey(0, n);

  302. 			return;

  303. 		} else if (msb == 0xE2) {

  304. 			press_system_key(n);

  305. 			return;

  306. 		} else if (msb >= 0xE4 && msb <= 0xE7) {

  307. 			press_consumer_key(n & 0x3FF);

  308. 			return;

  309. 		} else {

  310. 			return;

  311. 		}

  312. 	}

  313. 	KEYCODE_TYPE keycode = unicode_to_keycode(n);

  314. 	if (!keycode) return;

  315. #ifdef DEADKEYS_MASK

  316. 	KEYCODE_TYPE deadkeycode = deadkey_to_keycode(keycode);

  317. 	if (deadkeycode) {

  318. 		modrestore = keyboard_report_data[0];

  319. 		if (modrestore) {

  320. 			keyboard_report_data[0] = 0;

  321. 			send_now();

  322. 		}

  323. 		// TODO: test if operating systems recognize

  324. 		// deadkey sequences when other keys are held

  325. 		mod = keycode_to_modifier(deadkeycode);

  326. 		key = keycode_to_key(deadkeycode);

  327. 		presskey(key, mod);

  328. 		releasekey(key, mod);

  329. 	}

  330. #endif

  331. 	mod = keycode_to_modifier(keycode);

  332. 	key = keycode_to_key(keycode);

  333. 	presskey(key, mod | modrestore);

  334. }

  335. 

  336. void usb_keyboard_class::release(uint16_t n)

  337. {

  338. 	uint8_t key, mod, msb;

  339. 

  340. 	msb = n >> 8;

  341. 	if (msb >= 0xC2) {

  342. 		if (msb <= 0xDF) {

  343. 			n = (n & 0x3F) | ((uint16_t)(msb & 0x1F) << 6);

  344. 		} else if (msb == 0xF0) {

  345. 			releasekey(n, 0);

  346. 			return;

  347. 		} else if (msb == 0xE0) {

  348. 			releasekey(0, n);

  349. 			return;

  350. 		} else if (msb == 0xE2) {

  351. 			release_system_key(n);

  352. 			return;

  353. 		} else if (msb >= 0xE4 && msb <= 0xE7) {

  354. 			release_consumer_key(n & 0x3FF);

  355. 			return;

  356. 		} else {

  357. 			return;

  358. 		}

  359. 	}

  360. 	KEYCODE_TYPE keycode = unicode_to_keycode(n);

  361. 	if (!keycode) return;

  362. 	mod = keycode_to_modifier(keycode);

  363. 	key = keycode_to_key(keycode);

  364. 	releasekey(key, mod);

  365. }

  366. 

  367. void usb_keyboard_class::presskey(uint8_t key, uint8_t modifier)

  368. {

  369. 	bool send_required = false;

  370. 	uint8_t i;

  371. 

  372. 	if (modifier) {

  373. 		if ((keyboard_report_data[0] & modifier) != modifier) {

  374. 			keyboard_report_data[0] |= modifier;

  375. 			send_required = true;

  376. 		}

  377. 	}

  378. 	if (key) {

  379. 		for (i=2; i < 8; i++) {

  380. 			if (keyboard_report_data[i] == key) goto end;

  381. 		}

  382. 		for (i=2; i < 8; i++) {

  383. 			if (keyboard_report_data[i] == 0) {

  384. 				keyboard_report_data[i] = key;

  385. 				send_required = true;

  386. 				goto end;

  387. 			}

  388. 		}

  389. 	}

  390. 	end:

  391. 	if (send_required) send_now();

  392. }

  393. 

  394. void usb_keyboard_class::releasekey(uint8_t key, uint8_t modifier)

  395. {

  396. 	bool send_required = false;

  397. 	uint8_t i;

  398. 

  399. 	if (modifier) {

  400. 		if ((keyboard_report_data[0] & modifier) != 0) {

  401. 			keyboard_report_data[0] &= ~modifier;

  402. 			send_required = true;

  403. 		}

  404. 	}

  405. 	if (key) {

  406. 		for (i=2; i < 8; i++) {

  407. 			if (keyboard_report_data[i] == key) {

  408. 				keyboard_report_data[i] = 0;

  409. 				send_required = true;

  410. 			}

  411. 		}

  412. 	}

  413. 	if (send_required) send_now();

  414. }

  415. 

  416. void usb_keyboard_class::releaseAll(void)

  417. {

  418. 	uint8_t i, anybits;

  419. 

  420. 	anybits = keyboard_report_data[0];

  421. 	for (i=2; i < 8; i++) {

  422. 		anybits |= keyboard_report_data[i];

  423. 		keyboard_report_data[i] = 0;

  424. 	}

  425. 	if (!anybits) return;

  426. 	keyboard_report_data[0] = 0;

  427. 	send_now();

  428. }

  429. 

  430. void usb_keyboard_class::press_consumer_key(uint16_t key)

  431. {

  432.         if (key == 0) return;

  433.         for (uint8_t i=0; i < 4; i++) {

  434.                 if (keymedia_consumer_keys[i] == key) return;

  435.         }

  436.         for (uint8_t i=0; i < 4; i++) {

  437.                 if (keymedia_consumer_keys[i] == 0) {

  438.                         keymedia_consumer_keys[i] = key;

  439.                         keymedia_send();

  440.                         return;

  441.                 }

  442.         }

  443. }

  444. 

  445. void usb_keyboard_class::release_consumer_key(uint16_t key)

  446. {

  447.         if (key == 0) return;

  448.         for (uint8_t i=0; i < 4; i++) {

  449.                 if (keymedia_consumer_keys[i] == key) {

  450.                         keymedia_consumer_keys[i] = 0;

  451.                         keymedia_send();

  452.                         return;

  453.                 }

  454.         }

  455. }

  456. 

  457. void usb_keyboard_class::press_system_key(uint8_t key)

  458. {

  459.         if (key == 0) return;

  460.         for (uint8_t i=0; i < 3; i++) {

  461.                 if (keymedia_system_keys[i] == key) return;

  462.         }

  463.         for (uint8_t i=0; i < 3; i++) {

  464.                 if (keymedia_system_keys[i] == 0) {

  465.                         keymedia_system_keys[i] = key;

  466.                         keymedia_send();

  467.                         return;

  468.                 }

  469.         }

  470. }

  471. 

  472. void usb_keyboard_class::release_system_key(uint8_t key)

  473. {

  474.         if (key == 0) return;

  475.         for (uint8_t i=0; i < 3; i++) {

  476.                 if (keymedia_system_keys[i] == key) {

  477.                         keymedia_system_keys[i] = 0;

  478.                         keymedia_send();

  479.                         return;

  480.                 }

  481.         }

  482. }

  483. 

  484. void usb_keyboard_class::keymedia_release_all(void)

  485. {

  486.         uint8_t anybits = 0;

  487.         for (uint8_t i=0; i < 4; i++) {

  488.                 if (keymedia_consumer_keys[i] != 0) anybits = 1;

  489.                 keymedia_consumer_keys[i] = 0;

  490.         }

  491.         for (uint8_t i=0; i < 3; i++) {

  492.                 if (keymedia_system_keys[i] != 0) anybits = 1;

  493.                 keymedia_system_keys[i] = 0;

  494.         }

  495.         if (anybits) keymedia_send();

  496. }

  497. 

  498. // send the contents of keyboard_keys and keyboard_modifier_keys

  499. void usb_keyboard_class::keymedia_send(void)

  500. {

  501.         uint8_t intr_state, timeout;

  502. 

  503.         if (!usb_configuration) return;

  504.         intr_state = SREG;

  505.         cli();

  506.         UENUM = KEYMEDIA_ENDPOINT;

  507.         timeout = UDFNUML + 50;

  508.         while (1) {

  509.                 // are we ready to transmit?

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

  511.                 SREG = intr_state;

  512.                 // has the USB gone offline?

  513.                 if (!usb_configuration) return;

  514.                 // have we waited too long?

  515.                 if (UDFNUML == timeout) return;

  516.                 // get ready to try checking again

  517.                 intr_state = SREG;

  518.                 cli();

  519.                 UENUM = KEYMEDIA_ENDPOINT;

  520.         }

  521.         // 44444444 44333333 33332222 22222211 11111111

  522.         // 98765432 10987654 32109876 54321098 76543210

  523.         UEDATX = keymedia_consumer_keys[0];

  524.         UEDATX = (keymedia_consumer_keys[1] << 2) | ((keymedia_consumer_keys[0] >> 8) & 0x03);

  525.         UEDATX = (keymedia_consumer_keys[2] << 4) | ((keymedia_consumer_keys[1] >> 6) & 0x0F);

  526.         UEDATX = (keymedia_consumer_keys[3] << 6) | ((keymedia_consumer_keys[2] >> 4) & 0x3F);

  527.         UEDATX = keymedia_consumer_keys[3] >> 2;

  528.         UEDATX = keymedia_system_keys[0];

  529.         UEDATX = keymedia_system_keys[1];

  530.         UEDATX = keymedia_system_keys[2];

  531. 	UEINTX = 0x3A;

  532. 	SREG = intr_state;

  533. }

  534. 

  535. 

  536. 

  537. 

  538. 

  539. 

  540. 

  541. 

  542. 

  543. 

  544. 

  545. 

  546. 

  547. 

  548. void usb_mouse_class::move(int8_t x, int8_t y, int8_t wheel)

  549. {

  550.         uint8_t intr_state, timeout;

  551. 

  552.         if (!usb_configuration) return;

  553.         if (x == -128) x = -127;

  554.         if (y == -128) y = -127;

  555.         if (wheel == -128) wheel = -127;

  556.         intr_state = SREG;

  557.         cli();

  558.         UENUM = MOUSE_ENDPOINT;

  559.         timeout = UDFNUML + 50;

  560.         while (1) {

  561.                 // are we ready to transmit?

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

  563.                 SREG = intr_state;

  564.                 // has the USB gone offline?

  565.                 if (!usb_configuration) return;

  566.                 // have we waited too long?

  567.                 if (UDFNUML == timeout) return;

  568.                 // get ready to try checking again

  569.                 intr_state = SREG;

  570.                 cli();

  571.                 UENUM = MOUSE_ENDPOINT;

  572.         }

  573.         UEDATX = mouse_buttons;

  574.         UEDATX = x;

  575.         UEDATX = y;

  576.         UEDATX = wheel;

  577.         UEINTX = 0x3A;

  578.         SREG = intr_state;

  579. }

  580. 

  581. void usb_mouse_class::click(uint8_t b)

  582. {

  583. 	mouse_buttons = (b & 7);

  584. 	move(0, 0);

  585. 	mouse_buttons = 0;

  586. 	move(0, 0);

  587. }

  588. 

  589. void usb_mouse_class::scroll(int8_t wheel)

  590. {

  591. 	move(0, 0, wheel);

  592. }

  593. 

  594. void usb_mouse_class::set_buttons(uint8_t left, uint8_t middle, uint8_t right)

  595. {

  596.         uint8_t mask=0;

  597. 

  598.         if (left) mask |= 1;

  599.         if (middle) mask |= 4;

  600.         if (right) mask |= 2;

  601.         mouse_buttons = mask;

  602.         move(0, 0);

  603. }

  604. 

  605. void usb_mouse_class::press(uint8_t b)

  606. {

  607. 	uint8_t prev = mouse_buttons;

  608. 	mouse_buttons |= (b & 7);

  609. 	if (mouse_buttons != prev) move(0, 0);

  610. }

  611. 

  612. void usb_mouse_class::release(uint8_t b)

  613. {

  614. 	uint8_t prev = mouse_buttons;

  615. 	mouse_buttons &= ~(b & 7);

  616. 	if (mouse_buttons != prev) move(0, 0);

  617. }

  618. 

  619. bool usb_mouse_class::isPressed(uint8_t b)

  620. {

  621. 	return ((mouse_buttons & (b & 7)) != 0);

  622. }

  623. 

  624. 

  625. void usb_joystick_class::send_now(void)

  626. {

  627.         uint8_t intr_state, timeout;

  628. 

  629.         if (!usb_configuration) return;

  630.         intr_state = SREG;

  631.         cli();

  632.         UENUM = JOYSTICK_ENDPOINT;

  633.         timeout = UDFNUML + 50;

  634.         while (1) {

  635.                 // are we ready to transmit?

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

  637.                 SREG = intr_state;

  638.                 // has the USB gone offline?

  639.                 if (!usb_configuration) return;

  640.                 // have we waited too long?

  641.                 if (UDFNUML == timeout) return;

  642.                 // get ready to try checking again

  643.                 intr_state = SREG;

  644.                 cli();

  645.                 UENUM = JOYSTICK_ENDPOINT;

  646.         }

  647.         UEDATX = joystick_report_data[0];

  648.         UEDATX = joystick_report_data[1];

  649.         UEDATX = joystick_report_data[2];

  650.         UEDATX = joystick_report_data[3];

  651.         UEDATX = joystick_report_data[4];

  652.         UEDATX = joystick_report_data[5];

  653.         UEDATX = joystick_report_data[6];

  654.         UEDATX = joystick_report_data[7];

  655.         UEDATX = joystick_report_data[8];

  656.         UEDATX = joystick_report_data[9];

  657.         UEDATX = joystick_report_data[10];

  658.         UEDATX = joystick_report_data[11];

  659.         UEINTX = 0x3A;

  660.         SREG = intr_state;

  661. }

  662. 

  663. 

  664. 

  665. 

  666. static volatile uint8_t prev_byte=0;

  667. 

  668. void usb_serial_class::begin(long speed)

  669. {

  670. 	// make sure USB is initialized

  671. 	usb_init();

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

  673. 	while (1) {

  674. 		if (usb_configuration) {

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

  676. 			return;

  677. 		}

  678. 		if (usb_suspended) {

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

  680. 			while (usb_suspended) {

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

  682. 				// normal USB enumeration causes brief suspend

  683. 				// states, typically under 0.1 second

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

  685. 					return;

  686. 				}

  687. 			}

  688. 		}

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

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

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

  692. 	}

  693. 	prev_byte = 0;

  694. }

  695. 

  696. void usb_serial_class::end()

  697. {

  698. 	usb_shutdown();

  699. 	delay(25);

  700. }

  701. 

  702. 

  703. 

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

  705. int usb_serial_class::available()

  706. {

  707.         uint8_t c;

  708. 

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

  710. 	if (c) return 1;

  711. 	c = readnext();

  712. 	if (c) {

  713. 		prev_byte = c;

  714. 		return 1;

  715. 	}

  716. 	return 0;

  717. }

  718. 

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

  720. int usb_serial_class::read()

  721. {

  722. 	uint8_t c;

  723. 

  724. 	c = prev_byte;

  725. 	if (c) {

  726. 		prev_byte = 0;

  727. 		return c;

  728. 	}

  729. 	c = readnext();

  730. 	if (c) return c;

  731. 	return -1;

  732. }

  733. 

  734. int usb_serial_class::peek()

  735. {

  736. 	uint8_t c;

  737. 	

  738. 	c = prev_byte;

  739. 	if (c) return c;

  740. 	c = readnext();

  741. 	if (c) {

  742. 		prev_byte = c;

  743. 		return c;

  744. 	}

  745. 	return -1;

  746. }

  747. 

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

  749. uint8_t usb_serial_class::readnext(void)

  750. {

  751.         uint8_t c, intr_state;

  752. 

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

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

  755.         // even both in the same program!

  756.         intr_state = SREG;

  757.         cli();

  758.         if (!usb_configuration) {

  759.                 SREG = intr_state;

  760.                 return 0;

  761.         }

  762.         UENUM = DEBUG_RX_ENDPOINT;

  763. try_again:

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

  765.                 // no packet in buffer

  766.                 SREG = intr_state;

  767.                 return 0;

  768.         }

  769.         // take one byte out of the buffer

  770.         c = UEDATX;

  771. 	if (c == 0) {

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

  773. 		// discard the rest of this packet

  774. 		UEINTX = 0x6B;

  775. 		goto try_again;

  776. 	}

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

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

  779.         SREG = intr_state;

  780.         return c;

  781. }

  782. 

  783. // discard any buffered input

  784. void usb_serial_class::flush()

  785. {

  786.         uint8_t intr_state;

  787. 

  788.         if (usb_configuration) {

  789.                 intr_state = SREG;

  790.                 cli();

  791. 		UENUM = DEBUG_RX_ENDPOINT;

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

  793.                         UEINTX = 0x6B;

  794.                 }

  795.                 SREG = intr_state;

  796.         }

  797. 	prev_byte = 0;

  798. }

  799. 

  800. // transmit a character.

  801. size_t usb_serial_class::write(uint8_t c)

  802. {

  803.         //static uint8_t previous_timeout=0;

  804.         uint8_t timeout, intr_state;

  805. 

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

  807.         if (!usb_configuration) goto error;

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

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

  810.         // even both in the same program!

  811.         intr_state = SREG;

  812.         cli();

  813.         UENUM = DEBUG_TX_ENDPOINT;

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

  815. #if 0

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

  817.         if (previous_timeout) {

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

  819.                         SREG = intr_state;

  820.                         return;

  821.                 }

  822.                 previous_timeout = 0;

  823.         }

  824. #endif

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

  826.         timeout = UDFNUML + TRANSMIT_TIMEOUT;

  827.         while (1) {

  828.                 // are we ready to transmit?

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

  830.                 SREG = intr_state;

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

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

  833.                 if (UDFNUML == timeout) {

  834.                         //previous_timeout = 1;

  835. 			goto error;

  836. 		}

  837.                 // has the USB gone offline?

  838.                 if (!usb_configuration) goto error;

  839.                 // get ready to try checking again

  840.                 intr_state = SREG;

  841.                 cli();

  842.                 UENUM = DEBUG_TX_ENDPOINT;

  843.         }

  844.         // actually write the byte into the FIFO

  845.         UEDATX = c;

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

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

  848. 		UEINTX = 0x3A;

  849.         	debug_flush_timer = 0;

  850. 	} else {

  851.         	debug_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  852. 	}

  853.         SREG = intr_state;

  854. 	return 1;

  855. error:

  856. 	setWriteError();

  857. 	return 0;

  858. }

  859. 

  860. 

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

  862. 

  863. // immediately transmit any buffered output.

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

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

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

  867. void usb_serial_class::send_now(void)

  868. {

  869.         uint8_t intr_state;

  870. 

  871.         intr_state = SREG;

  872.         cli();

  873.         if (debug_flush_timer) {

  874.                 UENUM = DEBUG_TX_ENDPOINT;

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

  876. 			UEDATX = 0;

  877. 		}

  878.                 UEINTX = 0x3A;

  879.                 debug_flush_timer = 0;

  880.         }

  881.         SREG = intr_state;

  882. }

  883. 

  884. uint32_t usb_serial_class::baud(void)

  885. {

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

  887. }

  888. 

  889. uint8_t usb_serial_class::stopbits(void)

  890. {

  891. 	return 1;

  892. }

  893. 

  894. uint8_t usb_serial_class::paritytype(void)

  895. {

  896. 	return 0;

  897. }

  898. 

  899. uint8_t usb_serial_class::numbits(void)

  900. {

  901. 	return 8;

  902. }

  903. 

  904. uint8_t usb_serial_class::dtr(void)

  905. {

  906. 	return 1;

  907. }

  908. 

  909. uint8_t usb_serial_class::rts(void)

  910. {

  911. 	return 1;

  912. }

  913. 

  914. usb_serial_class::operator bool()

  915. {

  916. 	if (usb_configuration) return true;

  917. 	return false;

  918. }

  919. 

  920. 

  921. // Preinstantiate Objects //////////////////////////////////////////////////////

  922. 

  923. usb_serial_class	Serial = usb_serial_class();

  924. usb_keyboard_class	Keyboard = usb_keyboard_class();

  925. usb_mouse_class		Mouse = usb_mouse_class();

  926. usb_joystick_class	Joystick = usb_joystick_class();