MSP432P4011: MSP432P4011

/*
* Copyright (c) 2017, 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 MSP432P4011.h
*
* @brief MSP432P4011 Board Specific APIs
*
* The MSP432P4011 header file should be included in an application as
* follows:
* @code
* #include <MSP432P4011.h>
* @endcode
*
* ============================================================================
*/
#ifndef __MSP432P4011_H
#define __MSP432P4011_H

#ifdef __cplusplus
extern "C" {
#endif

/* LEDs on MSP432P4011 are active high. */
#define MSP432P4011_GPIO_LED_OFF (0)
#define MSP432P4011_GPIO_LED_ON (1)

/*!
* @def MSP432P4011_GPIOName
* @brief Enum of GPIO names on the MSP432P4011 dev board
*/
#ifndef _RGC_PKG_
typedef enum MSP432P4011_GPIOName {
MSP432P4011_GPIO_S1 = 0,
MSP432P4011_GPIO_S2,
MSP432P4011_BLE_SRDY,
MSP432P4011_BLE_MRDY,
MSP432P4011_BLE_RESET,
MSP432P4011_GPIO_LED1,
MSP432P4011_GPIO_RGBLED_RED,
MSP432P4011_GPIO_RGBLED_GREEN,
MSP432P4011_GPIO_RGBLED_BLUE,
MSP432P4011_GPIOCOUNT
} MSP432P4011_GPIOName;
#else
typedef enum MSP432P4011_GPIOName {
MSP432P4011_BLE_SRDY,
MSP432P4011_BLE_MRDY,
MSP432P4011_BLE_RESET,
MSP432P4011_GPIO_TP14,
MSP432P4011_GPIO_TP15,
MSP432P4011_GPIOCOUNT
} MSP432P4011_GPIOName;

#endif

/*!
* @def MSP432P4011_I2CName
* @brief Enum of I2C names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_I2CName {
#ifndef _RGC_PKG_
MSP432P4011_I2CB0 = 0,
MSP432P4011_I2CB1,
#else
MSP432P4011_I2CB0 = 0,
#endif
MSP432P4011_I2CCOUNT
} MSP432P4011_I2CName;

/*!
* @def MSP432P4011_I2CSlaveName
* @brief Enum of I2CSlave names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_I2CSlaveName {
MSP432P4011_I2CSLAVEB0 = 0,

MSP432P4011_I2CSLAVECOUNT
} MSP432P4011_I2CSlaveName;

/*!
* @def MSP432P4011_NVSName
* @brief Enum of NVS names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_NVSName {
MSP432P4011_NVSMSP4320 = 0,
MSP432P4011_NVSMSP4321 = 1,

MSP432P4011_NVSCOUNT
} MSP432P4011_NVSName;

/*!
* @def MSP432P4011_SDFatFSName
* @brief Enum of SDFatFS names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_SDFatFSName {
MSP432P4011_SDFatFS0 = 0,

MSP432P4011_SDFatFSCOUNT
} MSP432P4011_SDFatFSName;

/*!
* @def MSP432P4011_SDName
* @brief Enum of SD names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_SDName {
MSP432P4011_SDSPI0 = 0,

MSP432P4011_SDCOUNT
} MSP432P4011_SDName;
/*!
* @def MSP432P4011_SPIName
* @brief Enum of SPI names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_SPIName {
MSP432P4011_SPIB0 = 0,
MSP432P4011_SPIB2,
MSP432P4011_SPIB3,
MSP432P4011_SPIB4,

MSP432P4011_SPICOUNT
} MSP432P4011_SPIName;

/*!
* @def MSP432P4011_UARTName
* @brief Enum of UART names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_UARTName {
MSP432P4011_UARTA0 = 0,
#ifdef _RGC_PKG_
MSP432P4011_UARTA1,
#endif
MSP432P4011_UARTA2,

MSP432P4011_UARTCOUNT
} MSP432P4011_UARTName;

/*!
* @def MSP432P4011_WatchdogName
* @brief Enum of Watchdog names on the MSP432P4011 dev board
*/
typedef enum MSP432P4011_WatchdogName {
MSP432P4011_WATCHDOG = 0,

MSP432P4011_WATCHDOGCOUNT
} MSP432P4011_WatchdogName;

/*!
* @brief Initialize the general board specific settings
*
* This function initializes the general board specific settings.
*/
extern void MSP432P4011_initGeneral(void);

#ifdef __cplusplus
}
#endif

