led ok

simplelink/ble_sdk_2_02_02_25/src/boards/BOOSTXL_CC2650MA/BOOSTXL_CC2650MA.c

@@ -193,49 +193,49 @@ const UDMACC26XX_Config UDMACC26XX_config[] = {
  *  ========================== SPI DMA begin ===================================
  */
 /* Place into subsections to allow the TI linker to remove items properly */
-// #if defined(__TI_COMPILER_VERSION__)
-// #pragma DATA_SECTION(SPI_config, ".const:SPI_config")
-// #pragma DATA_SECTION(spiCC26XXDMAHWAttrs, ".const:spiCC26XXDMAHWAttrs")
-// #endif
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(SPI_config, ".const:SPI_config")
+#pragma DATA_SECTION(spiCC26XXDMAHWAttrs, ".const:spiCC26XXDMAHWAttrs")
+#endif
 
-// /* Include drivers */
-// #include <ti/drivers/spi/SPICC26XXDMA.h>
+/* Include drivers */
+#include <ti/drivers/spi/SPICC26XXDMA.h>
 
-// /* SPI objects */
-// SPICC26XXDMA_Object spiCC26XXDMAObjects[BOOSTXL_CC2650MA_SPICOUNT];
+/* SPI objects */
+SPICC26XXDMA_Object spiCC26XXDMAObjects[BOOSTXL_CC2650MA_SPICOUNT];
 
-// /* SPI configuration structure, describing which pins are to be used */
-// const SPICC26XXDMA_HWAttrsV1 spiCC26XXDMAHWAttrs[BOOSTXL_CC2650MA_UDMACOUNT] = {
-//     {
-//         .baseAddr           = SSI0_BASE,
-//         .intNum             = INT_SSI0_COMB,
-//         .intPriority        = ~0,
-//         .swiPriority        = 0,
-//         .powerMngrId        = PowerCC26XX_PERIPH_SSI0,
-//         .defaultTxBufValue  = 0,
-//         .rxChannelBitMask   = 1<<UDMA_CHAN_SSI0_RX,
-//         .txChannelBitMask   = 1<<UDMA_CHAN_SSI0_TX,
-//         .mosiPin            = Board_SPI0_MOSI,
-//         .misoPin            = Board_SPI0_MISO,
-//         .clkPin             = Board_SPI0_CLK,
-//         .csnPin             = Board_SPI0_CS
-//     },
-// };
+/* SPI configuration structure, describing which pins are to be used */
+const SPICC26XXDMA_HWAttrsV1 spiCC26XXDMAHWAttrs[BOOSTXL_CC2650MA_UDMACOUNT] = {
+    {
+        .baseAddr           = SSI0_BASE,
+        .intNum             = INT_SSI0_COMB,
+        .intPriority        = ~0,
+        .swiPriority        = 0,
+        .powerMngrId        = PowerCC26XX_PERIPH_SSI0,
+        .defaultTxBufValue  = 0,
+        .rxChannelBitMask   = 1<<UDMA_CHAN_SSI0_RX,
+        .txChannelBitMask   = 1<<UDMA_CHAN_SSI0_TX,
+        .mosiPin            = Board_SPI0_MOSI,
+        .misoPin            = Board_SPI0_MISO,
+        .clkPin             = Board_SPI0_CLK,
+        .csnPin             = Board_SPI0_CS
+    },
+};
 
-// /* SPI configuration structure */
-// const SPI_Config SPI_config[] = {
-//     {
-//          .fxnTablePtr = &SPICC26XXDMA_fxnTable,
-//          .object      = &spiCC26XXDMAObjects[0],
-//          .hwAttrs     = &spiCC26XXDMAHWAttrs[0]
-//     },
-//     {
-//          .fxnTablePtr = &SPICC26XXDMA_fxnTable,
-//          .object      = &spiCC26XXDMAObjects[1],
-//          .hwAttrs     = &spiCC26XXDMAHWAttrs[1]
-//     },
-//     {NULL, NULL, NULL}
-// };
+/* SPI configuration structure */
+const SPI_Config SPI_config[] = {
+    {
+         .fxnTablePtr = &SPICC26XXDMA_fxnTable,
+         .object      = &spiCC26XXDMAObjects[0],
+         .hwAttrs     = &spiCC26XXDMAHWAttrs[0]
+    },
+    {
+         .fxnTablePtr = &SPICC26XXDMA_fxnTable,
+         .object      = &spiCC26XXDMAObjects[1],
+         .hwAttrs     = &spiCC26XXDMAHWAttrs[1]
+    },
+    {NULL, NULL, NULL}
+};
 /*
  *  ========================== SPI DMA end =====================================
 */

simplelink/ble_sdk_2_02_02_25/src/boards/BOOSTXL_CC2650MA/BOOSTXL_CC2650MA.h

@@ -89,24 +89,24 @@ extern const PIN_Config BoardGpioInitTable[];
 */
 
 /* Connector J1 */
-#define Board_BP_Pin_J1_2              IOID_UNUSED
+#define Board_BP_Pin_J1_2              DIO7
 #define Board_BP_Pin_J1_3              DIO0
 #define Board_BP_Pin_J1_4              DIO1
 #define Board_BP_Pin_J1_5              DIO2
 #define Board_BP_Pin_J1_6              DIO3
-#define Board_BP_Pin_J1_7              DIO11        /* SCLK */
+#define Board_BP_Pin_J1_7              DIO10
 #define Board_BP_Pin_J1_8              DIO4
 #define Board_BP_Pin_J1_9              DIO5
 #define Board_BP_Pin_J1_10             DIO6
 
 /* Connector J2 */
-#define Board_BP_Pin_J2_19             IOID_UNUSED
-#define Board_BP_Pin_J2_18             IOID_UNUSED
+#define Board_BP_Pin_J2_19             DIO8
+#define Board_BP_Pin_J2_18             DIO9          /* CS */
 #define Board_BP_Pin_J2_17             IOID_UNUSED   /* NC */
-#define Board_BP_Pin_J2_15             DIO8         /* MOSI */
-#define Board_BP_Pin_J2_14             DIO7         /* MISO */
-#define Board_BP_Pin_J2_13             DIO9         /* DAC_CS */
-#define Board_BP_Pin_J2_12             DIO12        /* ADC_CS */
+#define Board_BP_Pin_J2_15             DIO11         /* MOSI */
+#define Board_BP_Pin_J2_14             DIO12         /* MISO */
+#define Board_BP_Pin_J2_13             DIO13
+#define Board_BP_Pin_J2_12             DIO14
 #define Board_BP_Pin_J2_11             IOID_UNUSED   /* NC */
 
 /* Mapping of BoosterPack Connector Pins to BoosterPack Standard Functions (reflecting the BoosterPack Standard)
@@ -125,12 +125,12 @@ extern const PIN_Config BoardGpioInitTable[];
 
 /* Connector J2 */
 #define Board_BP_PWM_0                 Board_BP_Pin_J2_19
-#define Board_BP_SPI_CS_Wireless       PIN_UNASSIGNED
+#define Board_BP_SPI_CS_Wireless       Board_BP_Pin_J2_18
 #define Board_BP_GPIO_3                Board_BP_Pin_J2_17
 #define Board_BP_SPI_MOSI              Board_BP_Pin_J2_15
 #define Board_BP_SPI_MISO              Board_BP_Pin_J2_14
-#define Board_BP_SPI_CS_Display        PIN_UNASSIGNED
-#define Board_BP_SPI_CS_Other          PIN_UNASSIGNED
+#define Board_BP_SPI_CS_Display        Board_BP_Pin_J2_13
+#define Board_BP_SPI_CS_Other          Board_BP_Pin_J2_12
 #define Board_BP_GPIO_2                Board_BP_Pin_J2_11
 
 
@@ -145,11 +145,11 @@ extern const PIN_Config BoardGpioInitTable[];
 #define Board_UART_TX                  Board_BP_UART_Rx          /* RXD */
 #define Board_UART_RX                  Board_BP_UART_Tx          /* TXD */
 
-
-
-//#define Board_SPI0_MISO                PIN_UNASSIGNED
-//#define Board_SPI0_MOSI                PIN_UNASSIGNED
-
+/* SPI Board */
+#define Board_SPI0_MISO                Board_BP_SPI_MISO
+#define Board_SPI0_MOSI                Board_BP_SPI_MOSI
+#define Board_SPI0_CLK                 Board_BP_SPI_CLK
+#define Board_SPI0_CS                  Board_BP_SPI_CS_Wireless
 
 /* Power Management Board */
 #define Board_SRDY                     Board_BP_Pin_J2_19
@@ -170,7 +170,6 @@ extern const PIN_Config BoardGpioInitTable[];
  *  ==========================================================================*/
 /* Generic SPI instance identifiers */
 #define Board_SPI0                  BOOSTXL_CC2650MA_SPI0
-#define Board_SPI1                  BOOSTXL_CC2650MA_SPI1
 /* Generic UART instance identifiers */
 #define Board_UART                  BOOSTXL_CC2650MA_UART0
 /* Generic TRNG instance identiifer */
@@ -209,7 +208,15 @@ typedef enum BOOSTXL_CC2650MA_CryptoName {
 } BOOSTXL_CC2650MA_CryptoName;
 
 
+/*!
+ *  @def    BOOSTXL_CC2650MA_SPIName
+ *  @brief  Enum of SPI names on the CC2650 Booster Pack
+ */
+typedef enum BOOSTXL_CC2650MA_SPIName {
+    BOOSTXL_CC2650MA_SPI0 = 0,
 
+    BOOSTXL_CC2650MA_SPICOUNT
+} BOOSTXL_CC2650MA_SPIName;
 
 /*!
  *  @def    BOOSTXL_CC2650MA_TRNGName

simplelink/ble_sdk_2_02_02_25/src/boards/BOOSTXL_CC2650MA_ELITE_EIS_1_1/BOOSTXL_CC2650MA_ELITE_EIS_1_1.c

@@ -0,0 +1,448 @@
+/*
+ * Copyright (c) 2016, 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.
+ */
+
+/*
+ *  ====================== BOOSTXL_CC2650MA.c ===================================
+ *  This file is responsible for setting up the board specific items for the
+ *  CC2650 Booster Pack.
+ */
+
+
+/*
+ *  ====================== Includes ============================================
+ */
+#include <xdc/std.h>
+#include <xdc/runtime/System.h>
+
+#include <ti/sysbios/family/arm/m3/Hwi.h>
+#include <ti/drivers/PIN.h>
+#include <ti/drivers/pin/PINCC26XX.h>
+#include <ti/drivers/PWM.h>
+#include <ti/drivers/pwm/PWMTimerCC26XX.h>
+#include <ti/drivers/timer/GPTimerCC26XX.h>
+#include <ti/drivers/Power.h>
+#include <ti/drivers/power/PowerCC26XX.h>
+
+#include <inc/hw_memmap.h>
+#include <inc/hw_ints.h>
+#include <driverlib/ioc.h>
+#include <driverlib/udma.h>
+
+#include "Board.h"
+
+/*
+ *  ========================= IO driver initialization =========================
+ *  From main, PIN_init(BoardGpioInitTable) should be called to setup safe
+ *  settings for this board.
+ *  When a pin is allocated and then de-allocated, it will revert to the state
+ *  configured in this table.
+*/
+
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(BoardGpioInitTable, ".const:BoardGpioInitTable")
+#pragma DATA_SECTION(PINCC26XX_hwAttrs, ".const:PINCC26XX_hwAttrs")
+#endif
+
+const PIN_Config BoardGpioInitTable[] = {
+    Board_RLED   | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,         /* LED initially off             */
+    Board_GLED   | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,         /* LED initially off             */
+    Board_UART_RX | PIN_INPUT_EN | PIN_PULLDOWN,                                              /* UART RX  */
+    Board_UART_TX | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL,                        /* UART TX */
+    Board_SRDY | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL,                           /* SRDY */
+    Board_MRDY | PIN_INPUT_EN | PIN_PULLDOWN,                                                 /* MRDY */
+    PIN_TERMINATE
+};
+
+/* EIS pin config */
+const PIN_Config EIS_1_1_BoardGpioInitTable[] = {
+    Board_5V_enable | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,    /* Board_5V_enable -> DIO9 */
+    Board_AD_CS | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,       /* Board_AD_CS -> DIO10 */
+    Board_AD_RST | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,      /* Board_AD_RST -> DIO13 */
+    Board_SHUT_DOWN | PIN_INPUT_EN | PIN_PULLDOWN,                                          /* Board_SHUT_DOWN -> DIO14 */
+    PIN_TERMINATE
+};
+
+const PINCC26XX_HWAttrs PINCC26XX_hwAttrs = {
+    .intPriority = ~0,
+    .swiPriority = 0
+};
+/*============================================================================*/
+
+/*
+ *  ============================= Power begin ==================================
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(PowerCC26XX_config, ".const:PowerCC26XX_config")
+#endif
+const PowerCC26XX_Config PowerCC26XX_config = {
+    .policyInitFxn      = NULL,
+    .policyFxn          = &PowerCC26XX_standbyPolicy,
+    .calibrateFxn       = &PowerCC26XX_calibrate,
+    .enablePolicy       = TRUE,
+    .calibrateRCOSC_LF  = TRUE,
+    .calibrateRCOSC_HF  = TRUE,
+};
+/*
+ *  ============================= Power end ====================================
+ */
+
+/*
+ *  ============================= UART begin ===================================
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(UART_config, ".const:UART_config")
+#pragma DATA_SECTION(uartCC26XXHWAttrs, ".const:uartCC26XXHWAttrs")
+#endif
+
+/* Include drivers */
+#include <ti/drivers/UART.h>
+#include <ti/drivers/uart/UARTCC26XX.h>
+
+/* UART objects */
+UARTCC26XX_Object uartCC26XXObjects[BOOSTXL_CC2650MA_UARTCOUNT];
+
+/* UART hardware parameter structure, also used to assign UART pins */
+const UARTCC26XX_HWAttrsV2 uartCC26XXHWAttrs[BOOSTXL_CC2650MA_UARTCOUNT] = {
+    {
+        .baseAddr       = UART0_BASE,
+        .powerMngrId    = PowerCC26XX_PERIPH_UART0,
+        .intNum         = INT_UART0_COMB,
+        .intPriority    = ~0,
+        .swiPriority    = 0,
+        .txPin          = Board_UART_TX,
+        .rxPin          = Board_UART_RX,
+        .ctsPin         = PIN_UNASSIGNED,
+        .rtsPin         = PIN_UNASSIGNED
+    }
+};
+
+/* UART configuration structure */
+const UART_Config UART_config[] = {
+    {
+        .fxnTablePtr = &UARTCC26XX_fxnTable,
+        .object      = &uartCC26XXObjects[0],
+        .hwAttrs     = &uartCC26XXHWAttrs[0]
+    },
+    {NULL, NULL, NULL}
+};
+/*
+ *  ============================= UART end =====================================
+ */
+
+/*
+ *  ============================= UDMA begin ===================================
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(UDMACC26XX_config, ".const:UDMACC26XX_config")
+#pragma DATA_SECTION(udmaHWAttrs, ".const:udmaHWAttrs")
+#endif
+
+/* Include drivers */
+#include <ti/drivers/dma/UDMACC26XX.h>
+
+/* UDMA objects */
+UDMACC26XX_Object udmaObjects[BOOSTXL_CC2650MA_UDMACOUNT];
+
+/* UDMA configuration structure */
+const UDMACC26XX_HWAttrs udmaHWAttrs[BOOSTXL_CC2650MA_UDMACOUNT] = {
+    {
+        .baseAddr    = UDMA0_BASE,
+        .powerMngrId = PowerCC26XX_PERIPH_UDMA,
+        .intNum      = INT_DMA_ERR,
+        .intPriority = ~0
+    }
+};
+
+/* UDMA configuration structure */
+const UDMACC26XX_Config UDMACC26XX_config[] = {
+    {
+         .object  = &udmaObjects[0],
+         .hwAttrs = &udmaHWAttrs[0]
+    },
+    {NULL, NULL}
+};
+/*
+ *  ============================= UDMA end =====================================
+ */
+
+/*
+ *  ========================== SPI DMA begin ===================================
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(SPI_config, ".const:SPI_config")
+#pragma DATA_SECTION(spiCC26XXDMAHWAttrs, ".const:spiCC26XXDMAHWAttrs")
+#endif
+
+/* Include drivers */
+#include <ti/drivers/spi/SPICC26XXDMA.h>
+
+/* SPI objects */
+SPICC26XXDMA_Object spiCC26XXDMAObjects[BOOSTXL_CC2650MA_SPICOUNT];
+
+/* SPI configuration structure, describing which pins are to be used */
+const SPICC26XXDMA_HWAttrsV1 spiCC26XXDMAHWAttrs[BOOSTXL_CC2650MA_SPICOUNT] = {
+    {
+        .baseAddr           = SSI0_BASE,
+        .intNum             = INT_SSI0_COMB,
+        .intPriority        = ~0,
+        .swiPriority        = 0,
+        .powerMngrId        = PowerCC26XX_PERIPH_SSI0,
+        .defaultTxBufValue  = 0,
+        .rxChannelBitMask   = 1<<UDMA_CHAN_SSI0_RX,
+        .txChannelBitMask   = 1<<UDMA_CHAN_SSI0_TX,
+        .mosiPin            = Board_SPI0_MOSI,
+        .misoPin            = Board_SPI0_MISO,
+        .clkPin             = Board_SPI0_CLK,
+        .csnPin             = Board_SPI0_CS
+    },
+    {
+        .baseAddr           = SSI1_BASE,
+        .intNum             = INT_SSI1_COMB,
+        .intPriority        = ~0,
+        .swiPriority        = 0,
+        .powerMngrId        = PowerCC26XX_PERIPH_SSI1,
+        .defaultTxBufValue  = 0,
+        .rxChannelBitMask   = 1<<UDMA_CHAN_SSI1_RX,
+        .txChannelBitMask   = 1<<UDMA_CHAN_SSI1_TX,
+        .mosiPin            = Board_SPI1_MOSI,
+        .misoPin            = Board_SPI1_MISO,
+        .clkPin             = Board_SPI1_CLK,
+        .csnPin             = Board_SPI1_CS
+    },
+};
+
+/* SPI configuration structure */
+const SPI_Config SPI_config[] = {
+    {
+         .fxnTablePtr = &SPICC26XXDMA_fxnTable,
+         .object      = &spiCC26XXDMAObjects[0],
+         .hwAttrs     = &spiCC26XXDMAHWAttrs[0]
+    },
+    {
+         .fxnTablePtr = &SPICC26XXDMA_fxnTable,
+         .object      = &spiCC26XXDMAObjects[1],
+         .hwAttrs     = &spiCC26XXDMAHWAttrs[1]
+    },
+    {NULL, NULL, NULL}
+};
+/*
+ *  ========================== SPI DMA end =====================================
+*/
+
+
+/*
+ *  ========================== Crypto begin ====================================
+ *  NOTE: The Crypto implementation should be considered experimental
+ *        and not validated!
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(CryptoCC26XX_config, ".const:CryptoCC26XX_config")
+#pragma DATA_SECTION(cryptoCC26XXHWAttrs, ".const:cryptoCC26XXHWAttrs")
+#endif
+
+/* Include drivers */
+#include <ti/drivers/crypto/CryptoCC26XX.h>
+
+/* Crypto objects */
+CryptoCC26XX_Object cryptoCC26XXObjects[BOOSTXL_CC2650MA_CRYPTOCOUNT];
+
+/* Crypto configuration structure, describing which pins are to be used */
+const CryptoCC26XX_HWAttrs cryptoCC26XXHWAttrs[BOOSTXL_CC2650MA_CRYPTOCOUNT] = {
+    {
+        .baseAddr       = CRYPTO_BASE,
+        .powerMngrId    = PowerCC26XX_PERIPH_CRYPTO,
+        .intNum         = INT_CRYPTO_RESULT_AVAIL_IRQ,
+        .intPriority    = ~0,
+    }
+};
+
+/* Crypto configuration structure */
+const CryptoCC26XX_Config CryptoCC26XX_config[] = {
+    {
+         .object  = &cryptoCC26XXObjects[0],
+         .hwAttrs = &cryptoCC26XXHWAttrs[0]
+    },
+    {NULL, NULL}
+};
+/*
+ *  ========================== Crypto end ======================================
+ */
+
+
+/*
+ *  ========================= RF driver begin ==================================
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(RFCC26XX_hwAttrs, ".const:RFCC26XX_hwAttrs")
+#endif
+
+/* Include drivers */
+#include <ti/drivers/rf/RF.h>
+
+/* RF hwi and swi priority */
+const RFCC26XX_HWAttrs RFCC26XX_hwAttrs = {
+    .hwiCpe0Priority = ~0,
+    .hwiHwPriority   = ~0,
+    .swiCpe0Priority =  5,
+    .swiHwPriority   =  5,
+};
+
+/*
+ *  ========================== RF driver end ===================================
+ */
+
+/*
+ *  ========================= TRNG begin ====================================
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(TRNGCC26XX_config, ".const:TRNGCC26XX_config")
+#pragma DATA_SECTION(TRNGCC26XXHWAttrs, ".const:TRNGCC26XXHWAttrs")
+#endif
+
+/* Include drivers */
+#include <TRNGCC26XX.h>
+
+/* TRNG objects */
+TRNGCC26XX_Object trngCC26XXObjects[BOOSTXL_CC2650MA_TRNGCOUNT];
+
+/* TRNG configuration structure, describing which pins are to be used */
+const TRNGCC26XX_HWAttrs TRNGCC26XXHWAttrs[BOOSTXL_CC2650MA_TRNGCOUNT] = {
+    {
+        .powerMngrId    = PowerCC26XX_PERIPH_TRNG,
+    }
+};
+
+/* TRNG configuration structure */
+const TRNGCC26XX_Config TRNGCC26XX_config[] = {
+    {
+         .object  = &trngCC26XXObjects[0],
+         .hwAttrs = &TRNGCC26XXHWAttrs[0]
+    },
+    {NULL, NULL}
+};
+
+/*
+ *  ========================= TRNG end ====================================
+ */
+
+/*
+ *  ============================ GPTimer begin =================================
+ *  Remove unused entries to reduce flash usage both in Board.c and Board.h
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(GPTimerCC26XX_config, ".const:GPTimerCC26XX_config")
+#pragma DATA_SECTION(gptimerCC26xxHWAttrs, ".const:gptimerCC26xxHWAttrs")
+#endif
+
+/* GPTimer hardware attributes, one per timer part (Timer 0A, 0B, 1A, 1B..) */
+const GPTimerCC26XX_HWAttrs gptimerCC26xxHWAttrs[BOOSTXL_CC2650MA_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, },
+};
+
+/*  GPTimer objects, one per full-width timer (A+B) (Timer 0, Timer 1..) */
+GPTimerCC26XX_Object gptimerCC26XXObjects[BOOSTXL_CC2650MA_GPTIMERCOUNT];
+
+/* GPTimer configuration (used as GPTimer_Handle by driver and application) */
+const GPTimerCC26XX_Config GPTimerCC26XX_config[BOOSTXL_CC2650MA_GPTIMERPARTSCOUNT] = {
+    { &gptimerCC26XXObjects[0], &gptimerCC26xxHWAttrs[0], GPT_A },
+    { &gptimerCC26XXObjects[0], &gptimerCC26xxHWAttrs[1], GPT_B },
+    { &gptimerCC26XXObjects[1], &gptimerCC26xxHWAttrs[2], GPT_A },
+    { &gptimerCC26XXObjects[1], &gptimerCC26xxHWAttrs[3], GPT_B },
+    { &gptimerCC26XXObjects[2], &gptimerCC26xxHWAttrs[4], GPT_A },
+    { &gptimerCC26XXObjects[2], &gptimerCC26xxHWAttrs[5], GPT_B },
+    { &gptimerCC26XXObjects[3], &gptimerCC26xxHWAttrs[6], GPT_A },
+    { &gptimerCC26XXObjects[3], &gptimerCC26xxHWAttrs[7], GPT_B },
+};
+
+/*
+ *  ============================ GPTimer end ===================================
+ */
+
+/*
+ *  ============================= PWM begin ====================================
+ *  Remove unused entries to reduce flash usage both in Board.c and Board.h
+ */
+/* Place into subsections to allow the TI linker to remove items properly */
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(PWM_config, ".const:PWM_config")
+#pragma DATA_SECTION(pwmtimerCC26xxHWAttrs, ".const:pwmtimerCC26xxHWAttrs")
+#endif
+/* PWM configuration, one per PWM output.   */
+PWMTimerCC26XX_HwAttrs pwmtimerCC26xxHWAttrs[BOOSTXL_CC2650MA_PWMCOUNT] = {
+    { .pwmPin = Board_PWMPIN0, .gpTimerUnit = Board_GPTIMER0A },
+    { .pwmPin = Board_PWMPIN1, .gpTimerUnit = Board_GPTIMER0B },
+    { .pwmPin = Board_PWMPIN2, .gpTimerUnit = Board_GPTIMER1A },
+    { .pwmPin = Board_PWMPIN3, .gpTimerUnit = Board_GPTIMER1B },
+    { .pwmPin = Board_PWMPIN4, .gpTimerUnit = Board_GPTIMER2A },
+    { .pwmPin = Board_PWMPIN5, .gpTimerUnit = Board_GPTIMER2B },
+    { .pwmPin = Board_PWMPIN6, .gpTimerUnit = Board_GPTIMER3A },
+    { .pwmPin = Board_PWMPIN7, .gpTimerUnit = Board_GPTIMER3B },
+};
+
+/* PWM object, one per PWM output */
+PWMTimerCC26XX_Object pwmtimerCC26xxObjects[BOOSTXL_CC2650MA_PWMCOUNT];
+
+extern const PWM_FxnTable PWMTimerCC26XX_fxnTable;
+
+/* PWM configuration (used as PWM_Handle by driver and application) */
+const PWM_Config PWM_config[BOOSTXL_CC2650MA_PWMCOUNT + 1] = {
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[0], &pwmtimerCC26xxHWAttrs[0] },
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[1], &pwmtimerCC26xxHWAttrs[1] },
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[2], &pwmtimerCC26xxHWAttrs[2] },
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[3], &pwmtimerCC26xxHWAttrs[3] },
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[4], &pwmtimerCC26xxHWAttrs[4] },
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[5], &pwmtimerCC26xxHWAttrs[5] },
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[6], &pwmtimerCC26xxHWAttrs[6] },
+    { &PWMTimerCC26XX_fxnTable, &pwmtimerCC26xxObjects[7], &pwmtimerCC26xxHWAttrs[7] },
+    { NULL,                NULL,                 NULL                 }
+};
+
+
+/*
+ *  ============================= PWM end ======================================
+ */

