OpenCores
URL https://opencores.org/ocsvn/neorv32/neorv32/trunk

Subversion Repositories neorv32

[/] [neorv32/] [trunk/] [sw/] [lib/] [source/] [neorv32_uart.c] - Blame information for rev 23

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 zero_gravi
// #################################################################################################
2
// # << NEORV32: neorv32_uart.c - Universal Asynchronous Receiver/Transmitter (UART) HW Driver >>  #
3
// # ********************************************************************************************* #
4
// # BSD 3-Clause License                                                                          #
5
// #                                                                                               #
6
// # Copyright (c) 2020, Stephan Nolting. All rights reserved.                                     #
7
// #                                                                                               #
8
// # Redistribution and use in source and binary forms, with or without modification, are          #
9
// # permitted provided that the following conditions are met:                                     #
10
// #                                                                                               #
11
// # 1. Redistributions of source code must retain the above copyright notice, this list of        #
12
// #    conditions and the following disclaimer.                                                   #
13
// #                                                                                               #
14
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #
15
// #    conditions and the following disclaimer in the documentation and/or other materials        #
16
// #    provided with the distribution.                                                            #
17
// #                                                                                               #
18
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #
19
// #    endorse or promote products derived from this software without specific prior written      #
20
// #    permission.                                                                                #
21
// #                                                                                               #
22
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #
23
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #
24
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #
25
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
26
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
27
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #
28
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #
29
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #
30
// # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #
31
// # ********************************************************************************************* #
32
// # The NEORV32 Processor - https://github.com/stnolting/neorv32              (c) Stephan Nolting #
33
// #################################################################################################
34
 
35
 
36
/**********************************************************************//**
37
 * @file neorv32_uart.c
38
 * @author Stephan Nolting
39
 * @brief Universal asynchronous receiver/transmitter (UART) HW driver source file.
40
 *
41
 * @note These functions should only be used if the UART unit was synthesized (IO_UART_USE = true).
42
 **************************************************************************/
43
 
44
#include "neorv32.h"
45
#include "neorv32_uart.h"
46
#include <string.h>
47
 
48
/// \cond
49
// Private functions
50
static void __neorv32_uart_itoa(uint32_t x, char *res) __attribute__((unused)); // GCC: do not ouput a warning when this variable is unused
51
static void __neorv32_uart_tohex(uint32_t x, char *res) __attribute__((unused)); // GCC: do not ouput a warning when this variable is unused
52
/// \endcond
53
 
54
 
55
/**********************************************************************//**
56
 * Check if UART unit was synthesized.
57
 *
58
 * @return 0 if UART was not synthesized, 1 if UART is available.
59
 **************************************************************************/
60
int neorv32_uart_available(void) {
61
 
62 12 zero_gravi
  if (SYSINFO_FEATURES & (1 << SYSINFO_FEATURES_IO_UART)) {
63 2 zero_gravi
    return 1;
64
  }
65
  else {
66
    return 0;
67
  }
68
}
69
 
70
 
71
/**********************************************************************//**
72
 * Enable and configure UART.
73
 *
74
 * @param[in] baudrate Targeted BAUD rate (e.g. 9600).
75
 * @param[in] rx_irq Enable RX interrupt (data received) when 1.
76
 * @param[in] tx_irq Enable TX interrupt (transmission done) when 1.
77
 **************************************************************************/
78
void neorv32_uart_setup(uint32_t baudrate, uint8_t rx_irq, uint8_t tx_irq) {
79
 
80
  UART_CT = 0; // reset
81
 
82
  // raw baud rate prescaler
83 12 zero_gravi
  uint32_t clock = SYSINFO_CLK;
84 2 zero_gravi
  uint16_t i = 0; // BAUD rate divisor
85
  uint8_t p = 0; // prsc = CLK/2
86
  while (clock >= 2*baudrate) {
87
    clock -= 2*baudrate;
88
    i++;
89
  }
90
 
91
  // find clock prsc
92
  while (i >= 0x0fff) {
93
    if ((p == 2) || (p == 4))
94
      i >>= 3;
95
    else
96
      i >>= 1;
97
    p++;
98
  }
99
 
100
  uint32_t prsc = (uint32_t)p;
101
  prsc = prsc << UART_CT_PRSC0;
102
 
103
  uint32_t baud = (uint32_t)i;
104
  baud = baud << UART_CT_BAUD00;
105
 
106
  uint32_t uart_en = 1;
107
  uart_en = uart_en << UART_CT_EN;
108
 
109
  uint32_t rx_irq_en = (uint32_t)(rx_irq & 1);
110
  rx_irq_en = rx_irq_en << UART_CT_RX_IRQ;
111
 
112
  uint32_t tx_irq_en = (uint32_t)(tx_irq & 1);
113
  tx_irq_en = tx_irq_en << UART_CT_TX_IRQ;
114
 
115
  UART_CT = prsc | baud | uart_en | rx_irq_en | tx_irq_en;
116
}
117
 
