visus
/
framework-arduinoteensy-cxx20
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & 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.
5 Commits
1 Branch
Tree: a7a66c2f14
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a7a66c2f14'
${ noResults }
framework-arduinoteensy-cxx20/cores/usb_hid/usb_api.cpp

932 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(uint16_t c)

  224. {

  225. 	keyboard_report_data[0] = (uint8_t)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, int8_t horiz)

  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.         if (horiz == -128) horiz = -127;

  557.         intr_state = SREG;

  558.         cli();

  559.         UENUM = MOUSE_ENDPOINT;

  560.         timeout = UDFNUML + 50;

  561.         while (1) {

  562.                 // are we ready to transmit?

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

  564.                 SREG = intr_state;

  565.                 // has the USB gone offline?

  566.                 if (!usb_configuration) return;

  567.                 // have we waited too long?

  568.                 if (UDFNUML == timeout) return;

  569.                 // get ready to try checking again

  570.                 intr_state = SREG;

  571.                 cli();

  572.                 UENUM = MOUSE_ENDPOINT;

  573.         }

  574.         UEDATX = mouse_buttons;

  575.         UEDATX = x;

  576.         UEDATX = y;

  577.         UEDATX = wheel;

  578.         UEDATX = horiz;

  579.         UEINTX = 0x3A;

  580.         SREG = intr_state;

  581. }

  582. 

  583. void usb_mouse_class::click(uint8_t b)

  584. {

  585. 	mouse_buttons = b;

  586. 	move(0, 0);

  587. 	mouse_buttons = 0;

  588. 	move(0, 0);

  589. }

  590. 

  591. void usb_mouse_class::scroll(int8_t wheel, int8_t horiz)

  592. {

  593. 	move(0, 0, wheel, horiz);

  594. }

  595. 

  596. void usb_mouse_class::set_buttons(uint8_t left, uint8_t middle, uint8_t right, uint8_t back, uint8_t forward)

  597. {

  598.         uint8_t mask=0;

  599. 

  600.         if (left) mask |= 1;

  601.         if (middle) mask |= 4;

  602.         if (right) mask |= 2;

  603.         if (back) mask |= 8;

  604.         if (forward) mask |= 16;

  605.         mouse_buttons = mask;

  606.         move(0, 0);

  607. }

  608. 

  609. void usb_mouse_class::press(uint8_t b)

  610. {

  611. 	uint8_t prev = mouse_buttons;

  612. 	mouse_buttons |= (b & 7);

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

  614. }

  615. 

  616. void usb_mouse_class::release(uint8_t b)

  617. {

  618. 	uint8_t prev = mouse_buttons;

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

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

  621. }

  622. 

  623. bool usb_mouse_class::isPressed(uint8_t b)

  624. {

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

  626. }

  627. 

  628. 

  629. void usb_joystick_class::send_now(void)

  630. {

  631.         uint8_t intr_state, timeout;

  632. 

  633.         if (!usb_configuration) return;

  634.         intr_state = SREG;

  635.         cli();

  636.         UENUM = JOYSTICK_ENDPOINT;

  637.         timeout = UDFNUML + 50;

  638.         while (1) {

  639.                 // are we ready to transmit?

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

  641.                 SREG = intr_state;

  642.                 // has the USB gone offline?

  643.                 if (!usb_configuration) return;

  644.                 // have we waited too long?

  645.                 if (UDFNUML == timeout) return;

  646.                 // get ready to try checking again

  647.                 intr_state = SREG;

  648.                 cli();

  649.                 UENUM = JOYSTICK_ENDPOINT;

  650.         }

  651.         UEDATX = joystick_report_data[0];

  652.         UEDATX = joystick_report_data[1];

  653.         UEDATX = joystick_report_data[2];

  654.         UEDATX = joystick_report_data[3];

  655.         UEDATX = joystick_report_data[4];

  656.         UEDATX = joystick_report_data[5];

  657.         UEDATX = joystick_report_data[6];

  658.         UEDATX = joystick_report_data[7];

  659.         UEDATX = joystick_report_data[8];

  660.         UEDATX = joystick_report_data[9];

  661.         UEDATX = joystick_report_data[10];

  662.         UEDATX = joystick_report_data[11];

  663.         UEINTX = 0x3A;

  664.         SREG = intr_state;

  665. }

  666. 

  667. 

  668. 

  669. 

  670. static volatile uint8_t prev_byte=0;

  671. 

  672. void usb_serial_class::begin(long speed)

  673. {

  674. 	// make sure USB is initialized

  675. 	usb_init();

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

  677. 	while (1) {

  678. 		if (usb_configuration) {

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

  680. 			return;

  681. 		}

  682. 		if (usb_suspended) {

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

  684. 			while (usb_suspended) {

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

  686. 				// normal USB enumeration causes brief suspend

  687. 				// states, typically under 0.1 second

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

  689. 					return;

  690. 				}

  691. 			}

  692. 		}

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

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

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

  696. 	}

  697. 	prev_byte = 0;

  698. }

  699. 

  700. void usb_serial_class::end()

  701. {

  702. 	usb_shutdown();

  703. 	delay(25);

  704. }

  705. 

  706. 

  707. 

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

  709. int usb_serial_class::available()

  710. {

  711.         uint8_t c;

  712. 

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

  714. 	if (c) return 1;

  715. 	c = readnext();

  716. 	if (c) {

  717. 		prev_byte = c;

  718. 		return 1;

  719. 	}

  720. 	return 0;

  721. }

  722. 

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

  724. int usb_serial_class::read()

  725. {

  726. 	uint8_t c;

  727. 

  728. 	c = prev_byte;

  729. 	if (c) {

  730. 		prev_byte = 0;

  731. 		return c;

  732. 	}

  733. 	c = readnext();

  734. 	if (c) return c;

  735. 	return -1;

  736. }

  737. 

  738. int usb_serial_class::peek()

  739. {

  740. 	uint8_t c;

  741. 	

  742. 	c = prev_byte;

  743. 	if (c) return c;

  744. 	c = readnext();

  745. 	if (c) {

  746. 		prev_byte = c;

  747. 		return c;

  748. 	}

  749. 	return -1;

  750. }

  751. 

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

  753. uint8_t usb_serial_class::readnext(void)

  754. {

  755.         uint8_t c, intr_state;

  756. 

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

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

  759.         // even both in the same program!

  760.         intr_state = SREG;

  761.         cli();

  762.         if (!usb_configuration) {

  763.                 SREG = intr_state;

  764.                 return 0;

  765.         }

  766.         UENUM = DEBUG_RX_ENDPOINT;

  767. try_again:

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

  769.                 // no packet in buffer

  770.                 SREG = intr_state;

  771.                 return 0;

  772.         }

  773.         // take one byte out of the buffer

  774.         c = UEDATX;

  775. 	if (c == 0) {

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

  777. 		// discard the rest of this packet

  778. 		UEINTX = 0x6B;

  779. 		goto try_again;

  780. 	}

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

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

  783.         SREG = intr_state;

  784.         return c;

  785. }

  786. 

  787. // discard any buffered input

  788. void usb_serial_class::flush()

  789. {

  790.         uint8_t intr_state;

  791. 

  792.         if (usb_configuration) {

  793.                 intr_state = SREG;

  794.                 cli();

  795. 		UENUM = DEBUG_RX_ENDPOINT;

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

  797.                         UEINTX = 0x6B;

  798.                 }

  799.                 SREG = intr_state;

  800.         }

  801. 	prev_byte = 0;

  802. }

  803. 

  804. // transmit a character.

  805. size_t usb_serial_class::write(uint8_t c)

  806. {

  807.         //static uint8_t previous_timeout=0;

  808.         uint8_t timeout, intr_state;

  809. 

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

  811.         if (!usb_configuration) goto error;

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

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

  814.         // even both in the same program!

  815.         intr_state = SREG;

  816.         cli();

  817.         UENUM = DEBUG_TX_ENDPOINT;

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

  819. #if 0

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

  821.         if (previous_timeout) {

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

  823.                         SREG = intr_state;

  824.                         return;

  825.                 }

  826.                 previous_timeout = 0;

  827.         }

  828. #endif

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

  830.         timeout = UDFNUML + TRANSMIT_TIMEOUT;

  831.         while (1) {

  832.                 // are we ready to transmit?

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

  834.                 SREG = intr_state;

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

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

  837.                 if (UDFNUML == timeout) {

  838.                         //previous_timeout = 1;

  839. 			goto error;

  840. 		}

  841.                 // has the USB gone offline?

  842.                 if (!usb_configuration) goto error;

  843.                 // get ready to try checking again

  844.                 intr_state = SREG;

  845.                 cli();

  846.                 UENUM = DEBUG_TX_ENDPOINT;

  847.         }

  848.         // actually write the byte into the FIFO

  849.         UEDATX = c;

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

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

  852. 		UEINTX = 0x3A;

  853.         	debug_flush_timer = 0;

  854. 	} else {

  855.         	debug_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  856. 	}

  857.         SREG = intr_state;

  858. 	return 1;

  859. error:

  860. 	setWriteError();

  861. 	return 0;

  862. }

  863. 

  864. 

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

  866. 

  867. // immediately transmit any buffered output.

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

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

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

  871. void usb_serial_class::send_now(void)

  872. {

  873.         uint8_t intr_state;

  874. 

  875.         intr_state = SREG;

  876.         cli();

  877.         if (debug_flush_timer) {

  878.                 UENUM = DEBUG_TX_ENDPOINT;

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

  880. 			UEDATX = 0;

  881. 		}

  882.                 UEINTX = 0x3A;

  883.                 debug_flush_timer = 0;

  884.         }

  885.         SREG = intr_state;

  886. }

  887. 

  888. uint32_t usb_serial_class::baud(void)

  889. {

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

  891. }

  892. 

  893. uint8_t usb_serial_class::stopbits(void)

  894. {

  895. 	return 1;

  896. }

  897. 

  898. uint8_t usb_serial_class::paritytype(void)

  899. {

  900. 	return 0;

  901. }

  902. 

  903. uint8_t usb_serial_class::numbits(void)

  904. {

  905. 	return 8;

  906. }

  907. 

  908. uint8_t usb_serial_class::dtr(void)

  909. {

  910. 	return 1;

  911. }

  912. 

  913. uint8_t usb_serial_class::rts(void)

  914. {

  915. 	return 1;

  916. }

  917. 

  918. usb_serial_class::operator bool()

  919. {

  920. 	if (usb_configuration) return true;

  921. 	return false;

  922. }

  923. 

  924. 

  925. // Preinstantiate Objects //////////////////////////////////////////////////////

  926. 

  927. usb_serial_class	Serial = usb_serial_class();

  928. usb_keyboard_class	Keyboard = usb_keyboard_class();

  929. usb_mouse_class		Mouse = usb_mouse_class();

  930. usb_joystick_class	Joystick = usb_joystick_class();