simplelink/ble_sdk_2_02_02_25/src/boards/BOOSTXL_CC2650MA_ELITE_EIS_1_1/BOOSTXL_CC2650MA_ELITE_EIS_1_1.h

@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) 2015-2016, 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       BOOSTXL_CC2650MA.h
+ *
+ *  @brief      CC2650 Booster Pack Board Specific header file.
+ *
+ *  NB! This is the board file for CC2650 Booster Pack
+ *
+ *  ============================================================================
+ */
+#ifndef __BOOSTXL_CC2650MA_BOARD_H__
+#define __BOOSTXL_CC2650MA_BOARD_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** ============================================================================
+ *  Includes
+ *  ==========================================================================*/
+#include <ti/drivers/PIN.h>
+#include <driverlib/ioc.h>
+
+/** ============================================================================
+ *  Externs
+ *  ==========================================================================*/
+extern const PIN_Config BoardGpioInitTable[];
+extern const PIN_Config EIS_1_1_BoardGpioInitTable[];
+
+/** ============================================================================
+ *  Defines
+ *  ==========================================================================*/
+
+#define CC2650M5A // Configures RF front-end
+
+ /* Mapping of chip I/Os to DIO (Chip specific for the CC26xx/CC13xx familiy)
+ */
+
+#define DIO0       IOID_0
+#define DIO1       IOID_1
+#define DIO2       IOID_2
+#define DIO3       IOID_3
+#define DIO4       IOID_4
+#define DIO5       IOID_5
+#define DIO6       IOID_6
+#define DIO7       IOID_7
+#define DIO8       IOID_8
+#define DIO9       IOID_9
+#define DIO10      IOID_10
+#define DIO11      IOID_11
+#define DIO12      IOID_12
+#define DIO13      IOID_13
+#define DIO14      IOID_14
+
+/* Mapping of pins to board signals using general board aliases
+ *      <board signal alias>        <pin mapping>
+ */
+
+/* Mapping of DIOs to BoosterPack Connector Pins (reflecting the schematic of tbe BoosterPack)
+*/
+
+/* Connector J1 */
+#define Board_BP_Pin_J1_2              DIO7
+#define Board_BP_Pin_J1_3              DIO0
+#define Board_BP_Pin_J1_4              DIO1
+#define Board_BP_Pin_J1_5              DIO2
+#define Board_BP_Pin_J1_6              DIO3
+#define Board_BP_Pin_J1_7              DIO10
+#define Board_BP_Pin_J1_8              DIO4
+#define Board_BP_Pin_J1_9              DIO5
+#define Board_BP_Pin_J1_10             DIO6
+
+/* Connector J2 */
+#define Board_BP_Pin_J2_19             DIO8
+#define Board_BP_Pin_J2_18             DIO9          /* CS */
+#define Board_BP_Pin_J2_17             IOID_UNUSED   /* NC */
+#define Board_BP_Pin_J2_15             DIO11         /* MOSI */
+#define Board_BP_Pin_J2_14             DIO12         /* MISO */
+#define Board_BP_Pin_J2_13             DIO13
+#define Board_BP_Pin_J2_12             DIO14
+#define Board_BP_Pin_J2_11             IOID_UNUSED   /* NC */
+
+/* Mapping of BoosterPack Connector Pins to BoosterPack Standard Functions (reflecting the BoosterPack Standard)
+*/
+
+/* Connector J1 */
+#define Board_BP_AnalogIn_0            Board_BP_Pin_J1_2
+#define Board_BP_UART_Rx               Board_BP_Pin_J1_3 /* To MCU on LaunchPad */
+#define Board_BP_UART_Tx               Board_BP_Pin_J1_4 /* From MCU on LauchPad*/
+#define Board_BP_GPIO_0                Board_BP_Pin_J1_5
+#define Board_BP_AnalogIn_1            Board_BP_Pin_J1_6
+#define Board_BP_SPI_CLK               Board_BP_Pin_J1_7
+#define Board_BP_GPIO_1                Board_BP_Pin_J1_8
+#define Board_BP_I2C_SCL               Board_BP_Pin_J1_9
+#define Board_BP_I2C_SDA               Board_BP_Pin_J1_10
+
+/* Connector J2 */
+#define Board_BP_PWM_0                 Board_BP_Pin_J2_19
+#define Board_BP_SPI_CS_Wireless       Board_BP_Pin_J2_18
+#define Board_BP_GPIO_3                Board_BP_Pin_J2_17
+#define Board_BP_SPI_MOSI              Board_BP_Pin_J2_15
+#define Board_BP_SPI_MISO              Board_BP_Pin_J2_14
+#define Board_BP_SPI_CS_Display        Board_BP_Pin_J2_13
+#define Board_BP_SPI_CS_Other          Board_BP_Pin_J2_12
+#define Board_BP_GPIO_2                Board_BP_Pin_J2_11
+
+
+/* Mapping of application specific functionality of the BoosterPack to BoosterPack Pins (application dependent)
+*/
+
+/* On-board LEDs */
+#define Board_GLED                     DIO2                      /* Green LED */
+#define Board_RLED                     DIO4                      /* Red LED */
+
+/* UART Board */
+#define Board_UART_TX                  Board_BP_UART_Rx          /* RXD */
+#define Board_UART_RX                  Board_BP_UART_Tx          /* TXD */
+
+
+/* EIS1.1 SPI Board */
+#define Board_SPI0_MISO                PIN_UNASSIGNED
+#define Board_SPI0_MOSI                DIO4
+#define Board_SPI0_CLK                 DIO3
+#define Board_SPI0_CS                  PIN_UNASSIGNED
+
+#define Board_SPI1_MISO                DIO1
+#define Board_SPI1_MOSI                DIO6
+#define Board_SPI1_CLK                 DIO5
+#define Board_SPI1_CS                  PIN_UNASSIGNED
+
+/* EIS1.1 GPIO */
+#define Board_5V_enable                DIO9
+#define Board_AD_CS                    DIO10
+#define Board_AD_RST                   DIO13
+#define Board_SHUT_DOWN                DIO14
+#define enable_10v                     PIN_UNASSIGNED
+#define HIGH_Z_MODE                    PIN_UNASSIGNED
+#define shutdown_6994                  PIN_UNASSIGNED
+#define Turnon_I_LARGE                 PIN_UNASSIGNED
+#define Turnon_I_MID                   PIN_UNASSIGNED
+#define Turnon_I_SMALL                 PIN_UNASSIGNED
+#define Turnon_V_MID                   PIN_UNASSIGNED
+#define Turnon_V_SMALL                 PIN_UNASSIGNED
+#define Turon_VOUT_SMALL               PIN_UNASSIGNED
+
+/* Power Management Board */
+#define Board_SRDY                     Board_BP_Pin_J2_19
+#define Board_MRDY                     Board_BP_Pin_J1_2
+
+/* PWM outputs */
+#define Board_PWMPIN0                  PIN_UNASSIGNED
+#define Board_PWMPIN1                  PIN_UNASSIGNED
+#define Board_PWMPIN2                  PIN_UNASSIGNED
+#define Board_PWMPIN3                  PIN_UNASSIGNED
+#define Board_PWMPIN4                  PIN_UNASSIGNED
+#define Board_PWMPIN5                  PIN_UNASSIGNED
+#define Board_PWMPIN6                  PIN_UNASSIGNED
+#define Board_PWMPIN7                  PIN_UNASSIGNED
+
+/** ============================================================================
+ *  Instance identifiers
+ *  ==========================================================================*/
+/* Generic SPI instance identifiers */
+#define Board_SPI0                  BOOSTXL_CC2650MA_SPI0
+#define Board_SPI1                  BOOSTXL_CC2650MA_SPI1
+/* Generic UART instance identifiers */
+#define Board_UART                  BOOSTXL_CC2650MA_UART0
+/* Generic TRNG instance identiifer */
+#define Board_TRNG                  BOOSTXL_CC2650MA_TRNG0
+/* Generic GPTimer instance identifiers */
+#define Board_GPTIMER0A             BOOSTXL_CC2650MA_GPTIMER0A
+#define Board_GPTIMER0B             BOOSTXL_CC2650MA_GPTIMER0B
+#define Board_GPTIMER1A             BOOSTXL_CC2650MA_GPTIMER1A
+#define Board_GPTIMER1B             BOOSTXL_CC2650MA_GPTIMER1B
+#define Board_GPTIMER2A             BOOSTXL_CC2650MA_GPTIMER2A
+#define Board_GPTIMER2B             BOOSTXL_CC2650MA_GPTIMER2B
+#define Board_GPTIMER3A             BOOSTXL_CC2650MA_GPTIMER3A
+#define Board_GPTIMER3B             BOOSTXL_CC2650MA_GPTIMER3B
+/* Generic PWM instance identifiers */
+#define Board_PWM0                  BOOSTXL_CC2650MA_PWM0
+#define Board_PWM1                  BOOSTXL_CC2650MA_PWM1
+#define Board_PWM2                  BOOSTXL_CC2650MA_PWM2
+#define Board_PWM3                  BOOSTXL_CC2650MA_PWM3
+#define Board_PWM4                  BOOSTXL_CC2650MA_PWM4
+#define Board_PWM5                  BOOSTXL_CC2650MA_PWM5
+#define Board_PWM6                  BOOSTXL_CC2650MA_PWM6
+#define Board_PWM7                  BOOSTXL_CC2650MA_PWM7
+
+/** ============================================================================
+ *  Number of peripherals and their names
+ *  ==========================================================================*/
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_CryptoName
+ *  @brief  Enum of Crypto names on the CC2650 Booster Pack
+ */
+typedef enum BOOSTXL_CC2650MA_CryptoName {
+    BOOSTXL_CC2650MA_CRYPTO0 = 0,
+
+    BOOSTXL_CC2650MA_CRYPTOCOUNT
+} BOOSTXL_CC2650MA_CryptoName;
+
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_SPIName
+ *  @brief  Enum of SPI names on the CC2650 Booster Pack
+ */
+/*!
+ *  @def    BOOSTXL_CC2650MA_SPIName
+ *  @brief  Enum of SPI names on the CC2650 Booster Pack
+ */
+typedef enum BOOSTXL_CC2650MA_SPIName {
+    BOOSTXL_CC2650MA_SPI0 = 0,
+    BOOSTXL_CC2650MA_SPI1 = 1,
+
+    BOOSTXL_CC2650MA_SPICOUNT
+} BOOSTXL_CC2650MA_SPIName;
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_TRNGName
+ *  @brief  Enum of TRNG names on the board
+ */
+typedef enum BOOSTXL_CC2650MA_TRNGName {
+    BOOSTXL_CC2650MA_TRNG0 = 0,
+    BOOSTXL_CC2650MA_TRNGCOUNT
+} BOOSTXL_CC2650MA_TRNGName;
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_UARTName
+ *  @brief  Enum of UARTs on the CC2650 Booster Pack
+ */
+typedef enum BOOSTXL_CC2650MA_UARTName {
+    BOOSTXL_CC2650MA_UART0 = 0,
+
+    BOOSTXL_CC2650MA_UARTCOUNT
+} BOOSTXL_CC2650MA_UARTName;
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_UdmaName
+ *  @brief  Enum of DMA buffers
+ */
+typedef enum BOOSTXL_CC2650MA_UdmaName {
+    BOOSTXL_CC2650MA_UDMA0 = 0,
+
+    BOOSTXL_CC2650MA_UDMACOUNT
+} BOOSTXL_CC2650MA_UdmaName;
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_GPTimerName
+ *  @brief  Enum of GPTimer parts
+ */
+typedef enum BOOSTXL_CC2650MA_GPTimerName
+{
+    BOOSTXL_CC2650MA_GPTIMER0A = 0,
+    BOOSTXL_CC2650MA_GPTIMER0B,
+    BOOSTXL_CC2650MA_GPTIMER1A,
+    BOOSTXL_CC2650MA_GPTIMER1B,
+    BOOSTXL_CC2650MA_GPTIMER2A,
+    BOOSTXL_CC2650MA_GPTIMER2B,
+    BOOSTXL_CC2650MA_GPTIMER3A,
+    BOOSTXL_CC2650MA_GPTIMER3B,
+    BOOSTXL_CC2650MA_GPTIMERPARTSCOUNT
+} BOOSTXL_CC2650MA_GPTimerName;
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_GPTimers
+ *  @brief  Enum of GPTimers
+ */
+typedef enum BOOSTXL_CC2650MA_GPTimers
+{
+    BOOSTXL_CC2650MA_GPTIMER0 = 0,
+    BOOSTXL_CC2650MA_GPTIMER1,
+    BOOSTXL_CC2650MA_GPTIMER2,
+    BOOSTXL_CC2650MA_GPTIMER3,
+    BOOSTXL_CC2650MA_GPTIMERCOUNT
+} BOOSTXL_CC2650MA_GPTimers;
+
+/*!
+ *  @def    BOOSTXL_CC2650MA_PWM
+ *  @brief  Enum of PWM outputs on the board
+ */
+typedef enum BOOSTXL_CC2650MA_PWM
+{
+    BOOSTXL_CC2650MA_PWM0 = 0,
+    BOOSTXL_CC2650MA_PWM1,
+    BOOSTXL_CC2650MA_PWM2,
+    BOOSTXL_CC2650MA_PWM3,
+    BOOSTXL_CC2650MA_PWM4,
+    BOOSTXL_CC2650MA_PWM5,
+    BOOSTXL_CC2650MA_PWM6,
+    BOOSTXL_CC2650MA_PWM7,
+    BOOSTXL_CC2650MA_PWMCOUNT
+} BOOSTXL_CC2650MA_PWM;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __BOOSTXL_CC2650MA_BOARD_H__ */

