UART driver implementation for a CC26X2 UART controller.
============================================================================
The UART header file should be included in an application as follows:
Refer to UART.h for a complete description of APIs.
The general UART API should used in application code, i.e. UART_open() is used instead of UARTCC26X2_open(). The board file will define the device specific config, and casting in the general API will ensure that the correct device specific functions are called. This is also reflected in the example code in Use Cases.
Before using the UART in CC26X2:
The following is true for receive operation:
The following apply for transmit operation:
If UART is no longer needed by application:
If the UART is configured in UART_MODE_CALLBACK mode:
If an error occurs during read operation:
A timeout value can only be specified for reads and writes in UART_MODE_BLOCKING. If a timeout occurs during a read when in UART_MODE_BLOCKING, the number of bytes received will be returned. After a read timeout, RX will be turned off and the device allowed to enter standby. For more details see Power Management chapter below.
In UART_MODE_CALLBACK there is no timeout and the application must call UART_readCancel() or UART_writeCancel() to abort the operation.
It's safe to call UART_close() during an ongoing UART_read() and/or UART_write(), this will cancel the ongoing RX/TX immediately.
The RX callback is alwyas called when you call UART_close() if there's an ongoing read. Note that if UART_close() is called during an ongoing read, the size provided in the RX callback function is 0 if < 16 bytes were received before calling UART_close(). This is because 16 bytes is the RX watermark that triggers the ISR to copy bytes from the internal UART FIFO to the software RX buffer.
The TX callback is always called when you call UART_close() if there's an ongoing write. The driver does not wait until a byte is transmitted correctly, so if UART_close() is called in the middle of sending a byte, this byte will be corrupted.
The TI-RTOS power management framework will try to put the device into the most power efficient mode whenever possible. Please see the technical reference manual for further details on each power mode.
The UARTCC26X2 driver sets a power constraint during operation to keep the device out of standby. When the operation has finished, the power constraint is released. The following statements are valid:
To enable Flow Control, the RTS and CTS pins must be assigned in the UARTCC26X2_HWAttrs and flowControl must be set to UARTCC26X2_FLOWCTRL_HARDWARE:
If the RTS and CTS pins are set to PIN_UNASSIGNED, or flowControl is set to UARTCC26X2_FLOWCONTROL_NONE, the flow control is disabled. An example is shown in the UARTCC26X2_HWAttrs description.
Generic API function | API function | Description |
---|---|---|
UART_init() | UARTCC26X2_init() | Initialize UART driver |
UART_open() | UARTCC26X2_open() | Initialize UART HW and set system dependencies |
UART_close() | UARTCC26X2_close() | Disable UART HW and release system dependencies |
UART_control() | UARTCC26X2_control() | Configure an already opened UART handle |
UART_read() | UARTCC26X2_read() | Start read from UART |
UART_readCancel() | UARTCC26X2_readCancel() | Cancel ongoing read from UART |
UART_readPolling() | UARTCC26X2_readPolling() | Polling read from UART |
UART_write() | UARTCC26X2_write() | Start write to UART |
UART_writeCancel() | UARTCC26X2_writeCancel() | Cancel ongoing write to UART |
UART_writePolling() | UARTCC26X2_writePolling() | Polling write to UART |
Receive 100 bytes over UART in UART_MODE_BLOCKING.
This use case will read in UART_MODE_BLOCKING until the wanted amount of bytes is received or until a started reception is inactive for a 32-bit period. This UART_read() call can also be used when unknown amount of bytes shall be read. Note: The partial return is also possible in UART_MODE_CALLBACK mode.
This case will configure the UART to send the data in txBuf in BLOCKING_MODE.
This case will configure the UART to receive and transmit continously in UART_MODE_CALLBACK, and transmit them back via UART TX. Note that UART_Params.readTimeout is not in use when using UART_MODE_CALLBACK mode.
The CC26xx driver supports baud rates up to 3Mbaud. However, when receiving more than 32 bytes back-to-back the baud rate is limited to approximately 2Mbaud. The throughput is also dependent on the user application.
There are no additional stack requirements for calling UART_read() within its own callback.
#include <stdint.h>
#include <stdbool.h>
#include <ti/drivers/dpl/ClockP.h>
#include <ti/drivers/dpl/HwiP.h>
#include <ti/drivers/dpl/SemaphoreP.h>
#include <ti/drivers/dpl/SwiP.h>
#include <ti/drivers/Power.h>
#include <ti/drivers/UART.h>
#include <ti/drivers/pin/PINCC26XX.h>
#include <ti/drivers/utils/RingBuf.h>
Go to the source code of this file.
Data Structures | |
struct | UARTCC26X2_HWAttrs |
UARTCC26X2 Hardware attributes. More... | |
struct | UARTCC26X2_Object |
UARTCC26X2 Object. More... | |
Macros | |
#define | UARTCC26X2_FLOWCTRL_NONE 0 |
No hardware flow control. More... | |
#define | UARTCC26X2_FLOWCTRL_HARDWARE 1 |
Hardware flow control. More... | |
#define | UARTCC26X2_CMD_RETURN_PARTIAL_ENABLE (UART_CMD_RESERVED + 0) |
Command used by UART_control to enable partial return. More... | |
#define | UARTCC26X2_CMD_RETURN_PARTIAL_DISABLE (UART_CMD_RESERVED + 1) |
Command used by UART_control to disable partial return. More... | |
#define | UARTCC26X2_CMD_RX_FIFO_FLUSH (UART_CMD_RESERVED + 2) |
Command used by UART_control to flush the RX FIFO. More... | |
#define | UARTCC26X2_FIFO_SIZE 32 |
Typedefs | |
typedef enum UARTCC26X2_FifoThreshold | UARTCC26X2_FifoThreshold |
UART TX/RX interrupt FIFO threshold select. More... | |
typedef void(* | UARTCC26X2_ErrorCallback) (UART_Handle handle, uint32_t error) |
The definition of an optional callback function used by the UART driver to notify the application when a receive error (FIFO overrun, parity error, etc) occurs. More... | |
typedef struct UARTCC26X2_HWAttrs | UARTCC26X2_HWAttrs |
UARTCC26X2 Hardware attributes. More... | |
typedef struct UARTCC26X2_Object | UARTCC26X2_Object |
UARTCC26X2 Object. More... | |
typedef struct UARTCC26X2_Object * | UARTCC26X2_Handle |
Enumerations | |
enum | UARTCC26X2_FifoThreshold { UARTCC26X2_FIFO_THRESHOLD_DEFAULT = 0, UARTCC26X2_FIFO_THRESHOLD_1_8, UARTCC26X2_FIFO_THRESHOLD_2_8, UARTCC26X2_FIFO_THRESHOLD_4_8, UARTCC26X2_FIFO_THRESHOLD_6_8, UARTCC26X2_FIFO_THRESHOLD_7_8 } |
UART TX/RX interrupt FIFO threshold select. More... | |
Variables | |
const UART_FxnTable | UARTCC26X2_fxnTable |
#define UARTCC26X2_FLOWCTRL_NONE 0 |
No hardware flow control.
#define UARTCC26X2_FLOWCTRL_HARDWARE 1 |
Hardware flow control.
#define UARTCC26X2_FIFO_SIZE 32 |
Size of the TX and RX FIFOs is 32 items
typedef enum UARTCC26X2_FifoThreshold UARTCC26X2_FifoThreshold |
UART TX/RX interrupt FIFO threshold select.
Defined FIFO thresholds for generation of both TX interrupt and RX interrupt. The default value (UARTCC26X2_FIFO_THRESHOLD_DEFAULT) is defined for backwards compatibility handling. If the RX and TX FIFO & thresholds are not set in the HwAttrs, or are set to UARTCC26X2_FIFO_THRESHOLD_DEFAULT, the RX interrupt FIFO threshold is set to 4/8 full, and the TX interrupt FIFO threshold is set to 1/8 full.
typedef void(* UARTCC26X2_ErrorCallback) (UART_Handle handle, uint32_t error) |
The definition of an optional callback function used by the UART driver to notify the application when a receive error (FIFO overrun, parity error, etc) occurs.
UART_Handle | UART_Handle |
error | The current value of the receive status register. |
typedef struct UARTCC26X2_HWAttrs UARTCC26X2_HWAttrs |
UARTCC26X2 Hardware attributes.
The fields, baseAddr and intNum are used by driverlib APIs and therefore must be populated by driverlib macro definitions. These definitions are found under the device family in:
intPriority is the UART peripheral's interrupt priority, as defined by the underlying OS. It is passed unmodified to the underlying OS's interrupt handler creation code, so you need to refer to the OS documentation for usage. For example, for SYS/BIOS applications, refer to the ti.sysbios.family.arm.m3.Hwi documentation for SYS/BIOS usage of interrupt priorities. If the driver uses the ti.dpl interface instead of making OS calls directly, then the HwiP port handles the interrupt priority in an OS specific way. In the case of the SYS/BIOS port, intPriority is passed unmodified to Hwi_create(). The CC26xx uses three of the priority bits, meaning ~0 has the same effect as (7 << 5).
(7 << 5) will apply the lowest priority. (1 << 5) will apply the highest priority.
Setting the priority to 0 is not supported by this driver. HWI's with priority 0 ignore the HWI dispatcher to support zero-latency interrupts, thus invalidating the critical sections in this driver.
A sample structure is shown below:
The .ctsPin and .rtsPin must be assigned to enable flow control.
typedef struct UARTCC26X2_Object UARTCC26X2_Object |
UARTCC26X2 Object.
The application must not access any member variables of this structure!
typedef struct UARTCC26X2_Object * UARTCC26X2_Handle |
UART TX/RX interrupt FIFO threshold select.
Defined FIFO thresholds for generation of both TX interrupt and RX interrupt. The default value (UARTCC26X2_FIFO_THRESHOLD_DEFAULT) is defined for backwards compatibility handling. If the RX and TX FIFO & thresholds are not set in the HwAttrs, or are set to UARTCC26X2_FIFO_THRESHOLD_DEFAULT, the RX interrupt FIFO threshold is set to 4/8 full, and the TX interrupt FIFO threshold is set to 1/8 full.
const UART_FxnTable UARTCC26X2_fxnTable |