UART.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2021, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  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 provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * 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 MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * 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 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 OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*!*****************************************************************************
 *  @file       UART.h
 *  @brief      Universal Asynchronous Receiver-Transmitter (UART) Driver
 *
 *  @warning "The UART1 driver will be removed in the 2Q22 release.
 *  Please port your application to the UART2 driver."
 *
 *  To use the UART driver, ensure that the correct driver library for your
 *  device is linked in and include this header file as follows:
 *  @code
 *  #include <ti/drivers/UART.h>
 *  @endcode
 *
 *  This module serves as the main interface for applications.  Its purpose
 *  is to redirect the UART APIs to specific driver implementations
 *  which are specified using a pointer to a #UART_FxnTable.
 *
 *  @anchor ti_drivers_UART_Overview
 *  # Overview
 *  A UART is used to translate data between the chip and a serial port.
 *  The UART driver simplifies reading and writing to any of the UART
 *  peripherals on the board, with multiple modes of operation and performance.
 *  These include blocking, non-blocking, and polling, as well as text/binary
 *  mode, echo and return characters.
 *
 *  The UART driver interface provides device independent APIs, data types,
 *  and macros. The APIs in this driver serve as an interface to a typical RTOS
 *  application. The specific peripheral implementations are responsible for
 *  creating all the RTOS specific primitives to allow for thread-safe
 *  operation.
 *
 *  <hr>
 *  @anchor ti_drivers_UART_Usage
 *  # Usage
 *
 *  This documentation provides a basic @ref ti_drivers_UART_Synopsis
 *  "usage summary" and a set of @ref ti_drivers_UART_Examples "examples"
 *  in the form of commented code fragments.  Detailed descriptions of the
 *  APIs are provided in subsequent sections.
 *
 *  @anchor ti_drivers_UART_Synopsis
 *  ## Synopsis
 *  @anchor ti_drivers_UART_Synopsis_Code
 *  @code
 *  // Import the UART driver definitions
 *  #include <ti/drivers/UART.h>
 *
 *  // One-time initialization of UART driver
 *  UART_init();
 *
 *  // Initialize UART parameters
 *  UART_Params params;
 *  UART_Params_init(&params);
 *  params.baudRate = 9600;
 *  params.readMode = UART_MODE_BLOCKING;
 *  params.writeMode = UART_MODE_BLOCKING;
 *  params.readTimeout = UART_WAIT_FOREVER;
 *  params.writeTimeout = UART_WAIT_FOREVER;
 *
 *  // Open the UART
 *  UART_Handle uart;
 *  uart = UART_open(CONFIG_UART0, &params);
 *
 *  // Read from the UART
 *  int32_t readCount;
 *  uint8_t buffer[BUFSIZE];
 *  readCount = UART_read(uart, buffer, BUFSIZE);
 *
 *  // Write to the UART
 *  UART_write(uart, buffer, BUFSIZE);
 *
 *  // Close the UART
 *  UART_close(uart);
 *  @endcode
 *
 *  <hr>
 *  @anchor ti_drivers_UART_Examples
 *  # Examples
 *  The following code example opens a UART instance, reads
 *  a byte from the UART, and then writes the byte back to the UART.
 *
 *  @code
 *    char        input;
 *    UART_Handle uart;
 *    UART_Params uartParams;
 *
 *    // Initialize the UART driver.  UART_init() must be called before
 *    // calling any other UART APIs.
 *    UART_init();
 *
 *    // Create a UART with data processing off.
 *    UART_Params_init(&uartParams);
 *    uartParams.writeDataMode = UART_DATA_BINARY;
 *    uartParams.readDataMode = UART_DATA_BINARY;
 *    uartParams.readReturnMode = UART_RETURN_FULL;
 *    uartParams.baudRate = 115200;
 *
 *    // Open an instance of the UART drivers
 *    uart = UART_open(CONFIG_UART0, &uartParams);
 *
 *    if (uart == NULL) {
 *        // UART_open() failed
 *        while (1);
 *    }
 *
 *    // Loop forever echoing
 *    while (1) {
 *        UART_read(uart, &input, 1);
 *        UART_write(uart, &input, 1);
 *    }
 *  @endcode
 *
 *  Details for the example code above are described in the following
 *  subsections.
 *
 *  ### Opening the UART Driver #
 *
 *  Opening a UART requires four steps:
 *  1.  Create and initialize a UART_Params structure.
 *  2.  Fill in the desired parameters.
 *  3.  Call UART_open(), passing the index of the UART in the UART_config
 *      structure, and the address of the UART_Params structure.  The
 *      UART instance is specified by the index in the UART_config structure.
 *  4.  Check that the UART handle returned by UART_open() is non-NULL,
 *      and save it.  The handle will be used to read and write to the
 *      UART you just opened.
 *
 *  Only one UART index can be used at a time; calling UART_open() a second
 *  time with the same index previosly passed to UART_open() will result in
 *  an error.  You can, though, re-use the index if the instance is closed
 *  via UART_close().
 *  In the example code, CONFIG_UART0 is passed to UART_open().  This macro
 *  is defined in the example's ti_drivers_config.h file.
 *
 *
 *  ### Modes of Operation #
 *
 *  The UART driver can operate in blocking mode or callback mode, by
 *  setting the writeMode and readMode parameters passed to UART_open().
 *  If these parameters are not set, as in the example code, the UART
 *  driver defaults to blocking mode.  Options for the writeMode and
 *  readMode parameters are #UART_MODE_BLOCKING and #UART_MODE_CALLBACK:
 *
 *  - #UART_MODE_BLOCKING uses a semaphore to block while data is being sent.
 *    The context of calling UART_read() or UART_write() must be a Task when
 *    using #UART_MODE_BLOCKING.  The UART_write() or UART_read() call
 *    will block until all data is sent or received, or the write timeout or
 *    read timeout expires, whichever happens first.
 *
 *  - #UART_MODE_CALLBACK is non-blocking and UART_read() and UART_write()
 *    will return while data is being sent in the context of a hardware
 *    interrupt.  When the read or write finishes, the UART driver will call
 *    the user's callback function.  In some cases, the UART data transfer
 *    may have been canceled, or a newline may have been received, so the
 *    number of bytes sent/received are passed to the callback function.  Your
 *    implementation of the callback function can use this information
 *    as needed.  Since the user's callback may be called in the context of an
 *    ISR, the callback function must not make any RTOS blocking calls.
 *    The buffer passed to UART_write() in #UART_MODE_CALLBACK is not copied.
 *    The buffer must remain coherent until all the characters have been sent
 *    (ie until the tx callback has been called with a byte count equal to
 *    that passed to UART_write()).
 *
 *  The example sets the writeDataMode and readDataMode parameters to
 *  #UART_DATA_BINARY.  Options for these parameters are #UART_DATA_BINARY
 *  and #UART_DATA_TEXT:
 *
 *  - #UART_DATA_BINARY:  The data is passed as is, without processing.
 *
 *  - #UART_DATA_TEXT: Write actions add a carriage return before a
 *    newline character, and read actions replace a return with a newline.
 *    This effectively treats all device line endings as LF and all host
 *    PC line endings as CRLF.
 *
 *  Other parameters set by the example are readReturnMode and readEcho.
 *  Options for the readReturnMode parameter are #UART_RETURN_FULL and
 *  #UART_RETURN_NEWLINE:
 *
 *  - #UART_RETURN_FULL:  The read action unblocks or returns when the buffer
 *    is full.
 *  - #UART_RETURN_NEWLINE:  The read action unblocks or returns when a
 *    newline character is read, before the buffer is full.
 *
 *  Options for the readEcho parameter are #UART_ECHO_OFF and #UART_ECHO_ON.
 *  This parameter determines whether the driver echoes data back to the
 *  UART.  When echo is turned on, each character that is read by the target
 *  is written back, independent of any write operations.  If data is
 *  received in the middle of a write and echo is turned on, the echoed
 *  characters will be mixed in with the write data.
 *
 *  ### Reading and Writing data #
 *
 *  The example code reads one byte frome the UART instance, and then writes
 *  one byte back to the same instance:
 *
 *  @code
 *  UART_read(uart, &input, 1);
 *  UART_write(uart, &input, 1);
 *  @endcode
 *
 *  The UART driver allows full duplex data transfers. Therefore, it is
 *  possible to call UART_read() and UART_write() at the same time (for
 *  either blocking or callback modes). It is not possible, however,
 *  to issue multiple concurrent operations in the same direction.
 *  For example, if one thread calls UART_read(uart0, buffer0...),
 *  any other thread attempting UART_read(uart0, buffer1...) will result in
 *  an error of UART_STATUS_ERROR, until all the data from the first UART_read()
 *  has been transferred to buffer0. This applies to both blocking and
 *  and callback modes. So applications must either synchronize
 *  UART_read() (or UART_write()) calls that use the same UART handle, or
 *  check for the UART_STATUS_ERROR return code indicating that a transfer is
 *  still ongoing.
 *
 *  <hr>
 *  @anchor ti_drivers_UART_Configuration
 *  # Configuration
 *
 *  Refer to the @ref driver_configuration "Driver's Configuration" section
 *  for driver configuration information.
 *  <hr>
 *
 *  ============================================================================
 */