simplelink/ble_sdk_2_02_02_25/src/boards/BOOSTXL_CC2650MA_ELITE_EIS_1_1/Board.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2016, 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.
+ */
+
+#ifndef __BOARD_H
+#define __BOARD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <ti/drivers/Power.h>
+
+#include "BOOSTXL_CC2650MA_ELITE_EIS_1_1.h"
+
+/* These #defines allow us to reuse TI-RTOS across other device families */
+#define     Board_LED0              Board_RLED
+#define     Board_LED1              Board_GLED
+#define     Board_LED2              Board_LED0
+
+#define     Board_UART0             Board_UART
+#define     Board_AES0              Board_AES
+#define     Board_WATCHDOG0         Board_WATCHDOG
+
+#define     Board_initGeneral() { \
+    Power_init(); \
+    if (PIN_init(BoardGpioInitTable) != PIN_SUCCESS) \
+        {System_abort("Error with PIN_init\n"); \
+    } \
+}
+
+#define     Board_initGPIO()
+#define     Board_initPWM()         PWM_init()
+#define     Board_initSPI()         SPI_init()
+#define     Board_initUART()        UART_init()
+#define     Board_initWatchdog()    Watchdog_init()
+#define     GPIO_toggle(n)
+#define     GPIO_write(n,m)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __BOARD_H */

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/AD5940.h

@@ -36,9 +36,9 @@ static void AD5940_sftreset(){
 }
 
 static void AD5940_HWReset(){
-    PIN_setOutputValue(pin_handle, AD_reset, 0);
+    PIN_setOutputValue(pin_handle, Board_AD_RST, 0);
     CPUdelay(2000); // 200us
-    PIN_setOutputValue(pin_handle, AD_reset, 1);
+    PIN_setOutputValue(pin_handle, Board_AD_RST, 1);
     CPUdelay(5000); // 500us
 }
 

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite15_PIN.h

@@ -136,49 +136,49 @@
 //    ELITE15_SPI_CLOSE();
 //    add_elite_pin();
 //    update_latch_status (latch_num, pin_num, highlow);
-////    PIN_setOutputValue(&ZM_rst, latch_num, 1);               // Turn on latch
+////    PIN_setOutputValue(&eliteState, latch_num, 1);               // Turn on latch
 //
 //    switch (latch_num) {
 //        case LOAD0: {
-////            PIN_setOutputValue(&ZM_rst, D0, LH.LATCH0[0]);
-////            PIN_setOutputValue(&ZM_rst, D1, LH.LATCH0[1]);
-////            PIN_setOutputValue(&ZM_rst, D2, LH.LATCH0[2]);
-////            PIN_setOutputValue(&ZM_rst, D3, LH.LATCH0[3]);
-//            PIN_setOutputValue(pin_handle, D4, LH.LATCH0[4]);
-//            PIN_setOutputValue(pin_handle, D5, LH.LATCH0[5]);
-//            PIN_setOutputValue(pin_handle, D6, LH.LATCH0[6]);
-//            PIN_setOutputValue(pin_handle, D7, LH.LATCH0[7]);
+////            PIN_setOutputValue(&eliteState, D0, LH.LATCH0[0]);
+////            PIN_setOutputValue(&eliteState, D1, LH.LATCH0[1]);
+////            PIN_setOutputValue(&eliteState, D2, LH.LATCH0[2]);
+////            PIN_setOutputValue(&eliteState, D3, LH.LATCH0[3]);
+//            PIN_setOutputValue(eliteCtrlHandle, D4, LH.LATCH0[4]);
+//            PIN_setOutputValue(eliteCtrlHandle, D5, LH.LATCH0[5]);
+//            PIN_setOutputValue(eliteCtrlHandle, D6, LH.LATCH0[6]);
+//            PIN_setOutputValue(eliteCtrlHandle, D7, LH.LATCH0[7]);
 //            break;
 //        }
 //        case LOAD1: {
-//            PIN_setOutputValue(pin_handle, D0, LH.LATCH1[0]);
-//            PIN_setOutputValue(pin_handle, D1, LH.LATCH1[1]);
-//            PIN_setOutputValue(pin_handle, D2, LH.LATCH1[2]);
-//            PIN_setOutputValue(pin_handle, D3, LH.LATCH1[3]);
-//            PIN_setOutputValue(pin_handle, D4, LH.LATCH1[4]);
-//            PIN_setOutputValue(pin_handle, D5, LH.LATCH1[5]);
-//            PIN_setOutputValue(pin_handle, D6, LH.LATCH1[6]);
-//            PIN_setOutputValue(pin_handle, D7, LH.LATCH1[7]);
+//            PIN_setOutputValue(eliteCtrlHandle, D0, LH.LATCH1[0]);
+//            PIN_setOutputValue(eliteCtrlHandle, D1, LH.LATCH1[1]);
+//            PIN_setOutputValue(eliteCtrlHandle, D2, LH.LATCH1[2]);
+//            PIN_setOutputValue(eliteCtrlHandle, D3, LH.LATCH1[3]);
+//            PIN_setOutputValue(eliteCtrlHandle, D4, LH.LATCH1[4]);
+//            PIN_setOutputValue(eliteCtrlHandle, D5, LH.LATCH1[5]);
+//            PIN_setOutputValue(eliteCtrlHandle, D6, LH.LATCH1[6]);
+//            PIN_setOutputValue(eliteCtrlHandle, D7, LH.LATCH1[7]);
 //            break;
 //        }
 //        case LOAD2: {
-//            PIN_setOutputValue(pin_handle, D0, LH.LATCH2[0]);
-//            PIN_setOutputValue(pin_handle, D1, LH.LATCH2[1]);
-//            PIN_setOutputValue(pin_handle, D2, LH.LATCH2[2]);
-//            PIN_setOutputValue(pin_handle, D3, LH.LATCH2[3]);
-//            PIN_setOutputValue(pin_handle, D4, LH.LATCH2[4]);
-//            PIN_setOutputValue(pin_handle, D5, LH.LATCH2[5]);
-//            PIN_setOutputValue(pin_handle, D6, LH.LATCH2[6]);
-//            PIN_setOutputValue(pin_handle, D7, LH.LATCH2[7]);
+//            PIN_setOutputValue(eliteCtrlHandle, D0, LH.LATCH2[0]);
+//            PIN_setOutputValue(eliteCtrlHandle, D1, LH.LATCH2[1]);
+//            PIN_setOutputValue(eliteCtrlHandle, D2, LH.LATCH2[2]);
+//            PIN_setOutputValue(eliteCtrlHandle, D3, LH.LATCH2[3]);
+//            PIN_setOutputValue(eliteCtrlHandle, D4, LH.LATCH2[4]);
+//            PIN_setOutputValue(eliteCtrlHandle, D5, LH.LATCH2[5]);
+//            PIN_setOutputValue(eliteCtrlHandle, D6, LH.LATCH2[6]);
+//            PIN_setOutputValue(eliteCtrlHandle, D7, LH.LATCH2[7]);
 //            break;
 //        }
 //        default: {
 //            break;
 //        }
 //    }
-//    PIN_setOutputValue(&ZM_rst, latch_num, 1);               // Turn on latch
+//    PIN_setOutputValue(&eliteState, latch_num, 1);               // Turn on latch
 ////    CPUdelay(10);
-//    PIN_setOutputValue(&ZM_rst, latch_num, 0);               // Turn off latch
+//    PIN_setOutputValue(&eliteState, latch_num, 0);               // Turn off latch
 //    remove_elite_pin();
 //    ELITE15_SPI_HOLD();
 //}
@@ -187,55 +187,55 @@
 //    InitLH();
 //    add_elite_pin();
 //
-//    PIN_setOutputValue(pin_handle, D0, 0);
-//    PIN_setOutputValue(pin_handle, D1, 0);
-//    PIN_setOutputValue(pin_handle, D2, 0);
-//    PIN_setOutputValue(pin_handle, D3, 0);
-//    PIN_setOutputValue(pin_handle, D4, 0);
-//    PIN_setOutputValue(pin_handle, D5, 0);
-//    PIN_setOutputValue(pin_handle, D6, 0);
-//    PIN_setOutputValue(pin_handle, D7, 0);
-//    PIN_setOutputValue(pin_handle, LOAD0, 0);
-//    PIN_setOutputValue(pin_handle, LOAD1, 1);
-//    PIN_setOutputValue(pin_handle, LOAD2, 1);
+//    PIN_setOutputValue(eliteCtrlHandle, D0, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D1, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D2, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D3, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D4, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D5, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D6, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D7, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, LOAD0, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, LOAD1, 1);
+//    PIN_setOutputValue(eliteCtrlHandle, LOAD2, 1);
 //    CPUdelay(10);
-//    PIN_setOutputValue(pin_handle, LOAD1, 0);
-//    PIN_setOutputValue(pin_handle, LOAD2, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, LOAD1, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, LOAD2, 0);
 //
 //
-//    PIN_setOutputValue(pin_handle, D0, 0);
-//    PIN_setOutputValue(pin_handle, D1, 0);
-//    PIN_setOutputValue(pin_handle, D2, 0);
-//    PIN_setOutputValue(pin_handle, D3, 0);
-//    PIN_setOutputValue(pin_handle, D4, 1);
-//    PIN_setOutputValue(pin_handle, D5, 1);
-//    PIN_setOutputValue(pin_handle, D6, 1);
-//    PIN_setOutputValue(pin_handle, D7, 1);
+//    PIN_setOutputValue(eliteCtrlHandle, D0, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D1, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D2, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D3, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, D4, 1);
+//    PIN_setOutputValue(eliteCtrlHandle, D5, 1);
+//    PIN_setOutputValue(eliteCtrlHandle, D6, 1);
+//    PIN_setOutputValue(eliteCtrlHandle, D7, 1);
 //    CPUdelay(10);
-//    PIN_setOutputValue(pin_handle, LOAD0, 1);
-//    PIN_setOutputValue(pin_handle, LOAD0, 0);
+//    PIN_setOutputValue(eliteCtrlHandle, LOAD0, 1);
+//    PIN_setOutputValue(eliteCtrlHandle, LOAD0, 0);
 //
 //    remove_elite_pin();
 //
 ////    InitLH();
 ////    add_elite_pin();
 ////
-////    PIN_setOutputValue(pin_handle, LOAD0, 1);
-////    PIN_setOutputValue(pin_handle, LOAD1, 1);
-////    PIN_setOutputValue(pin_handle, LOAD2, 1);
+////    PIN_setOutputValue(eliteCtrlHandle, LOAD0, 1);
+////    PIN_setOutputValue(eliteCtrlHandle, LOAD1, 1);
+////    PIN_setOutputValue(eliteCtrlHandle, LOAD2, 1);
 ////    CPUdelay(10);
-////    PIN_setOutputValue(pin_handle, D0, 0);
-////    PIN_setOutputValue(pin_handle, D1, 0);
-////    PIN_setOutputValue(pin_handle, D2, 0);
-////    PIN_setOutputValue(pin_handle, D3, 0);
-////    PIN_setOutputValue(pin_handle, D4, 0);
-////    PIN_setOutputValue(pin_handle, D5, 0);
-////    PIN_setOutputValue(pin_handle, D6, 0);
-////    PIN_setOutputValue(pin_handle, D7, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D0, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D1, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D2, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D3, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D4, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D5, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D6, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, D7, 0);
 ////    CPUdelay(10);
-////    PIN_setOutputValue(pin_handle, LOAD0, 0);
-////    PIN_setOutputValue(pin_handle, LOAD1, 0);
-////    PIN_setOutputValue(pin_handle, LOAD2, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, LOAD0, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, LOAD1, 0);
+////    PIN_setOutputValue(eliteCtrlHandle, LOAD2, 0);
 ////
 ////    remove_elite_pin();
 //}

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteADC.h

@@ -86,13 +86,13 @@ static void CAL_ADC_write(uint8_t ADCin) {
 static void IinADCGainControl(uint8_t IinADCLevel){
     if(IinADCLevel == 0){
         // ADC gain level = 0, using 3M resister
-        PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 0);
-        PIN_setOutputValue(pin_handle, Turnon_I_MID, 0);
-        PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 0);
+        PIN_setOutputValue(eliteCtrlHandle, Turnon_I_LARGE, 0);
+        PIN_setOutputValue(eliteCtrlHandle, Turnon_I_MID, 0);
+        PIN_setOutputValue(eliteCtrlHandle, Turnon_I_SMALL, 0);
     }
     else if(IinADCLevel == 1){
         // ADC gain level = 1, using 100K resister
-        PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 0);
+        PIN_setOutputValue(eliteCtrlHandle, Turnon_I_LARGE, 0);
         PIN_setOutputValue(pin_handle, Turnon_I_MID, 0);
         PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 1);
     }

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteCV3Mode.h

@@ -1,111 +1,111 @@
-#ifndef ELITECV3
-#define ELITECV3
-
-#define Vset instru.Vset
-
-static void cv_vscan(void)
-{
-    struct wm_cv_ctx_t *cv = (struct wm_cv_ctx_t *)wm_get();
-    static bool VminCounter;
-    static bool VmaxCounter;
-
-    NotifyCycleNumber = (instru.cycleNumber - cv->_cycleNumber + 1);
-
-    if (vscanReset) {
-        VmaxCounter = false;
-        VminCounter = false;
-
-        if (instru.directionInit == 1) {
-            cv->_direction_up         = true;
-            cv->_current_direction_up = true;
-        } else {
-            cv->_direction_up         = false;
-            cv->_current_direction_up = false;
-        }
-
-//        Vstep = x * 20 * N, x=xmV ; N=VscanRate   Vstep unit [5nV]/[0.1ms]
-        if (instru.step <= 10) {
-            cv->_Vstep = instru.step *  instru.VsetRate / 5;
-        } else {
-            cv->_Vstep = instru.step / 5 *  instru.VsetRate;
-        }
-
-
-        if (cv->_Vmin == cv->_Vinit) {
-            VminCounter = true;
-        }
-        if (cv->_Vmax == cv->_Vinit) {
-            VmaxCounter = true;
-        }
-
-        Vset = cv->_Vinit;
-    }
-
-    if (!vscanReset) {
-        cv->bFirst = false;
-        if ((instru.Vinit < instru.Ve1 && instru.Vinit < instru.Ve2) ||
-        (instru.Vinit > instru.Ve1 && instru.Vinit > instru.Ve2)
-        ) {
-            if (cv->_current_direction_up) {
-                Vset = Vset + cv->_Vstep; //* GPT.GptimerMultiple;
-            } else {
-                Vset = Vset - cv->_Vstep; //* GPT.GptimerMultiple;
-            }
-
-            if (instru.Vinit < instru.Ve1 && instru.Vinit < instru.Ve2) {
-                if (Vset == cv->_Vmin) {
-                    VminCounter = true;
-                    instru.Vinit = instru.Vmin;
-                    cv->_Vinit = cv->_Vmin;
-                }
-            } else if (instru.Vinit > instru.Ve1 && instru.Vinit > instru.Ve2) {
-                if (Vset == cv->_Vmax) {
-                    VmaxCounter = true;
-                    instru.Vinit = instru.Vmax;
-                    cv->_Vinit = cv->_Vmax;
-                }
-            }
-        } else {
-            if (Vset >= cv->_Vmax) {
-                VmaxCounter = true;
-            } else if (Vset <= cv->_Vmin) {
-                VminCounter = true;
-            }
-
-            if (cv->_current_direction_up) {
-                Vset = Vset + cv->_Vstep;// * GPT.GptimerMultiple;
-            } else {
-                Vset = Vset - cv->_Vstep;// * GPT.GptimerMultiple;
-            }
-
-            if (VmaxCounter && VminCounter) {
-                if (cv->_direction_up && cv->_current_direction_up) {
-                    if (Vset >= cv->_Vinit) {
-                        cv->_cycleNumber--;
-                        VminCounter = false;
-                        VmaxCounter = false;
-                    }
-                }
-                if (!cv->_direction_up && !cv->_current_direction_up) {
-                    if (Vset <= cv->_Vinit) {
-                        cv->_cycleNumber--;
-                        VminCounter = false;
-                        VmaxCounter = false;
-                    }
-                }
-            }
-
-            if (Vset >= cv->_Vmax) {
-                cv->_current_direction_up = false;
-            } else if (Vset <= cv->_Vmin) {
-                cv->_current_direction_up = true;
-            }
-
-            /*stop condition*/
-            if (cv->_cycleNumber == 0) {
-                PeriodicEvent = false;
-            }
-        }
-    }
-}
-#endif
+//#ifndef ELITECV3
+//#define ELITECV3
+//
+//#define Vset instru.Vset
+//
+//static void cv_vscan(void)
+//{
+//    struct wm_cv_ctx_t *cv = (struct wm_cv_ctx_t *)wm_get();
+//    static bool VminCounter;
+//    static bool VmaxCounter;
+//
+//    NotifyCycleNumber = (instru.cycleNumber - cv->_cycleNumber + 1);
+//
+//    if (vscanReset) {
+//        VmaxCounter = false;
+//        VminCounter = false;
+//
+//        if (instru.directionInit == 1) {
+//            cv->_direction_up         = true;
+//            cv->_current_direction_up = true;
+//        } else {
+//            cv->_direction_up         = false;
+//            cv->_current_direction_up = false;
+//        }
+//
+////        Vstep = x * 20 * N, x=xmV ; N=VscanRate   Vstep unit [5nV]/[0.1ms]
+//        if (instru.step <= 10) {
+//            cv->_Vstep = instru.step *  instru.VsetRate / 5;
+//        } else {
+//            cv->_Vstep = instru.step / 5 *  instru.VsetRate;
+//        }
+//
+//
+//        if (cv->_Vmin == cv->_Vinit) {
+//            VminCounter = true;
+//        }
+//        if (cv->_Vmax == cv->_Vinit) {
+//            VmaxCounter = true;
+//        }
+//
+//        Vset = cv->_Vinit;
+//    }
+//
+//    if (!vscanReset) {
+//        cv->bFirst = false;
+//        if ((instru.Vinit < instru.Ve1 && instru.Vinit < instru.Ve2) ||
+//        (instru.Vinit > instru.Ve1 && instru.Vinit > instru.Ve2)
+//        ) {
+//            if (cv->_current_direction_up) {
+//                Vset = Vset + cv->_Vstep; //* GPT.GptimerMultiple;
+//            } else {
+//                Vset = Vset - cv->_Vstep; //* GPT.GptimerMultiple;
+//            }
+//
+//            if (instru.Vinit < instru.Ve1 && instru.Vinit < instru.Ve2) {
+//                if (Vset == cv->_Vmin) {
+//                    VminCounter = true;
+//                    instru.Vinit = instru.Vmin;
+//                    cv->_Vinit = cv->_Vmin;
+//                }
+//            } else if (instru.Vinit > instru.Ve1 && instru.Vinit > instru.Ve2) {
+//                if (Vset == cv->_Vmax) {
+//                    VmaxCounter = true;
+//                    instru.Vinit = instru.Vmax;
+//                    cv->_Vinit = cv->_Vmax;
+//                }
+//            }
+//        } else {
+//            if (Vset >= cv->_Vmax) {
+//                VmaxCounter = true;
+//            } else if (Vset <= cv->_Vmin) {
+//                VminCounter = true;
+//            }
+//
+//            if (cv->_current_direction_up) {
+//                Vset = Vset + cv->_Vstep;// * GPT.GptimerMultiple;
+//            } else {
+//                Vset = Vset - cv->_Vstep;// * GPT.GptimerMultiple;
+//            }
+//
+//            if (VmaxCounter && VminCounter) {
+//                if (cv->_direction_up && cv->_current_direction_up) {
+//                    if (Vset >= cv->_Vinit) {
+//                        cv->_cycleNumber--;
+//                        VminCounter = false;
+//                        VmaxCounter = false;
+//                    }
+//                }
+//                if (!cv->_direction_up && !cv->_current_direction_up) {
+//                    if (Vset <= cv->_Vinit) {
+//                        cv->_cycleNumber--;
+//                        VminCounter = false;
+//                        VmaxCounter = false;
+//                    }
+//                }
+//            }
+//
+//            if (Vset >= cv->_Vmax) {
+//                cv->_current_direction_up = false;
+//            } else if (Vset <= cv->_Vmin) {
+//                cv->_current_direction_up = true;
+//            }
+//
+//            /*stop condition*/
+//            if (cv->_cycleNumber == 0) {
+//                PeriodicEvent = false;
+//            }
+//        }
+//    }
+//}
+//#endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteDAC.h

