// #################################################################################################
|
// #################################################################################################
|
// # << NEORV32: neorv32_uart.c - Universal Asynchronous Receiver/Transmitter (UART) HW Driver >> #
|
// # << NEORV32: neorv32_uart.c - Universal Asynchronous Receiver/Transmitter (UART) HW Driver >> #
|
// # ********************************************************************************************* #
|
// # ********************************************************************************************* #
|
// # BSD 3-Clause License #
|
// # BSD 3-Clause License #
|
// # #
|
// # #
|
// # Copyright (c) 2020, Stephan Nolting. All rights reserved. #
|
// # Copyright (c) 2020, Stephan Nolting. All rights reserved. #
|
// # #
|
// # #
|
// # Redistribution and use in source and binary forms, with or without modification, are #
|
// # Redistribution and use in source and binary forms, with or without modification, are #
|
// # permitted provided that the following conditions are met: #
|
// # permitted provided that the following conditions are met: #
|
// # #
|
// # #
|
// # 1. Redistributions of source code must retain the above copyright notice, this list of #
|
// # 1. Redistributions of source code must retain the above copyright notice, this list of #
|
// # conditions and the following disclaimer. #
|
// # conditions and the following disclaimer. #
|
// # #
|
// # #
|
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of #
|
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of #
|
// # conditions and the following disclaimer in the documentation and/or other materials #
|
// # conditions and the following disclaimer in the documentation and/or other materials #
|
// # provided with the distribution. #
|
// # provided with the distribution. #
|
// # #
|
// # #
|
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to #
|
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to #
|
// # endorse or promote products derived from this software without specific prior written #
|
// # endorse or promote products derived from this software without specific prior written #
|
// # permission. #
|
// # permission. #
|
// # #
|
// # #
|
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS #
|
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS #
|
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF #
|
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF #
|
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE #
|
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE #
|
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, #
|
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, #
|
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
|
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
|
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED #
|
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED #
|
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING #
|
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING #
|
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED #
|
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED #
|
// # OF THE POSSIBILITY OF SUCH DAMAGE. #
|
// # OF THE POSSIBILITY OF SUCH DAMAGE. #
|
// # ********************************************************************************************* #
|
// # ********************************************************************************************* #
|
// # The NEORV32 Processor - https://github.com/stnolting/neorv32 (c) Stephan Nolting #
|
// # The NEORV32 Processor - https://github.com/stnolting/neorv32 (c) Stephan Nolting #
|
// #################################################################################################
|
// #################################################################################################
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* @file neorv32_uart.c
|
* @file neorv32_uart.c
|
* @author Stephan Nolting
|
* @author Stephan Nolting
|
* @brief Universal asynchronous receiver/transmitter (UART) HW driver source file.
|
* @brief Universal asynchronous receiver/transmitter (UART) HW driver source file.
|
*
|
*
|
* @note These functions should only be used if the UART unit was synthesized (IO_UART_USE = true).
|
* @note These functions should only be used if the UART unit was synthesized (IO_UART_USE = true).
|
**************************************************************************/
|
**************************************************************************/
|
|
|
#include "neorv32.h"
|
#include "neorv32.h"
|
#include "neorv32_uart.h"
|
#include "neorv32_uart.h"
|
#include <string.h>
|
#include <string.h>
|
|
|
/// \cond
|
/// \cond
|
// Private functions
|
// Private functions
|
static void __neorv32_uart_itoa(uint32_t x, char *res) __attribute__((unused)); // GCC: do not ouput a warning when this variable is unused
|
static void __neorv32_uart_itoa(uint32_t x, char *res) __attribute__((unused)); // GCC: do not ouput a warning when this variable is unused
|
static void __neorv32_uart_tohex(uint32_t x, char *res) __attribute__((unused)); // GCC: do not ouput a warning when this variable is unused
|
static void __neorv32_uart_tohex(uint32_t x, char *res) __attribute__((unused)); // GCC: do not ouput a warning when this variable is unused
|
/// \endcond
|
/// \endcond
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Check if UART unit was synthesized.
|
* Check if UART unit was synthesized.
|
*
|
*
|
* @return 0 if UART was not synthesized, 1 if UART is available.
|
* @return 0 if UART was not synthesized, 1 if UART is available.
|
**************************************************************************/
|
**************************************************************************/
|
int neorv32_uart_available(void) {
|
int neorv32_uart_available(void) {
|
|
|
if (neorv32_cpu_csr_read(CSR_MFEATURES) & (1 << CPU_MFEATURES_IO_UART)) {
|
if (SYSINFO_FEATURES & (1 << SYSINFO_FEATURES_IO_UART)) {
|
return 1;
|
return 1;
|
}
|
}
|
else {
|
else {
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Enable and configure UART.
|
* Enable and configure UART.
|
*
|
*
|
* @param[in] baudrate Targeted BAUD rate (e.g. 9600).
|
* @param[in] baudrate Targeted BAUD rate (e.g. 9600).
|
* @param[in] rx_irq Enable RX interrupt (data received) when 1.
|
* @param[in] rx_irq Enable RX interrupt (data received) when 1.
|
* @param[in] tx_irq Enable TX interrupt (transmission done) when 1.
|
* @param[in] tx_irq Enable TX interrupt (transmission done) when 1.
|
**************************************************************************/
|
**************************************************************************/
|
void neorv32_uart_setup(uint32_t baudrate, uint8_t rx_irq, uint8_t tx_irq) {
|
void neorv32_uart_setup(uint32_t baudrate, uint8_t rx_irq, uint8_t tx_irq) {
|
|
|
UART_CT = 0; // reset
|
UART_CT = 0; // reset
|
|
|
// raw baud rate prescaler
|
// raw baud rate prescaler
|
uint32_t clock = neorv32_cpu_csr_read(CSR_MCLOCK);
|
uint32_t clock = SYSINFO_CLK;
|
uint16_t i = 0; // BAUD rate divisor
|
uint16_t i = 0; // BAUD rate divisor
|
uint8_t p = 0; // prsc = CLK/2
|
uint8_t p = 0; // prsc = CLK/2
|
while (clock >= 2*baudrate) {
|
while (clock >= 2*baudrate) {
|
clock -= 2*baudrate;
|
clock -= 2*baudrate;
|
i++;
|
i++;
|
}
|
}
|
|
|
// find clock prsc
|
// find clock prsc
|
while (i >= 0x0fff) {
|
while (i >= 0x0fff) {
|
if ((p == 2) || (p == 4))
|
if ((p == 2) || (p == 4))
|
i >>= 3;
|
i >>= 3;
|
else
|
else
|
i >>= 1;
|
i >>= 1;
|
p++;
|
p++;
|
}
|
}
|
|
|
uint32_t prsc = (uint32_t)p;
|
uint32_t prsc = (uint32_t)p;
|
prsc = prsc << UART_CT_PRSC0;
|
prsc = prsc << UART_CT_PRSC0;
|
|
|
uint32_t baud = (uint32_t)i;
|
uint32_t baud = (uint32_t)i;
|
baud = baud << UART_CT_BAUD00;
|
baud = baud << UART_CT_BAUD00;
|
|
|
uint32_t uart_en = 1;
|
uint32_t uart_en = 1;
|
uart_en = uart_en << UART_CT_EN;
|
uart_en = uart_en << UART_CT_EN;
|
|
|
uint32_t rx_irq_en = (uint32_t)(rx_irq & 1);
|
uint32_t rx_irq_en = (uint32_t)(rx_irq & 1);
|
rx_irq_en = rx_irq_en << UART_CT_RX_IRQ;
|
rx_irq_en = rx_irq_en << UART_CT_RX_IRQ;
|
|
|
uint32_t tx_irq_en = (uint32_t)(tx_irq & 1);
|
uint32_t tx_irq_en = (uint32_t)(tx_irq & 1);
|
tx_irq_en = tx_irq_en << UART_CT_TX_IRQ;
|
tx_irq_en = tx_irq_en << UART_CT_TX_IRQ;
|
|
|
UART_CT = prsc | baud | uart_en | rx_irq_en | tx_irq_en;
|
UART_CT = prsc | baud | uart_en | rx_irq_en | tx_irq_en;
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Disable UART.
|
* Disable UART.
|
**************************************************************************/
|
**************************************************************************/
|
void neorv32_uart_disable(void) {
|
void neorv32_uart_disable(void) {
|
|
|
UART_CT &= ~((uint32_t)(1 << UART_CT_EN));
|
UART_CT &= ~((uint32_t)(1 << UART_CT_EN));
|
}
|
}
|
|
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Send single char via UART.
|
* Send single char via UART.
|
*
|
*
|
* @note This function is blocking.
|
* @note This function is blocking.
|
* @warning The 'DEVNULL_UART_OVERRIDE' compiler user flag will forward all UART TX data to the DEVNULL simulation console output.
|
* @warning The 'DEVNULL_UART_OVERRIDE' compiler user flag will forward all UART TX data to the DEVNULL simulation console output.
|
*
|
*
|
* @param[in] c Char to be send.
|
* @param[in] c Char to be send.
|
**************************************************************************/
|
**************************************************************************/
|
void neorv32_uart_putc(char c) {
|
void neorv32_uart_putc(char c) {
|
|
|
#ifdef DEVNULL_UART_OVERRIDE
|
#ifdef DEVNULL_UART_OVERRIDE
|
#warning UART OVERRIDE! Sending all UART.TX data to DEVNULL simulation output instead of UART transmitter. Use this for simulations only!
|
#warning UART OVERRIDE! Sending all UART.TX data to DEVNULL simulation output instead of UART transmitter. Use this for simulations only!
|
DEVNULL_DATA = (uint32_t)c;
|
DEVNULL_DATA = (uint32_t)c;
|
#else
|
#else
|
// wait for previous transfer to finish
|
// wait for previous transfer to finish
|
while ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0);
|
while ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0);
|
UART_DATA = ((uint32_t)c) << UART_DATA_LSB;
|
UART_DATA = ((uint32_t)c) << UART_DATA_LSB;
|
#endif
|
#endif
|
|
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Get char from UART.
|
* Get char from UART.
|
*
|
*
|
* @note This function is blocking.
|
* @note This function is blocking.
|
*
|
*
|
* @return Received char.
|
* @return Received char.
|
**************************************************************************/
|
**************************************************************************/
|
char neorv32_uart_getc(void) {
|
char neorv32_uart_getc(void) {
|
|
|
uint32_t d = 0;
|
uint32_t d = 0;
|
while (1) {
|
while (1) {
|
d = UART_DATA;
|
d = UART_DATA;
|
if ((d & (1<<UART_DATA_AVAIL)) != 0) { // char received?
|
if ((d & (1<<UART_DATA_AVAIL)) != 0) { // char received?
|
return (char)d;
|
return (char)d;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Check if UARt has received a char.
|
* Check if UARt has received a char.
|
*
|
*
|
* @note This function is non-blocking.
|
* @note This function is non-blocking.
|
* @note Use neorv32_uart_char_received_get(void) to get the char.
|
* @note Use neorv32_uart_char_received_get(void) to get the char.
|
*
|
*
|
* @return =!0 when a char has been received.
|
* @return =!0 when a char has been received.
|
**************************************************************************/
|
**************************************************************************/
|
int neorv32_uart_char_received(void) {
|
int neorv32_uart_char_received(void) {
|
|
|
if ((UART_DATA & (1<<UART_DATA_AVAIL)) != 0) {
|
if ((UART_DATA & (1<<UART_DATA_AVAIL)) != 0) {
|
return 1;
|
return 1;
|
}
|
}
|
else {
|
else {
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Get a received char.
|
* Get a received char.
|
*
|
*
|
* @note This function is non-blocking.
|
* @note This function is non-blocking.
|
* @note Should only be used in combination with neorv32_uart_char_received(void).
|
* @note Should only be used in combination with neorv32_uart_char_received(void).
|
*
|
*
|
* @return Received char.
|
* @return Received char.
|
**************************************************************************/
|
**************************************************************************/
|
char neorv32_uart_char_received_get(void) {
|
char neorv32_uart_char_received_get(void) {
|
|
|
return (char)UART_DATA;
|
return (char)UART_DATA;
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Print string (zero-terminated) via UART. Print full line break "\r\n" for every '\n'.
|
* Print string (zero-terminated) via UART. Print full line break "\r\n" for every '\n'.
|
*
|
*
|
* @note This function is blocking.
|
* @note This function is blocking.
|
*
|
*
|
* @param[in] s Pointer to string.
|
* @param[in] s Pointer to string.
|
**************************************************************************/
|
**************************************************************************/
|
void neorv32_uart_print(char *s) {
|
void neorv32_uart_print(char *s) {
|
|
|
char c = 0;
|
char c = 0;
|
while ((c = *s++)) {
|
while ((c = *s++)) {
|
if (c == '\n') {
|
if (c == '\n') {
|
neorv32_uart_putc('\r');
|
neorv32_uart_putc('\r');
|
}
|
}
|
neorv32_uart_putc(c);
|
neorv32_uart_putc(c);
|
}
|
}
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Private function for 'neorv32_printf' to convert into decimal.
|
* Private function for 'neorv32_printf' to convert into decimal.
|
*
|
*
|
* @param[in] x Unsigned input number.
|
* @param[in] x Unsigned input number.
|
* @param[in,out] res Pointer for storing the reuslting number string (11 chars).
|
* @param[in,out] res Pointer for storing the reuslting number string (11 chars).
|
**************************************************************************/
|
**************************************************************************/
|
static void __neorv32_uart_itoa(uint32_t x, char *res) {
|
static void __neorv32_uart_itoa(uint32_t x, char *res) {
|
|
|
static const char numbers[10] = "0123456789";
|
static const char numbers[10] = "0123456789";
|
char buffer1[11];
|
char buffer1[11];
|
uint16_t i, j;
|
uint16_t i, j;
|
|
|
buffer1[10] = '\0';
|
buffer1[10] = '\0';
|
res[10] = '\0';
|
res[10] = '\0';
|
|
|
// convert
|
// convert
|
for (i=0; i<10; i++) {
|
for (i=0; i<10; i++) {
|
buffer1[i] = numbers[x%10];
|
buffer1[i] = numbers[x%10];
|
x /= 10;
|
x /= 10;
|
}
|
}
|
|
|
// delete 'leading' zeros
|
// delete 'leading' zeros
|
for (i=9; i!=0; i--) {
|
for (i=9; i!=0; i--) {
|
if (buffer1[i] == '0')
|
if (buffer1[i] == '0')
|
buffer1[i] = '\0';
|
buffer1[i] = '\0';
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
// reverse
|
// reverse
|
j = 0;
|
j = 0;
|
do {
|
do {
|
if (buffer1[i] != '\0')
|
if (buffer1[i] != '\0')
|
res[j++] = buffer1[i];
|
res[j++] = buffer1[i];
|
} while (i--);
|
} while (i--);
|
|
|
res[j] = '\0'; // terminate result string
|
res[j] = '\0'; // terminate result string
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Private function for 'neorv32_printf' to convert into hexadecimal.
|
* Private function for 'neorv32_printf' to convert into hexadecimal.
|
*
|
*
|
* @param[in] x Unsigned input number.
|
* @param[in] x Unsigned input number.
|
* @param[in,out] res Pointer for storing the reuslting number string (9 chars).
|
* @param[in,out] res Pointer for storing the reuslting number string (9 chars).
|
**************************************************************************/
|
**************************************************************************/
|
static void __neorv32_uart_tohex(uint32_t x, char *res) {
|
static void __neorv32_uart_tohex(uint32_t x, char *res) {
|
|
|
static const char symbols[16] = "0123456789abcdef";
|
static const char symbols[16] = "0123456789abcdef";
|
|
|
int i;
|
int i;
|
for (i=0; i<8; i++) { // nibble by bibble
|
for (i=0; i<8; i++) { // nibble by bibble
|
uint32_t num_tmp = x >> (4*i);
|
uint32_t num_tmp = x >> (4*i);
|
res[7-i] = (char)symbols[num_tmp & 0x0f];
|
res[7-i] = (char)symbols[num_tmp & 0x0f];
|
}
|
}
|
|
|
res[8] = '\0'; // terminate result string
|
res[8] = '\0'; // terminate result string
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Custom version of 'printf' function.
|
* Custom version of 'printf' function.
|
*
|
*
|
* @note This function is blocking.
|
* @note This function is blocking.
|
*
|
*
|
* @param[in] format Pointer to format string.
|
* @param[in] format Pointer to format string.
|
*
|
*
|
* <TABLE>
|
* <TABLE>
|
* <TR><TD>%s</TD><TD>String (array of chars, zero-terminated)</TD></TR>
|
* <TR><TD>%s</TD><TD>String (array of chars, zero-terminated)</TD></TR>
|
* <TR><TD>%c</TD><TD>Single char</TD></TR>
|
* <TR><TD>%c</TD><TD>Single char</TD></TR>
|
* <TR><TD>%i</TD><TD>32-bit signed number, printed as decimal</TD></TR>
|
* <TR><TD>%i</TD><TD>32-bit signed number, printed as decimal</TD></TR>
|
* <TR><TD>%u</TD><TD>32-bit unsigned number, printed as decimal</TD></TR>
|
* <TR><TD>%u</TD><TD>32-bit unsigned number, printed as decimal</TD></TR>
|
* <TR><TD>%x</TD><TD>32-bit number, printed as 8-char hexadecimal</TD></TR>
|
* <TR><TD>%x</TD><TD>32-bit number, printed as 8-char hexadecimal</TD></TR>
|
* </TABLE>
|
* </TABLE>
|
**************************************************************************/
|
**************************************************************************/
|
void neorv32_uart_printf(char *format, ...) {
|
void neorv32_uart_printf(char *format, ...) {
|
|
|
char c, string_buf[11];
|
char c, string_buf[11];
|
int32_t n;
|
int32_t n;
|
|
|
va_list a;
|
va_list a;
|
va_start(a, format);
|
va_start(a, format);
|
|
|
while ((c = *format++)) {
|
while ((c = *format++)) {
|
if (c == '%') {
|
if (c == '%') {
|
c = *format++;
|
c = *format++;
|
switch (c) {
|
switch (c) {
|
case 's': // string
|
case 's': // string
|
neorv32_uart_print(va_arg(a, char*));
|
neorv32_uart_print(va_arg(a, char*));
|
break;
|
break;
|
case 'c': // char
|
case 'c': // char
|
neorv32_uart_putc((char)va_arg(a, int));
|
neorv32_uart_putc((char)va_arg(a, int));
|
break;
|
break;
|
case 'i': // 32-bit signed
|
case 'i': // 32-bit signed
|
n = (int32_t)va_arg(a, int32_t);
|
n = (int32_t)va_arg(a, int32_t);
|
if (n < 0) {
|
if (n < 0) {
|
n = -n;
|
n = -n;
|
neorv32_uart_putc('-');
|
neorv32_uart_putc('-');
|
}
|
}
|
__neorv32_uart_itoa((uint32_t)n, string_buf);
|
__neorv32_uart_itoa((uint32_t)n, string_buf);
|
neorv32_uart_print(string_buf);
|
neorv32_uart_print(string_buf);
|
break;
|
break;
|
case 'u': // 32-bit unsigned
|
case 'u': // 32-bit unsigned
|
__neorv32_uart_itoa(va_arg(a, uint32_t), string_buf);
|
__neorv32_uart_itoa(va_arg(a, uint32_t), string_buf);
|
neorv32_uart_print(string_buf);
|
neorv32_uart_print(string_buf);
|
break;
|
break;
|
case 'x': // 32-bit hexadecimal
|
case 'x': // 32-bit hexadecimal
|
__neorv32_uart_tohex(va_arg(a, uint32_t), string_buf);
|
__neorv32_uart_tohex(va_arg(a, uint32_t), string_buf);
|
neorv32_uart_print(string_buf);
|
neorv32_uart_print(string_buf);
|
break;
|
break;
|
default:
|
default:
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else {
|
else {
|
if (c == '\n') {
|
if (c == '\n') {
|
neorv32_uart_putc('\r');
|
neorv32_uart_putc('\r');
|
}
|
}
|
neorv32_uart_putc(c);
|
neorv32_uart_putc(c);
|
}
|
}
|
}
|
}
|
va_end(a);
|
va_end(a);
|
}
|
}
|
|
|
|
|
/**********************************************************************//**
|
/**********************************************************************//**
|
* Simplified custom version of 'scanf' function.
|
* Simplified custom version of 'scanf' function.
|
*
|
*
|
* @note This function is blocking.
|
* @note This function is blocking.
|
*
|
*
|
* @param[in,out] buffer Pointer to array of chars to store string.
|
* @param[in,out] buffer Pointer to array of chars to store string.
|
* @param[in] max_size Maximum number of chars to sample.
|
* @param[in] max_size Maximum number of chars to sample.
|
* @param[in] echo Echo UART input when 1.
|
* @param[in] echo Echo UART input when 1.
|
* @return Number of chars read.
|
* @return Number of chars read.
|
**************************************************************************/
|
**************************************************************************/
|
int neorv32_uart_scan(char *buffer, int max_size, int echo) {
|
int neorv32_uart_scan(char *buffer, int max_size, int echo) {
|
|
|
char c = 0;
|
char c = 0;
|
int length = 0;
|
int length = 0;
|
|
|
while (1) {
|
while (1) {
|
c = neorv32_uart_getc();
|
c = neorv32_uart_getc();
|
if (c == '\b') { // BACKSPACE
|
if (c == '\b') { // BACKSPACE
|
if (length != 0) {
|
if (length != 0) {
|
if (echo) {
|
if (echo) {
|
neorv32_uart_print("\b \b"); // delete last char in console
|
neorv32_uart_print("\b \b"); // delete last char in console
|
}
|
}
|
buffer--;
|
buffer--;
|
length--;
|
length--;
|
}
|
}
|
}
|
}
|
else if (c == '\r') // carriage return
|
else if (c == '\r') // carriage return
|
break;
|
break;
|
else if ((c >= ' ') && (c <= '~') && (length < (max_size-1))) {
|
else if ((c >= ' ') && (c <= '~') && (length < (max_size-1))) {
|
if (echo) {
|
if (echo) {
|
neorv32_uart_putc(c); // echo
|
neorv32_uart_putc(c); // echo
|
}
|
}
|
*buffer++ = c;
|
*buffer++ = c;
|
length++;
|
length++;
|
}
|
}
|
}
|
}
|
*buffer = '\0'; // terminate string
|
*buffer = '\0'; // terminate string
|
|
|
return length;
|
return length;
|
}
|
}
|
|
|
|
|