#ifndef ti_drivers_UART__include
#define ti_drivers_UART__include

#include <stddef.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

#define UART_CMD_RESERVED           (32)

#define UART_STATUS_RESERVED        (-32)

#define UART_STATUS_SUCCESS         (0)

#define UART_STATUS_ERROR           (-1)

#define UART_STATUS_UNDEFINEDCMD    (-2)

#define UART_CMD_PEEK               (0)

#define UART_CMD_ISAVAILABLE        (1)

#define UART_CMD_GETRXCOUNT         (2)

#define UART_CMD_RXENABLE           (3)

#define UART_CMD_RXDISABLE          (4)

#define UART_ERROR                  (UART_STATUS_ERROR)

#define UART_WAIT_FOREVER           (~(0U))

typedef struct UART_Config_    *UART_Handle;

typedef void (*UART_Callback) (UART_Handle handle, void *buf, size_t count);

typedef enum {
    UART_MODE_BLOCKING,

    UART_MODE_CALLBACK
} UART_Mode;

typedef enum {
    UART_RETURN_FULL,

    UART_RETURN_NEWLINE
} UART_ReturnMode;

typedef enum {
    UART_DATA_BINARY = 0, 
    UART_DATA_TEXT = 1    
} UART_DataMode;

typedef enum {
    UART_ECHO_OFF = 0,  
    UART_ECHO_ON = 1    
} UART_Echo;