@@ -41,19 +41,19 @@ static uint32_t DAC_outputF(uint32_t freq) {
 static void VoutGainControl(uint8_t VOUTLevel){
     if(VOUTLevel == 0){
         // VOUT gain level = 0, using 240K resister
-        PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 0);
+        PIN_setOutputValue(eliteCtrlHandle, Turon_VOUT_SMALL, 0);
     }
     else if(VOUTLevel == 1){
         // VOUT gain level = 1, using 15K resister
-        PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 1);
+        PIN_setOutputValue(eliteCtrlHandle, Turon_VOUT_SMALL, 1);
     }
     else if(VOUTLevel == 2){
         // VOUT gain level = 2, using 15K resister
-        PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 1);
+        PIN_setOutputValue(eliteCtrlHandle, Turon_VOUT_SMALL, 1);
     }
     else{
         // default using 15K resister
-        PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 1);
+        PIN_setOutputValue(eliteCtrlHandle, Turon_VOUT_SMALL, 1);
     }
     record_flag = false;
 }

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteI2C.h

@@ -1,95 +1,95 @@
-
-#ifndef ELITE_I2C
-#define ELITE_I2C
-
-/*
-* Read I2C example in
-* http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/tirtos/2_14_02_22/
-*        exports/tirtos_full_2_14_02_22/docs/doxygen/html/_i2_c_c_c26_x_x_8h.html
-*
-*/
-
-#include <ti/drivers/I2C.h>
-#include <ti/drivers/Power.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <stddef.h>
-
-// I2C
-static I2C_Handle I2Chandle;
-static I2C_Params I2Cparams;
-static I2C_Transaction i2cTrans;
-
-#define I2CBufSize 4
-static uint8_t I2CtxBuf[I2CBufSize];      // Transmit buffer
-static uint8_t I2CrxBuf[I2CBufSize];      // Receive buffer
-bool transferDone = false;
-
-static void I2CCallbackFunction(I2C_Handle handle, I2C_Transaction *msg, bool transfer) {
-    if(transfer){
-        transferDone = true;
-    }
-}
-
-static void I2Cinit(){
-    I2C_init();
-
-    // Configure I2C parameters.
-    I2C_Params_init(&I2Cparams);
-
-    I2Cparams.transferMode  = I2C_MODE_CALLBACK;
-    I2Cparams.transferCallbackFxn = I2CCallbackFunction;
-    I2Cparams.bitRate  = I2C_100kHz;
-
-    // Initialize master I2C transaction structure
-    i2cTrans.writeCount   = I2CBufSize;
-    i2cTrans.writeBuf     = I2CtxBuf;
-    i2cTrans.readCount    = I2CBufSize;
-    i2cTrans.readBuf      = I2CrxBuf;
-    i2cTrans.slaveAddress = 0xA0;
-
-    for(int i=0 ; i<10 ; i++){
-        I2CtxBuf[i] = 0;
-        I2CrxBuf[i] = 0;
-    }
-
-    // Open I2C
-    I2Chandle = I2C_open(Board_I2C, &I2Cparams);
-
-}
-#define WriteMem 0b10100001
-#define ReadMem  0b10100000
-
-static void I2CWrite(uint8_t addr, uint8_t data){
-    for(int i=0 ; i<I2CBufSize ; i++){
-        I2CtxBuf[i] = 0;
-        I2CrxBuf[i] = 0;
-    }
-
-    I2CtxBuf[0] = WriteMem;
-    I2CtxBuf[1] = addr;
-    I2CtxBuf[2] = data;
-
+//
+//#ifndef ELITE_I2C
+//#define ELITE_I2C
+//
+///*
+//* Read I2C example in
+//* http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/tirtos/2_14_02_22/
+//*        exports/tirtos_full_2_14_02_22/docs/doxygen/html/_i2_c_c_c26_x_x_8h.html
+//*
+//*/
+//
+//#include <ti/drivers/I2C.h>
+//#include <ti/drivers/Power.h>
+//#include <stdint.h>
+//#include <stdbool.h>
+//#include <stddef.h>
+//
+//// I2C
+//static I2C_Handle I2Chandle;
+//static I2C_Params I2Cparams;
+//static I2C_Transaction i2cTrans;
+//
+//#define I2CBufSize 4
+//static uint8_t I2CtxBuf[I2CBufSize];      // Transmit buffer
+//static uint8_t I2CrxBuf[I2CBufSize];      // Receive buffer
+//bool transferDone = false;
+//
+//static void I2CCallbackFunction(I2C_Handle handle, I2C_Transaction *msg, bool transfer) {
+//    if(transfer){
+//        transferDone = true;
+//    }
+//}
+//
+//static void I2Cinit(){
+//    I2C_init();
+//
+//    // Configure I2C parameters.
+//    I2C_Params_init(&I2Cparams);
+//
+//    I2Cparams.transferMode  = I2C_MODE_CALLBACK;
+//    I2Cparams.transferCallbackFxn = I2CCallbackFunction;
+//    I2Cparams.bitRate  = I2C_100kHz;
+//
+//    // Initialize master I2C transaction structure
+//    i2cTrans.writeCount   = I2CBufSize;
+//    i2cTrans.writeBuf     = I2CtxBuf;
+//    i2cTrans.readCount    = I2CBufSize;
+//    i2cTrans.readBuf      = I2CrxBuf;
+//    i2cTrans.slaveAddress = 0xA0;
+//
+//    for(int i=0 ; i<10 ; i++){
+//        I2CtxBuf[i] = 0;
+//        I2CrxBuf[i] = 0;
+//    }
+//
+//    // Open I2C
 //    I2Chandle = I2C_open(Board_I2C, &I2Cparams);
-    I2C_transfer(I2Chandle, &i2cTrans);
-//    I2C_close(I2Chandle);
-}
-
-
-static void I2CRead(uint8_t addr){
-    for(int i=0 ; i<I2CBufSize ; i++){
-        I2CtxBuf[i] = 0;
-        I2CrxBuf[i] = 0;
-    }
-
-    I2CtxBuf[0] = ReadMem;
-    I2CtxBuf[1] = addr;
-
-//    I2Chandle = I2C_open(Board_I2C, &I2Cparams);
-    I2C_transfer(I2Chandle, &i2cTrans);
-//    I2C_close(I2Chandle);
-}
-
-
-#endif  // ELITE_I2C
-
+//
+//}
+//#define WriteMem 0b10100001
+//#define ReadMem  0b10100000
+//
+//static void I2CWrite(uint8_t addr, uint8_t data){
+//    for(int i=0 ; i<I2CBufSize ; i++){
+//        I2CtxBuf[i] = 0;
+//        I2CrxBuf[i] = 0;
+//    }
+//
+//    I2CtxBuf[0] = WriteMem;
+//    I2CtxBuf[1] = addr;
+//    I2CtxBuf[2] = data;
+//
+////    I2Chandle = I2C_open(Board_I2C, &I2Cparams);
+//    I2C_transfer(I2Chandle, &i2cTrans);
+////    I2C_close(I2Chandle);
+//}
+//
+//
+//static void I2CRead(uint8_t addr){
+//    for(int i=0 ; i<I2CBufSize ; i++){
+//        I2CtxBuf[i] = 0;
+//        I2CrxBuf[i] = 0;
+//    }
+//
+//    I2CtxBuf[0] = ReadMem;
+//    I2CtxBuf[1] = addr;
+//
+////    I2Chandle = I2C_open(Board_I2C, &I2Cparams);
+//    I2C_transfer(I2Chandle, &i2cTrans);
+////    I2C_close(I2Chandle);
+//}
+//
+//
+//#endif  // ELITE_I2C
+//

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteIVCurve.h

@@ -1,20 +1,20 @@
-
-#ifndef ELITEIV
-#define ELITEIV
-
-#define Vset instru.Vset
-
-static void vo_vscan(void)
-{
-    struct wm_vo_ctx_t *vo = (struct wm_vo_ctx_t *)wm_get();
-
-    if (vscanReset) {
-        Vset = vo->_Vinit;
-    }
-
-    if(!vscanReset) {
-        Vset = vo->_Vinit;
-    }
-}
-
-#endif
+//
+//#ifndef ELITEIV
+//#define ELITEIV
+//
+//#define Vset instru.Vset
+//
+//static void vo_vscan(void)
+//{
+//    struct wm_vo_ctx_t *vo = (struct wm_vo_ctx_t *)wm_get();
+//
+//    if (vscanReset) {
+//        Vset = vo->_Vinit;
+//    }
+//
+//    if(!vscanReset) {
+//        Vset = vo->_Vinit;
+//    }
+//}
+//
+//#endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteKeyDetect.h

@@ -12,10 +12,10 @@ static bool TurnOnElite(uint8_t key) {
 //            uint16_t bat = ((uint16_t)(NotifyVoltBat[2]) << 8 & 0xFF00 ) |
 //                           ((uint16_t)(NotifyVoltBat[3]) & 0x00FF);
 //            if( bat < 768 && bat > 20){
-//                PIN_setOutputValue(pin_handle, enable_5v, 0);
+//                PIN_setOutputValue(eliteCtrlHandle, Board_5V_enable, 0);
 //                return false;
 //            }else{
-                PIN_setOutputValue(pin_handle, enable_5v, 1);  // enable 5V
+                PIN_setOutputValue(eliteCtrlHandle, Board_5V_enable, 1);  // enable 5V
                 Elite_SPI_init();
                 // TurnOn10V();
                 ModeLED(BT_WAIT);
@@ -28,7 +28,7 @@ static bool TurnOnElite(uint8_t key) {
         }
     } else {
         TurnOnCounter = 0;
-        PIN_setOutputValue(pin_handle, enable_5v, 0);  // disable 5V
+        PIN_setOutputValue(eliteCtrlHandle, Board_5V_enable, 0);  // disable 5V
         return false;
     }
 }
