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/teensy4/usb_serial.h

309 lines
13KB
Raw Blame History 

  1. /* Teensyduino Core Library

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

  3.  * Copyright (c) 2017 PJRC.COM, LLC.

  4.  *

  5.  * Permission is hereby granted, free of charge, to any person obtaining

  6.  * a copy of this software and associated documentation files (the

  7.  * "Software"), to deal in the Software without restriction, including

  8.  * without limitation the rights to use, copy, modify, merge, publish,

  9.  * distribute, sublicense, and/or sell copies of the Software, and to

  10.  * permit persons to whom the Software is furnished to do so, subject to

  11.  * the following conditions:

  12.  *

  13.  * 1. The above copyright notice and this permission notice shall be

  14.  * included in all copies or substantial portions of the Software.

  15.  *

  16.  * 2. If the Software is incorporated into a build system that allows

  17.  * selection among a list of target devices, then similar target

  18.  * devices manufactured by PJRC.COM must be included in the list of

  19.  * target devices and selectable in the same manner.

  20.  *

  21.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  22.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  23.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  24.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  25.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  26.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  28.  * SOFTWARE.

  29.  */

  30. 

  31. #pragma once

  32. 

  33. #include "usb_desc.h"

  34. #include <stdint.h>

  35. 

  36. #if (defined(CDC_STATUS_INTERFACE) && defined(CDC_DATA_INTERFACE)) || defined(USB_DISABLED)

  37. 

  38. // C language implementation

  39. #ifdef __cplusplus

  40. extern "C" {

  41. #endif

  42. void usb_serial_reset(void);

  43. void usb_serial_configure(void);

  44. int usb_serial_getchar(void);

  45. int usb_serial_peekchar(void);

  46. int usb_serial_available(void);

  47. int usb_serial_read(void *buffer, uint32_t size);

  48. void usb_serial_flush_input(void);

  49. int usb_serial_putchar(uint8_t c);

  50. int usb_serial_write(const void *buffer, uint32_t size);

  51. int usb_serial_write_buffer_free(void);

  52. void usb_serial_flush_output(void);

  53. extern uint32_t usb_cdc_line_coding[2];

  54. extern volatile uint32_t usb_cdc_line_rtsdtr_millis;

  55. extern volatile uint32_t systick_millis_count;

  56. extern volatile uint8_t usb_cdc_line_rtsdtr;

  57. extern volatile uint8_t usb_cdc_transmit_flush_timer;

  58. extern volatile uint8_t usb_configuration;

  59. #ifdef __cplusplus

  60. }

  61. #endif

  62. 

  63. #define USB_SERIAL_DTR  0x01

  64. #define USB_SERIAL_RTS  0x02

  65. 

  66. // C++ interface

  67. #ifdef __cplusplus

  68. #include "Stream.h"

  69. class usb_serial_class : public Stream

  70. {

  71. public:

  72. 	constexpr usb_serial_class() {}

  73.         void begin(long) {

  74. 		//uint32_t millis_begin = systick_millis_count;

  75. 		//disabled for now - causes more trouble than it solves?

  76. 		//while (!(*this)) {

  77. 			// wait up to 2.5 seconds for Arduino Serial Monitor

  78. 			// Yes, this is a long time, but some Windows systems open

  79. 			// the port very slowly.  This wait allows programs for

  80. 			// Arduino Uno to "just work" (without forcing a reboot when

  81. 			// the port is opened), and when no PC is connected the user's

  82. 			// sketch still gets to run normally after this wait time.

  83. 			//if ((uint32_t)(systick_millis_count - millis_begin) > 2500) break;

  84. 		//}

  85. 	}

  86.         void end() { /* TODO: flush output and shut down USB port */ };

  87.         virtual int available() { return usb_serial_available(); }

  88.         virtual int read() { return usb_serial_getchar(); }

  89.         virtual int peek() { return usb_serial_peekchar(); }

  90.         virtual void flush() { usb_serial_flush_output(); }  // TODO: actually wait for data to leave USB...

  91.         virtual void clear(void) { usb_serial_flush_input(); }

  92.         virtual size_t write(uint8_t c) { return usb_serial_putchar(c); }

  93.         virtual size_t write(const uint8_t *buffer, size_t size) { return usb_serial_write(buffer, size); }

  94. 	size_t write(unsigned long n) { return write((uint8_t)n); }

  95. 	size_t write(long n) { return write((uint8_t)n); }

  96. 	size_t write(unsigned int n) { return write((uint8_t)n); }

  97. 	size_t write(int n) { return write((uint8_t)n); }

  98. 	virtual int availableForWrite() { return usb_serial_write_buffer_free(); }

  99. 	using Print::write;

  100.         void send_now(void) { usb_serial_flush_output(); }

  101.         uint32_t baud(void) { return usb_cdc_line_coding[0]; }

  102.         uint8_t stopbits(void) { uint8_t b = usb_cdc_line_coding[1]; if (!b) b = 1; return b; }

  103.         uint8_t paritytype(void) { return usb_cdc_line_coding[1] >> 8; } // 0=none, 1=odd, 2=even

  104.         uint8_t numbits(void) { return usb_cdc_line_coding[1] >> 16; }

  105.         uint8_t dtr(void) { return (usb_cdc_line_rtsdtr & USB_SERIAL_DTR) ? 1 : 0; }

  106.         uint8_t rts(void) { return (usb_cdc_line_rtsdtr & USB_SERIAL_RTS) ? 1 : 0; }

  107.         operator bool() { return usb_configuration && (usb_cdc_line_rtsdtr & USB_SERIAL_DTR) &&

  108. 		((uint32_t)(systick_millis_count - usb_cdc_line_rtsdtr_millis) >= 15);

  109. 	}

  110. 	size_t readBytes(char *buffer, size_t length) {

  111. 		size_t count=0;

  112. 		unsigned long startMillis = millis();

  113. 		do {

  114. 			count += usb_serial_read(buffer + count, length - count);

  115. 			if (count >= length) return count;

  116. 		} while(millis() - startMillis < _timeout);

  117. 		setReadError();

  118. 		return count;

  119. 	}

  120. 

  121. };

  122. extern usb_serial_class Serial;

  123. extern void serialEvent(void);

  124. #endif // __cplusplus

  125. 

  126. #endif // CDC_STATUS_INTERFACE && CDC_DATA_INTERFACE

  127. 

  128. 

  129. 

  130. 

  131. #if defined(CDC2_STATUS_INTERFACE) && defined(CDC2_DATA_INTERFACE)

  132. 

  133. // C language implementation

  134. #ifdef __cplusplus

  135. extern "C" {

  136. #endif

  137. void usb_serial2_configure(void);

  138. int usb_serial2_getchar(void);

  139. int usb_serial2_peekchar(void);

  140. int usb_serial2_available(void);

  141. int usb_serial2_read(void *buffer, uint32_t size);

  142. void usb_serial2_flush_input(void);

  143. int usb_serial2_putchar(uint8_t c);

  144. int usb_serial2_write(const void *buffer, uint32_t size);

  145. int usb_serial2_write_buffer_free(void);

  146. void usb_serial2_flush_output(void);

  147. extern uint32_t usb_cdc2_line_coding[2];

  148. extern volatile uint32_t usb_cdc2_line_rtsdtr_millis;

  149. extern volatile uint8_t usb_cdc2_line_rtsdtr;

  150. extern volatile uint8_t usb_cdc2_transmit_flush_timer;

  151. #ifdef __cplusplus

  152. }

  153. #endif

  154. 

  155. // C++ interface

  156. #ifdef __cplusplus

  157. #include "Stream.h"

  158. class usb_serial2_class : public Stream

  159. {

  160. public:

  161.         constexpr usb_serial2_class() {}

  162.         void begin(long) {

  163.                 //uint32_t millis_begin = systick_millis_count;

  164.                 //disabled for now - causes more trouble than it solves?

  165.                 //while (!(*this)) {

  166.                         // wait up to 2.5 seconds for Arduino Serial Monitor

  167.                         // Yes, this is a long time, but some Windows systems open

  168.                         // the port very slowly.  This wait allows programs for

  169.                         // Arduino Uno to "just work" (without forcing a reboot when

  170.                         // the port is opened), and when no PC is connected the user's

  171.                         // sketch still gets to run normally after this wait time.

  172.                         //if ((uint32_t)(systick_millis_count - millis_begin) > 2500) break;

  173.                 //}

  174.         }

  175.         void end() { /* TODO: flush output and shut down USB port */ };

  176.         virtual int available() { return usb_serial2_available(); }

  177.         virtual int read() { return usb_serial2_getchar(); }

  178.         virtual int peek() { return usb_serial2_peekchar(); }

  179.         virtual void flush() { usb_serial2_flush_output(); }  // TODO: actually wait for data to leave USB...

  180.         virtual void clear(void) { usb_serial2_flush_input(); }

  181.         virtual size_t write(uint8_t c) { return usb_serial2_putchar(c); }

  182.         virtual size_t write(const uint8_t *buffer, size_t size) { return usb_serial2_write(buffer, size); }

  183.         size_t write(unsigned long n) { return write((uint8_t)n); }

  184.         size_t write(long n) { return write((uint8_t)n); }

  185.         size_t write(unsigned int n) { return write((uint8_t)n); }

  186.         size_t write(int n) { return write((uint8_t)n); }

  187.         virtual int availableForWrite() { return usb_serial2_write_buffer_free(); }

  188.         using Print::write;

  189.         void send_now(void) { usb_serial2_flush_output(); }

  190.         uint32_t baud(void) { return usb_cdc2_line_coding[0]; }

  191.         uint8_t stopbits(void) { uint8_t b = usb_cdc2_line_coding[1]; if (!b) b = 1; return b; }

  192.         uint8_t paritytype(void) { return usb_cdc2_line_coding[1] >> 8; } // 0=none, 1=odd, 2=even

  193.         uint8_t numbits(void) { return usb_cdc2_line_coding[1] >> 16; }

  194.         uint8_t dtr(void) { return (usb_cdc2_line_rtsdtr & USB_SERIAL_DTR) ? 1 : 0; }

  195.         uint8_t rts(void) { return (usb_cdc2_line_rtsdtr & USB_SERIAL_RTS) ? 1 : 0; }

  196.         operator bool() { return usb_configuration && (usb_cdc2_line_rtsdtr & USB_SERIAL_DTR) &&

  197.                 ((uint32_t)(systick_millis_count - usb_cdc2_line_rtsdtr_millis) >= 15);

  198.         }

  199.         size_t readBytes(char *buffer, size_t length) {

  200.                 size_t count=0;

  201.                 unsigned long startMillis = millis();

  202.                 do {

  203.                         count += usb_serial2_read(buffer + count, length - count);

  204.                         if (count >= length) return count;

  205.                 } while(millis() - startMillis < _timeout);

  206.                 setReadError();

  207.                 return count;

  208.         }

  209. 

  210. };

  211. extern usb_serial2_class SerialUSB1;

  212. extern void serialEventUSB1(void);

  213. #endif // __cplusplus

  214. 

  215. #endif // CDC2_STATUS_INTERFACE && CDC2_DATA_INTERFACE

  216. 

  217. 

  218. 

  219. #if defined(CDC3_STATUS_INTERFACE) && defined(CDC3_DATA_INTERFACE)

  220. 

  221. // C language implementation

  222. #ifdef __cplusplus

  223. extern "C" {

  224. #endif

  225. void usb_serial3_configure(void);

  226. int usb_serial3_getchar(void);

  227. int usb_serial3_peekchar(void);

  228. int usb_serial3_available(void);

  229. int usb_serial3_read(void *buffer, uint32_t size);

  230. void usb_serial3_flush_input(void);

  231. int usb_serial3_putchar(uint8_t c);

  232. int usb_serial3_write(const void *buffer, uint32_t size);

  233. int usb_serial3_write_buffer_free(void);

  234. void usb_serial3_flush_output(void);

  235. extern uint32_t usb_cdc3_line_coding[2];

  236. extern volatile uint32_t usb_cdc3_line_rtsdtr_millis;

  237. extern volatile uint8_t usb_cdc3_line_rtsdtr;

  238. extern volatile uint8_t usb_cdc3_transmit_flush_timer;

  239. #ifdef __cplusplus

  240. }

  241. #endif

  242. 

  243. // C++ interface

  244. #ifdef __cplusplus

  245. #include "Stream.h"

  246. class usb_serial3_class : public Stream

  247. {

  248. public:

  249.         constexpr usb_serial3_class() {}

  250.         void begin(long) {

  251.                 //uint32_t millis_begin = systick_millis_count;

  252.                 //disabled for now - causes more trouble than it solves?

  253.                 //while (!(*this)) {

  254.                         // wait up to 2.5 seconds for Arduino Serial Monitor

  255.                         // Yes, this is a long time, but some Windows systems open

  256.                         // the port very slowly.  This wait allows programs for

  257.                         // Arduino Uno to "just work" (without forcing a reboot when

  258.                         // the port is opened), and when no PC is connected the user's

  259.                         // sketch still gets to run normally after this wait time.

  260.                         //if ((uint32_t)(systick_millis_count - millis_begin) > 2500) break;

  261.                 //}

  262.         }

  263.         void end() { /* TODO: flush output and shut down USB port */ };

  264.         virtual int available() { return usb_serial3_available(); }

  265.         virtual int read() { return usb_serial3_getchar(); }

  266.         virtual int peek() { return usb_serial3_peekchar(); }

  267.         virtual void flush() { usb_serial3_flush_output(); }  // TODO: actually wait for data to leave USB...

  268.         virtual void clear(void) { usb_serial3_flush_input(); }

  269.         virtual size_t write(uint8_t c) { return usb_serial3_putchar(c); }

  270.         virtual size_t write(const uint8_t *buffer, size_t size) { return usb_serial3_write(buffer, size); }

  271.         size_t write(unsigned long n) { return write((uint8_t)n); }

  272.         size_t write(long n) { return write((uint8_t)n); }

  273.         size_t write(unsigned int n) { return write((uint8_t)n); }

  274.         size_t write(int n) { return write((uint8_t)n); }

  275.         virtual int availableForWrite() { return usb_serial3_write_buffer_free(); }

  276.         using Print::write;

  277.         void send_now(void) { usb_serial3_flush_output(); }

  278.         uint32_t baud(void) { return usb_cdc3_line_coding[0]; }

  279.         uint8_t stopbits(void) { uint8_t b = usb_cdc3_line_coding[1]; if (!b) b = 1; return b; }

  280.         uint8_t paritytype(void) { return usb_cdc3_line_coding[1] >> 8; } // 0=none, 1=odd, 2=even

  281.         uint8_t numbits(void) { return usb_cdc3_line_coding[1] >> 16; }

  282.         uint8_t dtr(void) { return (usb_cdc3_line_rtsdtr & USB_SERIAL_DTR) ? 1 : 0; }

  283.         uint8_t rts(void) { return (usb_cdc3_line_rtsdtr & USB_SERIAL_RTS) ? 1 : 0; }

  284.         operator bool() { return usb_configuration && (usb_cdc3_line_rtsdtr & USB_SERIAL_DTR) &&

  285.                 ((uint32_t)(systick_millis_count - usb_cdc3_line_rtsdtr_millis) >= 15);

  286.         }

  287.         size_t readBytes(char *buffer, size_t length) {

  288.                 size_t count=0;

  289.                 unsigned long startMillis = millis();

  290.                 do {

  291.                         count += usb_serial3_read(buffer + count, length - count);

  292.                         if (count >= length) return count;

  293.                 } while(millis() - startMillis < _timeout);

  294.                 setReadError();

  295.                 return count;

  296.         }

  297. 

  298. };

  299. extern usb_serial3_class SerialUSB2;

  300. extern void serialEventUSB2(void);

  301. #endif // __cplusplus

  302. 

  303. #endif // CDC3_STATUS_INTERFACE && CDC3_DATA_INTERFACE

  304. 

  305. 

  306. 

  307.