/*
 *  ======== ti_drivers_config.c ========
 *  Configured TI-Drivers module definitions
 *
 *  DO NOT EDIT - This file is generated for the CC1352R1F3RGZ
 *  by the SysConfig tool.
 */

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

#ifndef DeviceFamily_CC13X2
#define DeviceFamily_CC13X2
#endif

#include <ti/devices/DeviceFamily.h>

#include "ti_drivers_config.h"

/*
 *  =============================== ADC ===============================
 */

#include <ti/drivers/ADC.h>
#include <ti/drivers/adc/ADCCC26XX.h>

#define CONFIG_ADC_COUNT 1

/*
 *  ======== adcCC26xxObjects ========
 */
ADCCC26XX_Object adcCC26xxObjects[CONFIG_ADC_COUNT];

/*
 *  ======== adcCC26xxHWAttrs ========
 */
const ADCCC26XX_HWAttrs adcCC26xxHWAttrs[CONFIG_ADC_COUNT] = {
    /* ADC */
    {
        .adcDIO              = IOID_24,
        .adcCompBInput       = ADC_COMPB_IN_AUXIO6,
        .refSource           = ADCCC26XX_FIXED_REFERENCE,
        .samplingDuration    = ADCCC26XX_SAMPLING_DURATION_2P7_US,
        .inputScalingEnabled = true,
        .refVoltage          = 3300000,
        .triggerSource       = ADCCC26XX_TRIGGER_MANUAL,
        .returnAdjustedVal   = false
    },
};

/*
 *  ======== ADC_config ========
 */
const ADC_Config ADC_config[CONFIG_ADC_COUNT] = {
    /* ADC */
    {
        .fxnTablePtr = &ADCCC26XX_fxnTable,
        .object = &adcCC26xxObjects[ADC],
        .hwAttrs = &adcCC26xxHWAttrs[ADC]
    },
};

const uint_least8_t ADC_CONST = ADC;
const uint_least8_t ADC_count = CONFIG_ADC_COUNT;

/*
 *  =============================== DMA ===============================
 */

#include <ti/drivers/dma/UDMACC26XX.h>
#include <ti/devices/cc13x2_cc26x2/driverlib/udma.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_memmap.h>

UDMACC26XX_Object udmaCC26XXObject;

const UDMACC26XX_HWAttrs udmaCC26XXHWAttrs = {
    .baseAddr        = UDMA0_BASE,
    .powerMngrId     = PowerCC26XX_PERIPH_UDMA,
    .intNum          = INT_DMA_ERR,
    .intPriority     = (~0)
};

const UDMACC26XX_Config UDMACC26XX_config[1] = {
    {
        .object         = &udmaCC26XXObject,
        .hwAttrs        = &udmaCC26XXHWAttrs,
    },
};

/*
 *  =============================== GPIO ===============================
 */

#include <ti/drivers/GPIO.h>
#include <ti/drivers/gpio/GPIOCC26XX.h>

#define CONFIG_GPIO_COUNT 17

/*
 *  ======== gpioPinConfigs ========
 *  Array of Pin configurations
 */
GPIO_PinConfig gpioPinConfigs[] = {
    /* INT */
    GPIOCC26XX_DIO_13 | GPIO_CFG_IN_NOPULL | GPIO_CFG_IN_INT_RISING,
    /* POWER_EEPROM */
    GPIOCC26XX_DIO_08 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* OUT_0 */
    GPIOCC26XX_DIO_28 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* OUT_1 */
    GPIOCC26XX_DIO_27 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* OUT_2 */
    GPIOCC26XX_DIO_07 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_HIGH,
    /* NOT_USED_GPIO_18 */
    GPIOCC26XX_DIO_18 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* OUT_3 */
    GPIOCC26XX_DIO_22 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* PWR_CLOCK */
    GPIOCC26XX_DIO_23 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_LOW | GPIO_CFG_OUT_LOW,
    /* OUT_4 */
    GPIOCC26XX_DIO_25 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* OUT_5 */
    GPIOCC26XX_DIO_26 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* DAC_O_PWM */
    GPIOCC26XX_DIO_06 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* TDO */
    GPIOCC26XX_DIO_16 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* TDI */
    GPIOCC26XX_DIO_17 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* CS_EEPROM */
    GPIOCC26XX_DIO_14 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_HIGH,
    /* IN_0 */
    GPIOCC26XX_DIO_15 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING,
    /* IN_1 */
    GPIOCC26XX_DIO_29 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING,
    /* IN_2 */
    GPIOCC26XX_DIO_30 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING,
};