@@ -47,8 +47,8 @@ static void EliteKeyPress(uint8_t key) {
 
         // press 3~4 sec, shutdown 2650
         else if (ShutDownCounter > (CLOCK_ONE_SECOND*3) ) {
-            LED_color(DARKLED, 0xFF, 0xFF, 0x00);
-            PIN_setOutputValue(pin_handle, enable_5v, 0);  // disable 5V
+            LED_color(LED_BR_LV1, 0xFF, 0xFF, 0x00);
+            PIN_setOutputValue(eliteCtrlHandle, Board_5V_enable, 0);  // disable 5V
         }
         ShutDownCounter ++;
     } else {
@@ -70,7 +70,7 @@ static void EliteKeyPress(uint8_t key) {
 
 static void TurnOn10V() {
     If10Von = true;
-    PIN_setOutputValue(pin_handle, enable_10v, 1);
+    PIN_setOutputValue(eliteCtrlHandle, enable_10v, 1);
     CPUdelay(8000);
 }
 

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteLED.h

@@ -1,188 +1,188 @@
 
-#ifndef ELITELED
-#define ELITELED
+// #ifndef ELITELED
+// #define ELITELED
 
-#define DARKLED                  0xE1
-#define LIGHTLED                 0xE8
+// #define LED_BR_LV1                  0xE1
+// #define LED_BR_LV8                 0xE8
 
-static void WorkModeLED();
+// static void WorkModeLED();
 
-static void LED_color(uint8_t bright, uint8_t red, uint8_t green, uint8_t blue) {
-    spi_LEDtxbuf[0] = 0x0000;
-    spi_LEDtxbuf[1] = 0x0000;
-    for (int i = 2; i < SPI_LED_SIZE - 2; i += 2) {
-        spi_LEDtxbuf[i]     = 0xE000 | ((uint16_t)bright << 8) | blue;
-        spi_LEDtxbuf[i + 1] = ((uint16_t)green << 8) | red;
-    }
+// static void LED_color(uint8_t bright, uint8_t red, uint8_t green, uint8_t blue) {
+//     spi_LEDtxbuf[0] = 0x0000;
+//     spi_LEDtxbuf[1] = 0x0000;
+//     for (int i = 2; i < SPI_LED_SIZE - 2; i += 2) {
+//         spi_LEDtxbuf[i]     = 0xE000 | ((uint16_t)bright << 8) | blue;
+//         spi_LEDtxbuf[i + 1] = ((uint16_t)green << 8) | red;
+//     }
 
-    spi_LEDtxbuf[SPI_LED_SIZE - 2] = 0xffff;
-    spi_LEDtxbuf[SPI_LED_SIZE - 1] = 0xffff;
+//     spi_LEDtxbuf[SPI_LED_SIZE - 2] = 0xffff;
+//     spi_LEDtxbuf[SPI_LED_SIZE - 1] = 0xffff;
 
-    LED_SPI(SPI_LED_SIZE, spi_LEDtxbuf, spi_LEDrxbuf);
-}
+//     LED_SPI(SPI_LED_SIZE, spi_LEDtxbuf, spi_LEDrxbuf);
+// }
 
-static void Elite_led_color(uint16_t color){
-    switch (color) {
-        case COLOR_RED: {
-            LED_color(DARKLED, 0xFF, 0x00, 0x00);
-            break;
-        }
-        case COLOR_ORANGE: {
-            LED_color(DARKLED, 0xFF, 0x58, 0x09);
-            break;
-        }
-        case COLOR_YELLOW: {
-            LED_color(LIGHTLED, 0xFF, 0x80, 0x00);
-            break;
-        }
-        case COLOR_GREEN: {
-            LED_color(DARKLED, 0x00, 0xFA, 0x00);
-            break;
-        }
-        case COLOR_YELLOWGREEN: {
-            LED_color(DARKLED, 0x64, 0xA6, 0x00);
-            break;
-        }
-        case COLOR_BLUE: {
-            LED_color(DARKLED, 0x00, 0x00, 0xAA);
-            break;
-        }
-        case COLOR_CYAN: {
-            LED_color(DARKLED, 0x00, 0x40, 0x40);
-            break;
-        }
-        case COLOR_MAGENTA: {
-            LED_color(DARKLED, 0xFF, 0x00, 0x80);
-            break;
-        }
-        case COLOR_PURPLE: {
-            LED_color(DARKLED, 0xFF, 0x00, 0xFF);
-            break;
-        }
-        case COLOR_WHITE: {
-            LED_color(DARKLED, 0xCA, 0xFF, 0xFF);
-            break;
-        }
-        case COLOR_BLACK: {
-            LED_color(0x00, 0x00, 0x00, 0x00);
-            break;
-        }
-        //dark LED
-        case COLOR_YELLOW_DARK: {
-            LED_color(DARKLED, 0xFF, 0x80, 0x00);
-            break;
-        }
-        case COLOR_GREEN_DARK: {
-            LED_color(DARKLED, 0x00, 0x33, 0x00);
-            break;
-        }
-        case COLOR_BLUE_DARK: {
-            LED_color(DARKLED, 0x00, 0x00, 0x33);
-            break;
-        }
-        case COLOR_CYAN_DARK: {
-            LED_color(DARKLED, 0x00, 0x10, 0x10);
-            break;
-        }
-        case COLOR_PURPLE_DARK: {
-            LED_color(DARKLED, 0x55, 0x00, 0x55);
-            break;
-        }
-        default: {
-            break;
-        }
-    }
-}
+// static void Elite_led_color(uint16_t color){
+//     switch (color) {
+//         case COLOR_RED: {
+//             LED_color(LED_BR_LV1, 0xFF, 0x00, 0x00);
+//             break;
+//         }
+//         case COLOR_ORANGE: {
+//             LED_color(LED_BR_LV1, 0xFF, 0x58, 0x09);
+//             break;
+//         }
+//         case COLOR_YELLOW: {
+//             LED_color(LED_BR_LV8, 0xFF, 0x80, 0x00);
+//             break;
+//         }
+//         case COLOR_GREEN: {
+//             LED_color(LED_BR_LV1, 0x00, 0xFA, 0x00);
+//             break;
+//         }
+//         case COLOR_YELLOWGREEN: {
+//             LED_color(LED_BR_LV1, 0x64, 0xA6, 0x00);
+//             break;
+//         }
+//         case COLOR_BLUE: {
+//             LED_color(LED_BR_LV1, 0x00, 0x00, 0xAA);
+//             break;
+//         }
+//         case COLOR_CYAN: {
+//             LED_color(LED_BR_LV1, 0x00, 0x40, 0x40);
+//             break;
+//         }
+//         case COLOR_MAGENTA: {
+//             LED_color(LED_BR_LV1, 0xFF, 0x00, 0x80);
+//             break;
+//         }
+//         case COLOR_PURPLE: {
+//             LED_color(LED_BR_LV1, 0xFF, 0x00, 0xFF);
+//             break;
+//         }
+//         case COLOR_WHITE: {
+//             LED_color(LED_BR_LV1, 0xCA, 0xFF, 0xFF);
+//             break;
+//         }
+//         case COLOR_BLACK: {
+//             LED_color(0x00, 0x00, 0x00, 0x00);
+//             break;
+//         }
+//         //dark LED
+//         case COLOR_YELLOW_DARK: {
+//             LED_color(LED_BR_LV1, 0xFF, 0x80, 0x00);
+//             break;
+//         }
+//         case COLOR_GREEN_DARK: {
+//             LED_color(LED_BR_LV1, 0x00, 0x33, 0x00);
+//             break;
+//         }
+//         case COLOR_BLUE_DARK: {
+//             LED_color(LED_BR_LV1, 0x00, 0x00, 0x33);
+//             break;
+//         }
+//         case COLOR_CYAN_DARK: {
+//             LED_color(LED_BR_LV1, 0x00, 0x10, 0x10);
+//             break;
+//         }
+//         case COLOR_PURPLE_DARK: {
+//             LED_color(LED_BR_LV1, 0x55, 0x00, 0x55);
+//             break;
+//         }
+//         default: {
+//             break;
+//         }
+//     }
+// }
 
-static void ModeLED(uint16_t modeStatus) {
-    btWaitLedFlag   = 0;
-    noEventLedFlag  = 0;
-    preWorkLedFlag  = 0;
-    workingLedFlag  = 0;
-    postWorkLedFlag = 0;
+// static void ModeLED(uint16_t modeStatus) {
+//     btWaitLedFlag   = 0;
+//     noEventLedFlag  = 0;
+//     preWorkLedFlag  = 0;
+//     workingLedFlag  = 0;
+//     postWorkLedFlag = 0;
 
-    switch (modeStatus) {
-    case BT_WAIT: {
-        btWaitLedFlag = 1;
-        BT_WAIT_LED();
-        break;
-    }
-    case NO_EVENT: {
-        noEventLedFlag = 1;
-        LEDPowerON();
-        break;
-    }
-    case PRE_WORK: {
-        preWorkLedFlag = 1;
-        Elite_led_color(COLOR_BLUE);
-        break;
-    }
-    case WORKING: {
-        workingLedFlag = 1;
-        WorkModeLED();
-        break;
-    }
-    case POST_WORK: {
-        postWorkLedFlag = 1;
-        Elite_led_color(COLOR_BLUE);
-        break;
-    }
-    default: {
-        LEDPowerON();
-        break;
-    }
-    }
-}
+//     switch (modeStatus) {
+//     case BT_WAIT: {
+//         btWaitLedFlag = 1;
+//         BT_WAIT_LED();
+//         break;
+//     }
+//     case NO_EVENT: {
+//         noEventLedFlag = 1;
+//         LEDPowerON();
+//         break;
+//     }
+//     case PRE_WORK: {
+//         preWorkLedFlag = 1;
+//         led_color_set(LED_NB_MAX, LED_CLR_BLUE);
+//         break;
+//     }
+//     case WORKING: {
+//         workingLedFlag = 1;
+//         WorkModeLED();
+//         break;
+//     }
+//     case POST_WORK: {
+//         postWorkLedFlag = 1;
+//         led_color_set(LED_NB_MAX, LED_CLR_BLUE);
+//         break;
+//     }
+//     default: {
+//         LEDPowerON();
+//         break;
+//     }
+//     }
+// }
 
-static void checkFlafLED()
-{
-    if(btWaitLedFlag == 1){
-        ModeLED(BT_WAIT);
-    }
-    else if(noEventLedFlag == 1){
-        ModeLED(NO_EVENT);
-    }
-    else if(preWorkLedFlag == 1){
-        ModeLED(PRE_WORK);
-    }
-    else if(workingLedFlag == 1){
-        ModeLED(WORKING);
-    }
-    else if(postWorkLedFlag == 1){
-        ModeLED(POST_WORK);
-    }
-}
+// static void checkFlafLED()
+// {
+//     if(btWaitLedFlag == 1){
+//         ModeLED(BT_WAIT);
+//     }
+//     else if(noEventLedFlag == 1){
+//         ModeLED(NO_EVENT);
+//     }
+//     else if(preWorkLedFlag == 1){
+//         ModeLED(PRE_WORK);
+//     }
+//     else if(workingLedFlag == 1){
+//         ModeLED(WORKING);
+//     }
+//     else if(postWorkLedFlag == 1){
+//         ModeLED(POST_WORK);
+//     }
+// }
 
-static void WorkModeLED()
-{
-    switch (instru.eliteFxn) {
-        case CURVE_EIS:
-        case CURVE_EIS_CV:
-            WORKLED();
-            break;
+// static void WorkModeLED()
+// {
+//     switch (instru.eliteFxn) {
+//         case CURVE_EIS:
+//         case CURVE_EIS_CV:
+//             WORKLED();
+//             break;
 
-        case CURVE_CALI_ADC:
-            if (instru.AdcChannel == IIN_ADC) {
-                Elite_led_color(COLOR_RED);
-            } else if (instru.AdcChannel == VIN_ADC) {
-                Elite_led_color(COLOR_ORANGE);
-            } else if (instru.AdcChannel == VOUT_DAC) {
-                Elite_led_color(COLOR_BLUE);
-            }else if (instru.AdcChannel == EIS_HSDAC) {
-                Elite_led_color(COLOR_PURPLE_DARK);
-            } else if (instru.AdcChannel == EIS_HSTIA) {
-                Elite_led_color(COLOR_WHITE);
-            } else if (instru.AdcChannel == EIS_LPTIA) {
-                Elite_led_color(COLOR_RED);
-            } else if (instru.AdcChannel == EIS_LPDAC) {
-                Elite_led_color(COLOR_BLUE);
-            }
-            break;
+//         case CURVE_CALI_ADC:
+//             if (instru.AdcChannel == IIN_ADC) {
+//                 led_color_set(LED_NB_MAX, LED_CLR_RED);
+//             } else if (instru.AdcChannel == VIN_ADC) {
+//                 led_color_set(LED_NB_MAX, LED_CLR_ORANGE);
+//             } else if (instru.AdcChannel == VOUT_DAC) {
+//                 led_color_set(LED_NB_MAX, LED_CLR_BLUE);
+//             }else if (instru.AdcChannel == EIS_HSDAC) {
+//                 led_color_set(LED_NB_MAX, LED_CLR_PURPLE);
+//             } else if (instru.AdcChannel == EIS_HSTIA) {
+//                 led_color_set(LED_NB_MAX, LED_CLR_WHITE);
+//             } else if (instru.AdcChannel == EIS_LPTIA) {
+//                 led_color_set(LED_NB_MAX, LED_CLR_RED);
+//             } else if (instru.AdcChannel == EIS_LPDAC) {
+//                 led_color_set(LED_NB_MAX, LED_CLR_BLUE);
+//             }
+//             break;
 
-        default:
-            break;
+//         default:
+//             break;
 
-    }
-}
+//     }
+// }
 
-#endif
+// #endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteLatchInit.h

@@ -1,16 +1,16 @@
-
-#ifndef ELITE_LATCH_INIT
-#define ELITE_LATCH_INIT
-
-static void InitLH() {
-    for (int i=0; i<LATCH_BUFF_SIZE; i++) {
-        LH.LATCH0[i]       = 0;
-        LH.LATCH1[i]       = 0;
-        LH.LATCH2[i]       = 0;
-    }
-    LH.LoadState    = 0;
-}
-
-
-#endif
-
+//
+//#ifndef ELITE_LATCH_INIT
+//#define ELITE_LATCH_INIT
+//
+//static void InitLH() {
+//    for (int i=0; i<LATCH_BUFF_SIZE; i++) {
+//        LH.LATCH0[i]       = 0;
+//        LH.LATCH1[i]       = 0;
+//        LH.LATCH2[i]       = 0;
+//    }
+//    LH.LoadState    = 0;
+//}
+//
+//
+//#endif
+//

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteReset.h

@@ -17,7 +17,7 @@ static void reset() {
     AD5940_init();
 //    AD5940_sftreset();
 
-//    PIN_setOutputValue(pin_handle, HIGH_Z_MODE, 0); // HIGH Z MODE // 1: close; 0: open;
+//    PIN_setOutputValue(eliteCtrlHandle, HIGH_Z_MODE, 0); // HIGH Z MODE // 1: close; 0: open;
 
     HSTIAGainCtrl(HSRTIA_200R);
     LPTIAGainCtrl(LPRTIA_200R);
@@ -39,7 +39,7 @@ static void reset() {
         spi_ADC_rxbuf[i] = 0;
     }
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);  // AD_CS HIGH
+    PIN_setOutputValue(eliteCtrlHandle, Board_AD_CS, 1);  // AD_CS HIGH
     ModeLED(NO_EVENT);
     CPUdelay(1600);
 }
@@ -77,7 +77,7 @@ static void Eliteinterrupt() {
         spi_ADC_rxbuf[i] = 0;
     }
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);  // AD_CS HIGH
+    PIN_setOutputValue(eliteCtrlHandle, Board_AD_CS, 1);  // AD_CS HIGH
     ModeLED(NO_EVENT);
     CPUdelay(8000);
 }

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteSPI.h

@@ -1,272 +1,272 @@
 
-#ifndef ELITE_SPI
-#define ELITE_SPI
+// #ifndef ELITE_SPI
+// #define ELITE_SPI
 
-/*
-* Read SPI example in
-* http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/tirtos/2_14_02_22/
-*        exports/tirtos_full_2_14_02_22/docs/doxygen/html/_s_p_i_c_c26_x_x_d_m_a_8h.html
-*/
+// /*
+// * Read SPI example in
+// * http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/tirtos/2_14_02_22/
+// *        exports/tirtos_full_2_14_02_22/docs/doxygen/html/_s_p_i_c_c26_x_x_d_m_a_8h.html
+// */
 
-#include <Board.h>
-#include <ti/drivers/SPI.h>
-#include <ti/drivers/dma/UDMACC26XX.h>
-#include <ti/drivers/spi/SPICC26XXDMA.h>
-#include "Elite_PIN.h"
+// #include <Board.h>
+// #include <ti/drivers/SPI.h>
+// #include <ti/drivers/dma/UDMACC26XX.h>
+// #include <ti/drivers/spi/SPICC26XXDMA.h>
+// #include "Elite_PIN.h"
 
-/* application use SPI parameters and buffers */
-#define SPI_LED_SIZE 28
-#define SPI_DAC_SIZE 6
-#define SPI_ADC_SIZE 4
+// /* application use SPI parameters and buffers */
+// #define SPI_LED_SIZE 28
+// #define SPI_DAC_SIZE 6
+// #define SPI_ADC_SIZE 4
 
-static uint16_t spi_LEDtxbuf[SPI_LED_SIZE] = {0};
-static uint16_t spi_LEDrxbuf[SPI_LED_SIZE] = {0};
+// static uint16_t spi_LEDtxbuf[SPI_LED_SIZE] = {0};
+// static uint16_t spi_LEDrxbuf[SPI_LED_SIZE] = {0};
 
-static uint8_t spi_DACtxbuf[SPI_DAC_SIZE] = {0};
-static uint8_t spi_rxbuf[SPI_DAC_SIZE]    = {0};
+// static uint8_t spi_DACtxbuf[SPI_DAC_SIZE] = {0};
+// static uint8_t spi_rxbuf[SPI_DAC_SIZE]    = {0};
 
-static uint8_t spi_ADC_txbuf[SPI_ADC_SIZE] = {0};
-static uint8_t spi_ADC_rxbuf[SPI_ADC_SIZE] = {0};
-//
-//static uint32_t SeqCmdBuff;
+// static uint8_t spi_ADC_txbuf[SPI_ADC_SIZE] = {0};
+// static uint8_t spi_ADC_rxbuf[SPI_ADC_SIZE] = {0};
+// //
+// //static uint32_t SeqCmdBuff;
 
-/* system use SPI parameters */
-static SPI_Handle      spiHandle0 = NULL;  // SPI0  = LED
-static SPI_Handle      spiHandle1 = NULL;  // SPI1  = ADC +DAC
-static SPI_Params      spiParams0;
-static SPI_Params      spiParams1;
-static SPI_Transaction LED_transaction;
-static SPI_Transaction ADC_DAC_transaction;
+// /* system use SPI parameters */
+// static SPI_Handle      spiHandle0 = NULL;  // SPI0  = LED
+// static SPI_Handle      spiHandle1 = NULL;  // SPI1  = ADC +DAC
+// static SPI_Params      spiParams0;
+// static SPI_Params      spiParams1;
+// static SPI_Transaction LED_transaction;
+// static SPI_Transaction ADC_DAC_transaction;
 
-static void ELITE15_SPI_HOLD();
-static void ELITE15_SPI_CLOSE();
+// static void ELITE15_SPI_HOLD();
+// static void ELITE15_SPI_CLOSE();
 
-static void Elite_SPI_init(){
-    SPI_init();
-    SPI_Params_init(&spiParams0);
-    spiParams0.bitRate     = 2000;  // 2k
-    spiParams0.mode        = SPI_MASTER;
-    spiParams0.dataSize    = 16;
-    spiParams0.frameFormat = SPI_POL0_PHA1;
-    spiHandle0 = SPI_open(Board_SPI0, &spiParams0);  // LED SPI
+// static void Elite_SPI_init(){
+//     SPI_init();
+//     SPI_Params_init(&spiParams0);
+//     spiParams0.bitRate     = 2000;  // 2k
+//     spiParams0.mode        = SPI_MASTER;
+//     spiParams0.dataSize    = 16;
+//     spiParams0.frameFormat = SPI_POL0_PHA1;
+//     spiHandle0 = SPI_open(Board_SPI0, &spiParams0);  // LED SPI
 
-    SPI_Params_init(&spiParams1);
-    spiParams1.bitRate     = 1000000;  // 1M
-    spiParams1.mode        = SPI_MASTER;
-    spiParams1.dataSize    = 8;
-    spiParams1.frameFormat = SPI_POL0_PHA0;
+//     SPI_Params_init(&spiParams1);
+//     spiParams1.bitRate     = 1000000;  // 1M
+//     spiParams1.mode        = SPI_MASTER;
+//     spiParams1.dataSize    = 8;
+//     spiParams1.frameFormat = SPI_POL0_PHA0;
 
-    spiHandle1 = SPI_open(Board_SPI1, &spiParams1);  // ADC DAC SPI
-}
+//     spiHandle1 = SPI_open(Board_SPI1, &spiParams1);  // ADC DAC SPI
+// }
 
-static void LED_SPI(uint8_t length, uint16_t *spi_txbuf, uint16_t *spi_rxbuf) {
-    LED_transaction.count = length;
-    LED_transaction.txBuf = spi_txbuf;
-    LED_transaction.rxBuf = spi_rxbuf;
+// static void LED_SPI(uint8_t length, uint16_t *spi_txbuf, uint16_t *spi_rxbuf) {
+//     LED_transaction.count = length;
+//     LED_transaction.txBuf = spi_txbuf;
+//     LED_transaction.rxBuf = spi_rxbuf;
 
-    SPI_transfer(spiHandle0, &LED_transaction);
-}
+//     SPI_transfer(spiHandle0, &LED_transaction);
+// }
 
-static void ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-    PIN_setOutputValue(pin_handle, AD_CS, 0);      // CS_ADC
+// static void ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 0);      // CS_ADC
 
-    ADC_DAC_transaction.count = length;
-    ADC_DAC_transaction.txBuf = spi_txbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
+//     ADC_DAC_transaction.count = length;
+//     ADC_DAC_transaction.txBuf = spi_txbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
 
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);      // CS_ADC
-}
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 1);      // CS_ADC
+// }
 
-static void DAC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-    ADC_DAC_transaction.count = length;
-    ADC_DAC_transaction.txBuf = spi_txbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
+// static void DAC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
+//     ADC_DAC_transaction.count = length;
+//     ADC_DAC_transaction.txBuf = spi_txbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
 
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
-}
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+// }
 
-static void ELITE15_SPI_HOLD() {
-    Elite_SPI_init();
-//    #ifdef ELITE_PIN_1_5_RE
-//    PIN_setOutputValue(pin_handle, D6, LH.LATCH0[6]);   // ADC_CS
-//    PIN_setOutputValue(pin_handle, D7, LH.LATCH0[7]);   // DAC_CS
-//    PIN_setOutputValue(pin_handle, D4, LH.LATCH0[4]);   // update HIGH_Z_MODE
-//    #endif
-//
-//    PIN_setOutputValue(pin_handle, LOAD0, 1);
-//    PIN_setOutputValue(pin_handle, LOAD1, 0);
-//    PIN_setOutputValue(pin_handle, LOAD2, 0);
-}
-static void ELITE15_SPI_CLOSE() {
-//    PIN_setOutputValue(pin_handle, LOAD0, 0);
-//    PIN_setOutputValue(pin_handle, LOAD1, 0);
-//    PIN_setOutputValue(pin_handle, LOAD2, 0);
+// static void ELITE15_SPI_HOLD() {
+//     Elite_SPI_init();
+// //    #ifdef ELITE_PIN_1_5_RE
+// //    PIN_setOutputValue(pin_handle, D6, LH.LATCH0[6]);   // ADC_CS
+// //    PIN_setOutputValue(pin_handle, D7, LH.LATCH0[7]);   // DAC_CS
+// //    PIN_setOutputValue(pin_handle, D4, LH.LATCH0[4]);   // update HIGH_Z_MODE
+// //    #endif
+// //
+// //    PIN_setOutputValue(pin_handle, LOAD0, 1);
+// //    PIN_setOutputValue(pin_handle, LOAD1, 0);
+// //    PIN_setOutputValue(pin_handle, LOAD2, 0);
+// }
+// static void ELITE15_SPI_CLOSE() {
+// //    PIN_setOutputValue(pin_handle, LOAD0, 0);
+// //    PIN_setOutputValue(pin_handle, LOAD1, 0);
+// //    PIN_setOutputValue(pin_handle, LOAD2, 0);
 
-    SPI_close(spiHandle0);
-    SPI_close(spiHandle1);
-}
+//     SPI_close(spiHandle0);
+//     SPI_close(spiHandle1);
+// }
 
-/* Elite1.5 Calibration SPI */
-static void CAL_ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-    ADC_DAC_transaction.count = length;
-    ADC_DAC_transaction.txBuf = spi_txbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
+// /* Elite1.5 Calibration SPI */
+// static void CAL_ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
+//     ADC_DAC_transaction.count = length;
+//     ADC_DAC_transaction.txBuf = spi_txbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
 
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);      // CS_ADC
-}
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 1);      // CS_ADC
+// }
 
-static void CAL_LED_SPI(uint8_t length, uint16_t *spi_txbuf, uint16_t *spi_rxbuf) {
-    LED_transaction.count = length;
-    LED_transaction.txBuf = spi_txbuf;
-    LED_transaction.rxBuf = spi_rxbuf;
+// static void CAL_LED_SPI(uint8_t length, uint16_t *spi_txbuf, uint16_t *spi_rxbuf) {
+//     LED_transaction.count = length;
+//     LED_transaction.txBuf = spi_txbuf;
+//     LED_transaction.rxBuf = spi_rxbuf;
 
-    SPI_transfer(spiHandle0, &LED_transaction);
-}
+//     SPI_transfer(spiHandle0, &LED_transaction);
+// }
 
 
 
