This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

[参考译文] CC1310:CC1310 SD_open()始终为空(自定义硬件)

Guru**** 657500 points
Other Parts Discussed in Thread: CC1310
请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz-group/sub-1-ghz/f/sub-1-ghz-forum/1098743/cc1310-cc1310-sd_open-always-null-custom-hardware

部件号:CC1310

下午好!

我正在使用CC1310处理定制PCB。 我有一个SD卡连接到以下CC1310引脚,带有100欧姆系列电阻器和10k上拉电阻器:

SD卡MOSI:引脚17 (DIO_11)

SD卡miso:引脚11 (DIO_6)

SD卡CS:引脚10 (DIO_5)

SD卡CLK:引脚18 (DIO_12)

我正在使用SDRAW.C (nortos)示例。 我在代码中没有更改任何内容,但这里只是为了以防:

/*
 * Copyright (c) 2016-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.
 */

/*
 *  ======== sdraw.c ========
 */
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

/* Driver Header files */
#include <ti/drivers/GPIO.h>
#include <ti/drivers/SD.h>
#include <ti/display/Display.h>

/* Example/Board Header files */
#include "Board.h"

/* Buffer size used for the file copy process */
#define BUFFSIZE 1024

 /* Starting sector to write/read to */
#define STARTINGSECTOR 0

#define BYTESPERKILOBYTE 1024

/*
 * Set this constant to 1 in order to write to the SD card.
 * WARNING: Running this example with WRITEENABLE set to 1 will cause
 * any filesystem present on the SD card to be corrupted!
 */
#define WRITEENABLE 1

static Display_Handle display;

unsigned char textarray[BUFFSIZE];

unsigned char cpy_buff[BUFFSIZE];

/*
 *  ======== mainThread ========
 *  Task to perform a raw write and read from the SD card.
 *  Note: Running this application will cause any filesystem on the
 *      SD card to become corrupted!
 */
