visus
/
teensy-core-4.1
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Teensy 4.1 core updated for 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.
1186 Commits
2 Branches
Tree: b515629a87
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b515629a87'
${ noResults }
teensy-core-4.1/teensy3/usb_serial_template.h

260 lines
8.4KB
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. #include <inttypes.h>

  32. #include <sys/cdefs.h> // for __CONCAT()

  33. 

  34. #include "usb_serial_port.h"

  35. 

  36. #define USB_SERIAL_PREFIX		__CONCAT(usb_serial, USB_SERIAL_SUFFIX)

  37. #define USB_SERIAL_NAME(func)		__CONCAT(USB_SERIAL_PREFIX, _ ## func)

  38. #define usb_serial_available		USB_SERIAL_NAME(available)

  39. #define usb_serial_class		USB_SERIAL_NAME(class)

  40. #define usb_serial_flush_callback	USB_SERIAL_NAME(flush_callback)

  41. #define usb_serial_flush_input		USB_SERIAL_NAME(flush_input)

  42. #define usb_serial_flush_output		USB_SERIAL_NAME(flush_output)

  43. #define usb_serial_getchar		USB_SERIAL_NAME(getchar)

  44. #define usb_serial_instance		USB_SERIAL_NAME(instance)

  45. #define usb_serial_peekchar		USB_SERIAL_NAME(peekchar)

  46. #define usb_serial_putchar		USB_SERIAL_NAME(putchar)

  47. #define usb_serial_read			USB_SERIAL_NAME(read)

  48. #define usb_serial_write_buffer_free	USB_SERIAL_NAME(write_buffer_free)

  49. #define usb_serial_write		USB_SERIAL_NAME(write)

  50. 

  51. #define Serial				__CONCAT(Serial, SERIAL_CLASS_SUFFIX)

  52. #define serialEvent			__CONCAT(serialEvent, SERIAL_CLASS_SUFFIX)

  53. 

  54. #if F_CPU >= 20000000 && !defined(USB_DISABLED)

  55. 

  56. #include "core_pins.h" // for millis()

  57. 

  58. // C language implementation

  59. #ifdef __cplusplus

  60. extern "C" {

  61. #endif

  62. extern struct usb_serial_port usb_serial_instance;

  63. 

  64. static inline int usb_serial_getchar(void)

  65. {

  66. 	return __usb_serial_getchar(&usb_serial_instance);

  67. }

  68. 

  69. static inline int usb_serial_peekchar(void)

  70. {

  71. 	return __usb_serial_peekchar(&usb_serial_instance);

  72. }

  73. 

  74. static inline int usb_serial_available(void)

  75. {

  76. 	return __usb_serial_available(&usb_serial_instance);

  77. }

  78. 

  79. static inline int usb_serial_read(void *buffer, uint32_t size)

  80. {

  81. 	return __usb_serial_read(&usb_serial_instance, buffer, size);

  82. }

  83. 

  84. static inline void usb_serial_flush_input(void)

  85. {

  86. 	__usb_serial_flush_input(&usb_serial_instance);

  87. }

  88. 

  89. static inline int usb_serial_putchar(uint8_t c)

  90. {

  91. 	return __usb_serial_putchar(&usb_serial_instance, c);

  92. }

  93. 

  94. static inline int usb_serial_write(const void *buffer, uint32_t size)

  95. {

  96. 	return __usb_serial_write(&usb_serial_instance, buffer, size);

  97. }

  98. 

  99. static inline int usb_serial_write_buffer_free(void)

  100. {

  101. 	return __usb_serial_write_buffer_free(&usb_serial_instance);

  102. }

  103. 

  104. static inline void usb_serial_flush_output(void)

  105. {

  106. 	__usb_serial_flush_output(&usb_serial_instance);

  107. }

  108. 

  109. static inline void usb_serial_flush_callback(void)

  110. {

  111. 	__usb_serial_flush_callback(&usb_serial_instance);

  112. }

  113. 

  114. #ifdef __cplusplus

  115. }

  116. #endif

  117. 

  118. #define USB_SERIAL_DTR  0x01

  119. #define USB_SERIAL_RTS  0x02

  120. 

  121. // C++ interface

  122. #ifdef __cplusplus

  123. #include "Stream.h"

  124. class usb_serial_class : public Stream

  125. {

  126. public:

  127. 	constexpr usb_serial_class() {}

  128.         void begin(long) {

  129. 		//uint32_t millis_begin = systick_millis_count;

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

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

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

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

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

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

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

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

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

  139. 		//}

  140. 	}

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

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

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

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

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

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

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

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

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

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

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

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

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

  154. 	using Print::write;

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

  156.         uint32_t baud(void) { return usb_serial_instance.cdc_line_coding[0]; }

  157.         uint8_t stopbits(void) {

  158. 		uint8_t b = usb_serial_instance.cdc_line_coding[1];

  159. 		if (!b) b = 1;

  160. 		return b;

  161. 	}

  162.         uint8_t paritytype(void) {

  163. 		// 0=none, 1=odd, 2=even

  164. 		return usb_serial_instance.cdc_line_coding[1] >> 8;

  165. 	}

  166.         uint8_t numbits(void) {

  167. 		return usb_serial_instance.cdc_line_coding[1] >> 16;

  168. 	}

  169.         uint8_t dtr(void) {

  170. 		return (usb_serial_instance.cdc_line_rtsdtr & USB_SERIAL_DTR) ?

  171. 		       1 : 0;

  172. 	}

  173.         uint8_t rts(void) {

  174. 		return (usb_serial_instance.cdc_line_rtsdtr & USB_SERIAL_RTS) ?

  175. 		       1 : 0;

  176. 	}

  177.         operator bool() {

  178. 		return usb_configuration &&

  179. 		       (usb_serial_instance.cdc_line_rtsdtr & USB_SERIAL_DTR) &&

  180. 		       ((uint32_t)(systick_millis_count - usb_serial_instance.cdc_line_rtsdtr_millis) >= 15);

  181. 	}

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

  183. 		size_t count=0;

  184. 		unsigned long startMillis = millis();

  185. 		do {

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

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

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

  189. 		setReadError();

  190. 		return count;

  191. 	}

  192. 

  193. };

  194. extern usb_serial_class Serial;

  195. extern void serialEvent(void);

  196. #endif // __cplusplus

  197. 

  198. 

  199. #else  // F_CPU < 20000000

  200. 

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

  202. #ifdef __cplusplus

  203. #include "Stream.h"

  204. class usb_serial_class : public Stream

  205. {

  206. public:

  207. 	constexpr usb_serial_class() {}

  208.         void begin(long) { };

  209.         void end() { };

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

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

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

  213.         virtual void flush() { }

  214.         virtual void clear() { }

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

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

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

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

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

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

  221. 	int availableForWrite() { return 0; }

  222. 	using Print::write;

  223.         void send_now(void) { }

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

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

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

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

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

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

  230.         operator bool() { return true; }

  231. };

  232. 

  233. extern usb_serial_class Serial;

  234. extern void serialEvent(void);

  235. #endif // __cplusplus

  236. 

  237. 

  238. #endif // F_CPU

  239. 

  240. #undef usb_serial_available

  241. #undef usb_serial_class

  242. #undef usb_serial_flush_callback

  243. #undef usb_serial_flush_input

  244. #undef usb_serial_flush_output

  245. #undef usb_serial_getchar

  246. #undef usb_serial_instance

  247. #undef usb_serial_peekchar

  248. #undef usb_serial_putchar

  249. #undef usb_serial_read

  250. #undef usb_serial_write_buffer_free

  251. #undef usb_serial_write

  252. 

  253. #undef Serial

  254. #undef serialEvent

  255. 

  256. #undef USB_SERIAL_SUFFIX

  257. #undef USB_SERIAL_PREFIX

  258. #undef USB_SERIAL_NAME

  259. #undef SERIAL_CLASS_SUFFIX