/*
 *  ======== gpioCallbackFunctions ========
 *  Array of callback function pointers
 *
 *  NOTE: Unused callback entries can be omitted from the callbacks array to
 *  reduce memory usage by enabling callback table optimization
 *  (GPIO.optimizeCallbackTableSize = true)
 */
extern void rfidInterruptFxn0(uint_least8_t index);
extern void ClearPressed(uint_least8_t index);
extern void InternalHandleOrDoorContactPressed(uint_least8_t index);
extern void MechDNDPressed(uint_least8_t index);

GPIO_CallbackFxn gpioCallbackFunctions[] = {
    /* INT */
    rfidInterruptFxn0,
    /* POWER_EEPROM */
    NULL,
    /* OUT_0 */
    NULL,
    /* OUT_1 */
    NULL,
    /* OUT_2 */
    NULL,
    /* NOT_USED_GPIO_18 */
    NULL,
    /* OUT_3 */
    NULL,
    /* PWR_CLOCK */
    NULL,
    /* OUT_4 */
    NULL,
    /* OUT_5 */
    NULL,
    /* DAC_O_PWM */
    NULL,
    /* TDO */
    NULL,
    /* TDI */
    NULL,
    /* CS_EEPROM */
    NULL,
    /* IN_0 */
    ClearPressed,
    /* IN_1 */
    InternalHandleOrDoorContactPressed,
    /* IN_2 */
    MechDNDPressed,
};

const uint_least8_t INT_CONST = INT;
const uint_least8_t POWER_EEPROM_CONST = POWER_EEPROM;
const uint_least8_t OUT_0_CONST = OUT_0;
const uint_least8_t OUT_1_CONST = OUT_1;
const uint_least8_t OUT_2_CONST = OUT_2;
const uint_least8_t NOT_USED_GPIO_18_CONST = NOT_USED_GPIO_18;
const uint_least8_t OUT_3_CONST = OUT_3;
const uint_least8_t PWR_CLOCK_CONST = PWR_CLOCK;
const uint_least8_t OUT_4_CONST = OUT_4;
const uint_least8_t OUT_5_CONST = OUT_5;
const uint_least8_t DAC_O_PWM_CONST = DAC_O_PWM;
const uint_least8_t TDO_CONST = TDO;
const uint_least8_t TDI_CONST = TDI;
const uint_least8_t CS_EEPROM_CONST = CS_EEPROM;
const uint_least8_t IN_0_CONST = IN_0;
const uint_least8_t IN_1_CONST = IN_1;
const uint_least8_t IN_2_CONST = IN_2;

/*
 *  ======== GPIOCC26XX_config ========
 */
const GPIOCC26XX_Config GPIOCC26XX_config = {
    .pinConfigs = (GPIO_PinConfig *)gpioPinConfigs,
    .callbacks = (GPIO_CallbackFxn *)gpioCallbackFunctions,
    .numberOfPinConfigs = 17,
    .numberOfCallbacks = 17,
    .intPriority = (~0)
};

/*
 *  =============================== PIN ===============================
 */
#include <ti/drivers/PIN.h>
#include <ti/drivers/pin/PINCC26XX.h>

#define CONFIG_PIN_COUNT 28