void *mainThread(void *arg0)
{
    int_fast8_t   result;
    uint_fast32_t cardCapacity;
    uint_fast32_t totalSectors;
    uint_fast32_t sectorSize;
    uint_fast32_t sectors;
    int           i;
    SD_Handle     sdHandle;

    Display_init();
    GPIO_init();
    SD_init();

    /* Configure the LED pin */
    GPIO_setConfig(Board_GPIO_RLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
//    GPIO_setConfig(Board_SPI_FLASH_CS, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_HIGH);
    /* Open the display for output */
    display = Display_open(Display_Type_UART, NULL);
    if (display == NULL) {
        /* Failed to open display driver */
        while (1);
    }

    /* Turn on user LED */
    GPIO_write(Board_GPIO_RLED, Board_GPIO_LED_ON);

    Display_printf(display, 0, 0, "Starting the SD example\n");

    /* Initialize the array to write to the SD card */
    for (i = 0; i < BUFFSIZE; i++) {
        textarray[i] = i & 0xFF;
    }

    /* Mount and register the SD Card */
    sdHandle = SD_open(Board_SD0, NULL);
    if (sdHandle == NULL) {
        Display_printf(display, 0, 0, "Error starting the SD card\n");
        while (1);
    }

    result = SD_initialize(sdHandle);
    if (result != SD_STATUS_SUCCESS) {
        Display_printf(display, 0, 0, "Error initializing the SD card\n");
        while (1);
    }

    totalSectors = SD_getNumSectors(sdHandle);
    sectorSize = SD_getSectorSize(sdHandle);
    cardCapacity = (totalSectors / BYTESPERKILOBYTE) * sectorSize;

    Display_printf(display, 0, 0,
        "There are %u total sectors on the SD card.\n", totalSectors);
    Display_printf(display, 0, 0,
        "The Read/Write sector size is %u bytes\n", sectorSize);
    Display_printf(display, 0, 0,
        "The total card capacity is %u KB\n", cardCapacity);

    /* Calculate number of sectors taken up by the array by rounding up */
    sectors = (sizeof(textarray) + sectorSize - 1) / sectorSize;

#if (WRITEENABLE)
    Display_printf(display, 0, 0, "Writing the array...\n");

    result = SD_write(sdHandle, textarray, STARTINGSECTOR, sectors);
    if (result != SD_STATUS_SUCCESS) {
        Display_printf(display, 0, 0, "Error writing to the SD card\n");
        while (1);
    }
#endif

    Display_printf(display, 0, 0, "Reading the array...\n");
    result = SD_read(sdHandle, cpy_buff, STARTINGSECTOR, sectors);
    if (result != SD_STATUS_SUCCESS) {
        Display_printf(display, 0, 0, "Error reading from the SD card\n");
        while (1);
    }

    /* Compare data read from the SD card with expected values */
    for (i = 0; i < BUFFSIZE; i++) {
        if (cpy_buff[i] != textarray[i]) {
            Display_printf(display, 0, 0,
                    "Data read from SD card differed from expected value\n");
            Display_printf(display, 0, 0,
                    "    Expected value for index %d: %d, got %d\n", i,
                    textarray[i], cpy_buff[i]);
            Display_printf(display, 0, 0, "Run the example with WRITEENABLE "
                    "= 1 to write expected values to the SD card\n");
            break;
        }
    }

    if (i == BUFFSIZE) {
        Display_printf(display, 0, 0,
                "Data read from SD card matched expected values\n");
    }

    SD_close(sdHandle);

    return (NULL);
}

我已更改CC1310_LAUNCHXL_SPI0_Miso,CC1310_LAUNCHXL_SPI0_MOSI,CC1310_LAUNCHXL_SPI0_CLK和CC1310_LAUNCHXL_SPI0_CSN 的针脚,使其与我的引脚匹配。 我没有更改此文件中的任何其他内容:

/* SPI */
#define CC1310_LAUNCHXL_SPI_FLASH_CS          IOID_5 // WAS IOID_20
#define CC1310_LAUNCHXL_FLASH_CS_ON           0
#define CC1310_LAUNCHXL_FLASH_CS_OFF          1

/* SPI Board */
#define CC1310_LAUNCHXL_SPI0_MISO             IOID_11     //WAS IOID_8        /* RF1.20 */
#define CC1310_LAUNCHXL_SPI0_MOSI             IOID_6    //WAS IOID_9      /* RF1.18 */
#define CC1310_LAUNCHXL_SPI0_CLK              IOID_12   //WAS IOID_10      /* RF1.16 */
#define CC1310_LAUNCHXL_SPI0_CSN              IOID_5 // WAS IOID_11
#define CC1310_LAUNCHXL_SPI1_MISO             PIN_UNASSIGNED
#define CC1310_LAUNCHXL_SPI1_MOSI             PIN_UNASSIGNED
#define CC1310_LAUNCHXL_SPI1_CLK              PIN_UNASSIGNED
#define CC1310_LAUNCHXL_SPI1_CSN              PIN_UNASSIGNED

/* UART Board */
#define CC1310_LAUNCHXL_UART_RX               IOID_2 //was 2         /* RXD */
#define CC1310_LAUNCHXL_UART_TX               IOID_3  //was 3        /* TXD */
#define CC1310_LAUNCHXL_UART_CTS              IOID_19         /* CTS */
#define CC1310_LAUNCHXL_UART_RTS              IOID_18         /* RTS */

然而当在我的PCB中插入一个新格式化的SD卡时,它会卡在while循环中,因为SD_OPEN返回NULL。

我做错了什么?  

提前感谢。

KR,

Mirte H  

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    iOID_6由CC1310_LAUNCHXL_PIN_RLED使用,因此您需要执行以下步骤以使用IOID_6作为MOSI。

    1.将CC1310_LAUNCHLX_PIN_RLED定义为 CC1310_LAUNCXL.h中的其它IO

    2.将GPIOCC26XX_DIO_06修改 为 CC1310_LAUNCHXL.c中gPIOCC26XX_DIO_06的"GPIOCC26XX_DIO_06 | gPIO_DO_NOT_CONFIG,/*红色LED */"中的其他IO

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    感谢您的回复! 这解决了SD_open()问题

    但是,现在我的程序在 sd_initialize()处卡住,在这里它返回-1。 我再次强调,主代码中没有任何更改。 这是否是另一个软件问题,还是我的硬件问题?

    以下是我的CC1310_LAUNCHXL.C和CC1310_LAUNCHXL.H文件:

    /*
     * 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.
     */
    
    /*
     *  ====================== CC1310_LAUNCHXL.c ===================================
     *  This file is responsible for setting up the board specific items for the
     *  CC1310_LAUNCHXL board.
     */
    
    #include <stdbool.h>
    #include <stddef.h>
    #include <stdint.h>
    
    #include <ti/devices/cc13x0/driverlib/ioc.h>
    #include <ti/devices/cc13x0/driverlib/udma.h>
    #include <ti/devices/cc13x0/inc/hw_ints.h>
    #include <ti/devices/cc13x0/inc/hw_memmap.h>
    
    #include "CC1310_LAUNCHXL.h"
    
    /*
     *  =============================== ADCBuf ===============================
     */
    #include <ti/drivers/ADCBuf.h>
    #include <ti/drivers/adcbuf/ADCBufCC26XX.h>
    
    ADCBufCC26XX_Object adcBufCC26xxObjects[CC1310_LAUNCHXL_ADCBUFCOUNT];
    
    /*
     *  This table converts a virtual adc channel into a dio and internal analogue
     *  input signal. This table is necessary for the functioning of the adcBuf
     *  driver. Comment out unused entries to save flash. Dio and internal signal
     *  pairs are hardwired. Do not remap them in the table. You may reorder entire
     *  entries. The mapping of dio and internal signals is package dependent.
     */
    const ADCBufCC26XX_AdcChannelLutEntry ADCBufCC26XX_adcChannelLut[CC1310_LAUNCHXL_ADCBUF0CHANNELCOUNT] = {
        {CC1310_LAUNCHXL_DIO23_ANALOG, ADC_COMPB_IN_AUXIO7},
        {CC1310_LAUNCHXL_DIO24_ANALOG, ADC_COMPB_IN_AUXIO6},
        {CC1310_LAUNCHXL_DIO25_ANALOG, ADC_COMPB_IN_AUXIO5},
        {CC1310_LAUNCHXL_DIO26_ANALOG, ADC_COMPB_IN_AUXIO4},
        {CC1310_LAUNCHXL_DIO27_ANALOG, ADC_COMPB_IN_AUXIO3},
        {CC1310_LAUNCHXL_DIO28_ANALOG, ADC_COMPB_IN_AUXIO2},
        {CC1310_LAUNCHXL_DIO29_ANALOG, ADC_COMPB_IN_AUXIO1},
        {CC1310_LAUNCHXL_DIO30_ANALOG, ADC_COMPB_IN_AUXIO0},
        {PIN_UNASSIGNED, ADC_COMPB_IN_VDDS},
        {PIN_UNASSIGNED, ADC_COMPB_IN_DCOUPL},
        {PIN_UNASSIGNED, ADC_COMPB_IN_VSS},
    };
    
    const ADCBufCC26XX_HWAttrs adcBufCC26xxHWAttrs[CC1310_LAUNCHXL_ADCBUFCOUNT] = {
        {
            .intPriority       = ~0,
            .swiPriority       = 0,
            .adcChannelLut     = ADCBufCC26XX_adcChannelLut,
        }
    };
    
    const ADCBuf_Config ADCBuf_config[CC1310_LAUNCHXL_ADCBUFCOUNT] = {
        {
            &ADCBufCC26XX_fxnTable,
            &adcBufCC26xxObjects[CC1310_LAUNCHXL_ADCBUF0],
            &adcBufCC26xxHWAttrs[CC1310_LAUNCHXL_ADCBUF0]
        },
    };
    
    const uint_least8_t ADCBuf_count = CC1310_LAUNCHXL_ADCBUFCOUNT;
    
    /*
     *  =============================== ADC ===============================
     */
    #include <ti/drivers/ADC.h>
    #include <ti/drivers/adc/ADCCC26XX.h>
    
    ADCCC26XX_Object adcCC26xxObjects[CC1310_LAUNCHXL_ADCCOUNT];
    
    
    const ADCCC26XX_HWAttrs adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADCCOUNT] = {
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO23_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO7,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO24_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO6,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO25_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO5,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO26_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO4,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO27_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO3,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO28_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO2,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO29_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO1,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = CC1310_LAUNCHXL_DIO30_ANALOG,
            .adcCompBInput       = ADC_COMPB_IN_AUXIO0,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_10P9_MS,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = PIN_UNASSIGNED,
            .adcCompBInput       = ADC_COMPB_IN_DCOUPL,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = PIN_UNASSIGNED,
            .adcCompBInput       = ADC_COMPB_IN_VSS,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        },
        {
            .adcDIO              = PIN_UNASSIGNED,
            .adcCompBInput       = ADC_COMPB_IN_VDDS,
            .refSource           = ADCCC26XX_FIXED_REFERENCE,
            .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
            .inputScalingEnabled = true,
            .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
            .returnAdjustedVal   = false
        }
    };
    
    const ADC_Config ADC_config[CC1310_LAUNCHXL_ADCCOUNT] = {
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC0], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC0]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC1], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC1]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC2], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC2]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC3], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC3]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC4], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC4]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC5], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC5]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC6], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC6]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADC7], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADC7]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADCDCOUPL], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADCDCOUPL]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADCVSS], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADCVSS]},
        {&ADCCC26XX_fxnTable, &adcCC26xxObjects[CC1310_LAUNCHXL_ADCVDDS], &adcCC26xxHWAttrs[CC1310_LAUNCHXL_ADCVDDS]},
    };
    
    const uint_least8_t ADC_count = CC1310_LAUNCHXL_ADCCOUNT;
    
    /*
     *  =============================== Crypto ===============================
     */
    #include <ti/drivers/crypto/CryptoCC26XX.h>
    
    CryptoCC26XX_Object cryptoCC26XXObjects[CC1310_LAUNCHXL_CRYPTOCOUNT];
    
    const CryptoCC26XX_HWAttrs cryptoCC26XXHWAttrs[CC1310_LAUNCHXL_CRYPTOCOUNT] = {
        {
            .baseAddr       = CRYPTO_BASE,
            .powerMngrId    = PowerCC26XX_PERIPH_CRYPTO,
            .intNum         = INT_CRYPTO_RESULT_AVAIL_IRQ,
            .intPriority    = ~0,
        }
    };
    
    const CryptoCC26XX_Config CryptoCC26XX_config[CC1310_LAUNCHXL_CRYPTOCOUNT] = {
        {
             .object  = &cryptoCC26XXObjects[CC1310_LAUNCHXL_CRYPTO0],
             .hwAttrs = &cryptoCC26XXHWAttrs[CC1310_LAUNCHXL_CRYPTO0]
        }
    };
    
    /*
     *  =============================== AESCCM ===============================
     */
    #include <ti/drivers/AESCCM.h>
    #include <ti/drivers/aesccm/AESCCMCC26XX.h>
    
    AESCCMCC26XX_Object aesccmCC26XXObjects[CC1310_LAUNCHXL_AESCCMCOUNT];
    
    const AESCCMCC26XX_HWAttrs aesccmCC26XXHWAttrs[CC1310_LAUNCHXL_AESCCMCOUNT] = {
        {
            .intPriority       = ~0,
        }
    };
    
    const AESCCM_Config AESCCM_config[CC1310_LAUNCHXL_AESCCMCOUNT] = {
        {
             .object  = &aesccmCC26XXObjects[CC1310_LAUNCHXL_AESCCM0],
             .hwAttrs = &aesccmCC26XXHWAttrs[CC1310_LAUNCHXL_AESCCM0]
        },
    };
    
    const uint_least8_t AESCCM_count = CC1310_LAUNCHXL_AESCCMCOUNT;
    
    
    /*
     *  =============================== AESGCM ===============================
     */
    #include <ti/drivers/AESGCM.h>
    #include <ti/drivers/aesgcm/AESGCMCC26XX.h>
    
    AESGCMCC26XX_Object aesgcmCC26XXObjects[CC1310_LAUNCHXL_AESGCMCOUNT];
    
    const AESGCMCC26XX_HWAttrs aesgcmCC26XXHWAttrs[CC1310_LAUNCHXL_AESGCMCOUNT] = {
        {
            .intPriority       = ~0,
        }
    };
    
    const AESGCM_Config AESGCM_config[CC1310_LAUNCHXL_AESGCMCOUNT] = {
        {
             .object  = &aesgcmCC26XXObjects[CC1310_LAUNCHXL_AESGCM0],
             .hwAttrs = &aesgcmCC26XXHWAttrs[CC1310_LAUNCHXL_AESGCM0]
        },
    };
    
    const uint_least8_t AESGCM_count = CC1310_LAUNCHXL_AESGCMCOUNT;
    
    /*
     *  =============================== AESCBC ===============================
     */
    #include <ti/drivers/AESCBC.h>
    #include <ti/drivers/aescbc/AESCBCCC26XX.h>
    
    AESCBCCC26XX_Object aescbcCC26XXObjects[CC1310_LAUNCHXL_AESCBCCOUNT];
    
    const AESCBCCC26XX_HWAttrs aescbcCC26XXHWAttrs[CC1310_LAUNCHXL_AESCBCCOUNT] = {
        {
            .intPriority       = ~0,
        }
    };
    
    const AESCBC_Config AESCBC_config[CC1310_LAUNCHXL_AESCBCCOUNT] = {
        {
             .object  = &aescbcCC26XXObjects[CC1310_LAUNCHXL_AESCBC0],
             .hwAttrs = &aescbcCC26XXHWAttrs[CC1310_LAUNCHXL_AESCBC0]
        },
    };
    
    const uint_least8_t AESCBC_count = CC1310_LAUNCHXL_AESCBCCOUNT;
    
    /*
     *  =============================== AESCTR ===============================
     */
    #include <ti/drivers/AESCTR.h>
    #include <ti/drivers/aesctr/AESCTRCC26XX.h>
    
    AESCTRCC26XX_Object aesctrCC26XXObjects[CC1310_LAUNCHXL_AESCTRCOUNT];
    
    const AESCTRCC26XX_HWAttrs aesctrCC26XXHWAttrs[CC1310_LAUNCHXL_AESCTRCOUNT] = {
        {
            .intPriority       = ~0,
        }
    };
    
    const AESCTR_Config AESCTR_config[CC1310_LAUNCHXL_AESCTRCOUNT] = {
        {
             .object  = &aesctrCC26XXObjects[CC1310_LAUNCHXL_AESCTR0],
             .hwAttrs = &aesctrCC26XXHWAttrs[CC1310_LAUNCHXL_AESCTR0]
        },
    };
    
    const uint_least8_t AESCTR_count = CC1310_LAUNCHXL_AESCTRCOUNT;
    
    /*
     *  =============================== AESECB ===============================
     */
    #include <ti/drivers/AESECB.h>
    #include <ti/drivers/aesecb/AESECBCC26XX.h>
    
    AESECBCC26XX_Object aesecbCC26XXObjects[CC1310_LAUNCHXL_AESECBCOUNT];
    
    const AESECBCC26XX_HWAttrs aesecbCC26XXHWAttrs[CC1310_LAUNCHXL_AESECBCOUNT] = {
        {
            .intPriority       = ~0,
        }
    };
    
    const AESECB_Config AESECB_config[CC1310_LAUNCHXL_AESECBCOUNT] = {
        {
             .object  = &aesecbCC26XXObjects[CC1310_LAUNCHXL_AESECB0],
             .hwAttrs = &aesecbCC26XXHWAttrs[CC1310_LAUNCHXL_AESECB0]
        },
    };
    
    const uint_least8_t AESECB_count = CC1310_LAUNCHXL_AESECBCOUNT;
    
    /*
     *  =============================== AESCTRDRBG ===============================
     */
    #include <ti/drivers/AESCTRDRBG.h>
    #include <ti/drivers/aesctrdrbg/AESCTRDRBGXX.h>
    
    AESCTRDRBGXX_Object aesctrdrbgXXObjects[CC1310_LAUNCHXL_AESCTRDRBGCOUNT];
    
    const AESCTRDRBGXX_HWAttrs aesctrdrbgXXHWAttrs[CC1310_LAUNCHXL_AESCTRDRBGCOUNT] = {
        {
            .aesctrIndex       = CC1310_LAUNCHXL_AESCTR0,
        }
    };
    
    const AESCTRDRBG_Config AESCTRDRBG_config[CC1310_LAUNCHXL_AESCTRDRBGCOUNT] = {
        {
             .object  = &aesctrdrbgXXObjects[CC1310_LAUNCHXL_AESCTRDRBG0],
             .hwAttrs = &aesctrdrbgXXHWAttrs[CC1310_LAUNCHXL_AESCTRDRBG0]
        },
    };
    
    const uint_least8_t AESCTRDRBG_count = CC1310_LAUNCHXL_AESCTRDRBGCOUNT;
    
    /*
     *  =============================== TRNG ===============================
     */
    #include <ti/drivers/TRNG.h>
    #include <ti/drivers/trng/TRNGCC26XX.h>
    
    TRNGCC26XX_Object trngCC26XXObjects[CC1310_LAUNCHXL_TRNGCOUNT];
    
    const TRNGCC26XX_HWAttrs trngCC26X2HWAttrs[CC1310_LAUNCHXL_TRNGCOUNT] = {
        {
            .intPriority       = ~0,
            .swiPriority       = 0,
            .samplesPerCycle   = 240000,
        }
    };
    
    const TRNG_Config TRNG_config[CC1310_LAUNCHXL_TRNGCOUNT] = {
        {
             .object  = &trngCC26XXObjects[CC1310_LAUNCHXL_TRNG0],
             .hwAttrs = &trngCC26X2HWAttrs[CC1310_LAUNCHXL_TRNG0]
        },
    };
    
    const uint_least8_t TRNG_count = CC1310_LAUNCHXL_TRNGCOUNT;
    
    /*
     *  =============================== Display ===============================
     */
    #include <ti/display/Display.h>
    #include <ti/display/DisplayUart.h>
    #include <ti/display/DisplaySharp.h>
    
    #ifndef BOARD_DISPLAY_UART_STRBUF_SIZE
    #define BOARD_DISPLAY_UART_STRBUF_SIZE    128
    #endif
    
    /* This value can be changed to 96 for use with the 430BOOST-SHARP96 BoosterPack. */
    #define BOARD_DISPLAY_SHARP_SIZE    128
    
    DisplayUart_Object     displayUartObject;
    DisplaySharp_Object    displaySharpObject;
    
    static char uartStringBuf[BOARD_DISPLAY_UART_STRBUF_SIZE];
    static uint_least8_t sharpDisplayBuf[BOARD_DISPLAY_SHARP_SIZE * BOARD_DISPLAY_SHARP_SIZE / 8];
    
    const DisplayUart_HWAttrs displayUartHWAttrs = {
        .uartIdx      = CC1310_LAUNCHXL_UART0,
        .baudRate     = 115200,
        .mutexTimeout = (unsigned int)(-1),
        .strBuf       = uartStringBuf,
        .strBufLen    = BOARD_DISPLAY_UART_STRBUF_SIZE,
    };
    
    const DisplaySharp_HWAttrsV1 displaySharpHWattrs = {
        .spiIndex    = CC1310_LAUNCHXL_SPI0,
        .csPin       = CC1310_LAUNCHXL_GPIO_LCD_CS,
        .powerPin    = CC1310_LAUNCHXL_GPIO_LCD_POWER,
        .enablePin   = CC1310_LAUNCHXL_GPIO_LCD_ENABLE,
        .pixelWidth  = BOARD_DISPLAY_SHARP_SIZE,
        .pixelHeight = BOARD_DISPLAY_SHARP_SIZE,
        .displayBuf  = sharpDisplayBuf,
    };
    
    #ifndef BOARD_DISPLAY_USE_UART
    #define BOARD_DISPLAY_USE_UART 1
    #endif
    #ifndef BOARD_DISPLAY_USE_UART_ANSI
    #define BOARD_DISPLAY_USE_UART_ANSI 0
    #endif
    #ifndef BOARD_DISPLAY_USE_LCD
    #define BOARD_DISPLAY_USE_LCD 0
    #endif
    
    /*
     * This #if/#else is needed to workaround a problem with the
     * IAR compiler. The IAR compiler doesn't like the empty array
     * initialization. (IAR Error[Pe1345])
     */
    #if (BOARD_DISPLAY_USE_UART || BOARD_DISPLAY_USE_LCD)
    
    const Display_Config Display_config[] = {
    #if (BOARD_DISPLAY_USE_UART)
        {
    #  if (BOARD_DISPLAY_USE_UART_ANSI)
            .fxnTablePtr = &DisplayUartAnsi_fxnTable,
    #  else /* Default to minimal UART with no cursor placement */
            .fxnTablePtr = &DisplayUartMin_fxnTable,
    #  endif
            .object      = &displayUartObject,
            .hwAttrs     = &displayUartHWAttrs,
        },
    #endif
    #if (BOARD_DISPLAY_USE_LCD)
        {
            .fxnTablePtr = &DisplaySharp_fxnTable,
            .object      = &displaySharpObject,
            .hwAttrs     = &displaySharpHWattrs
        },
    #endif
    };
    
    const uint_least8_t Display_count = sizeof(Display_config) / sizeof(Display_Config);
    
    #else
    
    const Display_Config *Display_config = NULL;
    const uint_least8_t Display_count = 0;
    
    #endif /* (BOARD_DISPLAY_USE_UART || BOARD_DISPLAY_USE_LCD) */
    
    /*
     *  =============================== GPIO ===============================
     */
    #include <ti/drivers/GPIO.h>
    #include <ti/drivers/gpio/GPIOCC26XX.h>
    
    /*
     * Array of Pin configurations
     * NOTE: The order of the pin configurations must coincide with what was
     *       defined in CC1310_LAUNCHXL.h
     * NOTE: Pins not used for interrupts should be placed at the end of the
     *       array. Callback entries can be omitted from callbacks array to
     *       reduce memory usage.
     */
    GPIO_PinConfig gpioPinConfigs[] = {
        /* Input pins */
        GPIOCC26XX_DIO_13 | GPIO_DO_NOT_CONFIG,  /* Button 0 */
        GPIOCC26XX_DIO_14 | GPIO_DO_NOT_CONFIG,  /* Button 1 */
    
        GPIOCC26XX_DIO_15 | GPIO_DO_NOT_CONFIG,  /* CC1310_LAUNCHXL_SPI_MASTER_READY */
        GPIOCC26XX_DIO_21 | GPIO_DO_NOT_CONFIG,  /* CC1310_LAUNCHXL_SPI_SLAVE_READY */
    
        /* Output pins */
        GPIOCC26XX_DIO_07 | GPIO_DO_NOT_CONFIG,  /* Green LED */
        GPIOCC26XX_DIO_20 | GPIO_DO_NOT_CONFIG,  /* Red LED */ // WAS 6
        GPIOCC26XX_DIO_30 | GPIO_DO_NOT_CONFIG,  /* TMP116_EN */
    
        /* SPI Flash CSN */
        GPIOCC26XX_DIO_20 | GPIO_DO_NOT_CONFIG,
    
        /* SD CS */
        GPIOCC26XX_DIO_21 | GPIO_DO_NOT_CONFIG,
    
        /* Sharp Display - GPIO configurations will be done in the Display files */
        GPIOCC26XX_DIO_24 | GPIO_DO_NOT_CONFIG, /* SPI chip select */
        GPIOCC26XX_DIO_22 | GPIO_DO_NOT_CONFIG, /* LCD power control */
        GPIOCC26XX_DIO_23 | GPIO_DO_NOT_CONFIG, /*LCD enable */
    
    };
    
    /*
     * Array of callback function pointers
     * NOTE: The order of the pin configurations must coincide with what was
     *       defined in CC1310_LAUNCH.h
     * NOTE: Pins not used for interrupts can be omitted from callbacks array to
     *       reduce memory usage (if placed at end of gpioPinConfigs array).
     */
    GPIO_CallbackFxn gpioCallbackFunctions[] = {
        NULL,  /* Button 0 */
        NULL,  /* Button 1 */
        NULL,  /* CC1310_LAUNCHXL_SPI_MASTER_READY */
        NULL,  /* CC1310_LAUNCHXL_SPI_SLAVE_READY */
    };
    
    const GPIOCC26XX_Config GPIOCC26XX_config = {
        .pinConfigs = (GPIO_PinConfig *)gpioPinConfigs,
        .callbacks = (GPIO_CallbackFxn *)gpioCallbackFunctions,
        .numberOfPinConfigs = CC1310_LAUNCHXL_GPIOCOUNT,
        .numberOfCallbacks  = sizeof(gpioCallbackFunctions)/sizeof(GPIO_CallbackFxn),
        .intPriority = (~0)
    };
    
    /*
     *  =============================== GPTimer ===============================
     *  Remove unused entries to reduce flash usage both in Board.c and Board.h
     */
    #include <ti/drivers/timer/GPTimerCC26XX.h>
    
    GPTimerCC26XX_Object gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMERCOUNT];
    
    const GPTimerCC26XX_HWAttrs gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMERPARTSCOUNT] = {
        { .baseAddr = GPT0_BASE, .intNum = INT_GPT0A, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT0, .pinMux = GPT_PIN_0A, },
        { .baseAddr = GPT0_BASE, .intNum = INT_GPT0B, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT0, .pinMux = GPT_PIN_0B, },
        { .baseAddr = GPT1_BASE, .intNum = INT_GPT1A, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT1, .pinMux = GPT_PIN_1A, },
        { .baseAddr = GPT1_BASE, .intNum = INT_GPT1B, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT1, .pinMux = GPT_PIN_1B, },
        { .baseAddr = GPT2_BASE, .intNum = INT_GPT2A, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT2, .pinMux = GPT_PIN_2A, },
        { .baseAddr = GPT2_BASE, .intNum = INT_GPT2B, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT2, .pinMux = GPT_PIN_2B, },
        { .baseAddr = GPT3_BASE, .intNum = INT_GPT3A, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT3, .pinMux = GPT_PIN_3A, },
        { .baseAddr = GPT3_BASE, .intNum = INT_GPT3B, .intPriority = (~0), .powerMngrId = PowerCC26XX_PERIPH_GPT3, .pinMux = GPT_PIN_3B, },
    };
    
    const GPTimerCC26XX_Config GPTimerCC26XX_config[CC1310_LAUNCHXL_GPTIMERPARTSCOUNT] = {
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER0], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER0A], GPT_A },
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER0], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER0B], GPT_B },
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER1], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER1A], GPT_A },
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER1], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER1B], GPT_B },
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER2], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER2A], GPT_A },
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER2], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER2B], GPT_B },
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER3], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER3A], GPT_A },
        { &gptimerCC26XXObjects[CC1310_LAUNCHXL_GPTIMER3], &gptimerCC26xxHWAttrs[CC1310_LAUNCHXL_GPTIMER3B], GPT_B },
    };
    
    /*
     *  =============================== I2C ===============================
    */
    #include <ti/drivers/I2C.h>
    #include <ti/drivers/i2c/I2CCC26XX.h>
    
    I2CCC26XX_Object i2cCC26xxObjects[CC1310_LAUNCHXL_I2CCOUNT];
    
    const I2CCC26XX_HWAttrsV1 i2cCC26xxHWAttrs[CC1310_LAUNCHXL_I2CCOUNT] = {
        {
            .baseAddr    = I2C0_BASE,
            .powerMngrId = PowerCC26XX_PERIPH_I2C0,
            .intNum      = INT_I2C_IRQ,
            .intPriority = ~0,
            .swiPriority = 0,
            .sdaPin      = CC1310_LAUNCHXL_I2C0_SDA0,
            .sclPin      = CC1310_LAUNCHXL_I2C0_SCL0,
        }
    };
    
    const I2C_Config I2C_config[CC1310_LAUNCHXL_I2CCOUNT] = {
        {
            .fxnTablePtr = &I2CCC26XX_fxnTable,
            .object      = &i2cCC26xxObjects[CC1310_LAUNCHXL_I2C0],
            .hwAttrs     = &i2cCC26xxHWAttrs[CC1310_LAUNCHXL_I2C0]
        }
    };
    
    const uint_least8_t I2C_count = CC1310_LAUNCHXL_I2CCOUNT;
    
    /*
     *  =============================== I2S ===============================
    */
    #include <ti/drivers/I2S.h>
    #include <ti/drivers/i2s/I2SCC26XX.h>
    
    I2SCC26XX_Object i2sCC26XXObjects[CC1310_LAUNCHXL_I2SCOUNT];
    
    const I2SCC26XX_HWAttrs i2sCC26XXHWAttrs[CC1310_LAUNCHXL_I2SCOUNT] = {
        {
            .pinSD1      =  CC1310_LAUNCHXL_I2S_ADI,
            .pinSD0      =  CC1310_LAUNCHXL_I2S_ADO,
            .pinSCK      =  CC1310_LAUNCHXL_I2S_BCLK,
            .pinMCLK     =  CC1310_LAUNCHXL_I2S_MCLK,
            .pinWS       =  CC1310_LAUNCHXL_I2S_WCLK,
            .intPriority = ~0,
        }
    };
    
    const I2S_Config I2S_config[CC1310_LAUNCHXL_I2SCOUNT] = {
        {
            .object      = &i2sCC26XXObjects[CC1310_LAUNCHXL_I2S0],
            .hwAttrs     = &i2sCC26XXHWAttrs[CC1310_LAUNCHXL_I2S0]
        },
    };
    
    const uint_least8_t I2S_count = CC1310_LAUNCHXL_I2SCOUNT;
    
    /*
     *  =============================== NVS ===============================
     */
    #include <ti/drivers/NVS.h>
    #include <ti/drivers/nvs/NVSSPI25X.h>
    #include <ti/drivers/nvs/NVSCC26XX.h>
    
    #define NVS_REGIONS_BASE 0x1A000
    #define SECTORSIZE       0x1000
    #define REGIONSIZE       (SECTORSIZE * 4)
    
    #ifndef Board_EXCLUDE_NVS_INTERNAL_FLASH
    
    /*
     * Reserve flash sectors for NVS driver use by placing an uninitialized byte
     * array at the desired flash address.
     */
    #if defined(__TI_COMPILER_VERSION__)
    
    /*
     * Place uninitialized array at NVS_REGIONS_BASE
     */
    #pragma LOCATION(flashBuf, NVS_REGIONS_BASE);
    #pragma NOINIT(flashBuf);
    static char flashBuf[REGIONSIZE];
    
    #elif defined(__IAR_SYSTEMS_ICC__)
    
    /*
     * Place uninitialized array at NVS_REGIONS_BASE
     */
    static __no_init char flashBuf[REGIONSIZE] @ NVS_REGIONS_BASE;
    
    #elif defined(__GNUC__)
    
    /*
     * Place the flash buffers in the .nvs section created in the gcc linker file.
     * The .nvs section enforces alignment on a sector boundary but may
     * be placed anywhere in flash memory.  If desired the .nvs section can be set
     * to a fixed address by changing the following in the gcc linker file:
     *
     * .nvs (FIXED_FLASH_ADDR) (NOLOAD) : AT (FIXED_FLASH_ADDR) {
     *      *(.nvs)
     * } > REGION_TEXT
     */
    __attribute__ ((section (".nvs")))
    static char flashBuf[REGIONSIZE];
    
    #endif
    
    /* Allocate objects for NVS Internal Regions */
    NVSCC26XX_Object nvsCC26xxObjects[1];
    
    /* Hardware attributes for NVS Internal Regions */
    const NVSCC26XX_HWAttrs nvsCC26xxHWAttrs[1] = {
        {
            .regionBase = (void *)flashBuf,
            .regionSize = REGIONSIZE,
        },
    };
    
    #endif /* Board_EXCLUDE_NVS_INTERNAL_FLASH */
    
    #ifndef Board_EXCLUDE_NVS_EXTERNAL_FLASH
    
    #define SPISECTORSIZE    0x1000
    #define SPIREGIONSIZE    (SPISECTORSIZE * 32)
    #define VERIFYBUFSIZE    64
    
    static uint8_t verifyBuf[VERIFYBUFSIZE];
    
    /* Allocate objects for NVS External Regions */
    NVSSPI25X_Object nvsSPI25XObjects[1];
    
    /* Hardware attributes for NVS External Regions */
    const NVSSPI25X_HWAttrs nvsSPI25XHWAttrs[1] = {
        {
            .regionBaseOffset = 0,
            .regionSize = SPIREGIONSIZE,
            .sectorSize = SPISECTORSIZE,
            .verifyBuf = verifyBuf,
            .verifyBufSize = VERIFYBUFSIZE,
            .spiHandle = NULL,
            .spiIndex = 0,
            .spiBitRate = 4000000,
            .spiCsnGpioIndex = CC1310_LAUNCHXL_GPIO_SPI_FLASH_CS,
            .statusPollDelayUs = 100,
        },
    };
    
    #endif /* Board_EXCLUDE_NVS_EXTERNAL_FLASH */
    
    /* NVS Region index 0 and 1 refer to NVS and NVS SPI respectively */
    const NVS_Config NVS_config[CC1310_LAUNCHXL_NVSCOUNT] = {
    #ifndef Board_EXCLUDE_NVS_INTERNAL_FLASH
        {
            .fxnTablePtr = &NVSCC26XX_fxnTable,
            .object = &nvsCC26xxObjects[0],
            .hwAttrs = &nvsCC26xxHWAttrs[0],
        },
    #endif
    #ifndef Board_EXCLUDE_NVS_EXTERNAL_FLASH
        {
            .fxnTablePtr = &NVSSPI25X_fxnTable,
            .object = &nvsSPI25XObjects[0],
            .hwAttrs = &nvsSPI25XHWAttrs[0],
        },
    #endif
    };
    
    const uint_least8_t NVS_count = CC1310_LAUNCHXL_NVSCOUNT;
    
    /*
     *  =============================== PIN ===============================
     */
    #include <ti/drivers/PIN.h>
    #include <ti/drivers/pin/PINCC26XX.h>
    
    const PIN_Config BoardGpioInitTable[] = {
    
        CC1310_LAUNCHXL_PIN_RLED | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,       /* LED initially off          */
        CC1310_LAUNCHXL_PIN_GLED | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,       /* LED initially off          */
        CC1310_LAUNCHXL_PIN_BTN1 | PIN_INPUT_EN | PIN_PULLUP | PIN_IRQ_BOTHEDGES | PIN_HYSTERESIS,          /* Button is active low       */
        CC1310_LAUNCHXL_PIN_BTN2 | PIN_INPUT_EN | PIN_PULLUP | PIN_IRQ_BOTHEDGES | PIN_HYSTERESIS,          /* Button is active low       */
        CC1310_LAUNCHXL_SPI_FLASH_CS | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MIN,  /* External flash chip select */
        CC1310_LAUNCHXL_UART_RX | PIN_INPUT_EN | PIN_PULLDOWN,                                              /* UART RX via debugger back channel */
        CC1310_LAUNCHXL_UART_TX | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,                         /* UART TX via debugger back channel */
        CC1310_LAUNCHXL_SPI0_MOSI | PIN_INPUT_EN | PIN_PULLDOWN,                                            /* SPI master out - slave in */
        CC1310_LAUNCHXL_SPI0_MISO | PIN_INPUT_EN | PIN_PULLDOWN,                                            /* SPI master in - slave out */
        CC1310_LAUNCHXL_SPI0_CLK | PIN_INPUT_EN | PIN_PULLDOWN,                                             /* SPI clock */
    
        PIN_TERMINATE
    };
    
    const PINCC26XX_HWAttrs PINCC26XX_hwAttrs = {
        .intPriority = ~0,
        .swiPriority = 0
    };
    
    /*
     *  =============================== Power ===============================
     */
    #include <ti/drivers/Power.h>
    #include <ti/drivers/power/PowerCC26XX.h>
    
    const PowerCC26XX_Config PowerCC26XX_config = {
        .policyInitFxn      = NULL,
        .policyFxn          = &PowerCC26XX_standbyPolicy,
        .calibrateFxn       = &PowerCC26XX_calibrate,
        .enablePolicy       = true,
        .calibrateRCOSC_LF  = true,
        .calibrateRCOSC_HF  = true,
    };
    
    /*
     *  =============================== PWM ===============================
     *  Remove unused entries to reduce flash usage both in Board.c and Board.h
     */
    #include <ti/drivers/PWM.h>
    #include <ti/drivers/pwm/PWMTimerCC26XX.h>
    
    PWMTimerCC26XX_Object pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWMCOUNT];
    
    const PWMTimerCC26XX_HwAttrs pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWMCOUNT] = {
        { .pwmPin = CC1310_LAUNCHXL_PWMPIN0, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER0A },
        { .pwmPin = CC1310_LAUNCHXL_PWMPIN1, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER0B },
        { .pwmPin = CC1310_LAUNCHXL_PWMPIN2, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER1A },
        { .pwmPin = CC1310_LAUNCHXL_PWMPIN3, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER1B },
        { .pwmPin = CC1310_LAUNCHXL_PWMPIN4, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER2A },
        { .pwmPin = CC1310_LAUNCHXL_PWMPIN5, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER2B },
        { .pwmPin = CC1310_LAUNCHXL_PWMPIN6, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER3A },
       // { .pwmPin = CC1310_LAUNCHXL_PWMPIN7, .gpTimerUnit = CC1310_LAUNCHXL_GPTIMER3B },
    };
    
    const PWM_Config PWM_config[CC1310_LAUNCHXL_PWMCOUNT] = {
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM0], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM0] },
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM1], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM1] },
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM2], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM2] },
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM3], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM3] },
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM4], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM4] },
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM5], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM5] },
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM6], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM6] },
        { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[CC1310_LAUNCHXL_PWM7], &pwmtimerCC26xxHWAttrs[CC1310_LAUNCHXL_PWM7] },
    };
    
    const uint_least8_t PWM_count = CC1310_LAUNCHXL_PWMCOUNT;
    
    /*
     *  =============================== RF Driver ===============================
     */
    #include <ti/drivers/rf/RF.h>
    
    const RFCC26XX_HWAttrsV2 RFCC26XX_hwAttrs = {
        .hwiPriority        = ~0,       /* Lowest HWI priority */
        .swiPriority        = 0,        /* Lowest SWI priority */
        .xoscHfAlwaysNeeded = true,     /* Keep XOSC dependency while in standby */
        .globalCallback     = NULL,     /* No board specific callback */
        .globalEventMask    = 0         /* No events subscribed to */
    };
    
    /*
     *  =============================== SD ===============================
     */
    #include <ti/drivers/SD.h>
    #include <ti/drivers/sd/SDSPI.h>
    
    SDSPI_Object sdspiObjects[CC1310_LAUNCHXL_SDCOUNT];
    
    const SDSPI_HWAttrs sdspiHWAttrs[CC1310_LAUNCHXL_SDCOUNT] = {
        {
            .spiIndex = CC1310_LAUNCHXL_SPI0,
            .spiCsGpioIndex = CC1310_LAUNCHXL_SDSPI_CS
        }
    };
    
    const SD_Config SD_config[CC1310_LAUNCHXL_SDCOUNT] = {
        {
            .fxnTablePtr = &SDSPI_fxnTable,
            .object = &sdspiObjects[CC1310_LAUNCHXL_SDSPI0],
            .hwAttrs = &sdspiHWAttrs[CC1310_LAUNCHXL_SDSPI0]
        },
    };
    
    const uint_least8_t SD_count = CC1310_LAUNCHXL_SDCOUNT;
    
    /*
     *  =============================== SPI DMA ===============================
     */
    #include <ti/drivers/SPI.h>
    #include <ti/drivers/spi/SPICC26XXDMA.h>
    
    SPICC26XXDMA_Object spiCC26XXDMAObjects[CC1310_LAUNCHXL_SPICOUNT];
    
    /*
     * NOTE: The SPI instances below can be used by the SD driver to communicate
     * with a SD card via SPI.  The 'defaultTxBufValue' fields below are set to 0xFF
     * to satisfy the SDSPI driver requirement.
     */
    const SPICC26XXDMA_HWAttrsV1 spiCC26XXDMAHWAttrs[CC1310_LAUNCHXL_SPICOUNT] = {
        {
            .baseAddr           = SSI0_BASE,
            .intNum             = INT_SSI0_COMB,
            .intPriority        = ~0,
            .swiPriority        = 0,
            .powerMngrId        = PowerCC26XX_PERIPH_SSI0,
            .defaultTxBufValue  = 0xFF,
            .rxChannelBitMask   = 1<<UDMA_CHAN_SSI0_RX,
            .txChannelBitMask   = 1<<UDMA_CHAN_SSI0_TX,
            .mosiPin            = CC1310_LAUNCHXL_SPI0_MOSI,
            .misoPin            = CC1310_LAUNCHXL_SPI0_MISO,
            .clkPin             = CC1310_LAUNCHXL_SPI0_CLK,
            .csnPin             = CC1310_LAUNCHXL_SPI0_CSN,
            .minDmaTransferSize = 10
        },
        {
            .baseAddr           = SSI1_BASE,
            .intNum             = INT_SSI1_COMB,
            .intPriority        = ~0,
            .swiPriority        = 0,
            .powerMngrId        = PowerCC26XX_PERIPH_SSI1,
            .defaultTxBufValue  = 0xFF,
            .rxChannelBitMask   = 1<<UDMA_CHAN_SSI1_RX,
            .txChannelBitMask   = 1<<UDMA_CHAN_SSI1_TX,
            .mosiPin            = CC1310_LAUNCHXL_SPI1_MOSI,
            .misoPin            = CC1310_LAUNCHXL_SPI1_MISO,
            .clkPin             = CC1310_LAUNCHXL_SPI1_CLK,
            .csnPin             = CC1310_LAUNCHXL_SPI1_CSN,
            .minDmaTransferSize = 10
        }
    };
    
    const SPI_Config SPI_config[CC1310_LAUNCHXL_SPICOUNT] = {
        {
             .fxnTablePtr = &SPICC26XXDMA_fxnTable,
             .object      = &spiCC26XXDMAObjects[CC1310_LAUNCHXL_SPI0],
             .hwAttrs     = &spiCC26XXDMAHWAttrs[CC1310_LAUNCHXL_SPI0]
        },
        {
             .fxnTablePtr = &SPICC26XXDMA_fxnTable,
             .object      = &spiCC26XXDMAObjects[CC1310_LAUNCHXL_SPI1],
             .hwAttrs     = &spiCC26XXDMAHWAttrs[CC1310_LAUNCHXL_SPI1]
        },
    };
    
    const uint_least8_t SPI_count = CC1310_LAUNCHXL_SPICOUNT;
    
    /*
     *  =============================== UART ===============================
     */
    #include <ti/drivers/UART.h>
    #include <ti/drivers/uart/UARTCC26XX.h>
    
    UARTCC26XX_Object uartCC26XXObjects[CC1310_LAUNCHXL_UARTCOUNT];
    
    uint8_t uartCC26XXRingBuffer[CC1310_LAUNCHXL_UARTCOUNT][32];
    
    const UARTCC26XX_HWAttrsV2 uartCC26XXHWAttrs[CC1310_LAUNCHXL_UARTCOUNT] = {
        {
            .baseAddr       = UART0_BASE,
            .powerMngrId    = PowerCC26XX_PERIPH_UART0,
            .intNum         = INT_UART0_COMB,
            .intPriority    = ~0,
            .swiPriority    = 0,
            .txPin          = CC1310_LAUNCHXL_UART_TX,
            .rxPin          = CC1310_LAUNCHXL_UART_RX,
            .ctsPin         = PIN_UNASSIGNED,
            .rtsPin         = PIN_UNASSIGNED,
            .ringBufPtr     = uartCC26XXRingBuffer[CC1310_LAUNCHXL_UART0],
            .ringBufSize    = sizeof(uartCC26XXRingBuffer[CC1310_LAUNCHXL_UART0]),
            .txIntFifoThr   = UARTCC26XX_FIFO_THRESHOLD_1_8,
            .rxIntFifoThr   = UARTCC26XX_FIFO_THRESHOLD_4_8,
            .errorFxn       = NULL
        }
    };
    
    const UART_Config UART_config[CC1310_LAUNCHXL_UARTCOUNT] = {
        {
            .fxnTablePtr = &UARTCC26XX_fxnTable,
            .object      = &uartCC26XXObjects[CC1310_LAUNCHXL_UART0],
            .hwAttrs     = &uartCC26XXHWAttrs[CC1310_LAUNCHXL_UART0]
        },
    };
    
    const uint_least8_t UART_count = CC1310_LAUNCHXL_UARTCOUNT;
    
    /*
     *  =============================== UDMA ===============================
     */
    #include <ti/drivers/dma/UDMACC26XX.h>
    
    UDMACC26XX_Object udmaObjects[CC1310_LAUNCHXL_UDMACOUNT];
    
    const UDMACC26XX_HWAttrs udmaHWAttrs[CC1310_LAUNCHXL_UDMACOUNT] = {
        {
            .baseAddr    = UDMA0_BASE,
            .powerMngrId = PowerCC26XX_PERIPH_UDMA,
            .intNum      = INT_DMA_ERR,
            .intPriority = ~0
        }
    };
    
    const UDMACC26XX_Config UDMACC26XX_config[CC1310_LAUNCHXL_UDMACOUNT] = {
        {
             .object  = &udmaObjects[CC1310_LAUNCHXL_UDMA0],
             .hwAttrs = &udmaHWAttrs[CC1310_LAUNCHXL_UDMA0]
        },
    };
    
    /*
     *  =============================== Watchdog ===============================
     */
    #include <ti/drivers/Watchdog.h>
    #include <ti/drivers/watchdog/WatchdogCC26XX.h>
    
    WatchdogCC26XX_Object watchdogCC26XXObjects[CC1310_LAUNCHXL_WATCHDOGCOUNT];
    
    const WatchdogCC26XX_HWAttrs watchdogCC26XXHWAttrs[CC1310_LAUNCHXL_WATCHDOGCOUNT] = {
        {
            .baseAddr    = WDT_BASE,
            .reloadValue = 1000 /* Reload value in milliseconds */
        },
    };
    
    const Watchdog_Config Watchdog_config[CC1310_LAUNCHXL_WATCHDOGCOUNT] = {
        {
            .fxnTablePtr = &WatchdogCC26XX_fxnTable,
            .object      = &watchdogCC26XXObjects[CC1310_LAUNCHXL_WATCHDOG0],
            .hwAttrs     = &watchdogCC26XXHWAttrs[CC1310_LAUNCHXL_WATCHDOG0]
        },
    };
    
    const uint_least8_t Watchdog_count = CC1310_LAUNCHXL_WATCHDOGCOUNT;
    
    /*
     *  Board-specific initialization function to disable external flash.
     *  This function is defined in the file CC1310_LAUNCHXL_fxns.c
     */
    extern void Board_initHook(void);
    
    /*
     *  ======== CC1310_LAUNCHXL_initGeneral ========
     */
    void CC1310_LAUNCHXL_initGeneral(void)
    {
        Power_init();
    
        if (PIN_init(BoardGpioInitTable) != PIN_SUCCESS) {
            /* Error with PIN_init */
            while (1);
        }
    
        /* Perform board-specific initialization */
        Board_initHook();
    }
    
    /*
     *  ======== Board_init ========
     */
    void Board_init(void)
    {
        CC1310_LAUNCHXL_initGeneral();
    }
    

    /*
     * 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       CC1310_LAUNCHXL.h
     *
     *  @brief      CC1310 LaunchPad Board Specific header file.
     *
     *  The CC1310_LAUNCHXL header file should be included in an application as
     *  follows:
     *  @code
     *  #include "CC1310_LAUNCHXL.h"
     *  @endcode
     *
     *  ============================================================================
     */
    #ifndef __CC1310_LAUNCHXL_BOARD_H__
    #define __CC1310_LAUNCHXL_BOARD_H__
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    /* Includes */
    #include <ti/drivers/PIN.h>
    #include <ti/devices/cc13x0/driverlib/ioc.h>
    
    /* Externs */
    extern const PIN_Config BoardGpioInitTable[];
    
    /* Defines */
    #define CC1310_LAUNCHXL
    
    /* Mapping of pins to board signals using general board aliases
     *      <board signal alias>                  <pin mapping>   <comments>
     */
    
    /* Analog capable DIOs */
    #define CC1310_LAUNCHXL_DIO23_ANALOG          IOID_23
    #define CC1310_LAUNCHXL_DIO24_ANALOG          IOID_24
    #define CC1310_LAUNCHXL_DIO25_ANALOG          IOID_25
    #define CC1310_LAUNCHXL_DIO26_ANALOG          IOID_26
    #define CC1310_LAUNCHXL_DIO27_ANALOG          IOID_27
    #define CC1310_LAUNCHXL_DIO28_ANALOG          IOID_28
    #define CC1310_LAUNCHXL_DIO29_ANALOG          IOID_29
    #define CC1310_LAUNCHXL_DIO30_ANALOG          IOID_30
    
    /* Digital IOs */
    #define CC1310_LAUNCHXL_DIO0                  IOID_0
    #define CC1310_LAUNCHXL_DIO1                  IOID_1
    #define CC1310_LAUNCHXL_DIO12                PIN_UNASSIGNED // IOID_12
    #define CC1310_LAUNCHXL_DIO15                 IOID_15
    #define CC1310_LAUNCHXL_DIO16_TDO             IOID_16
    #define CC1310_LAUNCHXL_DIO17_TDI             IOID_17
    #define CC1310_LAUNCHXL_DIO21                 IOID_21
    #define CC1310_LAUNCHXL_DIO22                 IOID_22
    
    /* Discrete Inputs */
    #define CC1310_LAUNCHXL_PIN_BTN1              IOID_13
    #define CC1310_LAUNCHXL_PIN_BTN2              IOID_14
    
    /* GPIO */
    #define CC1310_LAUNCHXL_GPIO_LED_ON           1
    #define CC1310_LAUNCHXL_GPIO_LED_OFF          0
    
    /* I2C */
    #define CC1310_LAUNCHXL_I2C0_SCL0             IOID_4
    #define CC1310_LAUNCHXL_I2C0_SDA0             PIN_UNASSIGNED //IOID_5
    
    /* I2S */
    #define CC1310_LAUNCHXL_I2S_ADO               IOID_25
    #define CC1310_LAUNCHXL_I2S_ADI               IOID_26
    #define CC1310_LAUNCHXL_I2S_BCLK              IOID_27
    #define CC1310_LAUNCHXL_I2S_MCLK              PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_I2S_WCLK              IOID_28
    
    /* LEDs */
    #define CC1310_LAUNCHXL_PIN_LED_ON            1
    #define CC1310_LAUNCHXL_PIN_LED_OFF           0
    #define CC1310_LAUNCHXL_PIN_RLED              IOID_20 // WAS IOID_6
    #define CC1310_LAUNCHXL_PIN_GLED              IOID_7
    
    /* PWM Outputs */
    #define CC1310_LAUNCHXL_PWMPIN0               CC1310_LAUNCHXL_PIN_RLED
    #define CC1310_LAUNCHXL_PWMPIN1               CC1310_LAUNCHXL_PIN_GLED
    #define CC1310_LAUNCHXL_PWMPIN2               PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_PWMPIN3               PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_PWMPIN4               PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_PWMPIN5               PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_PWMPIN6               PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_PWMPIN7               PIN_UNASSIGNEDS
    
    /* SPI */
    #define CC1310_LAUNCHXL_SPI_FLASH_CS          IOID_5 // WAS IOID_20
    #define CC1310_LAUNCHXL_FLASH_CS_ON           0
    #define CC1310_LAUNCHXL_FLASH_CS_OFF          1
    
    /* SPI Board */
    #define CC1310_LAUNCHXL_SPI0_MISO             IOID_11     //WAS IOID_8        /* RF1.20 */
    #define CC1310_LAUNCHXL_SPI0_MOSI             IOID_6    //WAS IOID_9      /* RF1.18 */
    #define CC1310_LAUNCHXL_SPI0_CLK              IOID_12   //WAS IOID_10      /* RF1.16 */
    #define CC1310_LAUNCHXL_SPI0_CSN              IOID_5 // WAS IOID_11
    #define CC1310_LAUNCHXL_SPI1_MISO             PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_SPI1_MOSI             PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_SPI1_CLK              PIN_UNASSIGNED
    #define CC1310_LAUNCHXL_SPI1_CSN              PIN_UNASSIGNED
    
    /* UART Board */
    #define CC1310_LAUNCHXL_UART_RX               IOID_3 //was 2         /* RXD */
    #define CC1310_LAUNCHXL_UART_TX               IOID_2  //was 3        /* TXD */
    #define CC1310_LAUNCHXL_UART_CTS              IOID_19         /* CTS */
    #define CC1310_LAUNCHXL_UART_RTS              IOID_18         /* RTS */
    
    /*!
     *  @brief  Initialize the general board specific settings
     *
     *  This function initializes the general board specific settings.
     */
    void CC1310_LAUNCHXL_initGeneral(void);
    
    /*!
     *  @brief  Turn off the external flash on LaunchPads
     *
     */
    void CC1310_LAUNCHXL_shutDownExtFlash(void);
    
    /*!
     *  @brief  Wake up the external flash present on the board files
     *
     *  This function toggles the chip select for the amount of time needed
     *  to wake the chip up.
     */
    void CC1310_LAUNCHXL_wakeUpExtFlash(void);
    
    /*!
     *  @def    CC1310_LAUNCHXL_ADCBufName
     *  @brief  Enum of ADCBufs
     */
    typedef enum CC1310_LAUNCHXL_ADCBufName {
        CC1310_LAUNCHXL_ADCBUF0 = 0,
    
        CC1310_LAUNCHXL_ADCBUFCOUNT
    } CC1310_LAUNCHXL_ADCBufName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_ADCBuf0SourceName
     *  @brief  Enum of ADCBuf channels
     */
    typedef enum CC1310_LAUNCHXL_ADCBuf0ChannelName {
        CC1310_LAUNCHXL_ADCBUF0CHANNEL0 = 0,
        CC1310_LAUNCHXL_ADCBUF0CHANNEL1,
        CC1310_LAUNCHXL_ADCBUF0CHANNEL2,
        CC1310_LAUNCHXL_ADCBUF0CHANNEL3,
        CC1310_LAUNCHXL_ADCBUF0CHANNEL4,
        CC1310_LAUNCHXL_ADCBUF0CHANNEL5,
        CC1310_LAUNCHXL_ADCBUF0CHANNEL6,
        CC1310_LAUNCHXL_ADCBUF0CHANNEL7,
        CC1310_LAUNCHXL_ADCBUF0CHANNELVDDS,
        CC1310_LAUNCHXL_ADCBUF0CHANNELDCOUPL,
        CC1310_LAUNCHXL_ADCBUF0CHANNELVSS,
    
        CC1310_LAUNCHXL_ADCBUF0CHANNELCOUNT
    } CC1310_LAUNCHXL_ADCBuf0ChannelName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_ADCName
     *  @brief  Enum of ADCs
     */
    typedef enum CC1310_LAUNCHXL_ADCName {
        CC1310_LAUNCHXL_ADC0 = 0,
        CC1310_LAUNCHXL_ADC1,
        CC1310_LAUNCHXL_ADC2,
        CC1310_LAUNCHXL_ADC3,
        CC1310_LAUNCHXL_ADC4,
        CC1310_LAUNCHXL_ADC5,
        CC1310_LAUNCHXL_ADC6,
        CC1310_LAUNCHXL_ADC7,
        CC1310_LAUNCHXL_ADCDCOUPL,
        CC1310_LAUNCHXL_ADCVSS,
        CC1310_LAUNCHXL_ADCVDDS,
    
        CC1310_LAUNCHXL_ADCCOUNT
    } CC1310_LAUNCHXL_ADCName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_CryptoName
     *  @brief  Enum of Crypto names
     */
    typedef enum CC1310_LAUNCHXL_CryptoName {
        CC1310_LAUNCHXL_CRYPTO0 = 0,
    
        CC1310_LAUNCHXL_CRYPTOCOUNT
    } CC1310_LAUNCHXL_CryptoName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_AESCCMName
     *  @brief  Enum of AESCCM names
     */
    typedef enum CC1310_LAUNCHXL_AESCCMName {
        CC1310_LAUNCHXL_AESCCM0 = 0,
    
        CC1310_LAUNCHXL_AESCCMCOUNT
    } CC1310_LAUNCHXL_AESCCMName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_AESGCMName
     *  @brief  Enum of AESGCM names
     */
    typedef enum CC1310_LAUNCHXL_AESGCMName {
        CC1310_LAUNCHXL_AESGCM0 = 0,
    
        CC1310_LAUNCHXL_AESGCMCOUNT
    } CC1310_LAUNCHXL_AESGCMName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_AESCBCName
     *  @brief  Enum of AESCBC names
     */
    typedef enum CC1310_LAUNCHXL_AESCBCName {
        CC1310_LAUNCHXL_AESCBC0 = 0,
    
        CC1310_LAUNCHXL_AESCBCCOUNT
    } CC1310_LAUNCHXL_AESCBCName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_AESCTRName
     *  @brief  Enum of AESCTR names
     */
    typedef enum CC1310_LAUNCHXL_AESCTRName {
        CC1310_LAUNCHXL_AESCTR0 = 0,
    
        CC1310_LAUNCHXL_AESCTRCOUNT
    } CC1310_LAUNCHXL_AESCTRName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_AESECBName
     *  @brief  Enum of AESECB names
     */
    typedef enum CC1310_LAUNCHXL_AESECBName {
        CC1310_LAUNCHXL_AESECB0 = 0,
    
        CC1310_LAUNCHXL_AESECBCOUNT
    } CC1310_LAUNCHXL_AESECBName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_AESCTRDRBGName
     *  @brief  Enum of AESCTRDRBG names
     */
    typedef enum CC1310_LAUNCHXL_AESCTRDRBGName {
        CC1310_LAUNCHXL_AESCTRDRBG0 = 0,
    
        CC1310_LAUNCHXL_AESCTRDRBGCOUNT
    } CC1310_LAUNCHXL_AESCTRDRBGName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_TRNGName
     *  @brief  Enum of TRNG names
     */
    typedef enum CC1310_LAUNCHXL_TRNGName {
        CC1310_LAUNCHXL_TRNG0 = 0,
    
        CC1310_LAUNCHXL_TRNGCOUNT
    } CC1310_LAUNCHXL_TRNGName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_GPIOName
     *  @brief  Enum of GPIO names
     */
    typedef enum CC1310_LAUNCHXL_GPIOName {
        CC1310_LAUNCHXL_GPIO_S1 = 0,
        CC1310_LAUNCHXL_GPIO_S2,
        CC1310_LAUNCHXL_SPI_MASTER_READY,
        CC1310_LAUNCHXL_SPI_SLAVE_READY,
        CC1310_LAUNCHXL_GPIO_LED_GREEN,
        CC1310_LAUNCHXL_GPIO_LED_RED,
        CC1310_LAUNCHXL_GPIO_TMP116_EN,
        CC1310_LAUNCHXL_GPIO_SPI_FLASH_CS,
        CC1310_LAUNCHXL_SDSPI_CS,
        CC1310_LAUNCHXL_GPIO_LCD_CS,
        CC1310_LAUNCHXL_GPIO_LCD_POWER,
        CC1310_LAUNCHXL_GPIO_LCD_ENABLE,
        CC1310_LAUNCHXL_GPIOCOUNT
    } CC1310_LAUNCHXL_GPIOName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_GPTimerName
     *  @brief  Enum of GPTimer parts
     */
    typedef enum CC1310_LAUNCHXL_GPTimerName {
        CC1310_LAUNCHXL_GPTIMER0A = 0,
        CC1310_LAUNCHXL_GPTIMER0B,
        CC1310_LAUNCHXL_GPTIMER1A,
        CC1310_LAUNCHXL_GPTIMER1B,
        CC1310_LAUNCHXL_GPTIMER2A,
        CC1310_LAUNCHXL_GPTIMER2B,
        CC1310_LAUNCHXL_GPTIMER3A,
        CC1310_LAUNCHXL_GPTIMER3B,
    
        CC1310_LAUNCHXL_GPTIMERPARTSCOUNT
    } CC1310_LAUNCHXL_GPTimerName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_GPTimers
     *  @brief  Enum of GPTimers
     */
    typedef enum CC1310_LAUNCHXL_GPTimers {
        CC1310_LAUNCHXL_GPTIMER0 = 0,
        CC1310_LAUNCHXL_GPTIMER1,
        CC1310_LAUNCHXL_GPTIMER2,
        CC1310_LAUNCHXL_GPTIMER3,
    
        CC1310_LAUNCHXL_GPTIMERCOUNT
    } CC1310_LAUNCHXL_GPTimers;
    
    /*!
     *  @def    CC1310_LAUNCHXL_I2CName
     *  @brief  Enum of I2C names
     */
    typedef enum CC1310_LAUNCHXL_I2CName {
        CC1310_LAUNCHXL_I2C0 = 0,
    
        CC1310_LAUNCHXL_I2CCOUNT
    } CC1310_LAUNCHXL_I2CName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_I2SName
     *  @brief  Enum of I2S names
     */
    typedef enum CC1310_LAUNCHXL_I2SName {
        CC1310_LAUNCHXL_I2S0 = 0,
    
        CC1310_LAUNCHXL_I2SCOUNT
    } CC1310_LAUNCHXL_I2SName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_NVSName
     *  @brief  Enum of NVS names
     */
    typedef enum CC1310_LAUNCHXL_NVSName {
    #ifndef Board_EXCLUDE_NVS_INTERNAL_FLASH
        CC1310_LAUNCHXL_NVSCC26XX0 = 0,
    #endif
    #ifndef Board_EXCLUDE_NVS_EXTERNAL_FLASH
        CC1310_LAUNCHXL_NVSSPI25X0,
    #endif
    
        CC1310_LAUNCHXL_NVSCOUNT
    } CC1310_LAUNCHXL_NVSName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_PWM
     *  @brief  Enum of PWM outputs
     */
    typedef enum CC1310_LAUNCHXL_PWMName {
        CC1310_LAUNCHXL_PWM0 = 0,
        CC1310_LAUNCHXL_PWM1,
        CC1310_LAUNCHXL_PWM2,
        CC1310_LAUNCHXL_PWM3,
        CC1310_LAUNCHXL_PWM4,
        CC1310_LAUNCHXL_PWM5,
        CC1310_LAUNCHXL_PWM6,
        CC1310_LAUNCHXL_PWM7,
    
        CC1310_LAUNCHXL_PWMCOUNT
    } CC1310_LAUNCHXL_PWMName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_SDName
     *  @brief  Enum of SD names
     */
    typedef enum CC1310_LAUNCHXL_SDName {
    
        CC1310_LAUNCHXL_SDSPI0 = 0  ,
    
        CC1310_LAUNCHXL_SDCOUNT
    } CC1310_LAUNCHXL_SDName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_SPIName
     *  @brief  Enum of SPI names
     */
    typedef enum CC1310_LAUNCHXL_SPIName {
        CC1310_LAUNCHXL_SPI0 = 0,
        CC1310_LAUNCHXL_SPI1,
    
        CC1310_LAUNCHXL_SPICOUNT
    } CC1310_LAUNCHXL_SPIName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_UARTName
     *  @brief  Enum of UARTs
     */
    typedef enum CC1310_LAUNCHXL_UARTName {
        CC1310_LAUNCHXL_UART0 = 0,
    
        CC1310_LAUNCHXL_UARTCOUNT
    } CC1310_LAUNCHXL_UARTName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_UDMAName
     *  @brief  Enum of DMA buffers
     */
    typedef enum CC1310_LAUNCHXL_UDMAName {
        CC1310_LAUNCHXL_UDMA0 = 0,
    
        CC1310_LAUNCHXL_UDMACOUNT
    } CC1310_LAUNCHXL_UDMAName;
    
    /*!
     *  @def    CC1310_LAUNCHXL_WatchdogName
     *  @brief  Enum of Watchdogs
     */
    typedef enum CC1310_LAUNCHXL_WatchdogName {
        CC1310_LAUNCHXL_WATCHDOG0 = 0,
    
        CC1310_LAUNCHXL_WATCHDOGCOUNT
    } CC1310_LAUNCHXL_WatchdogName;
    
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif /* __CC1310_LAUNCHXL_BOARD_H__ */
    

    再次感谢!

    Mirte H

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您是否尝试进入 sd_initialize()并确定返回-1的内容?  

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好,Ter:

    我进入sd_initialize(),发现在SDSPI.C中,它将SD卡置于空闲SPI模式的函数返回-1。 这是代码的第一部分,它实际上使用SPI与SD卡通信,所以我认为这是硬件问题。 看着我的针脚,我翻转了Miso和MOSI进行检查。 这解决了这个问题,这很奇怪,因为我几乎是肯定的,我第一次就正确地定义了这些问题。 哦,现在就能用了! 感谢你的帮助

    此致,  

    Mirte H