#endif /* __MSP432P4011_H */

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

CUSTOM_MSP432P4011.c

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

/*
* ======== MSP432P4011.c ========
* This file is responsible for setting up the board specific items for the
* MSP432P4011 board.
*/

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

#include <ti/drivers/Power.h>
#include <ti/drivers/power/PowerMSP432.h>

#include <ti/devices/msp432p4xx/inc/msp.h>
#include <ti/devices/msp432p4xx/driverlib/rom.h>
#include <ti/devices/msp432p4xx/driverlib/rom_map.h>
#include <ti/devices/msp432p4xx/driverlib/adc14.h>
#include <ti/devices/msp432p4xx/driverlib/dma.h>
#include <ti/devices/msp432p4xx/driverlib/gpio.h>
#include <ti/devices/msp432p4xx/driverlib/i2c.h>
#include <ti/devices/msp432p4xx/driverlib/interrupt.h>
#include <ti/devices/msp432p4xx/driverlib/pmap.h>
#include <ti/devices/msp432p4xx/driverlib/ref_a.h>
#include <ti/devices/msp432p4xx/driverlib/spi.h>
#include <ti/devices/msp432p4xx/driverlib/timer_a.h>
#include <ti/devices/msp432p4xx/driverlib/timer32.h>
#include <ti/devices/msp432p4xx/driverlib/uart.h>
#include <ti/devices/msp432p4xx/driverlib/wdt_a.h>

#include <ti/drivers/dma/UDMAMSP432.h>

#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_ALIGN(dmaControlTable, 256)
#elif defined(__IAR_SYSTEMS_ICC__)
#pragma data_alignment=256
#elif defined(__GNUC__)
__attribute__ ((aligned (256)))
#endif
static DMA_ControlTable dmaControlTable[16];

/*
* ======== dmaErrorHwi ========
* This is the handler for the uDMA error interrupt.
*/
static void dmaErrorHwi(uintptr_t arg)
{
int status = MAP_DMA_getErrorStatus();
MAP_DMA_clearErrorStatus();

/* Suppress unused variable warning */
(void)status;

while (1);
}

UDMAMSP432_Object udmaMSP432Object;

const UDMAMSP432_HWAttrs udmaMSP432HWAttrs = {
.controlBaseAddr = (void *)dmaControlTable,
.dmaErrorFxn = (UDMAMSP432_ErrorFxn)dmaErrorHwi,
.intNum = INT_DMA_ERR,
.intPriority = (~0)
};

const UDMAMSP432_Config UDMAMSP432_config = {
.object = &udmaMSP432Object,
.hwAttrs = &udmaMSP432HWAttrs
};

/*
* ============================= Display =============================
*/
#include <ti/display/Display.h>
#include <ti/display/DisplayUart.h>
#define MAXPRINTLEN 1024

DisplayUart_Object displayUartObject;

static char displayBuf[MAXPRINTLEN];

const DisplayUart_HWAttrs displayUartHWAttrs = {
#ifndef _RGC_PKG_
.uartIdx = MSP432P4011_UARTA0,
#else
.uartIdx = MSP432P4011_UARTA2,
#endif
.baudRate = 115200,
.mutexTimeout = (unsigned int)(-1),
.strBuf = displayBuf,
.strBufLen = MAXPRINTLEN
};

#ifndef BOARD_DISPLAY_USE_UART_ANSI
#define BOARD_DISPLAY_USE_UART_ANSI 0
#endif

const Display_Config Display_config[] = {
{
# if (BOARD_DISPLAY_USE_UART_ANSI)
.fxnTablePtr = &DisplayUartAnsi_fxnTable,
# else /* Default to minimal UART with no cursor placement */
.fxnTablePtr = &DisplayUartMin_fxnTable,
# endif
.object = &displayUartObject,
.hwAttrs = &displayUartHWAttrs
}
};

const uint_least8_t Display_count = sizeof(Display_config) / sizeof(Display_Config);

