visus
/
teensy-cores
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
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.
1407 Commits
1 Branch
Tree: a0f8e1107a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a0f8e1107a'
${ noResults }
teensy-cores/teensy4/usb_serial.h

351 lines
14KB
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. #if !defined(USB_DISABLED)

  39. 

  40. // C language implementation

  41. #ifdef __cplusplus

  42. extern "C" {

  43. #endif

  44. void usb_serial_reset(void);

  45. void usb_serial_configure(void);

  46. int usb_serial_getchar(void);

  47. int usb_serial_peekchar(void);

  48. int usb_serial_available(void);

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

  50. void usb_serial_flush_input(void);

  51. int usb_serial_putchar(uint8_t c);

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

  53. int usb_serial_write_buffer_free(void);

  54. void usb_serial_flush_output(void);

  55. extern uint32_t usb_cdc_line_coding[2];

  56. extern volatile uint32_t usb_cdc_line_rtsdtr_millis;

  57. extern volatile uint32_t systick_millis_count;

  58. extern volatile uint8_t usb_cdc_line_rtsdtr;

  59. extern volatile uint8_t usb_cdc_transmit_flush_timer;

  60. extern volatile uint8_t usb_configuration;

  61. #ifdef __cplusplus

  62. }

  63. #endif

  64. 

  65. #define USB_SERIAL_DTR  0x01

  66. #define USB_SERIAL_RTS  0x02

  67. 

  68. // C++ interface

  69. #ifdef __cplusplus

  70. #include "Stream.h"

  71. class usb_serial_class : public Stream

  72. {

  73. public:

  74. 	constexpr usb_serial_class() {}

  75.         void begin(long) {

  76. 		//uint32_t millis_begin = systick_millis_count;

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

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

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

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

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

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

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

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

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

  86. 		//}

  87. 	}

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

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

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

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

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

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

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

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

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

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

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

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

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

  101. 	using Print::write;

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

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

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

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

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

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

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

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

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

  111. 	}

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

  113. 		size_t count=0;

  114. 		unsigned long startMillis = millis();

  115. 		do {

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

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

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

  119. 		setReadError();

  120. 		return count;

  121. 	}

  122. 

  123. };

  124. extern usb_serial_class Serial;

  125. extern void serialEvent(void);

  126. #endif // __cplusplus

  127. 

  128. #else  // !defined(USB_DISABLED)

  129. 

  130. // Allow Arduino programs using Serial to compile, but Serial will do nothing.

  131. #ifdef __cplusplus

  132. #include "Stream.h"

  133. class usb_serial_class : public Stream

  134. {

  135. public:

  136.     constexpr usb_serial_class() {}

  137.         void begin(long) { };

  138.         void end() { };

  139.         virtual int available() { return 0; }

  140.         virtual int read() { return -1; }

  141.         virtual int peek() { return -1; }

  142.         virtual void flush() { }

  143.         virtual void clear() { }

  144.         virtual size_t write(uint8_t c) { return 1; }

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

  146.     size_t write(unsigned long n) { return 1; }

  147.     size_t write(long n) { return 1; }

  148.     size_t write(unsigned int n) { return 1; }

  149.     size_t write(int n) { return 1; }

  150.     int availableForWrite() { return 0; }

  151.     using Print::write;

  152.         void send_now(void) { }

  153.         uint32_t baud(void) { return 0; }

  154.         uint8_t stopbits(void) { return 1; }

  155.         uint8_t paritytype(void) { return 0; }

  156.         uint8_t numbits(void) { return 8; }

  157.         uint8_t dtr(void) { return 1; }

  158.         uint8_t rts(void) { return 1; }

  159.         operator bool() { return true; }

  160. };

  161. 

  162. extern usb_serial_class Serial;

  163. extern void serialEvent(void);

  164. #endif // __cplusplus

  165. 

  166. #endif // !defined(USB_DISABLED)

  167. 

  168. #endif // CDC_STATUS_INTERFACE && CDC_DATA_INTERFACE

  169. 

  170. 

  171. 

  172. 

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

  174. 

  175. // C language implementation

  176. #ifdef __cplusplus

  177. extern "C" {

  178. #endif

  179. void usb_serial2_configure(void);

  180. int usb_serial2_getchar(void);

  181. int usb_serial2_peekchar(void);

  182. int usb_serial2_available(void);

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

  184. void usb_serial2_flush_input(void);

  185. int usb_serial2_putchar(uint8_t c);

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

  187. int usb_serial2_write_buffer_free(void);

  188. void usb_serial2_flush_output(void);

  189. extern uint32_t usb_cdc2_line_coding[2];

  190. extern volatile uint32_t usb_cdc2_line_rtsdtr_millis;

  191. extern volatile uint8_t usb_cdc2_line_rtsdtr;

  192. extern volatile uint8_t usb_cdc2_transmit_flush_timer;

  193. #ifdef __cplusplus

  194. }

  195. #endif

  196. 

  197. // C++ interface

  198. #ifdef __cplusplus

  199. #include "Stream.h"

  200. class usb_serial2_class : public Stream

  201. {

  202. public:

  203.         constexpr usb_serial2_class() {}

  204.         void begin(long) {

  205.                 //uint32_t millis_begin = systick_millis_count;

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

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

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

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

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

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

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

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

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

  215.                 //}

  216.         }

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

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

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

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

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

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

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

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

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

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

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

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

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

  230.         using Print::write;

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

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

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

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

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

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

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

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

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

  240.         }

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

  242.                 size_t count=0;

  243.                 unsigned long startMillis = millis();

  244.                 do {

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

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

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

  248.                 setReadError();

  249.                 return count;

  250.         }

  251. 

  252. };

  253. extern usb_serial2_class SerialUSB1;

  254. extern void serialEventUSB1(void);

  255. #endif // __cplusplus

  256. 

  257. #endif // CDC2_STATUS_INTERFACE && CDC2_DATA_INTERFACE

  258. 

  259. 

  260. 

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

  262. 

  263. // C language implementation

  264. #ifdef __cplusplus

  265. extern "C" {

  266. #endif

  267. void usb_serial3_configure(void);

  268. int usb_serial3_getchar(void);

  269. int usb_serial3_peekchar(void);

  270. int usb_serial3_available(void);

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

  272. void usb_serial3_flush_input(void);

  273. int usb_serial3_putchar(uint8_t c);

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

  275. int usb_serial3_write_buffer_free(void);

  276. void usb_serial3_flush_output(void);

  277. extern uint32_t usb_cdc3_line_coding[2];

  278. extern volatile uint32_t usb_cdc3_line_rtsdtr_millis;

  279. extern volatile uint8_t usb_cdc3_line_rtsdtr;

  280. extern volatile uint8_t usb_cdc3_transmit_flush_timer;

  281. #ifdef __cplusplus

  282. }

  283. #endif

  284. 

  285. // C++ interface

  286. #ifdef __cplusplus

  287. #include "Stream.h"

  288. class usb_serial3_class : public Stream

  289. {

  290. public:

  291.         constexpr usb_serial3_class() {}

  292.         void begin(long) {

  293.                 //uint32_t millis_begin = systick_millis_count;

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

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

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

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

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

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

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

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

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

  303.                 //}

  304.         }

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

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

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

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

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

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

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

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

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

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

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

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

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

  318.         using Print::write;

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

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

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

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

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

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

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

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

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

  328.         }

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

  330.                 size_t count=0;

  331.                 unsigned long startMillis = millis();

  332.                 do {

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

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

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

  336.                 setReadError();

  337.                 return count;

  338.         }

  339. 

  340. };

  341. extern usb_serial3_class SerialUSB2;

  342. extern void serialEventUSB2(void);

  343. #endif // __cplusplus

  344. 

  345. #endif // CDC3_STATUS_INTERFACE && CDC3_DATA_INTERFACE

  346. 

  347. 

  348. 

  349.