118
 
119
/**********************************************************************//**
120
 * Disable UART.
121
 **************************************************************************/
122
void neorv32_uart_disable(void) {
123
 
124
  UART_CT &= ~((uint32_t)(1 << UART_CT_EN));
125
}
126
 
127
 
128
/**********************************************************************//**
129
 * Send single char via UART.
130
 *
131
 * @note This function is blocking.
132 4 zero_gravi
 * @warning The 'DEVNULL_UART_OVERRIDE' compiler user flag will forward all UART TX data to the DEVNULL simulation console output.
133 2 zero_gravi
 *
134
 * @param[in] c Char to be send.
135
 **************************************************************************/
136
void neorv32_uart_putc(char c) {
137
 
138 3 zero_gravi
#ifdef DEVNULL_UART_OVERRIDE
139
  #warning UART OVERRIDE! Sending all UART.TX data to DEVNULL simulation output instead of UART transmitter. Use this for simulations only!
140
  DEVNULL_DATA = (uint32_t)c;
141
#else
142 2 zero_gravi
  // wait for previous transfer to finish
143
  while ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0);
144
  UART_DATA = ((uint32_t)c) << UART_DATA_LSB;
145 3 zero_gravi
#endif
146
 
147 2 zero_gravi
}
148
 
149
 
150
/**********************************************************************//**
151 23 zero_gravi
 * Check if UART TX is busy.
152
 *
153
 * @note This function is blocking.
154
 *
155
 * @return 0 if idle, 1 if busy
156
 **************************************************************************/
157
int neorv32_uart_tx_busy(void) {
158
 
159
  if ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0) {
160
    return 1;
161
  }
162
  return 0;
163
}
164
 
165
 
166
/**********************************************************************//**
167 2 zero_gravi
 * Get char from UART.
168
 *
169
 * @note This function is blocking.
170
 *
171
 * @return Received char.
172
 **************************************************************************/
173
char neorv32_uart_getc(void) {
174
 
175
  uint32_t d = 0;
176
  while (1) {
177
    d = UART_DATA;
178
    if ((d & (1<<UART_DATA_AVAIL)) != 0) { // char received?
179
      return (char)d;
180
    }
181
  }
182
}
183
 
184
 
185
/**********************************************************************//**
186
 * Check if UARt has received a char.
187
 *
188
 * @note This function is non-blocking.
189
 * @note Use neorv32_uart_char_received_get(void) to get the char.
190
 *
191
 * @return =!0 when a char has been received.
192
 **************************************************************************/
193
int neorv32_uart_char_received(void) {
194
 
195
  if ((UART_DATA & (1<<UART_DATA_AVAIL)) != 0) {
196
    return 1;
197
  }
198
  else {
199
    return 0;
200
  }
201
}
202
 
203
 
204
/**********************************************************************//**
205
 * Get a received char.
206
 *
207
 * @note This function is non-blocking.
208
 * @note Should only be used in combination with neorv32_uart_char_received(void).
209
 *
210
 * @return Received char.
211
 **************************************************************************/
212
char neorv32_uart_char_received_get(void) {
213
 
214
  return (char)UART_DATA;
215
}
216
 
217
 
218
/**********************************************************************//**
219
 * Print string (zero-terminated) via UART. Print full line break "\r\n" for every '\n'.
220
 *
221
 * @note This function is blocking.
222
 *
223
 * @param[in] s Pointer to string.
224
 **************************************************************************/
225 22 zero_gravi
void neorv32_uart_print(const char *s) {
226 2 zero_gravi
 
227
  char c = 0;
228
  while ((c = *s++)) {
229
    if (c == '\n') {
230
      neorv32_uart_putc('\r');
231
    }
232
    neorv32_uart_putc(c);
233
  }
234
}
235
 
236
 
237
/**********************************************************************//**
238
 * Private function for 'neorv32_printf' to convert into decimal.
239
 *
240
 * @param[in] x Unsigned input number.
241
 * @param[in,out] res Pointer for storing the reuslting number string (11 chars).
242
 **************************************************************************/
243
static void __neorv32_uart_itoa(uint32_t x, char *res) {
244
 
245 22 zero_gravi
  static const char numbers[] = "0123456789";
246 2 zero_gravi
  char buffer1[11];
247
  uint16_t i, j;
248
 
249
  buffer1[10] = '\0';
250
  res[10] = '\0';
251
 
252
  // convert
253
  for (i=0; i<10; i++) {
254
    buffer1[i] = numbers[x%10];
255
    x /= 10;
256
  }
257
 
258
  // delete 'leading' zeros
259
  for (i=9; i!=0; i--) {
260
    if (buffer1[i] == '0')
261
      buffer1[i] = '\0';
262
    else
263
      break;
264
  }
265
 
266
  // reverse
267
  j = 0;
268
  do {
269
    if (buffer1[i] != '\0')
270
      res[j++] = buffer1[i];
271
  } while (i--);
272
 
273
  res[j] = '\0'; // terminate result string
274
}
275
 
