/ usb_rawhid / usb_api.cpp
usb_api.cpp
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, i, 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(); 765