mirror of
https://github.com/thelsing/knx.git
synced 2025-10-17 11:14:33 +02:00
e51b65f8c2
git-subtree-dir: examples/knx-cc1310/coresdk_cc13xx_cc26xx git-subtree-split: 0d78d3280357416a5c0388148cda13717c9ffaa5
646 lines
27 KiB
C
646 lines
27 KiB
C
/*
|
|
* Copyright (c) 2015-2019, 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 UARTCC26XX.h
|
|
*
|
|
* @brief UART driver implementation for a CC26XX UART controller
|
|
*
|
|
* # Driver include #
|
|
* The UART header file should be included in an application as follows:
|
|
* @code
|
|
* #include <ti/drivers/UART.h>
|
|
* #include <ti/drivers/uart/UARTCC26XX.h>
|
|
* @endcode
|
|
*
|
|
* Refer to @ref UART.h for a complete description of APIs.
|
|
*
|
|
* # Overview #
|
|
* The general UART API should used in application code, i.e. UART_open()
|
|
* is used instead of UARTCC26XX_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](@ref USE_CASES).
|
|
*
|
|
* # General Behavior #
|
|
* Before using the UART in CC26XX:
|
|
* - The UART driver is initialized by calling UART_init().
|
|
* - The UART HW is configured and flags system dependencies (e.g. IOs,
|
|
* power, etc.) by calling UART_open().
|
|
* - The RX and TX can operate independently of each other.
|
|
* .
|
|
* The following is true for receive operation:
|
|
* - RX is enabled by calling UART_read().
|
|
* - All received bytes are ignored after UART_open() is called, until
|
|
* the first UART_read().
|
|
* - If an RX error occur, RX is turned off and all bytes received before the
|
|
* error occured are returned.
|
|
* - After a successful read, RX remains on. UART_read() must be called
|
|
* again before FIFO goes full in order to avoid overflow. It is safe to
|
|
* call another UART_read() from the read callback, See
|
|
* [Receive Continously] (@ref USE_CASE_CB) use case below.
|
|
* - If a read times out (in ::UART_MODE_BLOCKING mode), RX will remain on.
|
|
* UART_read() must be called again before FIFO goes full in order to avoid overflow.
|
|
* - The UART_read() supports partial return, that can be used if the
|
|
* receive size is unknown. See [Use Cases](@ref USE_CASES) below.
|
|
* - The RingBuf serves as an extension of the FIFO. If data is received when
|
|
* UART_read() is not called, data will be stored in the RingBuf. The
|
|
* functionality of the RingBuf has been tested with a size of 32. This size
|
|
* can be changed to suit the application.
|
|
* .
|
|
* The following apply for transmit operation:
|
|
* - TX is enabled by calling UART_write().
|
|
* - If the UART_write() succeeds, the TX is disabled.
|
|
* .
|
|
* If UART is no longer needed by application:
|
|
* - Release system dependencies for UART by calling UART_close().
|
|
* .
|
|
* If the UART is configured in ::UART_MODE_CALLBACK mode:
|
|
* - The error handling callback is run in a HWI context.
|
|
* - The regular callback is run in a SWI context.
|
|
*
|
|
* # Error handling #
|
|
* ## Read errors ##
|
|
* If an error occurs during read operation:
|
|
* - All bytes received up until an error occurs will be returned, with the
|
|
* error signaled in the ::UARTCC26XX_Object.status field. The RX is then turned off
|
|
* and all bytes will be ignored until a new read is issued. Note that only
|
|
* the read is cancelled when the error occurs. If a write was active
|
|
* while the RX error occurred, it will complete.
|
|
* - If a RX break error occurs, an extra 0 byte will also be returned by the
|
|
* UART_read().
|
|
* .
|
|
*
|
|
* ## Write errors##
|
|
* If a timeout occurs during a write, an UART_ERROR will be returned and the
|
|
* UART_Object.status will be set to ::UART_TIMED_OUT. All bytes that are not
|
|
* transmitted, will be flushed.
|
|
* If flow control is not enabled, the ::UARTCC26XX_Object.writeTimeout should
|
|
* be kept at default value, BIOS_WAIT_FOREVER. The write call will return after
|
|
* all bytes are transmitted.
|
|
* If flow control is enabled, the timeout should be set by the application in
|
|
* order to recover if the receiver gets stuck.
|
|
*
|
|
* ## General timeout ##
|
|
* 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 and the UART_Object.status will be set to ::UART_TIMED_OUT.
|
|
* After a read timeout, RX will remain on, but device is allowed to enter standby.
|
|
* For more details see [Power Management](@ref 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.
|
|
*
|
|
* @note A new read or write will reset the UART_Object.status to UART_OK.
|
|
* Caution must be taken when doing parallel reads and writes.
|
|
*
|
|
* ## Closing driver during an ongoing read/write ##
|
|
* 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.
|
|
*
|
|
* # Power Management @anchor POWER_MANAGEMENT #
|
|
* 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 UARTCC26XX driver is setting 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:
|
|
* - After UART_open(): the device is still allowed to enter standby.
|
|
* - During UART_read(): the device cannot enter standby.
|
|
* - After an RX error (overrun, break, parity, framing): device is allowed to enter standby.
|
|
* - After a successful UART_read():
|
|
* The device is allowed to enter standby, but RX remains on.
|
|
* - _Note_: Device might enter standby while a byte is being
|
|
* received if UART_read() is not called again after a successful
|
|
* read. This could result in corrupt data being received.
|
|
* - _Note_: Application thread should typically either issue another read after
|
|
* UART_read() completes successfully, or call
|
|
* UART_readCancel() to disable RX and thus assuring that no data
|
|
* is received while entering standby.
|
|
* - After UART_read() times out in ::UART_MODE_BLOCKING:
|
|
* The device is allowed to enter standby, but RX remains on.
|
|
* - _Note_: Device might enter standby while a byte is being
|
|
* received if UART_read() is not called again after a timeout.
|
|
* This could result in corrupt data being received.
|
|
* - _Note_: Application thread should typically either issue another read after
|
|
* UART_read() times out to continue reception.
|
|
* .
|
|
* - During UART_write(): the device cannot enter standby.
|
|
* - After UART_write() succeeds: the device can enter standby.
|
|
* - If UART_writeCancel() is called: the device can enter standby.
|
|
* - After write timeout: the device can enter standby.
|
|
*
|
|
* # Flow Control #
|
|
* To enable Flow Control, the RTS and CTS pins must be assigned in the
|
|
* ::UARTCC26XX_HWAttrsV2:
|
|
* @code
|
|
* const UARTCC26XX_HWAttrsV2 uartCC26xxHWAttrs[] = {
|
|
* {
|
|
* .baseAddr = UART0_BASE,
|
|
* .powerMngrId = PERIPH_UART0,
|
|
* .intNum = INT_UART0,
|
|
* .intPriority = ~0,
|
|
* .swiPriority = 0,
|
|
* .txPin = Board_UART_TX,
|
|
* .rxPin = Board_UART_RX,
|
|
* .ctsPin = Board_UART_CTS,
|
|
* .rtsPin = Board_UART_RTS
|
|
* .ringBufPtr = uartCC26XXRingBuffer[0],
|
|
* .ringBufSize = sizeof(uartCC26XXRingBuffer[0]),
|
|
* .txIntFifoThr= UARTCC26XX_FIFO_THRESHOLD_1_8,
|
|
* .rxIntFifoThr= UARTCC26XX_FIFO_THRESHOLD_4_8
|
|
* }
|
|
* };
|
|
* @endcode
|
|
*
|
|
* If the RTS and CTS pins are set to ::PIN_UNASSIGNED, the flow control is
|
|
* disabled. An example is shown in the ::UARTCC26XX_HWAttrsV2 description.
|
|
*
|
|
* # Supported Functions #
|
|
* | Generic API function | API function | Description |
|
|
* |----------------------|--------------------------|------------------------
|
|
* | UART_init() | UARTCC26XX_init() | Initialize UART driver |
|
|
* | UART_open() | UARTCC26XX_open() | Initialize UART HW and set system dependencies |
|
|
* | UART_close() | UARTCC26XX_close() | Disable UART HW and release system dependencies |
|
|
* | UART_control() | UARTCC26XX_control() | Configure an already opened UART handle |
|
|
* | UART_read() | UARTCC26XX_read() | Start read from UART |
|
|
* | UART_readCancel() | UARTCC26XX_readCancel() | Cancel ongoing read from UART |
|
|
* | UART_write() | UARTCC26XX_write() | Start write to UART |
|
|
* | UART_writeCancel() | UARTCC26XX_writeCancel() | Cancel ongoing write to UART |
|
|
*
|
|
* @note All calls should go through the generic API
|
|
*
|
|
* # Not Supported Functionality #
|
|
* The CC26XX UART driver currently does not support:
|
|
* - ::UART_ECHO_ON
|
|
* - ::UART_DATA_TEXT
|
|
* - UART_readPolling()
|
|
* - UART_writePolling()
|
|
*
|
|
* # Use Cases @anchor USE_CASES #
|
|
* ## Basic Receive #
|
|
* Receive 100 bytes over UART in ::UART_MODE_BLOCKING.
|
|
* @code
|
|
* UART_Handle handle;
|
|
* UART_Params params;
|
|
* uint8_t rxBuf[100]; // Receive buffer
|
|
* uint32_t timeoutUs = 5000; // 5ms timeout, default timeout is no timeout (BIOS_WAIT_FOREVER)
|
|
*
|
|
* // Init UART and specify non-default parameters
|
|
* UART_Params_init(¶ms);
|
|
* params.baudRate = 9600;
|
|
* params.writeDataMode = UART_DATA_BINARY;
|
|
* params.readTimeout = timeoutUs / ClockP_tickPeriod; // Default tick period is 10us
|
|
*
|
|
* // Open the UART and do the read
|
|
* handle = UART_open(Board_UART, ¶ms);
|
|
* int rxBytes = UART_read(handle, rxBuf, 100);
|
|
* @endcode
|
|
*
|
|
* ## Receive with Return Partial #
|
|
* 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.
|
|
* @code
|
|
* UART_Handle handle;
|
|
* UART_Params params;
|
|
* uint8_t rxBuf[100]; // Receive buffer
|
|
*
|
|
* // Init UART and specify non-default parameters
|
|
* UART_Params_init(¶ms);
|
|
* params.baudRate = 9600;
|
|
* params.writeDataMode = UART_DATA_BINARY;
|
|
*
|
|
* // Open the UART and initiate the partial read
|
|
* handle = UART_open(Board_UART, ¶ms);
|
|
* // Enable RETURN_PARTIAL
|
|
* UART_control(handle, UARTCC26XX_CMD_RETURN_PARTIAL_ENABLE, NULL);
|
|
* // Begin read
|
|
* int rxBytes = UART_read(handle, rxBuf, 100));
|
|
* @endcode
|
|
*
|
|
* ## Basic Transmit #
|
|
* This case will configure the UART to send the data in txBuf in
|
|
* BLOCKING_MODE.
|
|
* @code
|
|
* UART_Handle handle;
|
|
* UART_Params params;
|
|
* uint8_t txBuf[] = "Hello World"; // Transmit buffer
|
|
*
|
|
* // Init UART and specify non-default parameters
|
|
* UART_Params_init(¶ms);
|
|
* params.baudRate = 9600;
|
|
* params.writeDataMode = UART_DATA_BINARY;
|
|
*
|
|
* // Open the UART and do the write
|
|
* handle = UART_open(Board_UART, ¶ms);
|
|
* UART_write(handle, txBuf, sizeof(txBuf));
|
|
* @endcode
|
|
*
|
|
* ## Receive Continously in ::UART_MODE_CALLBACK @anchor USE_CASE_CB #
|
|
* This case will configure the UART to receive and transmit continously in
|
|
* ::UART_MODE_CALLBACK, 16 bytes at the time and transmit them back via UART TX.
|
|
* Note that UART_Params.readTimeout is not in use when using ::UART_MODE_CALLBACK mode.
|
|
* @code
|
|
* #define MAX_NUM_RX_BYTES 1000 // Maximum RX bytes to receive in one go
|
|
* #define MAX_NUM_TX_BYTES 1000 // Maximum TX bytes to send in one go
|
|
*
|
|
* uint32_t wantedRxBytes; // Number of bytes received so far
|
|
* uint8_t rxBuf[MAX_NUM_RX_BYTES]; // Receive buffer
|
|
* uint8_t txBuf[MAX_NUM_TX_BYTES]; // Transmit buffer
|
|
*
|
|
* // Read callback function
|
|
* static void readCallback(UART_Handle handle, void *rxBuf, size_t size)
|
|
* {
|
|
* // Make sure we received all expected bytes
|
|
* if (size == wantedRxBytes) {
|
|
* // Copy bytes from RX buffer to TX buffer
|
|
* for(size_t i = 0; i < size; i++)
|
|
* txBuf[i] = ((uint8_t*)rxBuf)[i];
|
|
*
|
|
* // Echo the bytes received back to transmitter
|
|
* UART_write(handle, txBuf, size);
|
|
*
|
|
* // Start another read, with size the same as it was during first call to
|
|
* // UART_read()
|
|
* UART_read(handle, rxBuf, wantedRxBytes);
|
|
* }
|
|
* else {
|
|
* // Handle error or call to UART_readCancel()
|
|
* }
|
|
* }
|
|
*
|
|
* // Write callback function
|
|
* static void writeCallback(UART_Handle handle, void *rxBuf, size_t size)
|
|
* {
|
|
* // Do nothing
|
|
* }
|
|
*
|
|
* static void taskFxn(uintptr_t a0, uintptr_t a1)
|
|
* {
|
|
* UART_Handle handle;
|
|
* UART_Params params;
|
|
*
|
|
* // Init UART
|
|
* UART_init();
|
|
*
|
|
* // Specify non-default parameters
|
|
* UART_Params_init(¶ms);
|
|
* params.baudRate = 9600;
|
|
* params.writeMode = UART_MODE_CALLBACK;
|
|
* params.writeDataMode = UART_DATA_BINARY;
|
|
* params.writeCallback = writeCallback;
|
|
* params.readMode = UART_MODE_CALLBACK;
|
|
* params.readDataMode = UART_DATA_BINARY;
|
|
* params.readCallback = readCallback;
|
|
*
|
|
* // Open the UART and initiate the first read
|
|
* handle = UART_open(Board_UART, ¶ms);
|
|
* wantedRxBytes = 16;
|
|
* int rxBytes = UART_read(handle, rxBuf, wantedRxBytes);
|
|
*
|
|
* while(true); // Wait forever
|
|
* }
|
|
* @endcode
|
|
*
|
|
* # Baud Rate #
|
|
* 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.
|
|
*
|
|
* # Stack requirements #
|
|
* There are no additional stack requirements for calling UART_read() within
|
|
* its own callback.
|
|
*
|
|
* # Instrumentation #
|
|
* The UART driver interface produces log statements if instrumentation is
|
|
* enabled.
|
|
*
|
|
* Diagnostics Mask | Log details |
|
|
* ---------------- | ----------- |
|
|
* Diags_USER1 | basic UART operations performed |
|
|
* Diags_USER2 | detailed UART operations performed |
|
|
*
|
|
* ============================================================================
|
|
*/
|
|
|
|
#ifndef ti_drivers_uart_UARTCC26XX__include
|
|
#define ti_drivers_uart_UARTCC26XX__include
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
|
|
#include <ti/drivers/UART.h>
|
|
#include <ti/drivers/pin/PINCC26XX.h>
|
|
#include <ti/drivers/Power.h>
|
|
#include <ti/drivers/utils/RingBuf.h>
|
|
|
|
#include <ti/devices/DeviceFamily.h>
|
|
#include DeviceFamily_constructPath(driverlib/uart.h)
|
|
|
|
#include <ti/drivers/dpl/HwiP.h>
|
|
#include <ti/drivers/dpl/SwiP.h>
|
|
#include <ti/drivers/dpl/ClockP.h>
|
|
#include <ti/drivers/dpl/SemaphoreP.h>
|
|
|
|
/**
|
|
* @addtogroup UART_STATUS
|
|
* UARTCC26XX_STATUS_* macros are command codes only defined in the
|
|
* UARTCC26XX.h driver implementation and need to:
|
|
* @code
|
|
* #include <ti/drivers/uart/UARTCC26XX.h>
|
|
* @endcode
|
|
* @{
|
|
*/
|
|
|
|
/* Add UARTCC26XX_STATUS_* macros here */
|
|
|
|
/** @}*/
|
|
|
|
/**
|
|
* @addtogroup UART_CMD
|
|
* UARTCC26XX_CMD_* macros are command codes only defined in the UARTCC26XX.h
|
|
* driver implementation and need to:
|
|
* @code
|
|
* #include <ti/drivers/uart/UARTCC26XX.h>
|
|
* @endcode
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Command used by UART_control to enable partial return
|
|
*
|
|
* Enabling this command allows UART_read to return partial data if data
|
|
* reception is inactive for a given 32-bit period. With this command @b arg
|
|
* is @a don't @a care and it returns UART_STATUS_SUCCESS.
|
|
*/
|
|
#define UARTCC26XX_CMD_RETURN_PARTIAL_ENABLE (UART_CMD_RESERVED + 0)
|
|
|
|
/*!
|
|
* @brief Command used by UART_control to disable partial return
|
|
*
|
|
* Disabling this command returns the UARTCC26XX to the default blocking
|
|
* behavior where UART_read blocks until all data bytes were received. With
|
|
* this comand @b arg is @a don't @a care and it returns UART_STATUS_SUCCESS.
|
|
*/
|
|
#define UARTCC26XX_CMD_RETURN_PARTIAL_DISABLE (UART_CMD_RESERVED + 1)
|
|
|
|
/*!
|
|
* @brief Command used by UART_control to flush the RX FIFO
|
|
*
|
|
* This control command flushes any contents in the RX FIFO. With this command
|
|
* @b arg is @a don't @a care and it returns UART_STATUS_SUCCESS.
|
|
*/
|
|
#define UARTCC26XX_CMD_RX_FIFO_FLUSH (UART_CMD_RESERVED + 2)
|
|
/** @}*/
|
|
|
|
/*! Size of the TX and RX FIFOs is 32 items */
|
|
#define UARTCC26XX_FIFO_SIZE 32
|
|
|
|
/*!
|
|
* @brief UART TX/RX interrupt FIFO threshold select
|
|
*
|
|
* Defined FIFO thresholds for generation of both TX interrupt and RX interrupt.
|
|
* The default value (UARTCC26XX_FIFO_THRESHOLD_DEFAULT) is defined for backward compatibility handling.
|
|
*/
|
|
typedef enum UARTCC26XX_FifoThreshold {
|
|
UARTCC26XX_FIFO_THRESHOLD_DEFAULT = 0, /*!< Default value forces FIFO
|
|
threshold of 1/8 for TX
|
|
interrupt and 4/8 for RX
|
|
interrupt */
|
|
UARTCC26XX_FIFO_THRESHOLD_1_8, /*!< FIFO threshold of 1/8 full */
|
|
UARTCC26XX_FIFO_THRESHOLD_2_8, /*!< FIFO threshold of 2/8 full */
|
|
UARTCC26XX_FIFO_THRESHOLD_4_8, /*!< FIFO threshold of 4/8 full */
|
|
UARTCC26XX_FIFO_THRESHOLD_6_8, /*!< FIFO threshold of 6/8 full */
|
|
UARTCC26XX_FIFO_THRESHOLD_7_8 /*!< FIFO threshold of 7/8 full */
|
|
} UARTCC26XX_FifoThreshold;
|
|
|
|
/* BACKWARDS COMPATIBILITY */
|
|
#define UARTCC26XX_RETURN_PARTIAL_ENABLE UARTCC26XX_CMD_RETURN_PARTIAL_ENABLE
|
|
#define UARTCC26XX_RETURN_PARTIAL_DISABLE UARTCC26XX_CMD_RETURN_PARTIAL_DISABLE
|
|
/* END BACKWARDS COMPATIBILITY */
|
|
|
|
/*!
|
|
* @brief 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.
|
|
*
|
|
* @param UART_Handle UART_Handle
|
|
*
|
|
* @param error The current value of the receive
|
|
* status register.
|
|
*/
|
|
typedef void (*UARTCC26XX_ErrorCallback) (UART_Handle handle, uint32_t error);
|
|
|
|
/* UART function table pointer */
|
|
extern const UART_FxnTable UARTCC26XX_fxnTable;
|
|
|
|
/*!
|
|
* @brief UARTCC26XX Hardware attributes
|
|
*
|
|
* These fields, with the exception of intPriority, txIntFifoThr and
|
|
* rxIntFifoThr, are used by driverlib APIs and therefore must be populated
|
|
* by driverlib macro definitions.
|
|
* For CC26xxWare these definitions are found in:
|
|
* - inc/hw_memmap.h
|
|
* - inc/hw_ints.h
|
|
*
|
|
* 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().
|
|
*
|
|
* A sample structure is shown below:
|
|
* @code
|
|
* const UARTCC26XX_HWAttrsV2 uartCC26xxHWAttrs[] = {
|
|
* {
|
|
* .baseAddr = UART0_BASE,
|
|
* .powerMngrId = PERIPH_UART0,
|
|
* .intNum = INT_UART0,
|
|
* .intPriority = ~0,
|
|
* .swiPriority = 0,
|
|
* .txPin = Board_UART_TX,
|
|
* .rxPin = Board_UART_RX,
|
|
* .ctsPin = PIN_UNASSIGNED,
|
|
* .rtsPin = PIN_UNASSIGNED,
|
|
* .ringBufPtr = uartCC26XXRingBuffer[0],
|
|
* .ringBufSize = sizeof(uartCC26XXRingBuffer[0]),
|
|
* .txIntFifoThr= UARTCC26XX_FIFO_THRESHOLD_1_8,
|
|
* .rxIntFifoThr= UARTCC26XX_FIFO_THRESHOLD_4_8
|
|
* }
|
|
* };
|
|
* @endcode
|
|
*
|
|
* The .ctsPin and .rtsPin must be assigned to enable flow control.
|
|
*/
|
|
typedef struct UARTCC26XX_HWAttrsV2 {
|
|
uint32_t baseAddr; /*!< UART Peripheral's base address */
|
|
uint32_t powerMngrId; /*!< UART Peripheral's power manager ID */
|
|
int intNum; /*!< UART Peripheral's interrupt vector */
|
|
/*! @brief UART Peripheral's interrupt priority.
|
|
|
|
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.
|
|
*/
|
|
uint8_t intPriority;
|
|
/*! @brief SPI SWI priority.
|
|
The higher the number, the higher the priority.
|
|
The minimum is 0 and the maximum is 15 by default.
|
|
The maximum can be reduced to save RAM by adding or modifying Swi.numPriorities in the kernel configuration file.
|
|
*/
|
|
uint32_t swiPriority;
|
|
uint8_t txPin; /*!< UART TX pin */
|
|
uint8_t rxPin; /*!< UART RX pin */
|
|
uint8_t ctsPin; /*!< UART CTS pin */
|
|
uint8_t rtsPin; /*!< UART RTS pin */
|
|
unsigned char *ringBufPtr; /*!< Pointer to an application ring buffer */
|
|
size_t ringBufSize; /*!< Size of ringBufPtr */
|
|
UARTCC26XX_FifoThreshold txIntFifoThr; /*!< UART TX interrupt FIFO threshold select */
|
|
UARTCC26XX_FifoThreshold rxIntFifoThr; /*!< UART RX interrupt FIFO threshold select */
|
|
/*! Application error function to be called on receive errors */
|
|
UARTCC26XX_ErrorCallback errorFxn;
|
|
} UARTCC26XX_HWAttrsV2;
|
|
|
|
/*!
|
|
* @brief UART status
|
|
*
|
|
* The UART Status is used to flag the different Receive Errors.
|
|
*/
|
|
typedef enum UART_Status {
|
|
UART_TIMED_OUT = 0x10, /*!< UART timed out */
|
|
UART_PARITY_ERROR = UART_RXERROR_PARITY, /*!< UART Parity error */
|
|
UART_BRAKE_ERROR = UART_RXERROR_BREAK, /*!< UART Break error */
|
|
UART_OVERRUN_ERROR = UART_RXERROR_OVERRUN, /*!< UART overrun error */
|
|
UART_FRAMING_ERROR = UART_RXERROR_FRAMING, /*!< UART Framing error */
|
|
UART_OK = 0x0 /*!< UART OK */
|
|
} UART_Status;
|
|
|
|
/*!
|
|
* @brief UARTCC26XX Object
|
|
*
|
|
* The application must not access any member variables of this structure!
|
|
*/
|
|
typedef struct UARTCC26XX_Object {
|
|
/* UART control variables */
|
|
bool opened; /*!< Has the obj been opened */
|
|
UART_Mode readMode; /*!< Mode for all read calls */
|
|
UART_Mode writeMode; /*!< Mode for all write calls */
|
|
unsigned int readTimeout; /*!< Timeout for read semaphore in BLOCKING mode*/
|
|
unsigned int writeTimeout; /*!< Timeout for write semaphore in BLOCKING mode*/
|
|
UART_Callback readCallback; /*!< Pointer to read callback */
|
|
UART_Callback writeCallback; /*!< Pointer to write callback */
|
|
UART_ReturnMode readReturnMode; /*!< Receive return mode */
|
|
UART_DataMode readDataMode; /*!< Type of data being read */
|
|
UART_DataMode writeDataMode; /*!< Type of data being written */
|
|
/*! @brief Baud rate for CC26xx UART
|
|
*
|
|
* 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 approx. 2Mbaud.
|
|
* The throughput is also dependent on the user application.
|
|
*/
|
|
uint32_t baudRate;
|
|
UART_LEN dataLength; /*!< Data length for UART */
|
|
UART_STOP stopBits; /*!< Stop bits for UART */
|
|
UART_PAR parityType; /*!< Parity bit type for UART */
|
|
UART_Status status; /*!< Status variable */
|
|
|
|
/* UART write variables */
|
|
const void *writeBuf; /*!< Buffer data pointer */
|
|
size_t writeCount; /*!< Number of Chars sent */
|
|
size_t writeSize; /*!< Chars remaining in buffer */
|
|
bool writeCR; /*!< Write a return character */
|
|
|
|
/* UART receive variables */
|
|
bool readRetPartial; /*!< Return partial RX data if timeout occurs */
|
|
void *readBuf; /*!< Buffer data pointer */
|
|
size_t readCount; /*!< Number of Chars read */
|
|
size_t readSize; /*!< Chars remaining in buffer */
|
|
RingBuf_Object ringBuffer; /*!< local circular buffer object */
|
|
|
|
/* PIN driver state object and handle */
|
|
PIN_State pinState;
|
|
PIN_Handle hPin;
|
|
|
|
/*! UART post-notification function pointer */
|
|
void *uartPostFxn;
|
|
/*! UART post-notification object */
|
|
Power_NotifyObj uartPostObj;
|
|
|
|
/* UART SYS/BIOS objects */
|
|
HwiP_Struct hwi; /*!< Hwi object */
|
|
SwiP_Struct swi; /*!< Swi object */
|
|
SemaphoreP_Struct writeSem; /*!< UART write semaphore*/
|
|
SemaphoreP_Struct readSem; /*!< UART read semaphore */
|
|
ClockP_Struct txFifoEmptyClk; /*!< UART TX FIFO empty clock */
|
|
|
|
bool uartRxPowerConstraint;
|
|
bool uartTxPowerConstraint;
|
|
} UARTCC26XX_Object, *UARTCC26XX_Handle;
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* ti_drivers_uart_UARTCC26XX__include */
|