/*
* ======== MSP432P4011_initGeneral ========
*/
void MSP432P4011_initGeneral(void)
{
Power_init();
}

/*
* =============================== GPIO ===============================
*/
#include <ti/drivers/GPIO.h>
#include <ti/drivers/gpio/GPIOMSP432.h>

/*
* Array of Pin configurations
* NOTE: The order of the pin configurations must coincide with what was
* defined in MSP432P4011.h
* NOTE: Pins not used for interrupts should be placed at the end of the
* array. Callback entries can be omitted from callbacks array to
* reduce memory usage.
*/
GPIO_PinConfig gpioPinConfigs[] =
{
#ifndef _RGC_PKG_
/* Input pins */
/* MSP432P4011_S1 */
GPIOMSP432_P1_1 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_RISING,

/* MSP432P4011_S2 */
GPIOMSP432_P1_4 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_RISING,

/* MSP432P4011_SRDY */
GPIOMSP432_P2_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_HIGH,
/* MSP432P4011_MRDY */
GPIOMSP432_P6_0 | GPIO_CFG_IN_PU,

/* MSP432P4011_RESET */
GPIOMSP432_P6_7 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_HIGH,

/* Output pins */
/* MSP432P4011_LED1 */
GPIOMSP432_P1_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_LOW,

/* MSP432P4011_RGBLED_RED */
GPIOMSP432_P2_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_LOW,

/*
* MSP432P4011_LED_GREEN & MSP432P4011_LED_BLUE are used for
* PWM examples. Uncomment the following lines if you would like to control
* the LEDs with the GPIO driver.
*/
/* MSP432P4011_RGBLED_GREEN */
GPIOMSP432_P2_1 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_LOW,

/* MSP432P4011_RGBLED_BLUE */
GPIOMSP432_P2_2 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_LOW,

#else
/* MSP432P4011_SRDY TP11 */
GPIOMSP432_P1_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_HIGH,
/* MSP432P4011_MRDY TP12 */
GPIOMSP432_P8_0 | GPIO_CFG_IN_PU,

/* MSP432P4011_BLE_RESET */
GPIOMSP432_P1_4 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH
| GPIO_CFG_OUT_HIGH,

/* MSP432P4011_GPIO_TP14 */
GPIOMSP432_PJ_4 | GPIO_CFG_OUTPUT | GPIO_CFG_OUT_STR_LOW
| GPIO_CFG_OUT_HIGH,

/* MSP432P4011_GPIO_TP15 */
GPIOMSP432_P7_3 | GPIO_CFG_OUTPUT | GPIO_CFG_OUT_STR_LOW
| GPIO_CFG_OUT_HIGH,

#endif
};

/*
* Array of callback function pointers
* NOTE: The order of the pin configurations must coincide with what was
* defined in MSP432P4011.h
* NOTE: Pins not used for interrupts can be omitted from callbacks array to
* reduce memory usage (if placed at end of gpioPinConfigs array).
*/
GPIO_CallbackFxn gpioCallbackFunctions[] =
{
#ifndef _RGC_PKG_
/* MSP432P4011_S1 */
NULL,
/* MSP432P4011_S2 */
NULL,
/* MSP432P4011_SRDY */
NULL,
/* MSP432P4011_MRDY */
NULL,
/* MSP432P4011_RESET */
NULL,
/* MSP432P4011_LED1 */
NULL,
/* MSP432P4011__RGBLED_RED */
NULL,
/* MSP432P4011_RGBLED_GREEN */
NULL,
/* MSP432P4011_RGBLED_BLUE */
NULL
#else
/* MSP432P4011_SRDY */
NULL,
/* MSP432P4011_MRDY */
NULL,
/* MSP432P4011_BLE_RESET */
NULL,
/* MSP432P4011_GPIO_TP14 */
NULL,
/* MSP432P4011_GPIO_TP15 */
NULL
#endif
};

const GPIOMSP432_Config GPIOMSP432_config = {
.pinConfigs = (GPIO_PinConfig *)gpioPinConfigs,
.callbacks = (GPIO_CallbackFxn *)gpioCallbackFunctions,
.numberOfPinConfigs = sizeof(gpioPinConfigs)/sizeof(GPIO_PinConfig),
.numberOfCallbacks = sizeof(gpioCallbackFunctions)/sizeof(GPIO_CallbackFxn),
.intPriority = (~0)
};