const PIN_Config BoardGpioInitTable[CONFIG_PIN_COUNT + 1] = {
    /* Parent Signal: ADC ADC Pin, (DIO24) */
    CONFIG_PIN_14 | PIN_INPUT_EN | PIN_NOPULL | PIN_IRQ_DIS,
    /* Parent Signal: INT GPIO Pin, (DIO13) */
    CONFIG_PIN_0 | PIN_INPUT_EN | PIN_NOPULL | PIN_IRQ_DIS,
    /* Parent Signal: POWER_EEPROM GPIO Pin, (DIO8) */
    CONFIG_PIN_1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: OUT_0 GPIO Pin, (DIO28) */
    CONFIG_PIN_2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: OUT_1 GPIO Pin, (DIO27) */
    CONFIG_PIN_4 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: OUT_2 GPIO Pin, (DIO7) */
    CONFIG_PIN_10 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: NOT_USED_GPIO_18 GPIO Pin, (DIO18) */
    CONFIG_PIN_11 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: OUT_3 GPIO Pin, (DIO22) */
    CONFIG_PIN_12 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: PWR_CLOCK GPIO Pin, (DIO23) */
    CONFIG_PIN_13 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MIN,
    /* Parent Signal: OUT_4 GPIO Pin, (DIO25) */
    CONFIG_PIN_15 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: OUT_5 GPIO Pin, (DIO26) */
    CONFIG_PIN_16 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: DAC_O_PWM GPIO Pin, (DIO6) */
    CONFIG_PIN_3 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: TDO GPIO Pin, (DIO16) */
    CONFIG_PIN_20 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: TDI GPIO Pin, (DIO17) */
    CONFIG_PIN_21 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CS_EEPROM GPIO Pin, (DIO14) */
    CONFIG_PIN_22 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_SPI_EEPROM SCLK, (DIO5) */
    CONFIG_PIN_6 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_SPI_EEPROM MISO, (DIO3) */
    CONFIG_PIN_7 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_SPI_EEPROM MOSI, (DIO4) */
    CONFIG_PIN_8 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_SPI_RFID SCLK, (DIO11) */
    CONFIG_PIN_5 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_SPI_RFID MISO, (DIO9) */
    CONFIG_PIN_9 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_SPI_RFID MOSI, (DIO10) */
    CONFIG_PIN_24 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: IN_0 GPIO Pin, (DIO15) */
    CONFIG_PIN_26 | PIN_INPUT_EN | PIN_PULLUP | PIN_IRQ_DIS,
    /* Parent Signal: IN_1 GPIO Pin, (DIO29) */
    CONFIG_PIN_27 | PIN_INPUT_EN | PIN_PULLUP | PIN_IRQ_DIS,
    /* Parent Signal: IN_2 GPIO Pin, (DIO30) */
    CONFIG_PIN_28 | PIN_INPUT_EN | PIN_PULLUP | PIN_IRQ_DIS,
    /* Parent Signal: CONFIG_SPI_RFID SS, (DIO12) */
    CONFIG_PIN_25 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_GPTIMER_1 PWM Pin, (DIO21) */
    CONFIG_PIN_17 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_GPTIMER_2 PWM Pin, (DIO19) */
    CONFIG_PIN_18 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,
    /* Parent Signal: CONFIG_GPTIMER_3 PWM Pin, (DIO20) */
    CONFIG_PIN_19 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MED,

    PIN_TERMINATE
};

const PINCC26XX_HWAttrs PINCC26XX_hwAttrs = {
    .intPriority = (~0),
    .swiPriority = 0
};

/*
 *  =============================== PWM ===============================
 */

#include <ti/drivers/PWM.h>
#include <ti/drivers/pwm/PWMTimerCC26XX.h>

/* include driverlib definitions */
#include <ti/devices/cc13x2_cc26x2/driverlib/ioc.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_ints.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_memmap.h>

#define CONFIG_PWM_COUNT 3

/*
 *  ======== pwmCC26XXObjects ========
 */
PWMTimerCC26XX_Object pwmTimerCC26XXObjects[CONFIG_PWM_COUNT];

/*
 *  ======== pwmCC26XXHWAttrs ========
 */