typedef enum {
    UART_LEN_5 = 0,  
    UART_LEN_6 = 1,  
    UART_LEN_7 = 2,  
    UART_LEN_8 = 3   
} UART_LEN;

typedef enum {
    UART_STOP_ONE = 0,  
    UART_STOP_TWO = 1   
} UART_STOP;

typedef enum {
    UART_PAR_NONE = 0,  
    UART_PAR_EVEN = 1,  
    UART_PAR_ODD  = 2,  
    UART_PAR_ZERO = 3,  
    UART_PAR_ONE  = 4   
} UART_PAR;

typedef struct {
    UART_Mode       readMode;        
    UART_Mode       writeMode;       
    uint32_t        readTimeout;     
    uint32_t        writeTimeout;    
    UART_Callback   readCallback;    
    UART_Callback   writeCallback;   
    UART_ReturnMode readReturnMode;  
    UART_DataMode   readDataMode;    
    UART_DataMode   writeDataMode;   
    UART_Echo       readEcho;        
    uint32_t        baudRate;        
    UART_LEN        dataLength;      
    UART_STOP       stopBits;        
    UART_PAR        parityType;      
    void           *custom;          
} UART_Params;

typedef void (*UART_CloseFxn) (UART_Handle handle);

typedef int_fast16_t (*UART_ControlFxn) (UART_Handle handle, uint_fast16_t cmd, void *arg);

typedef void (*UART_InitFxn) (UART_Handle handle);

typedef UART_Handle (*UART_OpenFxn) (UART_Handle handle, UART_Params *params);
typedef int_fast32_t (*UART_ReadFxn) (UART_Handle handle, void *buffer,
    size_t size);

typedef int_fast32_t (*UART_ReadPollingFxn) (UART_Handle handle, void *buffer,
    size_t size);

typedef void (*UART_ReadCancelFxn) (UART_Handle handle);

typedef int_fast32_t (*UART_WriteFxn) (UART_Handle handle, const void *buffer,
    size_t size);

typedef int_fast32_t (*UART_WritePollingFxn) (UART_Handle handle,
    const void *buffer, size_t size);

typedef void (*UART_WriteCancelFxn) (UART_Handle handle);

typedef struct {
    UART_CloseFxn        closeFxn;

    UART_ControlFxn      controlFxn;

    UART_InitFxn         initFxn;

    UART_OpenFxn         openFxn;

    UART_ReadFxn         readFxn;

    UART_ReadPollingFxn  readPollingFxn;

    UART_ReadCancelFxn   readCancelFxn;

    UART_WriteFxn        writeFxn;

    UART_WritePollingFxn writePollingFxn;

    UART_WriteCancelFxn  writeCancelFxn;
} UART_FxnTable;

typedef struct UART_Config_ {
    UART_FxnTable const *fxnTablePtr;

    void                *object;

    void          const *hwAttrs;
} UART_Config;

extern void UART_close(UART_Handle handle);

extern int_fast16_t UART_control(UART_Handle handle, uint_fast16_t cmd, void *arg);

extern void UART_init(void);

extern UART_Handle UART_open(uint_least8_t index, UART_Params *params);

extern void UART_Params_init(UART_Params *params);

extern int_fast32_t UART_write(UART_Handle handle, const void *buffer, size_t size);

extern int_fast32_t UART_writePolling(UART_Handle handle, const void *buffer, size_t size);

extern void UART_writeCancel(UART_Handle handle);

extern int_fast32_t UART_read(UART_Handle handle, void *buffer, size_t size);

extern int_fast32_t UART_readPolling(UART_Handle handle, void *buffer, size_t size);

extern void UART_readCancel(UART_Handle handle);

#ifdef __cplusplus
}
#endif

#endif /* ti_drivers_UART__include */