276
 
277
/**********************************************************************//**
278
 * Private function for 'neorv32_printf' to convert into hexadecimal.
279
 *
280
 * @param[in] x Unsigned input number.
281
 * @param[in,out] res Pointer for storing the reuslting number string (9 chars).
282
 **************************************************************************/
283
static void __neorv32_uart_tohex(uint32_t x, char *res) {
284
 
285 22 zero_gravi
  static const char symbols[] = "0123456789abcdef";
286 2 zero_gravi
 
287
  int i;
288
  for (i=0; i<8; i++) { // nibble by bibble
289
    uint32_t num_tmp = x >> (4*i);
290
    res[7-i] = (char)symbols[num_tmp & 0x0f];
291
  }
292
 
293
  res[8] = '\0'; // terminate result string
294
}
295
 
296
 
297
/**********************************************************************//**
298
 * Custom version of 'printf' function.
299
 *
300
 * @note This function is blocking.
301
 *
302
 * @param[in] format Pointer to format string.
303
 *
304
 * <TABLE>
305
 * <TR><TD>%s</TD><TD>String (array of chars, zero-terminated)</TD></TR>
306
 * <TR><TD>%c</TD><TD>Single char</TD></TR>
307
 * <TR><TD>%i</TD><TD>32-bit signed number, printed as decimal</TD></TR>
308
 * <TR><TD>%u</TD><TD>32-bit unsigned number, printed as decimal</TD></TR>
309
 * <TR><TD>%x</TD><TD>32-bit number, printed as 8-char hexadecimal</TD></TR>
310
 * </TABLE>
311
 **************************************************************************/
312 22 zero_gravi
void neorv32_uart_printf(const char *format, ...) {
313 2 zero_gravi
 
314
  char c, string_buf[11];
315
  int32_t n;
316
 
317
  va_list a;
318
  va_start(a, format);
319
 
320
  while ((c = *format++)) {
321
    if (c == '%') {
322
      c = *format++;
323
      switch (c) {
324
        case 's': // string
325
          neorv32_uart_print(va_arg(a, char*));
326
          break;
327
        case 'c': // char
328
          neorv32_uart_putc((char)va_arg(a, int));
329
          break;
330
        case 'i': // 32-bit signed
331
          n = (int32_t)va_arg(a, int32_t);
332
          if (n < 0) {
333
            n = -n;
334
            neorv32_uart_putc('-');
335
          }
336
          __neorv32_uart_itoa((uint32_t)n, string_buf);
337
          neorv32_uart_print(string_buf);
338
          break;
339
        case 'u': // 32-bit unsigned
340
          __neorv32_uart_itoa(va_arg(a, uint32_t), string_buf);
341
          neorv32_uart_print(string_buf);
342
          break;
343
        case 'x': // 32-bit hexadecimal
344
          __neorv32_uart_tohex(va_arg(a, uint32_t), string_buf);
345
          neorv32_uart_print(string_buf);
346
          break;
347
        default:
348
          return;
349
      }
350
    }
351
    else {
352
      if (c == '\n') {
353
        neorv32_uart_putc('\r');
354
      }
355
      neorv32_uart_putc(c);
356
    }
357
  }
358
  va_end(a);
359
}
360
 
361
 
362
/**********************************************************************//**
363
 * Simplified custom version of 'scanf' function.
364
 *
365
 * @note This function is blocking.
366
 *
367
 * @param[in,out] buffer Pointer to array of chars to store string.
368
 * @param[in] max_size Maximum number of chars to sample.
369
 * @param[in] echo Echo UART input when 1.
370
 * @return Number of chars read.
371
 **************************************************************************/
372
int neorv32_uart_scan(char *buffer, int max_size, int echo) {
373
 
374
  char c = 0;
375
  int length = 0;
376
 
377
  while (1) {
378
    c = neorv32_uart_getc();
379
    if (c == '\b') { // BACKSPACE
380
      if (length != 0) {
381
        if (echo) {
382
          neorv32_uart_print("\b \b"); // delete last char in console
383
        }
384
        buffer--;
385
        length--;
386
      }
387
    }
388
    else if (c == '\r') // carriage return
389
      break;
390
    else if ((c >= ' ') && (c <= '~') && (length < (max_size-1))) {
391
      if (echo) {
392
        neorv32_uart_putc(c); // echo
393
      }
394
      *buffer++ = c;
395
      length++;
396
    }
397
  }
398
  *buffer = '\0'; // terminate string
399
 
400
  return length;
401
}
402
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.