Pico-Arduino
PicoHardwareSerial.h
1 #pragma once
2 
3 #include "Stream.h"
4 #include "HardwareSerial.h"
5 #include "RingBuffer.h"
6 #include "pico/stdlib.h"
7 
8 #ifndef BUFFER_SIZE
9 #define BUFFER_SIZE 512
10 #endif
11 
12 
18  public:
20  }
21 
22  virtual void begin(unsigned long baudrate=PICO_DEFAULT_UART_BAUD_RATE) {
23  stdio_init_all();
24  open = true;
25  };
26  virtual void begin(unsigned long baudrate, uint16_t config){
27  stdio_init_all();
28  open = true;
29 
30  }
31  virtual void end() {
32  open = false;
33  }
34  virtual int available(void){
35  readBuffer();
36  return buffer.available();
37  }
38  virtual int peek(void) {
39  readBuffer();
40  return buffer.peek();
41  }
42  virtual int read(void){
43  readBuffer();
44  return buffer.read_char();
45  }
46 
47  virtual void flush(void) {
48  stdio_flush();
49  }
50 
51  virtual size_t write(uint8_t c) {
52  size_t len = putchar(c);
53  stdio_flush();
54  return len;
55  }
56 
57  virtual int println(){
58  return println("");
59  }
60 
61  virtual int println(char const* str){
62  int len = printf("%s\n",str);
63  flush();
64  return len;
65  }
66 
67  using Print::write; // pull in write(str) and write(buf, size) from Print
68  using Print::print; // pull in write(str) and write(buf, size) from Print
69  using Print::println; // pull in write(str) and write(buf, size) from Print
70 
71  virtual operator bool(){
72  return open;
73  };
74 
75  protected:
76  bool open;
77  RingBufferN<BUFFER_SIZE> buffer;
78 
79  void readBuffer() {
80  if (buffer.available()==0){
81  char c = getchar();
82  while(c!=EOF && buffer.availableForStore()>0){
83  buffer.store_char(c);
84  }
85  }
86  }
87 };
88 
94  public:
96  }
97 
98  PicoHardwareSerial(int uart_no) {
99  this->uart_no = uart_no;
100  this->uart = uart_no == 0 ? uart0 : uart1;
101  }
102 
103  virtual void begin(unsigned long baudrate=PICO_DEFAULT_UART_BAUD_RATE) {
104  begin(baudrate, SERIAL_8N1);
105  }
106 
107  virtual void begin(unsigned long baudrate, uint16_t config) {
108  begin(baudrate, config);
109  }
110 
123  virtual void begin(unsigned long baudrate, uint32_t config, int rxPin=-1, int txPin=-1, bool invert=false, bool cts=false, bool rts=false) {
124  Logger.info("begin", toStr(baudrate));
125  rx_pin = rxPin;
126  tx_pin = txPin;
127  setupDefaultRxTxPins();
128  stdio_uart_init_full(uart, baudrate, tx_pin, rx_pin);
129  uart_set_hw_flow(uart, cts, rts);
130  set_config(config);
131  }
132 
133  virtual void end(){
134  uart_deinit(uart);
135  }
136 
137  virtual int available(void){
138  if (buffer.available()>0){
139  return buffer.available();
140  }
141  return uart_is_readable(uart);
142  }
143 
144  virtual int availableForWrite(void){
145  return uart_is_writable(uart);
146  }
147 
148  virtual int peek(void){
149  readBuffer();
150  return buffer.peek();
151  }
152 
153  virtual int read(void){
154  readBuffer();
155  return buffer.read_char();
156  }
157 
158  virtual size_t write(uint8_t c) {
159  uart_putc(uart, c);
160  return 1;
161  }
162 
163  inline size_t write(const uint8_t *buffer, size_t size) {
164  uart_write_blocking(uart, buffer, size);
165  flush();
166  return size;
167  }
168 
169  inline size_t write(const char * buffer, size_t size) {
170  return write((uint8_t*) buffer, size);
171  }
172 
173  inline size_t write(const char * s){
174  return write((uint8_t*) s, strlen(s));
175  }
176 
177  inline size_t write(unsigned long n){
178  return write((uint8_t) n);
179  }
180 
181  inline size_t write(long n){
182  return write((uint8_t) n);
183  }
184 
185  inline size_t write(unsigned int n) {
186  return write((uint8_t) n);
187  }
188 
189  inline size_t write(int n){
190  return write((uint8_t) n);
191  }
192 
193  uint32_t baudRate(){
194  return baud_rate;
195  }
196 
197  using Print::write; // pull in write(str) and write(buf, size) from Print
198  using Print::print; // pull in write(str) and write(buf, size) from Print
199  using Print::println; // pull in write(str) and write(buf, size) from Print
200 
201  virtual operator bool() {
202  return ok;
203  }
204 
205  virtual void flush(void) {
206  };
207 
208 
209  protected:
210  RingBufferN<BUFFER_SIZE> buffer;
211  uart_inst_t *uart;
212  uint baud_rate;
213  int tx_pin;
214  int rx_pin;
215  int uart_no;
216  bool ok = false;
217 
218  void readBuffer() {
219  if (buffer.available()==0){
220  char c = uart_getc(uart);
221  while(c!=0 && buffer.availableForStore()>0){
222  buffer.store_char(c);
223  }
224  }
225  }
226 
227  void set_config(uint32_t config){
228  //data, parity, and stop bits
229  switch(config){
230  case SERIAL_5N1:
231  uart_set_format(uart, 5, 1,UART_PARITY_NONE);
232  break;
233  case SERIAL_6N1:
234  uart_set_format(uart, 6, 1,UART_PARITY_NONE);
235  break;
236  case SERIAL_7N1:
237  uart_set_format(uart, 7, 1,UART_PARITY_NONE);
238  break;
239  case SERIAL_8N1:
240  uart_set_format(uart, 8, 1,UART_PARITY_NONE);
241  break;
242  case SERIAL_5N2:
243  uart_set_format(uart, 5, 2,UART_PARITY_NONE);
244  break;
245  case SERIAL_6N2:
246  uart_set_format(uart, 6, 2,UART_PARITY_NONE);
247  break;
248  case SERIAL_7N2:
249  uart_set_format(uart, 7, 2,UART_PARITY_NONE);
250  break;
251  case SERIAL_8N2:
252  uart_set_format(uart, 8, 2,UART_PARITY_NONE);
253  break;
254  case SERIAL_5E1:
255  uart_set_format(uart, 5, 1,UART_PARITY_EVEN);
256  break;
257  case SERIAL_6E1:
258  uart_set_format(uart, 6, 1,UART_PARITY_EVEN);
259  break;
260  case SERIAL_7E1:
261  uart_set_format(uart, 7, 1,UART_PARITY_EVEN);
262  break;
263  case SERIAL_8E1:
264  uart_set_format(uart, 8, 1,UART_PARITY_EVEN);
265  break;
266  case SERIAL_5E2:
267  uart_set_format(uart, 5, 2,UART_PARITY_EVEN);
268  break;
269  case SERIAL_6E2:
270  uart_set_format(uart, 6, 2,UART_PARITY_EVEN);
271  break;
272  case SERIAL_7E2:
273  uart_set_format(uart, 7, 2,UART_PARITY_EVEN);
274  break;
275  case SERIAL_8E2:
276  uart_set_format(uart, 8, 2,UART_PARITY_EVEN);
277  break;
278  case SERIAL_5O1:
279  uart_set_format(uart, 5, 1,UART_PARITY_ODD);
280  break;
281  case SERIAL_6O1:
282  uart_set_format(uart, 6, 1,UART_PARITY_ODD);
283  break;
284  case SERIAL_7O1:
285  uart_set_format(uart, 7, 1,UART_PARITY_ODD);
286  break;
287  case SERIAL_8O1:
288  uart_set_format(uart, 8, 1,UART_PARITY_ODD);
289  break;
290  case SERIAL_5O2:
291  uart_set_format(uart, 5, 2,UART_PARITY_ODD);
292  break;
293  case SERIAL_6O2:
294  uart_set_format(uart, 6, 2,UART_PARITY_ODD);
295  break;
296  case SERIAL_7O2:
297  uart_set_format(uart, 7, 2,UART_PARITY_ODD);
298  break;
299  case SERIAL_8O2:
300  uart_set_format(uart, 8, 2,UART_PARITY_ODD);
301  break;
302  };
303  }
304 
305  void setupDefaultRxTxPins(){
306  // we use different pins for uart0 and uar1. We assign values only if it has not been defined in setup
307  if (uart_no==0){
308  if (rx_pin==-1) {
309  rx_pin = 1;
310  }
311  if (tx_pin==-1){
312  tx_pin = 0;
313  }
314  } else {
315  if (rx_pin==-1){
316  rx_pin = 5;
317  }
318  if (tx_pin==-1){
319  tx_pin = 4;
320  }
321  }
322  // display pin assignments
323  if (Logger.isLogging()) {
324  Logger.info("Using UART: ", toStr(uart_no));
325  Logger.info("rxPin is ", toStr(rx_pin));
326  Logger.info("txPin is ", toStr(tx_pin));
327  }
328  if (tx_pin!=-1)
329  gpio_set_function(tx_pin, GPIO_FUNC_UART);
330  if (rx_pin!=-1)
331  gpio_set_function(rx_pin, GPIO_FUNC_UART);
332 
333  }
334 
335  const char* toStr(int value){
336  static char buffer[10];
337  itoa(value,buffer,10);
338  return (const char*)buffer;
339  }
340 };
341 
342 // #if !defined(TINYUSB_HOST_LINKED) && !defined(TINYUSB_DEVICE_LINKED)
343 // /**
344 // * @brief Output class which uses USB
345 // *
346 // */
347 // class PicoUSBSerial : public PicoDefaultSerial {
348 // PicoUSBSerial(){
349 // stdio_usb_init();
350 // }
351 
352 // // this does not do anything
353 // irtual void begin() {
354 // }
355 // };
356 // #endif
PicoDefaultSerial is using the pico default output. It is mapped to the Arduino Serial variable.
Definition: PicoHardwareSerial.h:17
Serial Stream for a defined UART. By default we use the following pins: UART0 tx/rx = gp0/gp1; UART1 ...
Definition: PicoHardwareSerial.h:93
virtual void begin(unsigned long baudrate, uint32_t config, int rxPin=-1, int txPin=-1, bool invert=false, bool cts=false, bool rts=false)
Initialization to output to UART.
Definition: PicoHardwareSerial.h:123
Definition: HardwareSerial.h:88