/*
* =============================== I2C ===============================
*/
#include <ti/drivers/I2C.h>
#include <ti/drivers/i2c/I2CMSP432.h>

I2CMSP432_Object i2cMSP432Objects[MSP432P4011_I2CCOUNT];
#ifndef _RGC_PKG
#define PERIPH_BASE ((uint32_t)0x40000000) /*!< Peripherals start address */
#define EUSCI_B1_BASE (PERIPH_BASE +0x00002400) /*!< Base address of module EUSCI_B1 registers */
#endif

const I2CMSP432_HWAttrsV1 i2cMSP432HWAttrs[MSP432P4011_I2CCOUNT] = {
#ifndef _RGC_PKG_
{
.baseAddr = EUSCI_B0_BASE,
.intNum = INT_EUSCIB0,
.intPriority = (~0),
.clockSource = EUSCI_B_I2C_CLOCKSOURCE_SMCLK,
.dataPin = I2CMSP432_P1_6_UCB0SDA,
.clkPin = I2CMSP432_P1_7_UCB0SCL
},
{
.baseAddr = EUSCI_B1_BASE,
.intNum = INT_EUSCIB1,
.intPriority = (~0),
.clockSource = EUSCI_B_I2C_CLOCKSOURCE_SMCLK,
.dataPin = I2CMSP432_P6_4_UCB1SDA,
.clkPin = I2CMSP432_P6_5_UCB1SCL
}
#else
{
.baseAddr = EUSCI_B0_BASE,
.intNum = INT_EUSCIB0,
.intPriority = (~0),
.clockSource = EUSCI_B_I2C_CLOCKSOURCE_SMCLK,
.dataPin = I2CMSP432_P1_6_UCB0SDA,
.clkPin = I2CMSP432_P1_7_UCB0SCL
}
#endif
};

const I2C_Config I2C_config[MSP432P4011_I2CCOUNT] = {
#ifndef _RGC_PKG_
{
.fxnTablePtr = &I2CMSP432_fxnTable,
.object = &i2cMSP432Objects[MSP432P4011_I2CB0],
.hwAttrs = &i2cMSP432HWAttrs[MSP432P4011_I2CB0]
},
{
.fxnTablePtr = &I2CMSP432_fxnTable,
.object = &i2cMSP432Objects[MSP432P4011_I2CB1],
.hwAttrs = &i2cMSP432HWAttrs[MSP432P4011_I2CB1]
}
#else
{
.fxnTablePtr = &I2CMSP432_fxnTable,
.object = &i2cMSP432Objects[MSP432P4011_I2CB0],
.hwAttrs = &i2cMSP432HWAttrs[MSP432P4011_I2CB0]
}
#endif
};

const uint_least8_t I2C_count = MSP432P4011_I2CCOUNT;

/*
* =============================== NVS ===============================
*/
#include <ti/drivers/NVS.h>
#include <ti/drivers/nvs/NVSMSP432.h>
#include "oad_parameters.h"

/*
* Reserve flash sectors for NVS driver use
* by placing an uninitialized byte array
* at the desired flash address.
* Place uninitialized array at base addresses
*/
#pragma LOCATION(SNP_code, NVS_OAD_BASE);
#pragma NOINIT(SNP_code);
uint8_t SNP_code[OAD_REGION_SIZE];

#pragma LOCATION(metaBuf, NVS_META_BASE);
#pragma NOINIT(metaBuf);
char metaBuf[OAD_META_SIZE];

NVSMSP432_Object nvsMSP432Objects[MSP432P4011_NVSCOUNT];

const NVSMSP432_HWAttrs nvsMSP432HWAttrs[MSP432P4011_NVSCOUNT] = {
{
.regionBase = (void *)metaBuf,
.regionSize = OAD_META_SIZE,
},
{
.regionBase = (void *)SNP_code,
.regionSize = OAD_REGION_SIZE,
},
};

