NavHAL/uart_8h_source.html

#ifndef CORTEX_M4_UART_H

#define CORTEX_M4_UART_H

#include "core/cortex-m4/uart_reg.h"

#include <stdint.h>


typedef enum {

  UART1 = 1,

  UART2 = 2,

  UART6 = 6

} hal_uart_t;


#define uart2_write(val)                                                       \

  _Generic((val),                                                              \

      char: uart2_write_char,                                                  \

      signed char: uart2_write_int,                                            \

      unsigned char: uart2_write_int,                                          \

      short: uart2_write_int,                                                  \

      unsigned short: uart2_write_int,                                         \

      int: uart2_write_int,                                                    \

      unsigned int: uart2_write_int,                                           \

      long: uart2_write_int,                                                   \

      unsigned long: uart2_write_int,                                          \

      long long: uart2_write_int,                                              \

      unsigned long long: uart2_write_int,                                     \

      float: uart2_write_float,                                                \

      double: uart2_write_float,                                               \

      const char *: uart2_write_string,                                        \

      char *: uart2_write_string)(val)


#define uart1_write(val)                                                       \

  _Generic((val),                                                              \

      char: uart1_write_char,                                                  \

      signed char: uart1_write_int,                                            \

      unsigned char: uart1_write_int,                                          \

      short: uart1_write_int,                                                  \

      unsigned short: uart1_write_int,                                         \

      int: uart1_write_int,                                                    \

      unsigned int: uart1_write_int,                                           \

      long: uart1_write_int,                                                   \

      unsigned long: uart1_write_int,                                          \

      long long: uart1_write_int,                                              \

      unsigned long long: uart1_write_int,                                     \

      float: uart1_write_float,                                                \

      double: uart1_write_float,                                               \

      const char *: uart1_write_string,                                        \

      char *: uart1_write_string)(val)


#define uart6_write(val)                                                       \

  _Generic((val),                                                              \

      char: uart6_write_char,                                                  \

      signed char: uart6_write_int,                                            \

      unsigned char: uart6_write_int,                                          \

      short: uart6_write_int,                                                  \

      unsigned short: uart6_write_int,                                         \

      int: uart6_write_int,                                                    \

      unsigned int: uart6_write_int,                                           \

      long: uart6_write_int,                                                   \

      unsigned long: uart6_write_int,                                          \

      long long: uart6_write_int,                                              \

      unsigned long long: uart6_write_int,                                     \

      float: uart6_write_float,                                                \

      double: uart6_write_float,                                               \

      const char *: uart6_write_string,                                        \

      char *: uart6_write_string)(val)


 // end of UART_WRITE_MACROS


void uart_init(uint32_t baudrate, hal_uart_t uart);


void uart_write_char(char c, hal_uart_t uart);


void uart_write_int(int32_t num, hal_uart_t uart);


void uart_write_float(float num, hal_uart_t uart);


void uart_write_string(const char *s, hal_uart_t uart);


/* USART1 specific functions */


void uart1_init(uint32_t baudrate);


void uart1_write_char(char c);


void uart1_write_int(int32_t num);


void uart1_write_float(float num);


void uart1_write_string(const char *s);


/* USART2 specific functions */


void uart2_init(uint32_t baudrate);

void uart2_write_char(char c);

void uart2_write_int(int32_t num);

void uart2_write_float(float num);

void uart2_write_string(const char *s);


/* USART6 specific functions */


void uart6_init(uint32_t baudrate);

void uart6_write_char(char c);

void uart6_write_int(int32_t num);

void uart6_write_float(float num);

void uart6_write_string(const char *s);


char uart_read_char(hal_uart_t uart);


int uart_available(hal_uart_t uart);


/* USART1 specific receive functions */

int uart1_available(void);

char uart1_read_char(void);


/* USART2 specific receive functions */

int uart2_available(void);

char uart2_read_char(void);


/* USART6 specific receive functions */

int uart6_available(void);

char uart6_read_char(void);


uint32_t uart2_read_until(char *buffer, uint32_t maxlen, char delimiter);

 // end of UART_API


#endif // !CORTEX_M4_UART_H

uart6_write_int
void uart6_write_int(int32_t num)

uart_write_int
void uart_write_int(int32_t num, hal_uart_t uart)
Transmit a 32-bit signed integer via UART.
Definition uart.c:80

uart1_read_char
char uart1_read_char(void)
Read a single character from USART1.
Definition uart.c:449

uart1_available
int uart1_available(void)
Check if data is available to read from USART1.
Definition uart.c:509

uart2_write_float
void uart2_write_float(float num)

uart6_write_float
void uart6_write_float(float num)

uart1_init
void uart1_init(uint32_t baudrate)
Initialize USART1 peripheral.
Definition uart.c:129

uart2_write_string
void uart2_write_string(const char *s)
Definition main.c:97

uart2_read_until
uint32_t uart2_read_until(char *buffer, uint32_t maxlen, char delimiter)
Read characters into a buffer until a delimiter is found or max length is reached.
Definition uart.c:552

uart_write_float
void uart_write_float(float num, hal_uart_t uart)
Transmit a floating-point number via UART.
Definition uart.c:95

uart_write_char
void uart_write_char(char c, hal_uart_t uart)
Transmit a single character via the specified UART.
Definition uart.c:57

uart6_init
void uart6_init(uint32_t baudrate)
Initialize USART6 peripheral.
Definition uart.c:154

uart1_write_int
void uart1_write_int(int32_t num)
Transmit a 32-bit signed integer via USART1.

uart1_write_float
void uart1_write_float(float num)
Transmit a floating-point number via USART1.

uart_read_char
char uart_read_char(hal_uart_t uart)
Read a single character from the specified UART.
Definition uart.c:432

uart2_read_char
char uart2_read_char(void)
Read a single character from USART2.
Definition uart.c:463

uart_available
int uart_available(hal_uart_t uart)
Check if data is available to read.
Definition uart.c:492

uart6_read_char
char uart6_read_char(void)
Read a single character from USART6.
Definition uart.c:477

uart1_write_char
void uart1_write_char(char c)
Transmit a single character via USART1.
Definition uart.c:218

uart_write_string
void uart_write_string(const char *s, hal_uart_t uart)
Transmit a null-terminated string via UART.
Definition uart.c:109

uart6_write_char
void uart6_write_char(char c)

uart1_write_string
void uart1_write_string(const char *s)
Transmit a null-terminated string via USART1.

uart2_write_int
void uart2_write_int(int32_t num)

uart6_write_string
void uart6_write_string(const char *s)

uart2_write_char
void uart2_write_char(char c)
Transmit a single character via USART2.
Definition main.c:61

uart_init
void uart_init(uint32_t baudrate, hal_uart_t uart)
Initialize the specified UART peripheral.
Definition uart.c:42

uart2_available
int uart2_available(void)
Check if data is available to read from USART2.
Definition uart.c:521

uart6_available
int uart6_available(void)
Check if data is available to read from USART6.
Definition uart.c:533

uart2_init
void uart2_init(void)
Definition main.c:41

hal_uart_t
hal_uart_t
UART identifier enumeration.
Definition uart.h:34

UART2
@ UART2
USART2 - APB1 peripheral.
Definition uart.h:36

UART6
@ UART6
USART6 - APB2 peripheral.
Definition uart.h:37

UART1
@ UART1
USART1 - APB2 peripheral, typically higher speed.
Definition uart.h:35

uart_reg.h