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.
2 Commits
1 Branch
Tree: daa7cc5a30
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'daa7cc5a30'
${ noResults }
framework-arduinoteensy-cxx20/cores/usb_rawhid/usb_api.cpp

766 lines
19KB
Raw Blame History 

  1. /* USB API for Teensy USB Development Board

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

  3.  * Copyright (c) 2011 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. int usb_rawhid_class::available(void)

  34. {

  35. 	uint8_t n=0, intr_state;

  36. 

  37. 	intr_state = SREG;

  38. 	cli();

  39. 	if (usb_configuration) {

  40. 		UENUM = RAWHID_RX_ENDPOINT;

  41. 		n = UEBCLX;

  42. 	}

  43. 	SREG = intr_state;

  44. 	return n;

  45. }

  46. 

  47. // receive a packet, with timeout

  48. int usb_rawhid_class::recv(void *ptr, uint16_t timeout)

  49. {

  50. 	uint8_t *buffer = (uint8_t *)ptr;

  51.         uint8_t intr_state;

  52. 

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

  54.         if (!usb_configuration) return -1;

  55.         intr_state = SREG;

  56.         cli();

  57.         rawhid_rx_timeout_count = timeout;

  58.         UENUM = RAWHID_RX_ENDPOINT;

  59.         // wait for data to be available in the FIFO

  60.         while (1) {

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

  62.                 SREG = intr_state;

  63.                 if (rawhid_rx_timeout_count == 0) return 0;

  64.                 if (!usb_configuration) return -1;

  65.                 intr_state = SREG;

  66.                 cli();

  67.                 UENUM = RAWHID_RX_ENDPOINT;

  68.         }

  69.         // read bytes from the FIFO

  70.         #if (RAWHID_RX_SIZE >= 64)

  71.         *buffer++ = UEDATX;

  72.         #endif

  73.         #if (RAWHID_RX_SIZE >= 63)

  74.         *buffer++ = UEDATX;

  75.         #endif

  76.         #if (RAWHID_RX_SIZE >= 62)

  77.         *buffer++ = UEDATX;

  78.         #endif

  79.         #if (RAWHID_RX_SIZE >= 61)

  80.         *buffer++ = UEDATX;

  81.         #endif

  82.         #if (RAWHID_RX_SIZE >= 60)

  83.         *buffer++ = UEDATX;

  84.         #endif

  85.         #if (RAWHID_RX_SIZE >= 59)

  86.         *buffer++ = UEDATX;

  87.         #endif

  88.         #if (RAWHID_RX_SIZE >= 58)

  89.         *buffer++ = UEDATX;

  90.         #endif

  91.         #if (RAWHID_RX_SIZE >= 57)

  92.         *buffer++ = UEDATX;

  93.         #endif

  94.         #if (RAWHID_RX_SIZE >= 56)

  95.         *buffer++ = UEDATX;

  96.         #endif

  97.         #if (RAWHID_RX_SIZE >= 55)

  98.         *buffer++ = UEDATX;

  99.         #endif

  100.         #if (RAWHID_RX_SIZE >= 54)

  101.         *buffer++ = UEDATX;

  102.         #endif

  103.         #if (RAWHID_RX_SIZE >= 53)

  104.         *buffer++ = UEDATX;

  105.         #endif

  106.         #if (RAWHID_RX_SIZE >= 52)

  107.         *buffer++ = UEDATX;

  108.         #endif

  109.         #if (RAWHID_RX_SIZE >= 51)

  110.         *buffer++ = UEDATX;

  111.         #endif

  112.         #if (RAWHID_RX_SIZE >= 50)

  113.         *buffer++ = UEDATX;

  114.         #endif

  115.         #if (RAWHID_RX_SIZE >= 49)

  116.         *buffer++ = UEDATX;

  117.         #endif

  118.         #if (RAWHID_RX_SIZE >= 48)

  119.         *buffer++ = UEDATX;

  120.         #endif

  121.         #if (RAWHID_RX_SIZE >= 47)

  122.         *buffer++ = UEDATX;

  123.         #endif

  124.         #if (RAWHID_RX_SIZE >= 46)

  125.         *buffer++ = UEDATX;

  126.         #endif

  127.         #if (RAWHID_RX_SIZE >= 45)

  128.         *buffer++ = UEDATX;

  129.         #endif

  130.         #if (RAWHID_RX_SIZE >= 44)

  131.         *buffer++ = UEDATX;

  132.         #endif

  133.         #if (RAWHID_RX_SIZE >= 43)

  134.         *buffer++ = UEDATX;

  135.         #endif

  136.         #if (RAWHID_RX_SIZE >= 42)

  137.         *buffer++ = UEDATX;

  138.         #endif

  139.         #if (RAWHID_RX_SIZE >= 41)

  140.         *buffer++ = UEDATX;

  141.         #endif

  142.         #if (RAWHID_RX_SIZE >= 40)

  143.         *buffer++ = UEDATX;

  144.         #endif

  145.         #if (RAWHID_RX_SIZE >= 39)

  146.         *buffer++ = UEDATX;

  147.         #endif

  148.         #if (RAWHID_RX_SIZE >= 38)

  149.         *buffer++ = UEDATX;

  150.         #endif

  151.         #if (RAWHID_RX_SIZE >= 37)

  152.         *buffer++ = UEDATX;

  153.         #endif

  154.         #if (RAWHID_RX_SIZE >= 36)

  155.         *buffer++ = UEDATX;

  156.         #endif

  157.         #if (RAWHID_RX_SIZE >= 35)

  158.         *buffer++ = UEDATX;

  159.         #endif

  160.         #if (RAWHID_RX_SIZE >= 34)

  161.         *buffer++ = UEDATX;

  162.         #endif

  163.         #if (RAWHID_RX_SIZE >= 33)

  164.         *buffer++ = UEDATX;

  165.         #endif

  166.         #if (RAWHID_RX_SIZE >= 32)

  167.         *buffer++ = UEDATX;

  168.         #endif

  169.         #if (RAWHID_RX_SIZE >= 31)

  170.         *buffer++ = UEDATX;

  171.         #endif

  172.         #if (RAWHID_RX_SIZE >= 30)

  173.         *buffer++ = UEDATX;

  174.         #endif

  175.         #if (RAWHID_RX_SIZE >= 29)

  176.         *buffer++ = UEDATX;

  177.         #endif

  178.         #if (RAWHID_RX_SIZE >= 28)

  179.         *buffer++ = UEDATX;

  180.         #endif

  181.         #if (RAWHID_RX_SIZE >= 27)

  182.         *buffer++ = UEDATX;

  183.         #endif

  184.         #if (RAWHID_RX_SIZE >= 26)

  185.         *buffer++ = UEDATX;

  186.         #endif

  187.         #if (RAWHID_RX_SIZE >= 25)

  188.         *buffer++ = UEDATX;

  189.         #endif

  190.         #if (RAWHID_RX_SIZE >= 24)

  191.         *buffer++ = UEDATX;

  192.         #endif

  193.         #if (RAWHID_RX_SIZE >= 23)

  194.         *buffer++ = UEDATX;

  195.         #endif

  196.         #if (RAWHID_RX_SIZE >= 22)

  197.         *buffer++ = UEDATX;

  198.         #endif

  199.         #if (RAWHID_RX_SIZE >= 21)

  200.         *buffer++ = UEDATX;

  201.         #endif

  202.         #if (RAWHID_RX_SIZE >= 20)

  203.         *buffer++ = UEDATX;

  204.         #endif

  205.         #if (RAWHID_RX_SIZE >= 19)

  206.         *buffer++ = UEDATX;

  207.         #endif

  208.         #if (RAWHID_RX_SIZE >= 18)

  209.         *buffer++ = UEDATX;

  210.         #endif

  211.         #if (RAWHID_RX_SIZE >= 17)

  212.         *buffer++ = UEDATX;

  213.         #endif

  214.         #if (RAWHID_RX_SIZE >= 16)

  215.         *buffer++ = UEDATX;

  216.         #endif

  217.         #if (RAWHID_RX_SIZE >= 15)

  218.         *buffer++ = UEDATX;

  219.         #endif

  220.         #if (RAWHID_RX_SIZE >= 14)

  221.         *buffer++ = UEDATX;

  222.         #endif

  223.         #if (RAWHID_RX_SIZE >= 13)

  224.         *buffer++ = UEDATX;

  225.         #endif

  226.         #if (RAWHID_RX_SIZE >= 12)

  227.         *buffer++ = UEDATX;

  228.         #endif

  229.         #if (RAWHID_RX_SIZE >= 11)

  230.         *buffer++ = UEDATX;

  231.         #endif

  232.         #if (RAWHID_RX_SIZE >= 10)

  233.         *buffer++ = UEDATX;

  234.         #endif

  235.         #if (RAWHID_RX_SIZE >= 9)

  236.         *buffer++ = UEDATX;

  237.         #endif

  238.         #if (RAWHID_RX_SIZE >= 8)

  239.         *buffer++ = UEDATX;

  240.         #endif

  241.         #if (RAWHID_RX_SIZE >= 7)

  242.         *buffer++ = UEDATX;

  243.         #endif

  244.         #if (RAWHID_RX_SIZE >= 6)

  245.         *buffer++ = UEDATX;

  246.         #endif

  247.         #if (RAWHID_RX_SIZE >= 5)

  248.         *buffer++ = UEDATX;

  249.         #endif

  250.         #if (RAWHID_RX_SIZE >= 4)

  251.         *buffer++ = UEDATX;

  252.         #endif

  253.         #if (RAWHID_RX_SIZE >= 3)

  254.         *buffer++ = UEDATX;

  255.         #endif

  256.         #if (RAWHID_RX_SIZE >= 2)

  257.         *buffer++ = UEDATX;

  258.         #endif

  259.         #if (RAWHID_RX_SIZE >= 1)

  260.         *buffer++ = UEDATX;

  261.         #endif

  262.         // release the buffer

  263.         UEINTX = 0x6B;

  264.         SREG = intr_state;

  265.         return RAWHID_RX_SIZE;

  266. }

  267. 

  268. 

  269. // send a packet, with timeout

  270. int usb_rawhid_class::send(const void *ptr, uint16_t timeout)

  271. {

  272. 	const uint8_t *buffer = (const uint8_t *)ptr;

  273.         uint8_t intr_state;

  274. 

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

  276.         if (!usb_configuration) return -1;

  277.         intr_state = SREG;

  278.         cli();

  279.         rawhid_tx_timeout_count = timeout;

  280.         UENUM = RAWHID_TX_ENDPOINT;

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

  282.         while (1) {

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

  284.                 SREG = intr_state;

  285.                 if (rawhid_tx_timeout_count == 0) return 0;

  286.                 if (!usb_configuration) return -1;

  287.                 intr_state = SREG;

  288.                 cli();

  289.                 UENUM = RAWHID_TX_ENDPOINT;

  290.         }

  291.         // write bytes from the FIFO

  292.         #if (RAWHID_TX_SIZE >= 64)

  293.         UEDATX = *buffer++;

  294.         #endif

  295.         #if (RAWHID_TX_SIZE >= 63)

  296.         UEDATX = *buffer++;

  297.         #endif

  298.         #if (RAWHID_TX_SIZE >= 62)

  299.         UEDATX = *buffer++;

  300.         #endif

  301.         #if (RAWHID_TX_SIZE >= 61)

  302.         UEDATX = *buffer++;

  303.         #endif

  304.         #if (RAWHID_TX_SIZE >= 60)

  305.         UEDATX = *buffer++;

  306.         #endif

  307.         #if (RAWHID_TX_SIZE >= 59)

  308.         UEDATX = *buffer++;

  309.         #endif

  310.         #if (RAWHID_TX_SIZE >= 58)

  311.         UEDATX = *buffer++;

  312.         #endif

  313.         #if (RAWHID_TX_SIZE >= 57)

  314.         UEDATX = *buffer++;

  315.         #endif

  316.         #if (RAWHID_TX_SIZE >= 56)

  317.         UEDATX = *buffer++;

  318.         #endif

  319.         #if (RAWHID_TX_SIZE >= 55)

  320.         UEDATX = *buffer++;

  321.         #endif

  322.         #if (RAWHID_TX_SIZE >= 54)

  323.         UEDATX = *buffer++;

  324.         #endif

  325.         #if (RAWHID_TX_SIZE >= 53)

  326.         UEDATX = *buffer++;

  327.         #endif

  328.         #if (RAWHID_TX_SIZE >= 52)

  329.         UEDATX = *buffer++;

  330.         #endif

  331.         #if (RAWHID_TX_SIZE >= 51)

  332.         UEDATX = *buffer++;

  333.         #endif

  334.         #if (RAWHID_TX_SIZE >= 50)

  335.         UEDATX = *buffer++;

  336.         #endif

  337.         #if (RAWHID_TX_SIZE >= 49)

  338.         UEDATX = *buffer++;

  339.         #endif

  340.         #if (RAWHID_TX_SIZE >= 48)

  341.         UEDATX = *buffer++;

  342.         #endif

  343.         #if (RAWHID_TX_SIZE >= 47)

  344.         UEDATX = *buffer++;

  345.         #endif

  346.         #if (RAWHID_TX_SIZE >= 46)

  347.         UEDATX = *buffer++;

  348.         #endif

  349.         #if (RAWHID_TX_SIZE >= 45)

  350.         UEDATX = *buffer++;

  351.         #endif

  352.         #if (RAWHID_TX_SIZE >= 44)

  353.         UEDATX = *buffer++;

  354.         #endif

  355.         #if (RAWHID_TX_SIZE >= 43)

  356.         UEDATX = *buffer++;

  357.         #endif

  358.         #if (RAWHID_TX_SIZE >= 42)

  359.         UEDATX = *buffer++;

  360.         #endif

  361.         #if (RAWHID_TX_SIZE >= 41)

  362.         UEDATX = *buffer++;

  363.         #endif

  364.         #if (RAWHID_TX_SIZE >= 40)

  365.         UEDATX = *buffer++;

  366.         #endif

  367.         #if (RAWHID_TX_SIZE >= 39)

  368.         UEDATX = *buffer++;

  369.         #endif

  370.         #if (RAWHID_TX_SIZE >= 38)

  371.         UEDATX = *buffer++;

  372.         #endif

  373.         #if (RAWHID_TX_SIZE >= 37)

  374.         UEDATX = *buffer++;

  375.         #endif

  376.         #if (RAWHID_TX_SIZE >= 36)

  377.         UEDATX = *buffer++;

  378.         #endif

  379.         #if (RAWHID_TX_SIZE >= 35)

  380.         UEDATX = *buffer++;

  381.         #endif

  382.         #if (RAWHID_TX_SIZE >= 34)

  383.         UEDATX = *buffer++;

  384.         #endif

  385.         #if (RAWHID_TX_SIZE >= 33)

  386.         UEDATX = *buffer++;

  387.         #endif

  388.         #if (RAWHID_TX_SIZE >= 32)

  389.         UEDATX = *buffer++;

  390.         #endif

  391.         #if (RAWHID_TX_SIZE >= 31)

  392.         UEDATX = *buffer++;

  393.         #endif

  394.         #if (RAWHID_TX_SIZE >= 30)

  395.         UEDATX = *buffer++;

  396.         #endif

  397.         #if (RAWHID_TX_SIZE >= 29)

  398.         UEDATX = *buffer++;

  399.         #endif

  400.         #if (RAWHID_TX_SIZE >= 28)

  401.         UEDATX = *buffer++;

  402.         #endif

  403.         #if (RAWHID_TX_SIZE >= 27)

  404.         UEDATX = *buffer++;

  405.         #endif

  406.         #if (RAWHID_TX_SIZE >= 26)

  407.         UEDATX = *buffer++;

  408.         #endif

  409.         #if (RAWHID_TX_SIZE >= 25)

  410.         UEDATX = *buffer++;

  411.         #endif

  412.         #if (RAWHID_TX_SIZE >= 24)

  413.         UEDATX = *buffer++;

  414.         #endif

  415.         #if (RAWHID_TX_SIZE >= 23)

  416.         UEDATX = *buffer++;

  417.         #endif

  418.         #if (RAWHID_TX_SIZE >= 22)

  419.         UEDATX = *buffer++;

  420.         #endif

  421.         #if (RAWHID_TX_SIZE >= 21)

  422.         UEDATX = *buffer++;

  423.         #endif

  424.         #if (RAWHID_TX_SIZE >= 20)

  425.         UEDATX = *buffer++;

  426.         #endif

  427.         #if (RAWHID_TX_SIZE >= 19)

  428.         UEDATX = *buffer++;

  429.         #endif

  430.         #if (RAWHID_TX_SIZE >= 18)

  431.         UEDATX = *buffer++;

  432.         #endif

  433.         #if (RAWHID_TX_SIZE >= 17)

  434.         UEDATX = *buffer++;

  435.         #endif

  436.         #if (RAWHID_TX_SIZE >= 16)

  437.         UEDATX = *buffer++;

  438.         #endif

  439.         #if (RAWHID_TX_SIZE >= 15)

  440.         UEDATX = *buffer++;

  441.         #endif

  442.         #if (RAWHID_TX_SIZE >= 14)

  443.         UEDATX = *buffer++;

  444.         #endif

  445.         #if (RAWHID_TX_SIZE >= 13)

  446.         UEDATX = *buffer++;

  447.         #endif

  448.         #if (RAWHID_TX_SIZE >= 12)

  449.         UEDATX = *buffer++;

  450.         #endif

  451.         #if (RAWHID_TX_SIZE >= 11)

  452.         UEDATX = *buffer++;

  453.         #endif

  454.         #if (RAWHID_TX_SIZE >= 10)

  455.         UEDATX = *buffer++;

  456.         #endif

  457.         #if (RAWHID_TX_SIZE >= 9)

  458.         UEDATX = *buffer++;

  459.         #endif

  460.         #if (RAWHID_TX_SIZE >= 8)

  461.         UEDATX = *buffer++;

  462.         #endif

  463.         #if (RAWHID_TX_SIZE >= 7)

  464.         UEDATX = *buffer++;

  465.         #endif

  466.         #if (RAWHID_TX_SIZE >= 6)

  467.         UEDATX = *buffer++;

  468.         #endif

  469.         #if (RAWHID_TX_SIZE >= 5)

  470.         UEDATX = *buffer++;

  471.         #endif

  472.         #if (RAWHID_TX_SIZE >= 4)

  473.         UEDATX = *buffer++;

  474.         #endif

  475.         #if (RAWHID_TX_SIZE >= 3)

  476.         UEDATX = *buffer++;

  477.         #endif

  478.         #if (RAWHID_TX_SIZE >= 2)

  479.         UEDATX = *buffer++;

  480.         #endif

  481.         #if (RAWHID_TX_SIZE >= 1)

  482.         UEDATX = *buffer++;

  483.         #endif

  484.         // transmit it now

  485.         UEINTX = 0x3A;

  486.         SREG = intr_state;

  487.         return RAWHID_TX_SIZE;

  488. }

  489. 

  490. 

  491. 

  492. 

  493. 

  494. 

  495. static volatile uint8_t prev_byte=0;

  496. 

  497. void usb_serial_class::begin(long speed)

  498. {

  499. 	// make sure USB is initialized

  500. 	usb_init();

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

  502. 	while (1) {

  503. 		if (usb_configuration) {

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

  505. 			return;

  506. 		}

  507. 		if (usb_suspended) {

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

  509. 			while (usb_suspended) {

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

  511. 				// normal USB enumeration causes brief suspend

  512. 				// states, typically under 0.1 second

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

  514. 					return;

  515. 				}

  516. 			}

  517. 		}

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

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

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

  521. 	}

  522. 	prev_byte = 0;

  523. }

  524. 

  525. void usb_serial_class::end()

  526. {

  527. 	usb_shutdown();

  528. 	delay(25);

  529. }

  530. 

  531. 

  532. 

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

  534. int usb_serial_class::available()

  535. {

  536.         uint8_t c;

  537. 

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

  539. 	if (c) return 1;

  540. 	c = readnext();

  541. 	if (c) {

  542. 		prev_byte = c;

  543. 		return 1;

  544. 	}

  545. 	return 0;

  546. }

  547. 

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

  549. int usb_serial_class::read()

  550. {

  551. 	uint8_t c;

  552. 

  553. 	c = prev_byte;

  554. 	if (c) {

  555. 		prev_byte = 0;

  556. 		return c;

  557. 	}

  558. 	c = readnext();

  559. 	if (c) return c;

  560. 	return -1;

  561. }

  562. 

  563. int usb_serial_class::peek()

  564. {

  565. 	uint8_t c;

  566. 	

  567. 	c = prev_byte;

  568. 	if (c) return c;

  569. 	c = readnext();

  570. 	if (c) {

  571. 		prev_byte = c;

  572. 		return c;

  573. 	}

  574. 	return -1;

  575. }

  576. 

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

  578. uint8_t usb_serial_class::readnext(void)

  579. {

  580.         uint8_t c, intr_state;

  581. 

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

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

  584.         // even both in the same program!

  585.         intr_state = SREG;

  586.         cli();

  587.         if (!usb_configuration) {

  588.                 SREG = intr_state;

  589.                 return 0;

  590.         }

  591.         UENUM = DEBUG_RX_ENDPOINT;

  592. try_again:

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

  594.                 // no packet in buffer

  595.                 SREG = intr_state;

  596.                 return 0;

  597.         }

  598.         // take one byte out of the buffer

  599.         c = UEDATX;

  600. 	if (c == 0) {

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

  602. 		// discard the rest of this packet

  603. 		UEINTX = 0x6B;

  604. 		goto try_again;

  605. 	}

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

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

  608.         SREG = intr_state;

  609.         return c;

  610. }

  611. 

  612. // discard any buffered input

  613. void usb_serial_class::flush()

  614. {

  615.         uint8_t intr_state;

  616. 

  617.         if (usb_configuration) {

  618.                 intr_state = SREG;

  619.                 cli();

  620. 		UENUM = DEBUG_RX_ENDPOINT;

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

  622.                         UEINTX = 0x6B;

  623.                 }

  624.                 SREG = intr_state;

  625.         }

  626. 	prev_byte = 0;

  627. }

  628. 

  629. // transmit a character.

  630. #if ARDUINO >= 100

  631. size_t usb_serial_class::write(uint8_t c)

  632. #else

  633. void usb_serial_class::write(uint8_t c)

  634. #endif

  635. {

  636.         //static uint8_t previous_timeout=0;

  637.         uint8_t timeout, intr_state;

  638. 

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

  640.         if (!usb_configuration) goto error;

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

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

  643.         // even both in the same program!

  644.         intr_state = SREG;

  645.         cli();

  646.         UENUM = DEBUG_TX_ENDPOINT;

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

  648. #if 0

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

  650.         if (previous_timeout) {

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

  652.                         SREG = intr_state;

  653.                         return;

  654.                 }

  655.                 previous_timeout = 0;

  656.         }

  657. #endif

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

  659.         timeout = UDFNUML + TRANSMIT_TIMEOUT;

  660.         while (1) {

  661.                 // are we ready to transmit?

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

  663.                 SREG = intr_state;

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

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

  666.                 if (UDFNUML == timeout) {

  667.                         //previous_timeout = 1;

  668. 			goto error;

  669. 		}

  670.                 // has the USB gone offline?

  671.                 if (!usb_configuration) goto error;

  672.                 // get ready to try checking again

  673.                 intr_state = SREG;

  674.                 cli();

  675.                 UENUM = DEBUG_TX_ENDPOINT;

  676.         }

  677.         // actually write the byte into the FIFO

  678.         UEDATX = c;

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

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

  681. 		UEINTX = 0x3A;

  682.         	debug_flush_timer = 0;

  683. 	} else {

  684.         	debug_flush_timer = TRANSMIT_FLUSH_TIMEOUT;

  685. 	}

  686.         SREG = intr_state;

  687. #if ARDUINO >= 100

  688. 	return 1;

  689. #endif

  690. error:

  691. #if ARDUINO >= 100

  692. 	setWriteError();

  693. 	return 0;

  694. #else

  695. 	return;

  696. #endif

  697. }

  698. 

  699. 

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

  701. 

  702. // immediately transmit any buffered output.

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

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

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

  706. void usb_serial_class::send_now(void)

  707. {

  708.         uint8_t intr_state;

  709. 

  710.         intr_state = SREG;

  711.         cli();

  712.         if (debug_flush_timer) {

  713.                 UENUM = DEBUG_TX_ENDPOINT;

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

  715. 			UEDATX = 0;

  716. 		}

  717.                 UEINTX = 0x3A;

  718.                 debug_flush_timer = 0;

  719.         }

  720.         SREG = intr_state;

  721. }

  722. 

  723. uint32_t usb_serial_class::baud(void)

  724. {

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

  726. }

  727. 

  728. uint8_t usb_serial_class::stopbits(void)

  729. {

  730. 	return 1;

  731. }

  732. 

  733. uint8_t usb_serial_class::paritytype(void)

  734. {

  735. 	return 0;

  736. }

  737. 

  738. uint8_t usb_serial_class::numbits(void)

  739. {

  740. 	return 8;

  741. }

  742. 

  743. uint8_t usb_serial_class::dtr(void)

  744. {

  745. 	return 1;

  746. }

  747. 

  748. uint8_t usb_serial_class::rts(void)

  749. {

  750. 	return 1;

  751. }

  752. 

  753. usb_serial_class::operator bool()

  754. {

  755. 	if (usb_configuration) return true;

  756. 	return false;

  757. }

  758. 

  759. 

  760. 

  761. // Preinstantiate Objects //////////////////////////////////////////////////////

  762. 

  763. usb_serial_class	Serial = usb_serial_class();

  764. usb_rawhid_class	RawHID = usb_rawhid_class();