const NVS_Config NVS_config[MSP432P4011_NVSCOUNT] = {
{
.fxnTablePtr = &NVSMSP432_fxnTable,
.object = &nvsMSP432Objects[MSP432P4011_NVSMSP4320],
.hwAttrs = &nvsMSP432HWAttrs[MSP432P4011_NVSMSP4320],
},
{
.fxnTablePtr = &NVSMSP432_fxnTable,
.object = &nvsMSP432Objects[MSP432P4011_NVSMSP4321],
.hwAttrs = &nvsMSP432HWAttrs[MSP432P4011_NVSMSP4321],
},
};

const uint_least8_t NVS_count = MSP432P4011_NVSCOUNT;
/*
* =============================== Power ===============================
*/
const PowerMSP432_ConfigV1 PowerMSP432_config = {
.policyInitFxn = &PowerMSP432_initPolicy,
.policyFxn = &PowerMSP432_sleepPolicy,
.initialPerfLevel = 2,
.enablePolicy = true,
.enablePerf = true,
.enableParking = true
};

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

SPIMSP432DMA_Object spiMSP432DMAObjects[MSP432P4011_SPICOUNT];

/*
* NOTE: The SPI instances below can be used by the SD driver to communicate
* with a SD card via SPI. The 'defaultTxBufValue' fields below are set to 0xFF
* to satisfy the SDSPI driver requirement.
*/
const SPIMSP432DMA_HWAttrsV1 spiMSP432DMAHWAttrs[MSP432P4011_SPICOUNT] = {
{
.baseAddr = EUSCI_B0_BASE,
.bitOrder = EUSCI_B_SPI_MSB_FIRST,
.clockSource = EUSCI_B_SPI_CLOCKSOURCE_SMCLK,
.defaultTxBufValue = 0xFF,
.dmaIntNum = INT_DMA_INT1,
.intPriority = (~0),
.rxDMAChannelIndex = DMA_CH1_EUSCIB0RX0,
.txDMAChannelIndex = DMA_CH0_EUSCIB0TX0,
.clkPin = SPIMSP432DMA_P1_5_UCB0CLK,
.simoPin = SPIMSP432DMA_P1_6_UCB0SIMO,
.somiPin = SPIMSP432DMA_P1_7_UCB0SOMI,
.stePin = SPIMSP432DMA_P1_4_UCB0STE,
.pinMode = EUSCI_SPI_3PIN,
.minDmaTransferSize = 10
},
{
.baseAddr = EUSCI_B2_BASE,
.bitOrder = EUSCI_B_SPI_MSB_FIRST,
.clockSource = EUSCI_B_SPI_CLOCKSOURCE_SMCLK,
.defaultTxBufValue = 0xFF,
.dmaIntNum = INT_DMA_INT2,
.intPriority = (~0),
.rxDMAChannelIndex = DMA_CH5_EUSCIB2RX0,
.txDMAChannelIndex = DMA_CH4_EUSCIB2TX0,
.clkPin = SPIMSP432DMA_P3_5_UCB2CLK,
.simoPin = SPIMSP432DMA_P3_6_UCB2SIMO,
.somiPin = SPIMSP432DMA_P3_7_UCB2SOMI,
.stePin = SPIMSP432DMA_P3_4_UCB2STE,
.pinMode = EUSCI_SPI_3PIN,
.minDmaTransferSize = 10
},
{
.baseAddr = EUSCI_A1_BASE,
.bitOrder = EUSCI_A_SPI_MSB_FIRST,
.clockSource = EUSCI_A_SPI_CLOCKSOURCE_SMCLK,
.defaultTxBufValue = 0xFF,
.dmaIntNum = INT_DMA_INT2,
.intPriority = (~0),
.rxDMAChannelIndex = DMA_CH3_EUSCIA1RX,
.txDMAChannelIndex = DMA_CH2_EUSCIA1TX,
.clkPin = SPIMSP432DMA_P2_5_UCA1CLK,
.simoPin = SPIMSP432DMA_P2_6_UCA1SIMO,
.somiPin = SPIMSP432DMA_P2_7_UCA1SOMI,
.stePin = SPIMSP432DMA_P2_3_UCA1STE,
.pinMode = EUSCI_SPI_4PIN_UCxSTE_ACTIVE_LOW,
.minDmaTransferSize = 10
},
{
.baseAddr = EUSCI_B2_BASE,
.bitOrder = EUSCI_B_SPI_MSB_FIRST,
.clockSource = EUSCI_B_SPI_CLOCKSOURCE_SMCLK,
.defaultTxBufValue = 0xFF,
.dmaIntNum = INT_DMA_INT3,
.intPriority = (~0),
.rxDMAChannelIndex = DMA_CH5_EUSCIB2RX0,
.txDMAChannelIndex = DMA_CH4_EUSCIB2TX0,
.clkPin = SPIMSP432DMA_P3_5_UCB2CLK,
.simoPin = SPIMSP432DMA_P3_6_UCB2SIMO,
.somiPin = SPIMSP432DMA_P3_7_UCB2SOMI,
.stePin = SPIMSP432DMA_P2_4_UCB2STE,
.pinMode = EUSCI_SPI_4PIN_UCxSTE_ACTIVE_LOW,
.minDmaTransferSize = 10
}
};