-#ifdef ELITE_VERSION_EIS
-/* define SPI command */
-// datasheet page 98
-#define SPICMD_SETADDR  0x20
-#define SPICMD_WRITEREG 0x2D
-#define SPICMD_READREG  0x6D
+// #ifdef ELITE_VERSION_EIS
+// /* define SPI command */
+// // datasheet page 98
+// #define SPICMD_SETADDR  0x20
+// #define SPICMD_WRITEREG 0x2D
+// #define SPICMD_READREG  0x6D
 
-//define REG
-#define LPDACCON0       0x2128
-#define LPDACSW0        0x2124
-#define LPDACDAT0       0x2120
-#define LPREFBUFCON     0x2050
-#define SWMUX           0x235C
-#define LPTIASW0        0x20E4
-#define SWCON           0x200C
-#define HSDACCON        0x2010
-#define HSDACDAT        0x2048
-#define LPTIACON0       0x20EC
-#define HSTIACON        0x20FC
-#define AFECON          0x2000
-#define DSWFULLCON      0x2150
-#define NSWFULLCON      0x2154
-#define PSWFULLCON      0x2158
-#define TSWFULLCON      0x215C
-#define WGFCW           0x2030
-#define WGPHASE         0x2034
-#define WGOFFSET        0x2038
-#define WGAMPLITUDE     0x203C
-#define WGCON           0x2014
-#define DE0RESCON       0x20F8
-#define ADCCON          0x21A8
-#define DFTCON          0x20D0
-#define ADCFILTERCON    0x2044
-#define PMBW            0x22F0
-#define CLKSEL          0x0414
-#define CLKCON0         0x0408
-#define CLKCON0KEY      0x0420
-#define HSOSCCON        0x20BC
-#define ADCBUFCON       0x238C
-#define HSRTIACON       0x20F0
-#define ADCDAT          0x2074
-#define DFTREAL         0x2078
-#define DFTIMAG         0x207C
+// //define REG
+// #define LPDACCON0       0x2128
+// #define LPDACSW0        0x2124
+// #define LPDACDAT0       0x2120
+// #define LPREFBUFCON     0x2050
+// #define SWMUX           0x235C
+// #define LPTIASW0        0x20E4
+// #define SWCON           0x200C
+// #define HSDACCON        0x2010
+// #define HSDACDAT        0x2048
+// #define LPTIACON0       0x20EC
+// #define HSTIACON        0x20FC
+// #define AFECON          0x2000
+// #define DSWFULLCON      0x2150
+// #define NSWFULLCON      0x2154
+// #define PSWFULLCON      0x2158
+// #define TSWFULLCON      0x215C
+// #define WGFCW           0x2030
+// #define WGPHASE         0x2034
+// #define WGOFFSET        0x2038
+// #define WGAMPLITUDE     0x203C
+// #define WGCON           0x2014
+// #define DE0RESCON       0x20F8
+// #define ADCCON          0x21A8
+// #define DFTCON          0x20D0
+// #define ADCFILTERCON    0x2044
+// #define PMBW            0x22F0
+// #define CLKSEL          0x0414
+// #define CLKCON0         0x0408
+// #define CLKCON0KEY      0x0420
+// #define HSOSCCON        0x20BC
+// #define ADCBUFCON       0x238C
+// #define HSRTIACON       0x20F0
+// #define ADCDAT          0x2074
+// #define DFTREAL         0x2078
+// #define DFTIMAG         0x207C
 
-static void select_REG(uint16_t addr){
-    PIN_setOutputValue(pin_handle, AD_CS, 0);
-//    CPUdelay(16000);
+// static void select_REG(uint16_t addr){
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 0);
+// //    CPUdelay(16000);
 
-    spi_DACtxbuf[0] = SPICMD_SETADDR;
-    spi_DACtxbuf[1] = (uint8_t)((addr & 0xFF00) >> 8);
-    spi_DACtxbuf[2] = (uint8_t)(addr & 0x00FF);
+//     spi_DACtxbuf[0] = SPICMD_SETADDR;
+//     spi_DACtxbuf[1] = (uint8_t)((addr & 0xFF00) >> 8);
+//     spi_DACtxbuf[2] = (uint8_t)(addr & 0x00FF);
 
-    ADC_DAC_transaction.count = 3;
-    ADC_DAC_transaction.txBuf = spi_DACtxbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
-//    CPUdelay(16000);
-    PIN_setOutputValue(pin_handle, AD_CS, 1);
-}
+//     ADC_DAC_transaction.count = 3;
+//     ADC_DAC_transaction.txBuf = spi_DACtxbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+// //    CPUdelay(16000);
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 1);
+// }
 
-static void w16_REG(uint16_t data){
-    PIN_setOutputValue(pin_handle, AD_CS, 0);
-    spi_DACtxbuf[0] = SPICMD_WRITEREG;
-    spi_DACtxbuf[1] = (uint8_t)((data & 0xFF00) >> 8);
-    spi_DACtxbuf[2] = (uint8_t)(data & 0x00FF);
+// static void w16_REG(uint16_t data){
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 0);
+//     spi_DACtxbuf[0] = SPICMD_WRITEREG;
+//     spi_DACtxbuf[1] = (uint8_t)((data & 0xFF00) >> 8);
+//     spi_DACtxbuf[2] = (uint8_t)(data & 0x00FF);
 
-    ADC_DAC_transaction.count = 3;
-    ADC_DAC_transaction.txBuf = spi_DACtxbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+//     ADC_DAC_transaction.count = 3;
+//     ADC_DAC_transaction.txBuf = spi_DACtxbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);
-}
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 1);
+// }
 
-static int16_t r16_REG(){
-    int16_t ret;
+// static int16_t r16_REG(){
+//     int16_t ret;
 
-    PIN_setOutputValue(pin_handle, AD_CS, 0);
-    spi_DACtxbuf[0] = SPICMD_READREG;
-    spi_DACtxbuf[1] = 0x00;
-    spi_DACtxbuf[2] = 0x00;
-    spi_DACtxbuf[3] = 0x00;
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 0);
+//     spi_DACtxbuf[0] = SPICMD_READREG;
+//     spi_DACtxbuf[1] = 0x00;
+//     spi_DACtxbuf[2] = 0x00;
+//     spi_DACtxbuf[3] = 0x00;
 
-    ADC_DAC_transaction.count = 4;
-    ADC_DAC_transaction.txBuf = spi_DACtxbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+//     ADC_DAC_transaction.count = 4;
+//     ADC_DAC_transaction.txBuf = spi_DACtxbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    ret = (int16_t)spi_rxbuf[2] << 8 |    \
-          (int16_t)spi_rxbuf[3];
+//     ret = (int16_t)spi_rxbuf[2] << 8 |    \
+//           (int16_t)spi_rxbuf[3];
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 1);
 
-    return ret;
-}
+//     return ret;
+// }
 
-static void w32_REG(uint32_t data){
-    PIN_setOutputValue(pin_handle, AD_CS, 0);
-    spi_DACtxbuf[0] = SPICMD_WRITEREG;
-    spi_DACtxbuf[1] = (uint8_t)((data & 0xFF000000) >> 24);
-    spi_DACtxbuf[2] = (uint8_t)((data & 0x00FF0000) >> 16);
-    spi_DACtxbuf[3] = (uint8_t)((data & 0x0000FF00) >> 8);
-    spi_DACtxbuf[4] = (uint8_t)(data & 0x000000FF);
+// static void w32_REG(uint32_t data){
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 0);
+//     spi_DACtxbuf[0] = SPICMD_WRITEREG;
+//     spi_DACtxbuf[1] = (uint8_t)((data & 0xFF000000) >> 24);
+//     spi_DACtxbuf[2] = (uint8_t)((data & 0x00FF0000) >> 16);
+//     spi_DACtxbuf[3] = (uint8_t)((data & 0x0000FF00) >> 8);
+//     spi_DACtxbuf[4] = (uint8_t)(data & 0x000000FF);
 
-    ADC_DAC_transaction.count = 5;
-    ADC_DAC_transaction.txBuf = spi_DACtxbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+//     ADC_DAC_transaction.count = 5;
+//     ADC_DAC_transaction.txBuf = spi_DACtxbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);
-}
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 1);
+// }
 
-static int32_t r32_REG(){
-    int32_t ret;
+// static int32_t r32_REG(){
+//     int32_t ret;
 
-    PIN_setOutputValue(pin_handle, AD_CS, 0);
-    spi_DACtxbuf[0] = SPICMD_READREG;
-    spi_DACtxbuf[1] = 0x00;
-    spi_DACtxbuf[2] = 0x00;
-    spi_DACtxbuf[3] = 0x00;
-    spi_DACtxbuf[4] = 0x00;
-    spi_DACtxbuf[5] = 0x00;
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 0);
+//     spi_DACtxbuf[0] = SPICMD_READREG;
+//     spi_DACtxbuf[1] = 0x00;
+//     spi_DACtxbuf[2] = 0x00;
+//     spi_DACtxbuf[3] = 0x00;
+//     spi_DACtxbuf[4] = 0x00;
+//     spi_DACtxbuf[5] = 0x00;
 
-    ADC_DAC_transaction.count = 6;
-    ADC_DAC_transaction.txBuf = spi_DACtxbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
+//     ADC_DAC_transaction.count = 6;
+//     ADC_DAC_transaction.txBuf = spi_DACtxbuf;
+//     ADC_DAC_transaction.rxBuf = spi_rxbuf;
+//     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    ret = (int32_t)spi_rxbuf[2] << 24 |    \
-          (int32_t)spi_rxbuf[3] << 16 |    \
-          (int32_t)spi_rxbuf[4] << 8 |     \
-          (int32_t)spi_rxbuf[5];
+//     ret = (int32_t)spi_rxbuf[2] << 24 |    \
+//           (int32_t)spi_rxbuf[3] << 16 |    \
+//           (int32_t)spi_rxbuf[4] << 8 |     \
+//           (int32_t)spi_rxbuf[5];
 
-    PIN_setOutputValue(pin_handle, AD_CS, 1);
+//     PIN_setOutputValue(pin_handle, Board_AD_CS, 1);
 
-    return ret;
-}
+//     return ret;
+// }
 
-#endif // ELITE_EIS
+// #endif // ELITE_EIS
 
-#endif // ELITE_SPI
+// #endif // ELITE_SPI

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_PIN.h

@@ -1,309 +0,0 @@
-
-#ifndef Elite_PIN
-#define Elite_PIN
-
-#include <ti/drivers/pin/PINCC26XX.h>
-#include <Board.h>
-#include <ti/drivers/PIN.h>
-
-//#define ELITE_PIN_1_5
-//#define ELITE_PIN_1_5_RE
-#define ELITE_PIN_EIS
-
-#ifdef ELITE_PIN_EIS
-/* SPI Board */
-#define Board_SPI0_MISO                 PIN_UNASSIGNED
-#define Board_SPI0_MOSI                 IOID_4
-#define Board_SPI0_CLK                  IOID_3
-#define Board_SPI0_CS                   PIN_UNASSIGNED
-
-#define Board_SPI1_MISO                 IOID_1
-#define Board_SPI1_MOSI                 IOID_6
-#define Board_SPI1_CLK                  IOID_5
-#define Board_SPI1_CS                   PIN_UNASSIGNED
-
-#define AD_CS                           IOID_10
-
-//#define SD_MISO                         IOID_11
-//#define SD_CS                           IOID_8
-//#define SD_CLK                          IOID_7
-//#define SD_MOSI                         IOID_13
-
-#define switch_on                       IOID_14
-#define enable_5v                       IOID_9
-#define AD_reset                        IOID_13
-#define enable_10v                      PIN_UNASSIGNED
-#define HIGH_Z_MODE                     PIN_UNASSIGNED
-#define shutdown_6994                   PIN_UNASSIGNED
-
-#define Turnon_I_LARGE                  PIN_UNASSIGNED
-#define Turnon_I_MID                    PIN_UNASSIGNED
-#define Turnon_I_SMALL                  PIN_UNASSIGNED
-
-#define Turnon_V_MID                    PIN_UNASSIGNED
-#define Turnon_V_SMALL                  PIN_UNASSIGNED
-
-#define Turon_VOUT_SMALL                PIN_UNASSIGNED
-
-
-PIN_Handle       pin_handle;
-static PIN_State ZM_rst;
-
-const PIN_Config BLE_IO[] = {
-    enable_5v | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,// 5V_enable
-    AD_reset | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,
-    switch_on | PIN_INPUT_EN | PIN_PULLDOWN,
-    AD_CS | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,
-    PIN_TERMINATE
-};
-
-static void remove_elite_pin() {
-    PIN_close(pin_handle);
-    pin_handle = PIN_open(&ZM_rst, BLE_IO);
-}
-#endif
-
-
-#ifdef ELITE_PIN_1_5_RE
-/* SPI Board */
-#define Board_SPI0_MISO                 PIN_UNASSIGNED
-#define Board_SPI0_MOSI                 D1
-#define Board_SPI0_CLK                  D0
-#define Board_SPI0_CS                   PIN_UNASSIGNED
-
-#define Board_SPI1_MISO                 IOID_1
-#define Board_SPI1_MOSI                 D3
-#define Board_SPI1_CLK                  D2
-#define Board_SPI1_CS                   PIN_UNASSIGNED
-
-#define D0                              IOID_3
-#define D1                              IOID_4
-#define D2                              IOID_5
-#define D3                              IOID_6
-#define D4                              IOID_7
-#define D5                              IOID_8
-#define D6                              IOID_9
-#define D7                              IOID_10
-
-#define LOAD0                           IOID_13
-#define LOAD1                           IOID_12
-#define LOAD2                           IOID_11
-
-#define ADC_CS                          LOAD0, D6
-#define DAC_CS                          LOAD0, D7
-#define ADC_DAC_SPI_MOSI                LOAD0, D3
-#define ADC_DAC_SPI_CLK                 LOAD0, D2
-#define LED_MOSI                        LOAD0, D1
-#define LED_CLK                         LOAD0, D0
-#define MEM_CS                          LOAD0, D5
-
-#ifdef ELITE_PIN_1_5
-#define MEM_HOLD                        LOAD0, D4
-#define HIGH_Z_MODE                     LOAD2, D5
-#endif
-#ifdef ELITE_PIN_1_5_RE
-#define MEM_HOLD                        LOAD1, D0
-#define HIGH_Z_MODE                     LOAD0, D4
-#endif
-
-#define Turnon_I_MID                    LOAD2, D0
-#define Turnon_I_SMALL                  LOAD2, D4
-#define Turnon_I_LARGE                  LOAD2, D1
-#define Turnon_V_SMALL                  LOAD2, D2
-#define Turnon_V_MID                    LOAD2, D3
-#define Turon_VOUT_SMALL                LOAD2, D7
-#define shutdown_6994                   LOAD2, D6
-
-//#define Turnon10K                       Turnon_I_MID
-//#define Turnon200R                      Turnon_I_LARGE
-
-/* I2C */
-#ifdef ELITE_VERSION_1_4
-#define Board_I2C0_SCL0                 PIN_UNASSIGNED
-#define Board_I2C0_SDA0                 PIN_UNASSIGNED
-#endif
-
-#define switch_on                       IOID_14
-#define enable_10v                      LOAD1, D5
-#define enable_5v                       LOAD1, D6
-
-PIN_Handle       pin_handle;
-static PIN_State ZM_rst;
-
-const PIN_Config BLE_IO[] = {
-//    D0 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-//    D1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-//    D2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-//    D3 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    D4 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    D5 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    D6 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    D7 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-
-    LOAD0 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    LOAD1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    LOAD2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-
-    switch_on | PIN_INPUT_EN | PIN_PULLDOWN,                                    // to sense switch
-
-    PIN_TERMINATE
-};
-
-static void add_elite_pin() {
-//    PIN_Status elite15_status;
-    PIN_add(pin_handle,
-    D0 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL);
-    PIN_add(pin_handle,
-    D1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL);
-    PIN_add(pin_handle,
-    D2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL);
-    PIN_add(pin_handle,
-    D3 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL);
-
-//    if(elite15_status != PIN_SUCCESS) {
-//        LED_color(DARKLED, 0x0F, 0x0F, 0x0F);
-//    }
-}
-
-static void remove_elite_pin() {
-    PIN_close(pin_handle);
-    pin_handle = PIN_open(&ZM_rst, BLE_IO);
-}
-#endif
-
-/*!
- *  @def    BOOSTXL_CC2650MA_SPIName
- *  @brief  Enum of SPI names on the CC2650 Booster Pack
- */
-typedef enum BOOSTXL_CC2650MA_SPIName {
-    BOOSTXL_CC2650MA_SPI0 = 0,
-    BOOSTXL_CC2650MA_SPI1 = 1,
-
-    BOOSTXL_CC2650MA_SPICOUNT
-} BOOSTXL_CC2650MA_SPIName;
-
-/*
- *  ========================== SPI DMA begin ===================================
- */
-/* Place into subsections to allow the TI linker to remove items properly */
-#if defined(__TI_COMPILER_VERSION__)
-#pragma DATA_SECTION(SPI_config, ".const:SPI_config")
-#pragma DATA_SECTION(spiCC26XXDMAHWAttrs, ".const:spiCC26XXDMAHWAttrs")
-#endif
-
-/* Include drivers */
-#include <ti/drivers/spi/SPICC26XXDMA.h>
-
-/* SPI objects */
-SPICC26XXDMA_Object spiCC26XXDMAObjects[BOOSTXL_CC2650MA_SPICOUNT];
-
-/* SPI configuration structure, describing which pins are to be used */
-const SPICC26XXDMA_HWAttrsV1 spiCC26XXDMAHWAttrs[BOOSTXL_CC2650MA_SPICOUNT] = {
-    {
-        .baseAddr           = SSI0_BASE,
-        .intNum             = INT_SSI0_COMB,
-        .intPriority        = ~0,
-        .swiPriority        = 0,
-        .powerMngrId        = PowerCC26XX_PERIPH_SSI0,
-        .defaultTxBufValue  = 0,
-        .rxChannelBitMask   = 1<<UDMA_CHAN_SSI0_RX,
-        .txChannelBitMask   = 1<<UDMA_CHAN_SSI0_TX,
-        .mosiPin            = Board_SPI0_MOSI,
-        .misoPin            = Board_SPI0_MISO,
-        .clkPin             = Board_SPI0_CLK,
-        .csnPin             = Board_SPI0_CS
-    },
-    {
-        .baseAddr           = SSI1_BASE,
-        .intNum             = INT_SSI1_COMB,
-        .intPriority        = ~0,
-        .swiPriority        = 0,
-        .powerMngrId        = PowerCC26XX_PERIPH_SSI1,
-        .defaultTxBufValue  = 0,
-        .rxChannelBitMask   = 1<<UDMA_CHAN_SSI1_RX,
-        .txChannelBitMask   = 1<<UDMA_CHAN_SSI1_TX,
-        .mosiPin            = Board_SPI1_MOSI,
-        .misoPin            = Board_SPI1_MISO,
-        .clkPin             = Board_SPI1_CLK,
-        .csnPin             = Board_SPI1_CS
-    },
-};
-
-/* SPI configuration structure */
-const SPI_Config SPI_config[] = {
-    {
-         .fxnTablePtr = &SPICC26XXDMA_fxnTable,
-         .object      = &spiCC26XXDMAObjects[0],
-         .hwAttrs     = &spiCC26XXDMAHWAttrs[0]
-    },
-    {
-         .fxnTablePtr = &SPICC26XXDMA_fxnTable,
-         .object      = &spiCC26XXDMAObjects[1],
-         .hwAttrs     = &spiCC26XXDMAHWAttrs[1]
-    },
-    {NULL, NULL, NULL}
-};
-/*
- *  ========================== SPI DMA end =====================================
-*/
-
-
-/*
- *  ============================= I2C Begin=====================================
-*/
-
-#ifdef ELITE_VERSION_1_4
-
-/* Generic I2C instance identifiers */
-#define Board_I2C                   CC2650_MA_I2C0
-/*!
- *  @def    CC2650_LAUNCHXL_I2CName
- *  @brief  Enum of I2C names on the CC2650 dev board
- */
-typedef enum CC2650_MA_I2CName {
-    CC2650_MA_I2C0 = 0,
-
-    CC2650_MA_I2CCOUNT
-} CC2650_MA_I2CName;
-
-/* Place into subsections to allow the TI linker to remove items properly */
-#if defined(__TI_COMPILER_VERSION__)
-#pragma DATA_SECTION(I2C_config, ".const:I2C_config")
-#pragma DATA_SECTION(i2cCC26xxHWAttrs, ".const:i2cCC26xxHWAttrs")
-#endif
-
-/* Include drivers */
-#include <ti/drivers/i2c/I2CCC26XX.h>
-
-/* I2C objects */
-I2CCC26XX_Object i2cCC26xxObjects[CC2650_MA_I2CCOUNT];
-
-/* I2C configuration structure, describing which pins are to be used */
-const I2CCC26XX_HWAttrsV1 i2cCC26xxHWAttrs[CC2650_MA_I2CCOUNT] = {
-    {
-        .baseAddr = I2C0_BASE,
-        .powerMngrId = PowerCC26XX_PERIPH_I2C0,
-        .intNum = INT_I2C_IRQ,
-        .intPriority = ~0,
-        .swiPriority = 0,
-        .sdaPin = Board_I2C0_SDA0,
-        .sclPin = Board_I2C0_SCL0,
-    }
-};
-
-/* I2C configuration structure */
-const I2C_Config I2C_config[] = {
-    {
-        .fxnTablePtr = &I2CCC26XX_fxnTable,
-        .object = &i2cCC26xxObjects[0],
-        .hwAttrs = &i2cCC26xxHWAttrs[0]
-    },
-    {NULL, NULL, NULL}
-};
-/*
- *  ========================== I2C end =========================================
- */
-#endif
-
-#endif
-

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_batt.h