const PWMTimerCC26XX_HwAttrs pwmTimerCC26XXHWAttrs[CONFIG_PWM_COUNT] = {
    /* PWM_11_PWM */
    {
        .pwmPin = IOID_21,
        .gpTimerUnit = CONFIG_GPTIMER_1
    },
    /* PWM_00_PWM */
    {
        .pwmPin = IOID_19,
        .gpTimerUnit = CONFIG_GPTIMER_2
    },
    /* PWM_22_PWM */
    {
        .pwmPin = IOID_20,
        .gpTimerUnit = CONFIG_GPTIMER_3
    },
};

/*
 *  ======== PWM_config ========
 */
const PWM_Config PWM_config[CONFIG_PWM_COUNT] = {
    /* PWM_11_PWM */
    {
        .fxnTablePtr = &PWMTimerCC26XX_fxnTable,
        .object = &pwmTimerCC26XXObjects[PWM_11_PWM],
        .hwAttrs = &pwmTimerCC26XXHWAttrs[PWM_11_PWM]
    },
    /* PWM_00_PWM */
    {
        .fxnTablePtr = &PWMTimerCC26XX_fxnTable,
        .object = &pwmTimerCC26XXObjects[PWM_00_PWM],
        .hwAttrs = &pwmTimerCC26XXHWAttrs[PWM_00_PWM]
    },
    /* PWM_22_PWM */
    {
        .fxnTablePtr = &PWMTimerCC26XX_fxnTable,
        .object = &pwmTimerCC26XXObjects[PWM_22_PWM],
        .hwAttrs = &pwmTimerCC26XXHWAttrs[PWM_22_PWM]
    },
};

const uint_least8_t PWM_11_PWM_CONST = PWM_11_PWM;
const uint_least8_t PWM_00_PWM_CONST = PWM_00_PWM;
const uint_least8_t PWM_22_PWM_CONST = PWM_22_PWM;
const uint_least8_t PWM_count = CONFIG_PWM_COUNT;

/*
 *  =============================== Power ===============================
 */
#include <ti/drivers/Power.h>
#include <ti/drivers/power/PowerCC26X2.h>
#include "ti_drivers_config.h"

extern void PowerCC26XX_standbyPolicy(void);
extern bool PowerCC26XX_calibrate(unsigned int);
extern void Power_enableTCXO(bool enable);

const PowerCC26X2_Config PowerCC26X2_config = {
    .enablePolicy             = true,
    .policyInitFxn            = NULL,
    .policyFxn                = PowerCC26XX_standbyPolicy,
    .calibrateFxn             = PowerCC26XX_calibrate,
    .calibrateRCOSC_LF        = true,
    .calibrateRCOSC_HF        = true,
    .enableTCXOFxn            = Power_enableTCXO
};


/*
 *  =============================== RF Driver ===============================
 */
#include <ti/drivers/rf/RF.h>

/*
 * Platform-specific driver configuration
 */
const RFCC26XX_HWAttrsV2 RFCC26XX_hwAttrs = {
    .hwiPriority        = (~0),
    .swiPriority        = (uint8_t)0,
    .xoscHfAlwaysNeeded = true,
    .globalCallback     = NULL,
    .globalEventMask    = 0
};


/*
 *  =============================== SPI DMA ===============================
 */
#include <ti/drivers/SPI.h>
#include <ti/drivers/spi/SPICC26X2DMA.h>

#define CONFIG_SPI_COUNT 2

/*
 *  ======== spiCC26X2DMAObjects ========
 */
SPICC26X2DMA_Object spiCC26X2DMAObjects[CONFIG_SPI_COUNT];

/*
 *  ======== spiCC26X2DMAHWAttrs ========
 */
const SPICC26X2DMA_HWAttrs spiCC26X2DMAHWAttrs[CONFIG_SPI_COUNT] = {
    /* CONFIG_SPI_EEPROM */
    {
        .baseAddr = SSI1_BASE,
        .intNum = INT_SSI1_COMB,
        .intPriority = (~0),
        .swiPriority = 0,
        .powerMngrId = PowerCC26XX_PERIPH_SSI1,
        .defaultTxBufValue = 0xff,
        .rxChannelBitMask = 1<<UDMA_CHAN_SSI1_RX,
        .txChannelBitMask = 1<<UDMA_CHAN_SSI1_TX,
        .minDmaTransferSize = 1,
        .mosiPin = IOID_4,
        .misoPin = IOID_3,
        .clkPin  = IOID_5,
        .csnPin  = PIN_UNASSIGNED
    },
    /* CONFIG_SPI_RFID */
    {
        .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,
        .minDmaTransferSize = 1,
        .mosiPin = IOID_10,
        .misoPin = IOID_9,
        .clkPin  = IOID_11,
        .csnPin  = IOID_12
    },
};