const SPI_Config SPI_config[MSP432P4011_SPICOUNT] = {
{
.fxnTablePtr = &SPIMSP432DMA_fxnTable,
.object = &spiMSP432DMAObjects[MSP432P4011_SPIB0],
.hwAttrs = &spiMSP432DMAHWAttrs[MSP432P4011_SPIB0]
},
{
.fxnTablePtr = &SPIMSP432DMA_fxnTable,
.object = &spiMSP432DMAObjects[MSP432P4011_SPIB2],
.hwAttrs = &spiMSP432DMAHWAttrs[MSP432P4011_SPIB2]
},
{
.fxnTablePtr = &SPIMSP432DMA_fxnTable,
.object = &spiMSP432DMAObjects[MSP432P4011_SPIB3],
.hwAttrs = &spiMSP432DMAHWAttrs[MSP432P4011_SPIB3]
},
{
.fxnTablePtr = &SPIMSP432DMA_fxnTable,
.object = &spiMSP432DMAObjects[MSP432P4011_SPIB4],
.hwAttrs = &spiMSP432DMAHWAttrs[MSP432P4011_SPIB4]
}
};

const uint_least8_t SPI_count = MSP432P4011_SPICOUNT;

/*
* =============================== UART ===============================
*/
#include <ti/drivers/UART.h>
#include <ti/drivers/uart/UARTMSP432.h>

UARTMSP432_Object uartMSP432Objects[MSP432P4011_UARTCOUNT];
unsigned char uartMSP432RingBuffer[MSP432P4011_UARTCOUNT][32];

/*
* The baudrate dividers were determined by using the MSP432 baudrate
* calculator
* software-dl.ti.com/.../index.html
*/
const UARTMSP432_BaudrateConfig uartMSP432Baudrates[] = {
/* {baudrate, input clock, prescalar, UCBRFx, UCBRSx, oversampling} */
{
.outputBaudrate = 115200,
.inputClockFreq = 24000000,
.prescalar = 13,
.hwRegUCBRFx = 0,
.hwRegUCBRSx = 37,
.oversampling = 1
},
{115200, 12000000, 6, 8, 32, 1},
{115200, 6000000, 3, 4, 2, 1},
{115200, 3000000, 1, 10, 0, 1},
{9600, 24000000, 156, 4, 0, 1},
{9600, 12000000, 78, 2, 0, 1},
{9600, 6000000, 39, 1, 0, 1},
{9600, 3000000, 19, 8, 85, 1},
{9600, 32768, 3, 0, 146, 0}
};