@@ -81,7 +81,7 @@ static void measureBat(){
     uint16_t bat = ((uint16_t)(NotifyVoltBat[2]) << 8 & 0xFF00 ) |
                    ((uint16_t)(NotifyVoltBat[3]) & 0x00FF);
     if( bat < 768 && bat > 20){
-        PIN_setOutputValue(pin_handle, enable_5v, 0);
+        PIN_setOutputValue(eliteCtrlHandle, Board_5V_enable, 0);
     }
 }
 

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_def.h

@@ -90,10 +90,10 @@ enum all_mode_e {
 #define COLOR_CYAN_DARK          0xF6
 #define COLOR_PURPLE_DARK        0xF8
 
-#define LEDPowerON()             Elite_led_color(COLOR_GREEN)
-#define WORKLED()                Elite_led_color(COLOR_CYAN)
-#define KEYLED()                 Elite_led_color(COLOR_YELLOW)
-#define BT_WAIT_LED()            Elite_led_color(COLOR_YELLOWGREEN)
+#define LEDPowerON()             led_color_set(LED_NB_MAX, LED_CLR_GREEN);
+#define WORKLED()                led_color_set(LED_NB_MAX, LED_CLR_CYAN);
+#define KEYLED()                 led_color_set(LED_NB_MAX, LED_CLR_YELLOW);
+#define BT_WAIT_LED()            led_color_set(LED_NB_MAX, LED_CLR_BLUE);
 
 
 #define BT_WAIT                  0x01

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_mode_ADC_DAC.h

@@ -48,9 +48,9 @@ static void vscan_volt_out(void)
     MEAS_VOUT(wm) = DAC_outputV(Vset);
 
     if (Vset == cv->_Vinit && cv->bFirst){
-        Elite_led_color(COLOR_ORANGE);
+        led_color_set(LED_NB_MAX, LED_CLR_ORANGE);
         CPUdelay(30000);
-        Elite_led_color(COLOR_CYAN);
+        led_color_set(LED_NB_MAX, LED_CLR_CYAN);
     }
 
 //    InputNotify(NOTIFY_VOLT, vscan);
@@ -125,7 +125,7 @@ static void DACenable(uint8_t afterRead)
                 break;
 
             default:{
-                Elite_led_color(COLOR_PURPLE);
+                led_color_set(LED_NB_MAX, LED_CLR_PURPLE);
                 break;
             }
         }

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/headstage.h

@@ -427,7 +427,6 @@ characteristic change event
 #define SBP_CHAR_CHANGE_EVT  0x0002
 #define SBP_PERIODIC_EVT     0x0004
 #define SBP_CONN_EVT_END_EVT 0x0008