/*
 *  ======== SPI_config ========
 */
const SPI_Config SPI_config[CONFIG_SPI_COUNT] = {
    /* CONFIG_SPI_EEPROM */
    {
        .fxnTablePtr = &SPICC26X2DMA_fxnTable,
        .object = &spiCC26X2DMAObjects[CONFIG_SPI_EEPROM],
        .hwAttrs = &spiCC26X2DMAHWAttrs[CONFIG_SPI_EEPROM]
    },
    /* CONFIG_SPI_RFID */
    {
        .fxnTablePtr = &SPICC26X2DMA_fxnTable,
        .object = &spiCC26X2DMAObjects[CONFIG_SPI_RFID],
        .hwAttrs = &spiCC26X2DMAHWAttrs[CONFIG_SPI_RFID]
    },
};

const uint_least8_t CONFIG_SPI_EEPROM_CONST = CONFIG_SPI_EEPROM;
const uint_least8_t CONFIG_SPI_RFID_CONST = CONFIG_SPI_RFID;
const uint_least8_t SPI_count = CONFIG_SPI_COUNT;

/*
 *  =============================== Temperature ===============================
 */
#include <ti/drivers/Temperature.h>
#include <ti/drivers/temperature/TemperatureCC26X2.h>

const TemperatureCC26X2_Config TemperatureCC26X2_config = {
    .intPriority = (~0),
};

/*
 *  =============================== Timer ===============================
 */

#include <ti/drivers/Timer.h>
#include <ti/drivers/timer/TimerCC26XX.h>

#define CONFIG_TIMER_COUNT 1

/*
 *  ======== timerCC26XXObjects ========
 */
TimerCC26XX_Object timerCC26XXObjects[CONFIG_TIMER_COUNT];

/*
 *  ======== timerCC26XXHWAttrs ========
 */
const TimerCC26XX_HWAttrs timerCC26XXHWAttrs[CONFIG_TIMER_COUNT] = {
    {
        .gpTimerUnit = CONFIG_GPTIMER_0,
        .subTimer    = TimerCC26XX_timer32

    },
};

/*
 *  ======== Timer_config ========
 */
const Timer_Config Timer_config[CONFIG_TIMER_COUNT] = {
    /* CONFIG_TIMER_1 */
    {
        .fxnTablePtr = &TimerCC26XX_fxnTable,
        .object    = &timerCC26XXObjects[CONFIG_TIMER_1],
        .hwAttrs   = &timerCC26XXHWAttrs[CONFIG_TIMER_1]
    },
};

const uint_least8_t CONFIG_TIMER_1_CONST = CONFIG_TIMER_1;
const uint_least8_t Timer_count = CONFIG_TIMER_COUNT;

/*
 *  =============================== Watchdog ===============================
 */

#include <ti/drivers/Watchdog.h>
#include <ti/drivers/watchdog/WatchdogCC26XX.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_memmap.h>

#define CONFIG_WATCHDOG_COUNT 1


WatchdogCC26XX_Object watchdogCC26XXObjects[CONFIG_WATCHDOG_COUNT];

const WatchdogCC26XX_HWAttrs watchdogCC26XXHWAttrs[CONFIG_WATCHDOG_COUNT] = {
    /* CONFIG_WATCHDOG_0: period = 1000 */
    {
        .baseAddr    = WDT_BASE,
        .reloadValue = 1000
    },
};