const UARTMSP432_HWAttrsV1 uartMSP432HWAttrs[MSP432P4011_UARTCOUNT] = {
{
.baseAddr = EUSCI_A0_BASE,
.intNum = INT_EUSCIA0,
.intPriority = (~0),
.clockSource = EUSCI_A_UART_CLOCKSOURCE_SMCLK,
.bitOrder = EUSCI_A_UART_LSB_FIRST,
.numBaudrateEntries = sizeof(uartMSP432Baudrates) /
sizeof(UARTMSP432_BaudrateConfig),
.baudrateLUT = uartMSP432Baudrates,
.ringBufPtr = uartMSP432RingBuffer[MSP432P4011_UARTA0],
.ringBufSize = sizeof(uartMSP432RingBuffer[MSP432P4011_UARTA0]),
.rxPin = UARTMSP432_P1_2_UCA0RXD,
.txPin = UARTMSP432_P1_3_UCA0TXD,
.errorFxn = NULL
},
#ifdef _RGC_PKG_
{
.baseAddr = EUSCI_A1_BASE,
.intNum = INT_EUSCIA1,
.intPriority = (~0),
.clockSource = EUSCI_A_UART_CLOCKSOURCE_SMCLK,
.bitOrder = EUSCI_A_UART_LSB_FIRST,
.numBaudrateEntries = sizeof(uartMSP432Baudrates) /
sizeof(UARTMSP432_BaudrateConfig),
.baudrateLUT = uartMSP432Baudrates,
.ringBufPtr = uartMSP432RingBuffer[MSP432P4011_UARTA1],
.ringBufSize = sizeof(uartMSP432RingBuffer[MSP432P4011_UARTA1]),
.rxPin = UARTMSP432_P2_2_UCA1RXD,
.txPin = UARTMSP432_P2_3_UCA1TXD,
.errorFxn = NULL
},
#endif
{
.baseAddr = EUSCI_A2_BASE,
.intNum = INT_EUSCIA2,
.intPriority = (~0),
.clockSource = EUSCI_A_UART_CLOCKSOURCE_SMCLK,
.bitOrder = EUSCI_A_UART_LSB_FIRST,
.numBaudrateEntries = sizeof(uartMSP432Baudrates) /
sizeof(UARTMSP432_BaudrateConfig),
.baudrateLUT = uartMSP432Baudrates,
.ringBufPtr = uartMSP432RingBuffer[MSP432P4011_UARTA2],
.ringBufSize = sizeof(uartMSP432RingBuffer[MSP432P4011_UARTA2]),
.rxPin = UARTMSP432_P3_2_UCA2RXD,
.txPin = UARTMSP432_P3_3_UCA2TXD,
.errorFxn = NULL
}
};

const UART_Config UART_config[MSP432P4011_UARTCOUNT] = {
{
.fxnTablePtr = &UARTMSP432_fxnTable,
.object = &uartMSP432Objects[MSP432P4011_UARTA0],
.hwAttrs = &uartMSP432HWAttrs[MSP432P4011_UARTA0]
},
#ifdef _RGC_PKG_
{
.fxnTablePtr = &UARTMSP432_fxnTable,
.object = &uartMSP432Objects[MSP432P4011_UARTA1],
.hwAttrs = &uartMSP432HWAttrs[MSP432P4011_UARTA1]
},
#endif
{
.fxnTablePtr = &UARTMSP432_fxnTable,
.object = &uartMSP432Objects[MSP432P4011_UARTA2],
.hwAttrs = &uartMSP432HWAttrs[MSP432P4011_UARTA2]
}
};

const uint_least8_t UART_count = MSP432P4011_UARTCOUNT;

/*
* =============================== Watchdog ===============================
*/
#include <ti/drivers/Watchdog.h>
#include <ti/drivers/watchdog/WatchdogMSP432.h>

WatchdogMSP432_Object watchdogMSP432Objects[MSP432P4011_WATCHDOGCOUNT];

const WatchdogMSP432_HWAttrs
watchdogMSP432HWAttrs[MSP432P4011_WATCHDOGCOUNT] = {
{
.baseAddr = WDT_A_BASE,
.intNum = INT_WDT_A,
.intPriority = (~0),
.clockSource = WDT_A_CLOCKSOURCE_SMCLK,
.clockDivider = WDT_A_CLOCKDIVIDER_8192K
}
};

const Watchdog_Config Watchdog_config[MSP432P4011_WATCHDOGCOUNT] = {
{
.fxnTablePtr = &WatchdogMSP432_fxnTable,
.object = &watchdogMSP432Objects[MSP432P4011_WATCHDOG],
.hwAttrs = &watchdogMSP432HWAttrs[MSP432P4011_WATCHDOG]
}
};

const uint_least8_t Watchdog_count = MSP432P4011_WATCHDOGCOUNT;