-#define SBP_KEY_CHANGE_EVT   0x0010
 #endif
 
 /**************************
@@ -451,7 +450,6 @@ characteristic change event
 #define BLE_CIS_BUFF_CHAR SIMPLEPROFILE_CHAR2
 #define BLE_INS_BUFF_CHAR SIMPLEPROFILE_CHAR3
 #define BLE_DAT_BUFF_CHAR SIMPLEPROFILE_CHAR4
-#define BLE_CIS_BUFF_SIZE SIMPLEPROFILE_CHAR2_LEN
 #define BLE_INS_BUFF_SIZE SIMPLEPROFILE_CHAR3_LEN
 #define BLE_DAT_BUFF_SIZE SIMPLEPROFILE_CHAR4_LEN
 #define CHANNEL_COUNT     16
@@ -493,7 +491,7 @@ static void InitLH();
 static void Init_Elite15_PIN();
 
 
-static Clock_Struct    periodicClock;
+//static Clock_Struct    periodicClock;
 static bool            PeriodicEvent     = false;
 static bool            InitPeriodicEvent = true;
 static bool            megaStiEnable     = false;
@@ -624,7 +622,7 @@ static void     VoutGainControl(uint8_t VOUTLevel);
 static void     PIN15_setOutputValue (uint32_t latch_num, uint32_t pin_num, bool highlow);
 
 // Elite key detection & turn on/ shutdown function (peripheral hardware control)
-static void     Elite_led_color(uint16_t color);
+//static void     Elite_led_color(uint16_t color);
 static void     ModeLED(uint16_t modeStatus);
 //static void LED_color(uint8_t bright, uint8_t red, uint8_t green, uint8_t blue);
 static bool     If10Von = false;
@@ -633,7 +631,7 @@ static void     TurnOn10V();
 // periodic event control
 static void     EliteADCControl(void);
 static void     vscan_ctrl(void);
-static void     cv_vscan(void);
+//static void     cv_vscan(void);
 static void     mode_done(void);
 
 //mode (DAC)
@@ -875,7 +873,7 @@ static void update_ZM_instruction(uint8 *ins) {
                     instru.notifyRate    = 1000;
                     instru.sampleRate    = 15;
                     instru.VoViSwitch    = 0x00;   // 0: read Vout voltage
-//                    PIN_setOutputValue(pin_handle, HIGH_Z_MODE, 1);   // 1 => close high_z mode
+//                    PIN_setOutputValue(eliteCtrlHandle, HIGH_Z_MODE, 1);   // 1 => close high_z mode
                     instru.VoltConstant  = ( ((uint16_t)(ins[4])) << 8) | (uint16_t)(ins[5]);      // output voltage
                     DAC_outputV(instru.VoltConstant); //UserCode -> DAC code -> DAC out
                     ModeLED(WORKING);
@@ -1021,19 +1019,19 @@ static void update_ZM_instruction(uint8 *ins) {
 
                 case 0x03: { // ble write: 0x3000FF 03
                     if (ins[4] == 1) {
-                        Elite_led_color(COLOR_RED); //0301
+                        led_color_set(LED_NB_MAX, LED_CLR_RED); //0301
                     } else if (ins[4] == 2){
-                        Elite_led_color(COLOR_ORANGE); //0302
+                        led_color_set(LED_NB_MAX, LED_CLR_ORANGE); //0302
                     } else if (ins[4] == 3){
-                        Elite_led_color(COLOR_YELLOW);
+                        led_color_set(LED_NB_MAX, LED_CLR_YELLOW);
                     } else if (ins[4] == 4){
-                        Elite_led_color(COLOR_GREEN);
+                        led_color_set(LED_NB_MAX, LED_CLR_GREEN);
                     } else if (ins[4] == 5){
-                        Elite_led_color(COLOR_BLUE);
+                        led_color_set(LED_NB_MAX, LED_CLR_BLUE);
                     } else if (ins[4] == 6){
-                        Elite_led_color(COLOR_MAGENTA);
+                        led_color_set(LED_NB_MAX, LED_CLR_PURPLE);
                     } else if (ins[4] == 7){
-                        Elite_led_color(COLOR_RED);
+                        led_color_set(LED_NB_MAX, LED_CLR_MAGENTA);
                     }
                     break;
                 }
@@ -1047,7 +1045,7 @@ static void update_ZM_instruction(uint8 *ins) {
 
                     setEIS_EIS();
                     DAC_outputF(instru.fset);
-                    LED_color(DARKLED, 0x80, 0x00, 0x80);
+                    LED_color(LED_BR_LV1, 0x80, 0x00, 0x80);
                     break;
                 }
 
@@ -1060,7 +1058,7 @@ static void update_ZM_instruction(uint8 *ins) {
                     cali_flag = true;
                     setEIS_EIS();
                     freq_out();
-                    LED_color(DARKLED, 0x80, 0x00, 0x80);
+                    LED_color(LED_BR_LV1, 0x80, 0x00, 0x80);
                     break;
                 }
             }
@@ -1104,7 +1102,7 @@ static void update_ZM_instruction(uint8 *ins) {
         }
 
         case VIS_FUH: {
-            LED_color(DARKLED, 0x0F, 0x00, 0x0F);
+            LED_color(LED_BR_LV1, 0x0F, 0x00, 0x0F);
             break;
         }
 
@@ -1117,10 +1115,10 @@ static void update_ZM_instruction(uint8 *ins) {
         }
 
         case VIS_DEVICE_SHINY: { //detect
-            Elite_led_color(COLOR_PURPLE);
+            led_color_set(LED_NB_MAX, LED_CLR_PURPLE);
 //            uint8_t deviceShinySwitch = (ins[2] & 0b11110000) >> 4;//1:open 0:close
 //            if(deviceShinySwitch == 1){
-//                 Elite_led_color(COLOR_PURPLE);
+//                 led_color_set(LED_NB_MAX, LED_CLR_PURPLE);
 //            }else if(deviceShinySwitch == 0){
 //                 if(PeriodicEvent){
 //                      WORKLED();
@@ -1179,15 +1177,15 @@ static void update_ZM_instruction(uint8 *ins) {
 
         case CIS_LED_TEST: { //0x7070
             if (ins[2] == 0) {
-                Elite_led_color(ins[3]);
+                
             } else if (ins[2] == 1) {
-                LED_color(LIGHTLED, ins[3], ins[4], ins[5]);
+                LED_color(LED_BR_LV8, ins[3], ins[4], ins[5]);
             } else if (ins[2] == 2) {
-                LED_color(DARKLED, ins[3], ins[4], ins[5]);
+                LED_color(LED_BR_LV1, ins[3], ins[4], ins[5]);
             } else if (ins[2] == 3) {
-                Elite_led_color(COLOR_PURPLE);
+                led_color_set(LED_NB_MAX, LED_CLR_PURPLE);
             } else if (ins[2] == 4) {
-                Elite_led_color(COLOR_ORANGE);
+                led_color_set(LED_NB_MAX, LED_CLR_ORANGE);
             }
             break;
         }
@@ -1357,92 +1355,92 @@ p information ====
 #include "gapgattserver.h"
 #include "gattservapp.h"
 
-static void headstage_init_device_info() {
-    char *  date  = __DATE__;
-    uint8_t year  = 10 * (date[9] - '0') + (date[10] - '0');
-    uint8_t month = 0;
-
-    switch (date[0]) {
-    case 'J':
-        // Jan, January
-        // Jun, June
-        // Jul, July
-        if (date[1] == 'a') {
-            month = 1;
-        } else if (date[2] == 'n') {
-            month = 6;
-        } else {
-            month = 7;
-        }
-        break;
-    case 'F':
-        // Feb, February
-        month = 2;
-        break;
-    case 'M':
-        // Mar, March
-        // May, May
-        if (date[2] == 'r') {
-            month = 3;
-        } else {
-            month = 5;
-        }
-        break;
-    case 'A':
-        // Apr, April
-        // Ang, August
-        if (date[1] == 'p') {
-            month = 4;
-        } else {
-            month = 8;
-        }
-        break;
-    case 'S':
-        // Sep, September
-        month = 9;
-        break;
-    case 'O':
-        // Oct, October
-        month = 10;
-        break;
-    case 'N':
-        // Nov, November
-        month = 11;
-        break;
-    case 'D':
-        // Dec, December
-        month = 12;
-        break;
-    }
-
-    uint8_t  scanRspData[64];
-    uint8_t *p = scanRspData;
-    *p++       = sizeof(DEVICE_NAME);
-    *p++       = GAP_ADTYPE_LOCAL_NAME_COMPLETE;
-    for (unsigned int i = 0; i < sizeof(DEVICE_NAME) - 1; i++) {
-        *p++ = DEVICE_NAME[i];
-    }
-    *p++ = 16;
-    *p++ = GAP_ADTYPE_MANUFACTURER_SPECIFIC;
-    *p++ = 'B';
-    *p++ = 'P';
-    *p++ = 'H';
-    *p++ = 'S';
-    *p++ = MAJOR_PRODUCT_NUMBER;
-    *p++ = MINOR_PRODUCT_NUMBER;
-    *p++ = MAJOR_VERSION_NUMBER;
-    *p++ = MINOR_VERSION_NUMBER;
-    *p++ = year;
-    *p++ = month;
-    *p++ = 'B';
-    *p++ = 'A';
-    *p++ = 'T';
-    *p++ = NotifyVoltBat[3];
-    *p++ = NotifyVoltBat[2];
-
-    GGS_SetParameter(GGS_DEVICE_NAME_ATT, sizeof(DEVICE_NAME), DEVICE_NAME);
-
-    GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, p - scanRspData, scanRspData);
-}
+//static void headstage_init_device_info() {
+//    char *  date  = __DATE__;
+//    uint8_t year  = 10 * (date[9] - '0') + (date[10] - '0');
+//    uint8_t month = 0;
+//
+//    switch (date[0]) {
+//    case 'J':
+//        // Jan, January
+//        // Jun, June
+//        // Jul, July
+//        if (date[1] == 'a') {
+//            month = 1;
+//        } else if (date[2] == 'n') {
+//            month = 6;
+//        } else {
+//            month = 7;
+//        }
+//        break;
+//    case 'F':
+//        // Feb, February
+//        month = 2;
+//        break;
+//    case 'M':
+//        // Mar, March
+//        // May, May
+//        if (date[2] == 'r') {
+//            month = 3;
+//        } else {
+//            month = 5;
+//        }
+//        break;
+//    case 'A':
+//        // Apr, April
+//        // Ang, August
+//        if (date[1] == 'p') {
+//            month = 4;
+//        } else {
+//            month = 8;
+//        }
+//        break;
+//    case 'S':
+//        // Sep, September
+//        month = 9;
+//        break;
+//    case 'O':
+//        // Oct, October
+//        month = 10;
+//        break;
+//    case 'N':
+//        // Nov, November
+//        month = 11;
+//        break;
+//    case 'D':
+//        // Dec, December
+//        month = 12;
+//        break;
+//    }
+//
+//    uint8_t  scanRspData[64];
+//    uint8_t *p = scanRspData;
+//    *p++       = sizeof(DEVICE_NAME);
+//    *p++       = GAP_ADTYPE_LOCAL_NAME_COMPLETE;
+//    for (unsigned int i = 0; i < sizeof(DEVICE_NAME) - 1; i++) {
+//        *p++ = DEVICE_NAME[i];
+//    }
+//    *p++ = 16;
+//    *p++ = GAP_ADTYPE_MANUFACTURER_SPECIFIC;
+//    *p++ = 'B';
+//    *p++ = 'P';
+//    *p++ = 'H';
+//    *p++ = 'S';
+//    *p++ = MAJOR_PRODUCT_NUMBER;
+//    *p++ = MINOR_PRODUCT_NUMBER;
+//    *p++ = MAJOR_VERSION_NUMBER;
+//    *p++ = MINOR_VERSION_NUMBER;
+//    *p++ = year;
+//    *p++ = month;
+//    *p++ = 'B';
+//    *p++ = 'A';
+//    *p++ = 'T';
+//    *p++ = NotifyVoltBat[3];
+//    *p++ = NotifyVoltBat[2];
+//
+//    GGS_SetParameter(GGS_DEVICE_NAME_ATT, sizeof(DEVICE_NAME), DEVICE_NAME);
+//
+//    GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, p - scanRspData, scanRspData);
+//}
 
 #endif  // HEADSTAGE_H

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/headstage_tni.h

@@ -1,305 +0,0 @@
-
-#ifndef HEADSTAGE_H
-#error "headstage.h not include"
-#endif
-
-#ifdef HEADSTAGE_H_H
-#error "headstage_*.h has be included"
-#endif
-
-#ifndef HEADSTAGE_TNI_H
-#define HEADSTAGE_H_H
-#define HEADSTAGE_TNI_H
-
-// product information
-#define DEVICE_NAME "Elite-v0.1"
-#define MAJOR_PRODUCT_NUMBER 0
-#define MINOR_PRODUCT_NUMBER 1
-#define MAJOR_VERSION_NUMBER 0
-#define MINOR_VERSION_NUMBER 1
-
-// header
-#include <ti/drivers/PIN.h>
-#include "board.h"
-
-/*============
- ==== SPI ====
- ===========*/
-
-/* application use SPI parameters and buffers */
-
-#define SPI_BUFFER_SIZE 16
-
-static uint8_t spi_txbuf[SPI_BUFFER_SIZE] = {0};
-static uint8_t spi_rxbuf[SPI_BUFFER_SIZE] = {0};
-
-/*=============================
- ==== headstage variable ====
- ============================*/
-
-PIN_Handle       pin_handle;
-static PIN_State DBS_rst;
-
-// DBS reset pin
-
-const PIN_Config BLE_IO[] = {
-    //
-    IOID_9 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    IOID_2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    IOID_3 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    IOID_13 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
-    PIN_TERMINATE  //
-};
-
-/**
- * ADC clock switch signal.
- */
-static bool adc_clock_signal = FALSE;
-
-/*=======================================
- ==== headstage function declaration ====
- ======================================*/
-
-static void headstage_tni_update_instruction_callback(uint8_t ins_type, uint8_t ins_op, uint8_t ins_len, uint8_t *ins);
-
-/*=============================
- ==== ramp data generating ====
- ============================*/
-
-static uint16_t ramp_data_counter = 0;
-
-static void create_ramp(uint8_t *buff) {
-    buff[0] = 0b10110000 | (0b00001111 & (uint8_t)(ramp_data_counter >> 6));
-    buff[1] = (uint8_t)(ramp_data_counter << 2);
-    ramp_data_counter += 1;
-}
-
-/*=======================================
- ==== headstage function implemented ====
- ======================================*/
-
-/**
- * change channel value to little endian
- */
-static uint8 encode_channel(uint8 channel) {
-    return 0x0F & (((channel & 0b1000) >> 3) |  //
-                   ((channel & 0b0100) >> 1) |  //
-                   ((channel & 0b0010) << 1) |  //
-                   ((channel & 0b0001) << 3));
-}
-
-static void headstage_init() {
-    set_update_instruction_callback(headstage_tni_update_instruction_callback);
-
-    // initialize the DBS reset pin
-    pin_handle = PIN_open(&DBS_rst, BLE_IO);
-    PIN_setOutputValue(pin_handle, IOID_9, 1);
-    PIN_setOutputValue(pin_handle, IOID_2, 0);
-    PIN_setOutputValue(pin_handle, IOID_3, 0);
-}
-
-/**
- * change the recording clock bit in the instruction buffer.
- */
-static void update_ins_rec_clock(uint8_t *buf, bool adc_clock_signal) {
-    buf[3] = (buf[3] & 0b11110000) | ((adc_clock_signal) ? 0b1000 : 0);
-}
-
-/**
- * change the recording channel bit in the instruction buffer.
- */
-static void update_ins_rec_channel(uint8_t *buf, uint8 channel) {
-    buf[1] = (buf[1] & 0b00001111) | (encode_channel(channel) << 4);
-}
-
-/**
- * change the stimulation enable bit in the instruction buffer.
- */
-static void update_ins_sti_enable(uint8_t *buf, bool enable) {
-    buf[1] = (buf[1] & 0b11111101) | ((enable) ? 0b10 : 0);
-}
-
-/**
- * change the stimulating channel bit in the instruction buffer.
- */
-static void update_ins_sti_channel(uint8_t *buf, uint8 sti_chp, uint8 sti_chn) {
-    buf[2] = (buf[2] & 0b11110000) | encode_channel(sti_chp);
-    buf[3] = (buf[3] & 0b00001111) | (encode_channel(sti_chn) << 4);
-}
-
-static void update_ins_buffer() {
-    uint8 header      = 0b10100000;
-    uint8 amp_gain    = (instru.amp_gain & 0b11) << 3;
-    uint8 amp_lbf     = instru.amp_low_band_freq & 0b111;
-    uint8 channel     = 0;  // should be call update_ins_channel to modify this value
-    uint8 chopper     = (instru.chopper) ? 0b00001000 : 0;
-    uint8 fast_settle = (instru.fast_settle) ? 0b00000100 : 0;
-    uint8 sti_enable  = (instru.work_mode != STI_MODE_DISABLE) ? 0b00000010 : 0;
-    uint8 sti_volt_l  = (instru.sti_volt & 0b11111) >> 4;
-    uint8 sti_volt_h  = (instru.sti_volt & 0b01111) << 4;
-    uint8 sti_chp     = instru.sti_channel_pmos & 0b1111;
-    uint8 sti_chn     = (instru.sti_channel_nmos & 0b1111) << 4;
-    uint8 clk_signal  = 0;  // should be call update_ins_clock to modify this value
-
-    spi_txbuf[0] = header | amp_gain | amp_lbf;
-    spi_txbuf[1] = channel | chopper | fast_settle | sti_enable | sti_volt_l;
-    spi_txbuf[2] = sti_volt_h | sti_chp;
-    spi_txbuf[3] = sti_chn | clk_signal;
-}
-
-static bool update_ins_rec_buffer() {
-    adc_clock_signal = (adc_clock_signal) ? FALSE : TRUE;  // switch adc_clock
-    update_ins_rec_clock(spi_txbuf, adc_clock_signal);
-
-    if (adc_clock_signal) {
-        // change to next channel
-
-        if (next_active_channel()) {
-            update_ins_rec_channel(spi_txbuf, channel_pointer);
-        } else {
-            // no channel active
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Change the instruction content for SPI buffer, which is depended on the
- * work_mode. Expend the remind instruction according to the base instruction
- * which allocated at the beginning 4 bytes of the SPI buffer.
- *
- * ========= ===========
- * work_mode ins pattern
- * ========= ===========
- * POS, NEG  4 F  D 0
- * P2N, N2P  4 4' F D
- * AWF       not impl
- * ========= ===========
- *
- * pattern *4*
- *     stimulation instruction.
- *
- * pattern *F*
- *     set pmos channel to 0xF, release the remain voltage in the capacitance.
- *
- * pattern *D*
- *     disable stimulation
- *
- * pattern *0*
- *     nop.
- *
- * @param: buf: pointer of the SPI buffer.
- */
-static void update_ins_sti_buffer() {
-    switch (instru.work_mode) {
-    case STI_MODE_POS:
-    case STI_MODE_NEG:
-        // copy [4:7]
-        spi_txbuf[4] = spi_txbuf[0];
-        spi_txbuf[5] = spi_txbuf[1];
-        spi_txbuf[6] = spi_txbuf[2];
-        spi_txbuf[7] = spi_txbuf[3];
-        // copy [8:B]
-        spi_txbuf[8]  = spi_txbuf[0];
-        spi_txbuf[9]  = spi_txbuf[1];
-        spi_txbuf[10] = spi_txbuf[2];
-        spi_txbuf[11] = spi_txbuf[3];
-        // reset [C:F]
-        spi_txbuf[12] = 0;
-        spi_txbuf[13] = 0;
-        spi_txbuf[14] = 0;
-        spi_txbuf[15] = 0;
-        // change content
-        update_ins_sti_enable(spi_txbuf, TRUE);
-        // ins buf [4:7]
-        update_ins_sti_enable(spi_txbuf + 4, TRUE);
-        update_ins_sti_channel(spi_txbuf + 4, 0xF, instru.sti_channel_pmos);
-        // ins buf [8:B]
-        update_ins_sti_enable(spi_txbuf + 8, FALSE);
-        break;
-    case STI_MODE_P2N:
-    case STI_MODE_N2P:
-        // copy [4:7]
-        spi_txbuf[4] = spi_txbuf[0];
-        spi_txbuf[5] = spi_txbuf[1];
-        spi_txbuf[6] = spi_txbuf[2];
-        spi_txbuf[7] = spi_txbuf[3];
-        // copy [8:B]
-        spi_txbuf[8]  = spi_txbuf[0];
-        spi_txbuf[9]  = spi_txbuf[1];
-        spi_txbuf[10] = spi_txbuf[2];
-        spi_txbuf[11] = spi_txbuf[3];
-        // copy [C:F]
-        spi_txbuf[12] = spi_txbuf[0];
-        spi_txbuf[13] = spi_txbuf[1];
-        spi_txbuf[14] = spi_txbuf[2];
-        spi_txbuf[15] = spi_txbuf[3];
-        // change content
-        update_ins_sti_enable(spi_txbuf + 0, TRUE);
-        update_ins_sti_channel(spi_txbuf + 0, instru.sti_channel_pmos, instru.sti_channel_nmos);
-        // ins buf [4:7]
-        update_ins_sti_enable(spi_txbuf + 4, TRUE);
-        update_ins_sti_channel(spi_txbuf + 4, instru.sti_channel_nmos, instru.sti_channel_pmos);
-        // ins buf [8:B]
-        update_ins_sti_enable(spi_txbuf + 8, TRUE);
-        update_ins_sti_channel(spi_txbuf + 8, 0xF, instru.sti_channel_nmos);
-        // ins buf [C:F]
-        update_ins_sti_enable(spi_txbuf + 12, FALSE);
-        break;
-    case STI_MODE_AWF:
-        // XXX define the voltage change
-        break;
-    default:
-        // do nothing
-        break;
-    }
-}
-
-static void headstage_tni_update_instruction_callback(uint8_t ins_type, uint8_t ins_op, uint8_t ins_len, uint8_t *ins) {
-    switch (ins_type) {
-    case INS_TYPE_VIS: {
-    // reset
-    case VIS_RST:
-        // reset. reset all variable
-        adc_clock_signal = FALSE;
-        memset(spi_txbuf, 0, SPI_BUFFER_SIZE);
-        break;
-
-    // interrupt
-    case VIS_INT:
-        // stop. reset channel table
-        ramp_data_counter = 0;
-        memset(spi_txbuf, 0, SPI_BUFFER_SIZE);
-        break;
-    }
-    case INS_TYPE_RIS:
-    default:
-        break;
-    }
-}
-
-static uint8_t *spi_transact_rec_instruction() {
-    if (IS_REC_MODE(instru.work_mode)) {
-        PIN_setOutputValue(pin_handle, IOID_13, 1);  // DBS_P2S turn on
-        headstage_spi_transaction(SPI_BUFFER_SIZE, spi_txbuf, spi_rxbuf);
-        PIN_setOutputValue(pin_handle, IOID_13, 0);  // DBS_P2S turn off
-
-    } else if (IS_ARM_MODE(instru.work_mode) && !adc_clock_signal) {
-        create_ramp(spi_rxbuf);
-    }
-
-    if (adc_clock_signal) {
-        return NULL;
-    } else {
-        return spi_rxbuf;
-    }
-}
-
-static uint8_t *spi_transact_sti_instruction() {
-    headstage_spi_transaction(16, spi_txbuf, NULL);
-    return NULL;
-}
-
-#endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/impedance_meter.h

@@ -45,8 +45,8 @@ static void ZM_init() {
     set_update_instruction_callback(ZM_update_instruction_callback);
 
     // initialize
-    pin_handle = PIN_open(&ZM_rst, BLE_IO);
-    PIN_setOutputValue(pin_handle, AD_CS, 1);            // AD_CS HIGH
+    eliteCtrlHandle = PIN_open(&eliteState, EIS_1_1_BoardGpioInitTable);
+    PIN_setOutputValue(eliteCtrlHandle, Board_AD_CS, 1);            // AD_CS HIGH
 
     InitEliteInstruction();
 
@@ -55,8 +55,8 @@ static void ZM_init() {
     elite_gptimer_open();
     elite_gptimer_start();
 
-    //    PIN_registerIntCb(pin_handle, switch_on_callback);
-    //    PIN_setInterrupt(pin_handle, switch_on | PIN_IRQ_POSEDGE);
+    //    PIN_registerIntCb(eliteCtrlHandle, switch_on_callback);
+    //    PIN_setInterrupt(eliteCtrlHandle, Board_SHUT_DOWN | PIN_IRQ_POSEDGE);
 }
 
 static void ZM_update_instruction_callback(uint8_t ins_type, uint8_t chip_ID, uint8_t *ins) {}
@@ -198,7 +198,7 @@ static void SimpleBLEPeripheral_performPeriodicTask(void) {
                         DAC_outputV(instru.Ve1);
                         PeriodicEvent = false;
                         SetEISHIGHZ(1);
-                        // PIN_setOutputValue(pin_handle, HIGH_Z_MODE, 0); // 0: open highz;
+                        // PIN_setOutputValue(eliteCtrlHandle, HIGH_Z_MODE, 0); // 0: open highz;
                         ModeLED(NO_EVENT);
                     }
                 }
@@ -209,7 +209,7 @@ static void SimpleBLEPeripheral_performPeriodicTask(void) {
                 vscanReset = true;
                 if (first_highz_flag && GPT.LeadTimeCounter >= 1000) {
                         SetEISHIGHZ(1); // // High Z | 1 off | 0 on
-    //                    PIN_setOutputValue(pin_handle, HIGH_Z_MODE, 1); // HIGH Z MODE // 1: close; 0: open;
+    //                    PIN_setOutputValue(eliteCtrlHandle, HIGH_Z_MODE, 1); // HIGH Z MODE // 1: close; 0: open;
                     first_highz_flag = false;
                 }
             } else {
@@ -323,9 +323,9 @@ static void vscan_ctrl(void)
             eis_fscan();
             break;
 
-        case CURVE_EIS_CV:
-            cv_vscan();
-            break;
+//        case CURVE_EIS_CV:
+//            cv_vscan();
+//            break;
 
         default:{
             break;

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/scan_volt.h

@@ -1,64 +1,64 @@
-#ifndef SCAN_VOLT_H
-#define SCAN_VOLT_H
-
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-#define Vset instru.Vset
-
-static void vo_vscan(void)
-{
-    struct wm_vo_ctx_t *vo = (struct wm_vo_ctx_t *)wm_get();
-
-    if (vscanReset) {
-        Vset = vo->_Vinit;
-    }
-
-    if(!vscanReset) {
-        Vset = vo->_Vinit;
-    }
-
-    return;
-}
-
-static void chg_vo_para(uint16_t parameter, int32_t value)
-{
-    uint16_t pa = parameter;
-    int32_t val = value;
-    struct wm_vo_ctx_t *vo = (struct wm_vo_ctx_t *)wm_get();
-
-    if (pa == DAC_VOLT) {
-        vo->_Vinit = val;
-    }
-
-    return;
-}
-
-static void chg_it_para(uint16_t parameter, int32_t value)
-{
-    uint16_t pa = parameter;
-    int32_t val = value;
-    struct wm_it_ctx_t *it = (struct wm_it_ctx_t *)wm_get();
-
-    if (pa == DAC_VOLT) {
-        it->_Vinit = val;
-    }
-
-    return;
-}
-
-static void chg_rt_para(uint16_t parameter, int32_t value)
-{
-    uint16_t pa = parameter;
-    int32_t val = value;
-    struct wm_rt_ctx_t *rt = (struct wm_rt_ctx_t *)wm_get();
-
-    if (pa == DAC_VOLT) {
-        rt->_Vinit = val;
-    }
-
-    return;
-}
-
-#endif
+//#ifndef SCAN_VOLT_H
+//#define SCAN_VOLT_H
+//
+//#ifdef  __cplusplus
+//extern "C" {
+//#endif
+//
+//#define Vset instru.Vset
+//
+//static void vo_vscan(void)
+//{
+//    struct wm_vo_ctx_t *vo = (struct wm_vo_ctx_t *)wm_get();
+//
+//    if (vscanReset) {
+//        Vset = vo->_Vinit;
+//    }
+//
+//    if(!vscanReset) {
+//        Vset = vo->_Vinit;
+//    }
+//
+//    return;
+//}
+//
+//static void chg_vo_para(uint16_t parameter, int32_t value)
+//{
+//    uint16_t pa = parameter;
+//    int32_t val = value;
+//    struct wm_vo_ctx_t *vo = (struct wm_vo_ctx_t *)wm_get();
+//
+//    if (pa == DAC_VOLT) {
+//        vo->_Vinit = val;
+//    }
+//
+//    return;
+//}
+//
+//static void chg_it_para(uint16_t parameter, int32_t value)
+//{
+//    uint16_t pa = parameter;
+//    int32_t val = value;
+//    struct wm_it_ctx_t *it = (struct wm_it_ctx_t *)wm_get();
+//
+//    if (pa == DAC_VOLT) {
+//        it->_Vinit = val;
+//    }
+//
+//    return;
+//}
+//
+//static void chg_rt_para(uint16_t parameter, int32_t value)
+//{
+//    uint16_t pa = parameter;
+//    int32_t val = value;
+//    struct wm_rt_ctx_t *rt = (struct wm_rt_ctx_t *)wm_get();
+//
+//    if (pa == DAC_VOLT) {
+//        rt->_Vinit = val;
+//    }
+//
+//    return;
+//}
+//
+//#endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/main.c

@@ -50,13 +50,9 @@
 
 #include <xdc/runtime/Error.h>
 
-
 #include <ti/drivers/Power.h>
 #include <ti/drivers/power/PowerCC26XX.h>
 #include <ti/sysbios/BIOS.h>
-#include <ti/drivers/SPI.h>
-#include <ti/drivers/spi/SPICC26XXDMA.h>
-#include <ti/drivers/dma/UDMACC26XX.h>
 
 #include "icall.h"
 #include "hal_assert.h"
@@ -86,7 +82,7 @@ bleUserCfg_t user0Cfg = BLE_USER_CFG;
 /*******************************************************************************
  * MACROS
  */
-
+#define BOOSTXL_CC2650MA_ELITE_EIS_1_1
 /*******************************************************************************
  * CONSTANTS
  */

simplelink/ble_sdk_2_02_02_25/src/target/board.c

@@ -76,7 +76,7 @@
     #include "./cc2650rc/cc2650rc_board.c"
 #elif defined(CC2650_LAUNCHXL)
     #include "./cc2650lp/cc2650lp_board.c"
-#elif defined(BOOSTXL_CC2650MA)
+#elif defined(BOOSTXL_CC2650MA) || defined(BOOSTXL_CC2650MA_ELITE_EIS_1_1)
     #include "./cc2650bp/cc2650bp_board.c"
 #elif defined(CC1310DK_7XD) || defined(CC1310DK_5XD) || defined(CC1310DK_4XD)
     #include "./cc1310em/cc1310em_board.c"

simplelink/ble_sdk_2_02_02_25/src/target/board.h

@@ -76,7 +76,7 @@
     #include "./cc2650rc/cc2650rc_board.h"
 #elif defined(CC2650_LAUNCHXL)
     #include "./cc2650lp/cc2650lp_board.h"
-#elif defined(BOOSTXL_CC2650MA)
+#elif defined(BOOSTXL_CC2650MA) || defined(BOOSTXL_CC2650MA_ELITE_EIS_1_1)
     #include "./cc2650bp/cc2650bp_board.h"
 #elif defined(CC1310DK_7XD) || defined(CC1310DK_5XD) || defined(CC1310DK_4XD)
     #include "./cc1310em/cc1310em_board.h"

simplelink/ble_sdk_2_02_02_25/src/target/cc2650bp/cc2650bp_board.c

@@ -57,6 +57,8 @@
  */
 #if defined(BOOSTXL_CC2650MA)
     #include <../../boards/BOOSTXL_CC2650MA/BOOSTXL_CC2650MA.c>
+#elif defined(BOOSTXL_CC2650MA_ELITE_EIS_1_1)
+    #include <../../boards/BOOSTXL_CC2650MA_ELITE_EIS_1_1/BOOSTXL_CC2650MA_ELITE_EIS_1_1.c>
 #else
     #error "Must define 'BOOSTXL_CC2650MA'. Please \
             set include path to point to appropriate device."

simplelink/ble_sdk_2_02_02_25/src/target/cc2650bp/cc2650bp_board.h

@@ -65,6 +65,8 @@
  */
 #if defined(BOOSTXL_CC2650MA)
     #include <../../boards/BOOSTXL_CC2650MA/Board.h>
+#elif defined(BOOSTXL_CC2650MA_ELITE_EIS_1_1)
+    #include <../../boards/BOOSTXL_CC2650MA_ELITE_EIS_1_1/Board.h>
 #else
     #error "Must define 'BOOSTXL_CC2650MA'. Please set include path to \
             point to appropriate device."