const Watchdog_Config Watchdog_config[CONFIG_WATCHDOG_COUNT] = {
    /* CONFIG_WATCHDOG_0 */
    {
        .fxnTablePtr = &WatchdogCC26XX_fxnTable,
        .object      = &watchdogCC26XXObjects[CONFIG_WATCHDOG_0],
        .hwAttrs     = &watchdogCC26XXHWAttrs[CONFIG_WATCHDOG_0]
    }
};

const uint_least8_t CONFIG_WATCHDOG_0_CONST = CONFIG_WATCHDOG_0;
const uint_least8_t Watchdog_count = CONFIG_WATCHDOG_COUNT;

/*
 *  =============================== Button ===============================
 */
#include <ti/drivers/apps/Button.h>

#define CONFIG_BUTTON_COUNT 3
Button_Object ButtonObjects[CONFIG_BUTTON_COUNT];

static const Button_HWAttrs ButtonHWAttrs[CONFIG_BUTTON_COUNT] = {
    /* IN_00 */
    {
        .gpioIndex = IN_0
    },
    /* IN_11 */
    {
        .gpioIndex = IN_1
    },
    /* IN_22 */
    {
        .gpioIndex = IN_2
    },
};

const Button_Config Button_config[CONFIG_BUTTON_COUNT] = {
    /* IN_00 */
    {
        .object = &ButtonObjects[IN_00],
        .hwAttrs = &ButtonHWAttrs[IN_00]
    },
    /* IN_11 */
    {
        .object = &ButtonObjects[IN_11],
        .hwAttrs = &ButtonHWAttrs[IN_11]
    },
    /* IN_22 */
    {
        .object = &ButtonObjects[IN_22],
        .hwAttrs = &ButtonHWAttrs[IN_22]
    },
};

const uint_least8_t IN_00_CONST = IN_00;
const uint_least8_t IN_11_CONST = IN_11;
const uint_least8_t IN_22_CONST = IN_22;
const uint_least8_t Button_count = CONFIG_BUTTON_COUNT;

/*
 *  =============================== LED ===============================
 */
#include <ti/drivers/apps/LED.h>

#define CONFIG_LED_COUNT 3
LED_Object LEDObjects[CONFIG_LED_COUNT];

static const LED_HWAttrs LEDHWAttrs[CONFIG_LED_COUNT] = {
    /* PWM_11 */
    {
        .type = LED_PWM_CONTROLLED,
        .index = PWM_11_PWM,
    },
    /* PWM_00 */
    {
        .type = LED_PWM_CONTROLLED,
        .index = PWM_00_PWM,
    },
    /* PWM_22 */
    {
        .type = LED_PWM_CONTROLLED,
        .index = PWM_22_PWM,
    },
};

const LED_Config LED_config[CONFIG_LED_COUNT] = {
    /* PWM_11 */
    {
        .object = &LEDObjects[PWM_11],
        .hwAttrs = &LEDHWAttrs[PWM_11]
    },
    /* PWM_00 */
    {
        .object = &LEDObjects[PWM_00],
        .hwAttrs = &LEDHWAttrs[PWM_00]
    },
    /* PWM_22 */
    {
        .object = &LEDObjects[PWM_22],
        .hwAttrs = &LEDHWAttrs[PWM_22]
    },
};

const uint_least8_t PWM_11_CONST = PWM_11;
const uint_least8_t PWM_00_CONST = PWM_00;
const uint_least8_t PWM_22_CONST = PWM_22;
const uint_least8_t LED_count = CONFIG_LED_COUNT;

/*
 *  =============================== GPTimer ===============================
 */

#include <ti/drivers/timer/GPTimerCC26XX.h>
#include <ti/drivers/power/PowerCC26XX.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_memmap.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_ints.h>

#define CONFIG_GPTIMER_COUNT 4

/*
 *  ======== gptimerCC26XXObjects ========
 */
GPTimerCC26XX_Object gptimerCC26XXObjects[CONFIG_GPTIMER_COUNT];

/*
 *  ======== gptimerCC26XXHWAttrs ========
 */
const GPTimerCC26XX_HWAttrs gptimerCC26XXHWAttrs[CONFIG_GPTIMER_COUNT] = {
    /* CONFIG_GPTIMER_0, used by CONFIG_TIMER_1 */
    {
        .baseAddr = GPT2_BASE,
        .intNum      = INT_GPT2A,
        .intPriority = (~0),
        .powerMngrId = PowerCC26XX_PERIPH_GPT2,
        .pinMux      = GPT_PIN_2A
    },
    /* CONFIG_GPTIMER_1, used by PWM_11_PWM */
    {
        .baseAddr = GPT0_BASE,
        .intNum      = INT_GPT0A,
        .intPriority = (~0),
        .powerMngrId = PowerCC26XX_PERIPH_GPT0,
        .pinMux      = GPT_PIN_0A
    },
    /* CONFIG_GPTIMER_2, used by PWM_00_PWM */
    {
        .baseAddr = GPT3_BASE,
        .intNum      = INT_GPT3A,
        .intPriority = (~0),
        .powerMngrId = PowerCC26XX_PERIPH_GPT3,
        .pinMux      = GPT_PIN_3A
    },
    /* CONFIG_GPTIMER_3, used by PWM_22_PWM */
    {
        .baseAddr = GPT3_BASE,
        .intNum      = INT_GPT3B,
        .intPriority = (~0),
        .powerMngrId = PowerCC26XX_PERIPH_GPT3,
        .pinMux      = GPT_PIN_3B
    },
};

/*
 *  ======== GPTimer_config ========
 */
const GPTimerCC26XX_Config GPTimerCC26XX_config[CONFIG_GPTIMER_COUNT] = {
    /* CONFIG_GPTIMER_0 */
    {
        .object    = &gptimerCC26XXObjects[CONFIG_GPTIMER_0],
        .hwAttrs   = &gptimerCC26XXHWAttrs[CONFIG_GPTIMER_0],
        .timerPart = GPT_A
    },
    /* CONFIG_GPTIMER_1 */
    {
        .object    = &gptimerCC26XXObjects[CONFIG_GPTIMER_1],
        .hwAttrs   = &gptimerCC26XXHWAttrs[CONFIG_GPTIMER_1],
        .timerPart = GPT_A
    },
    /* CONFIG_GPTIMER_2 */
    {
        .object    = &gptimerCC26XXObjects[CONFIG_GPTIMER_2],
        .hwAttrs   = &gptimerCC26XXHWAttrs[CONFIG_GPTIMER_2],
        .timerPart = GPT_A
    },
    /* CONFIG_GPTIMER_3 */
    {
        .object    = &gptimerCC26XXObjects[CONFIG_GPTIMER_3],
        .hwAttrs   = &gptimerCC26XXHWAttrs[CONFIG_GPTIMER_3],
        .timerPart = GPT_B
    },
};

const uint_least8_t CONFIG_GPTIMER_0_CONST = CONFIG_GPTIMER_0;
const uint_least8_t CONFIG_GPTIMER_1_CONST = CONFIG_GPTIMER_1;
const uint_least8_t CONFIG_GPTIMER_2_CONST = CONFIG_GPTIMER_2;
const uint_least8_t CONFIG_GPTIMER_3_CONST = CONFIG_GPTIMER_3;
const uint_least8_t GPTimer_count = CONFIG_GPTIMER_COUNT;

#include <ti/drivers/Board.h>

/*
 *  ======== Board_initHook ========
 *  Perform any board-specific initialization needed at startup.  This
 *  function is declared weak to allow applications to override it if needed.
 */
void __attribute__((weak)) Board_initHook(void)
{
}

/*
 *  ======== Board_init ========
 *  Perform any initialization needed before using any board APIs
 */
void Board_init(void)
{
    /* ==== /ti/drivers/Power initialization ==== */
    Power_init();

    /* ==== /ti/drivers/PIN initialization ==== */
    if (PIN_init(BoardGpioInitTable) != PIN_SUCCESS) {
        /* Error with PIN_init */
        while (1);
    }
    /* ==== /ti/devices/CCFGTemplate initialization ==== */

    /* ==== /ti/drivers/RF initialization ==== */

    Board_initHook();
}