/******************************************************************************
DEFINE PRIVATE FUNCTIONS
******************************************************************************/
STATIC void pin_obj_configure (const pin_obj_t *self) {
// Skip all this if the pin is to be used in analog mode
if (self->type != PYBPIN_ANALOG_TYPE) {
// verify the alternate function
pin_verify_af (self->af);
// PIN_MODE_0 means it stays as a pin, else, another peripheral will take control of it
if (self->af == PIN_MODE_0) {
// enable the peripheral clock for the GPIO port of this pin
switch (self->port) {
case PORT_A0:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A1:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A2:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A3:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA3, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
default:
break;
}
// configure the direction
MAP_GPIODirModeSet(self->port, self->bit, self->mode);
}
// now set the alternate function, strenght and type
MAP_PinModeSet (self->pin_num, self->af);
}
MAP_PinConfigSet(self->pin_num, self->strength, self->type);
}
//****************************************************************************
//
//! \brief This function restore the backed up data (after S3)
//!
//! \param none
//!
//! \return none
//
//****************************************************************************
void lp3p0_restore_soc_data(void)
{
/* Invoking the default CC3xxx service impl. */
cc_restore_soc_data();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
cc_gpio_restore_context();
#ifdef DEBUG_GPIO
cc_gpio_write(tGPIODbgHndl, GPIO_09, 1);
#endif
/* Initialize timer services */
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK|
PRCM_SLP_MODE_CLK);
/* ungates the clk for the shared SPI*/
MAP_PRCMPeripheralClkEnable(PRCM_SSPI, PRCM_RUN_MODE_CLK|
PRCM_SLP_MODE_CLK);
/* Initialize the DMA module */
MAP_PRCMPeripheralClkEnable(PRCM_UDMA, PRCM_RUN_MODE_CLK|
PRCM_SLP_MODE_CLK);
MAP_uDMAControlBaseSet(dma_ctrl_table);
MAP_uDMAEnable();
MAP_PRCMIntEnable(PRCM_INT_SLOW_CLK_CTR);
}
//*****************************************************************************
void
PinMuxConfig(void)
{
//
// Enable Peripheral Clocks
//
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
//
// Configure PIN_55 for UART0 UART0_TX
//
MAP_PinTypeUART(PIN_55, PIN_MODE_3);
//
// Configure PIN_57 for UART0 UART0_RX
//
MAP_PinTypeUART(PIN_57, PIN_MODE_3);
//
// Configure PIN_64 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_64, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x2, GPIO_DIR_MODE_OUT);
//
// Configure PIN_02 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_02, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x8, GPIO_DIR_MODE_OUT);
}
//*****************************************************************************
//
//! \InterruptTestInit
//!
//! Performs initialization.
//! This function is called at the start of the test to enable any peripherals
//! used during the test.
//!
//! \param None.
//!
//! \return None.
//
//*****************************************************************************
static void
InterruptTestInit(void)
{
//
// Enable and Reset the timer blocks
//
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA1, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralReset(PRCM_TIMERA0);
MAP_PRCMPeripheralReset(PRCM_TIMERA1);
MAP_PRCMPeripheralReset(PRCM_TIMERA2);
//
// Remember the timer interrupt priorities and priority group settings as
// they are on entry so that we can restore them on exit.
//
g_ulTimer0APriority = MAP_IntPriorityGet(INT_TIMERA0A);
g_ulTimer1APriority = MAP_IntPriorityGet(INT_TIMERA1A);
g_lPriorityGrouping = MAP_IntPriorityGroupingGet();
SysTickInit();
}
//****************************************************************************
//
//! Sets up the identified timers as PWM to drive the peripherals
//!
//! \param none
//!
//! This function sets up the folowing
//! 1. TIMERA2 (TIMER B) as RED of RGB light
//! 2. TIMERA3 (TIMER B) as YELLOW of RGB light
//! 3. TIMERA3 (TIMER A) as GREEN of RGB light
//!
//! \return None.
//
//****************************************************************************
void InitPWMModules()
{
//
// Initialization of timers to generate PWM output
//
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA3, PRCM_RUN_MODE_CLK);
//
// TIMERA2 (TIMER B) as RED of RGB light. GPIO 9 --> PWM_5
//
SetupTimerPWMMode(TIMERA2_BASE, TIMER_B,
(TIMER_CFG_SPLIT_PAIR | TIMER_CFG_B_PWM), 1);
//
// TIMERA3 (TIMER B) as YELLOW of RGB light. GPIO 10 --> PWM_6
//
SetupTimerPWMMode(TIMERA3_BASE, TIMER_A,
(TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PWM | TIMER_CFG_B_PWM), 1);
//
// TIMERA3 (TIMER A) as GREEN of RGB light. GPIO 11 --> PWM_7
//
SetupTimerPWMMode(TIMERA3_BASE, TIMER_B,
(TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PWM | TIMER_CFG_B_PWM), 1);
MAP_TimerEnable(TIMERA2_BASE,TIMER_B);
MAP_TimerEnable(TIMERA3_BASE,TIMER_A);
MAP_TimerEnable(TIMERA3_BASE,TIMER_B);
}
//*****************************************************************************
void
PinMuxConfig(void)
{
//
// Enable Peripheral Clocks
//
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
//
// Configure PIN_55 for UART0 UART0_TX
//
MAP_PinTypeUART(PIN_55, PIN_MODE_3);
//
// Configure PIN_57 for UART0 UART0_RX
//
MAP_PinTypeUART(PIN_57, PIN_MODE_3);
//
// Configure PIN_01 for I2C0 I2C_SCL
//
MAP_PinTypeI2C(PIN_01, PIN_MODE_1);
//
// Configure PIN_02 for I2C0 I2C_SDA
//
MAP_PinTypeI2C(PIN_02, PIN_MODE_1);
}
/*
* ======== Board_openUART ========
* Initialize the UART driver.
* Initialize the UART port's pins.
* Open the UART port.
*/
UART_Handle Board_openUART(UInt uartPortIndex, UART_Params *uartParams)
{
/* Initialize the UART driver */
/* By design, UART_init() is idempotent */
UART_init();
/* initialize the pins associated with the respective UART */
switch(uartPortIndex) {
case 0:
/* Serial */
/* enable UART1 clock */
MAP_PRCMPeripheralClkEnable(PRCM_UARTA1, PRCM_RUN_MODE_CLK);
/*
* Configure LaunchPad P2.9 as a UART1: UART1 TX (via USB port)
* device pin: 55 (UART1_TX)
* Wiring id : 12
*/
MAP_PinTypeUART(PIN_55, PIN_MODE_6);
/*
* Configure LaunchPad P3.3 as a UART1: UART1 RX (via USB port)
* device pin: 57 (UART1_RX)
* Wiring id : 23
*/
MAP_PinTypeUART(PIN_57, PIN_MODE_6);
break;
case 1:
/* Serial1 */
/* enable UART0 clock */
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
/*
* Configure LaunchPad P1.4 as a UART0: UART0 TX
* device pin: 3 (UART0_TX)
* Wiring id : 4
*/
MAP_PinTypeUART(PIN_03, PIN_MODE_7);
/*
* Configure LaunchPad P1.3 as a UART0: UART0 RX
* device pin: 4 (UART0_RX)
* Wiring id : 3
*/
MAP_PinTypeUART(PIN_04, PIN_MODE_7);
break;
default:
return (NULL);
}
/* open the UART */
return (UART_open(uartPortIndex, uartParams));
}
/*
* ======== Board_initGeneral ========
*/
void Board_initGeneral(void)
{
/* Reset DMA + other essential peripheral initialization
* ASSUMED by the simplelink and driverlib libraries
*/
PRCMCC3200MCUInit();
/* Configure pins as specified in the current configuration */
/*
* ======== Enable Peripheral Clocks ========
* Enable all clocks (because wiring can use any pin in any mode
* at runtime)
*/
MAP_PRCMPeripheralClkEnable(PRCM_CAMERA, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GSPI, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_I2S, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_SDHOST, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA1, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA3, PRCM_RUN_MODE_CLK);
}
void InitGPIO(void)
{
/* Activate GPIO clock per port. Not sure of which ports we use, so enable everything */
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA3, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA4, PRCM_RUN_MODE_CLK);
/* Configure UART pins */
MAP_PinTypeUART(PIN_55, PIN_MODE_3);
MAP_PinTypeUART(PIN_57, PIN_MODE_3);
/* Configure I2C pins */
MAP_PinTypeI2C(PIN_01, PIN_MODE_1);
MAP_PinTypeI2C(PIN_02, PIN_MODE_1);
/* COngifure current sense ADC inputs */
MAP_PinTypeADC(AISEN,PIN_MODE_255);
MAP_PinTypeADC(BISEN,PIN_MODE_255);
MAP_ADCChannelEnable(ADC_BASE, AISENx);
MAP_ADCChannelEnable(ADC_BASE, BISENx);
MAP_ADCEnable(ADC_BASE);
/* Set pin mode for DIP and LED pins */
MAP_PinTypeGPIO(RLED, PIN_MODE_0, false);
MAP_PinTypeGPIO(BLED, PIN_MODE_0, false);
MAP_PinTypeGPIO(DIP1, PIN_MODE_0, false);
MAP_PinTypeGPIO(DIP2, PIN_MODE_0, false);
MAP_PinTypeGPIO(DIP3, PIN_MODE_0, false);
MAP_PinTypeGPIO(DIP4, PIN_MODE_0, false);
MAP_PinTypeGPIO(ODO1, PIN_MODE_0, false);
MAP_PinTypeGPIO(ODO2, PIN_MODE_0, false);
/* Get port name and bin number from GPIO number (TI lookup table) LED, DIP, ODO */
GPIO_IF_GetPortNPin(RLEDx, &port_rled, &pin_rled);
GPIO_IF_GetPortNPin(BLEDx, &port_bled, &pin_bled);
GPIO_IF_GetPortNPin(DIP1x, &port_dip1, &pin_dip1);
GPIO_IF_GetPortNPin(DIP2x, &port_dip2, &pin_dip2);
GPIO_IF_GetPortNPin(DIP3x, &port_dip3, &pin_dip3);
GPIO_IF_GetPortNPin(DIP4x, &port_dip4, &pin_dip4);
GPIO_IF_GetPortNPin(ODO1x, &port_odo1, &pin_odo1);
GPIO_IF_GetPortNPin(ODO2x, &port_odo2, &pin_odo2);
/* Set pin direction LED, DIP, ODO */
GPIODirModeSet(port_rled, pin_rled, 1);
GPIODirModeSet(port_bled, pin_bled, 1);
GPIODirModeSet(port_dip1, pin_dip1, 0);
GPIODirModeSet(port_dip2, pin_dip2, 0);
GPIODirModeSet(port_dip3, pin_dip3, 0);
GPIODirModeSet(port_dip4, pin_dip4, 0);
GPIODirModeSet(port_odo1, pin_odo1, 0);
GPIODirModeSet(port_odo2, pin_odo2, 0);
}
/**
* @brief Initialize the board
*/
void board_init(void) {
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA3, PRCM_RUN_MODE_CLK);
/* initialize the CPU */
cpu_init();
/* initialize the boards LEDs */
led_init();
}
int main() {
#ifndef USE_TIRTOS
MAP_IntVTableBaseSet((unsigned long) &g_pfnVectors[0]);
#endif
MAP_IntEnable(FAULT_SYSTICK);
MAP_IntMasterEnable();
PRCMCC3200MCUInit();
/* Console UART init. */
MAP_PRCMPeripheralClkEnable(CONSOLE_UART_PERIPH, PRCM_RUN_MODE_CLK);
MAP_PinTypeUART(PIN_55, PIN_MODE_3); /* PIN_55 -> UART0_TX */
MAP_PinTypeUART(PIN_57, PIN_MODE_3); /* PIN_57 -> UART0_RX */
MAP_UARTConfigSetExpClk(
CONSOLE_UART, MAP_PRCMPeripheralClockGet(CONSOLE_UART_PERIPH),
CONSOLE_BAUD_RATE,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
MAP_UARTFIFOLevelSet(CONSOLE_UART, UART_FIFO_TX1_8, UART_FIFO_RX4_8);
MAP_UARTFIFOEnable(CONSOLE_UART);
setvbuf(stdout, NULL, _IOLBF, 0);
setvbuf(stderr, NULL, _IOLBF, 0);
cs_log_set_level(LL_INFO);
cs_log_set_file(stdout);
LOG(LL_INFO, ("Hello, world!"));
MAP_PinTypeI2C(PIN_01, PIN_MODE_1); /* SDA */
MAP_PinTypeI2C(PIN_02, PIN_MODE_1); /* SCL */
I2C_IF_Open(I2C_MASTER_MODE_FST);
/* Set up the red LED. Note that amber and green cannot be used as they share
* pins with I2C. */
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
MAP_PinTypeGPIO(PIN_64, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x2, GPIO_DIR_MODE_OUT);
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
if (VStartSimpleLinkSpawnTask(8) != 0) {
LOG(LL_ERROR, ("Failed to create SL task"));
}
if (!mg_start_task(MG_TASK_PRIORITY, MG_TASK_STACK_SIZE, mg_init)) {
LOG(LL_ERROR, ("Failed to create MG task"));
}
osi_start();
return 0;
}
//****************************************************************************
//
//! Initialize the watchdog timer
//!
//! \param fpAppWDTCB is the WDT interrupt handler to be registered
//! \param uiReloadVal is the reload value to be set to the WDT
//!
//! This function
//! 1. Initializes the WDT
//!
//! \return None.
//
//****************************************************************************
void WDT_IF_Init(fAPPWDTDevCallbk fpAppWDTCB,
unsigned int uiReloadVal)
{
//
// Enable the peripherals used by this example.
//
MAP_PRCMPeripheralClkEnable(PRCM_WDT, PRCM_RUN_MODE_CLK);
//
// Unlock to be able to configure the registers
//
MAP_WatchdogUnlock(WDT_BASE);
if(fpAppWDTCB != NULL)
{
#ifdef USE_TIRTOS
osi_InterruptRegister(INT_WDT, fpAppWDTCB, INT_PRIORITY_LVL_1);
#else
MAP_WatchdogIntRegister(WDT_BASE,fpAppWDTCB);
#endif
}
//
// Set the watchdog timer reload value
//
MAP_WatchdogReloadSet(WDT_BASE,uiReloadVal);
//
// Start the timer. Once the timer is started, it cannot be disable.
//
MAP_WatchdogEnable(WDT_BASE);
}
//****************************************************************************
//
//! Implements Sleep followed by wakeup using WDT timeout
//!
//! \param none
//!
//! This function
//! 1. Implements Sleep followed by wakeup using WDT
//!
//! \return None.
//
//****************************************************************************
void PerformPRCMSleepWDTWakeup()
{
//
// Initialize the WDT
//
WDT_IF_Init(AppWDTCallBackHandler, (4 * SYS_CLK));
//
// Enable the Sleep Clock
//
MAP_PRCMPeripheralClkEnable(PRCM_WDT, PRCM_SLP_MODE_CLK);
//
// Enter SLEEP...WaitForInterrupt ARM intrinsic
//
DBG_PRINT("WDT_SLEEP: Entering Sleep\n\r");
MAP_UtilsDelay(80000);
MAP_PRCMSleepEnter();
DBG_PRINT("WDT_SLEEP: Exiting Sleep\n\r");
//
// Disable the Sleep Clock
//
MAP_PRCMPeripheralClkDisable(PRCM_WDT, PRCM_SLP_MODE_CLK);
//
// Deinitialize the WDT
//
WDT_IF_DeInit();
//
// PowerOff WDT
//
MAP_PRCMPeripheralClkDisable(PRCM_WDT, PRCM_RUN_MODE_CLK);
}
int main() {
MAP_IntVTableBaseSet((unsigned long) &g_pfnVectors[0]);
MAP_IntEnable(FAULT_SYSTICK);
MAP_IntMasterEnable();
PRCMCC3200MCUInit();
cc3200_leds_init();
/* Console UART init. */
MAP_PRCMPeripheralClkEnable(CONSOLE_UART_PERIPH, PRCM_RUN_MODE_CLK);
MAP_PinTypeUART(PIN_55, PIN_MODE_3); /* PIN_55 -> UART0_TX */
MAP_PinTypeUART(PIN_57, PIN_MODE_3); /* PIN_57 -> UART0_RX */
MAP_UARTConfigSetExpClk(
CONSOLE_UART, MAP_PRCMPeripheralClockGet(CONSOLE_UART_PERIPH),
CONSOLE_BAUD_RATE,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
MAP_UARTFIFODisable(CONSOLE_UART);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
VStartSimpleLinkSpawnTask(8);
osi_TaskCreate(v7_task, (const signed char *) "v7", V7_STACK_SIZE + 256, NULL,
3, NULL);
osi_TaskCreate(blinkenlights_task, (const signed char *) "blink", 256, NULL,
9, NULL);
osi_start();
return 0;
}
bool mgos_uart_hal_init(struct mgos_uart_state *us) {
uint32_t base = cc32xx_uart_get_base(us->uart_no);
uint32_t periph, int_no;
void (*int_handler)();
/* TODO(rojer): Configurable pin mappings? */
if (us->uart_no == 0) {
periph = PRCM_UARTA0;
int_no = INT_UARTA0;
int_handler = u0_int;
MAP_PinTypeUART(PIN_55, PIN_MODE_3); /* UART0_TX */
MAP_PinTypeUART(PIN_57, PIN_MODE_3); /* UART0_RX */
} else if (us->uart_no == 1) {
periph = PRCM_UARTA1;
int_no = INT_UARTA1;
int_handler = u1_int;
MAP_PinTypeUART(PIN_07, PIN_MODE_5); /* UART1_TX */
MAP_PinTypeUART(PIN_08, PIN_MODE_5); /* UART1_RX */
} else {
return false;
}
struct cc32xx_uart_state *ds =
(struct cc32xx_uart_state *) calloc(1, sizeof(*ds));
ds->base = base;
cs_rbuf_init(&ds->isr_rx_buf, CC32xx_UART_ISR_RX_BUF_SIZE);
us->dev_data = ds;
MAP_PRCMPeripheralClkEnable(periph, PRCM_RUN_MODE_CLK);
MAP_UARTIntDisable(base, ~0); /* Start with ints disabled. */
MAP_IntRegister(int_no, int_handler);
MAP_IntPrioritySet(int_no, INT_PRIORITY_LVL_1);
MAP_IntEnable(int_no);
return true;
}
//*****************************************************************************
//
//! Initialize the DMA controller
//!
//! \param None
//!
//! This function initializes
//! 1. Initializes the McASP module
//!
//! \return None.
//
//*****************************************************************************
void UDMAInit()
{
unsigned int uiLoopCnt;
//
// Enable McASP at the PRCM module
//
MAP_PRCMPeripheralClkEnable(PRCM_UDMA,PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralReset(PRCM_UDMA);
//
// Register interrupt handlers
//
MAP_uDMAIntRegister(UDMA_INT_SW, DmaSwIntHandler);
MAP_uDMAIntRegister(UDMA_INT_ERR, DmaErrorIntHandler);
//
// Enable uDMA using master enable
//
MAP_uDMAEnable();
//
// Set Control Table
//
memset(gpCtlTbl,0,sizeof(tDMAControlTable)*CTL_TBL_SIZE);
MAP_uDMAControlBaseSet(gpCtlTbl);
//
// Reset App Callbacks
//
for(uiLoopCnt = 0; uiLoopCnt < MAX_NUM_CH; uiLoopCnt++)
{
gfpAppCallbackHndl[uiLoopCnt] = NULL;
}
}
//*****************************************************************************
void
PinMuxConfig(void)
{
//
// Enable Peripheral Clocks
//
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
//
// Configure PIN_64 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_64, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x2, GPIO_DIR_MODE_OUT);
//
// Configure PIN_01 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_01, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x4, GPIO_DIR_MODE_OUT);
//
// Configure PIN_02 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_02, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x8, GPIO_DIR_MODE_OUT);
}
void HardwareSerial::begin(unsigned long baud)
{
baudRate = baud;
/* Set the UART to interrupt whenever the TX FIFO is almost empty or
* when any character is received. */
//MAP_UARTFIFOLevelSet(UART_BASE, UART_FIFO_TX7_8, UART_FIFO_RX7_8);
/* Initialize the UART. */
// UARTClockSourceSet(UART_BASE, UART_CLOCK_SYSTEM);
MAP_PRCMPeripheralReset(g_ulUARTPeriph[uartModule]);
MAP_PRCMPeripheralClkEnable(g_ulUARTPeriph[uartModule], PRCM_RUN_MODE_CLK);
MAP_PinTypeUART(g_ulUARTConfig[uartModule][0], PIN_MODE_3);
MAP_PinTypeUART(g_ulUARTConfig[uartModule][1], PIN_MODE_3);
MAP_UARTConfigSetExpClk(UART_BASE, 80000000, baudRate,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8));
flushAll();
MAP_IntEnable(g_ulUARTInt[uartModule]);
/* Enable the UART operation. */
MAP_UARTEnable(UART_BASE);
MAP_UARTIntEnable(UART_BASE, UART_INT_RT | UART_INT_TX);
}
Uart0::Error Uart0::open() {
if (is_open())
return kPortAlreadyOpen;
/* Initializes the Buffers */
in_buffer_.create("Uart0 Rx Buffer", kBufferSize);
out_buffer_.create("Uart0 Tx Buffer", kBufferSize);
/* Enable the UART0 peripheral. */
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
/* Configure Pins. */
Error pins_ok = init_pins();
if (pins_ok != kOK)
return pins_ok;
/* Configure UART. */
Error uart_ok = config_uart();
if (uart_ok != kOK)
return uart_ok;
/* Change the status */
open_ = true;
g_uart0_object = this;
return kOK;
}
//****************************************************************************
//
//! \brief This function restore the backed up data (after S3)
//!
//! \param none
//!
//! \return none
//
//****************************************************************************
void lp3p0_restore_soc_data(void)
{
/* Invoking the default CC3xxx service impl. */
cc_restore_soc_data();
PRCMCC3200MCUInit();
/* disabling all wk up srcs */
PRCMLPDSWakeupSourceDisable(PRCM_LPDS_HOST_IRQ|PRCM_LPDS_GPIO|PRCM_LPDS_TIMER);
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
//
// enable peripherals
//
enable_peripherals();
/* ungates the clk for the shared SPI*/
MAP_PRCMPeripheralClkEnable(PRCM_SSPI, PRCM_RUN_MODE_CLK|
PRCM_SLP_MODE_CLK);
MAP_PRCMIntEnable(PRCM_INT_SLOW_CLK_CTR);
}
void tone(uint8_t pin, unsigned int frequency, unsigned long duration)
{
/* Use TIMERA0B since it is not on any pin */
tone_timer = digitalPinToTimer(pin);
if(tone_timer == NOT_ON_TIMER)
return;
if(tone_state != 0 && pin != current_pin)
return;
g_duration = duration;
current_pin = pin;
tone_state = 2;
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralReset(PRCM_TIMERA0);
MAP_TimerConfigure(TIMERA0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_B_PERIODIC);
MAP_TimerIntRegister(TIMERA0_BASE, TIMER_B, ToneIntHandler);
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMB_TIMEOUT);
MAP_TimerPrescaleSet(TIMERA0_BASE, TIMER_B, 7);
MAP_TimerLoadSet(TIMERA0_BASE, TIMER_B, (F_CPU / 8) / 1000);
MAP_TimerEnable(TIMERA0_BASE, TIMER_B);
PWMWrite(pin, 256, 128, frequency);
}
//****************************************************************************
//
//! The delay function uses timer to implement the delay time in milliseconds
//!
//! \param time in millisecond
//
//! \return void
//****************************************************************************
static void delay(int time_ms)
{
// Initialize Timer 0B as one-shot down counter.
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralReset(PRCM_TIMERA0);
MAP_TimerConfigure(TIMERA0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_B_ONE_SHOT);
MAP_TimerPrescaleSet(TIMERA0_BASE, TIMER_B, PRESCALE);
//Load the value in milisecond
MAP_TimerLoadSet(TIMERA0_BASE, TIMER_B, MILLISECONDS_TO_TICKS(time_ms));
// Enable the timer
MAP_TimerEnable(TIMERA0_BASE, TIMER_B);
//Stall during debug
MAP_TimerControlStall(TIMERA0_BASE, TIMER_B, 1);
// Enable interrupt upon Time-out
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMB_TIMEOUT);
// Clear Interrupt Flag
MAP_TimerIntClear(TIMERA0_BASE, MAP_TimerIntStatus(TIMERA0_BASE, true));
//Wait until timer time-out
while (MAP_TimerIntStatus(TIMERA0_BASE, true) != TIMER_TIMB_TIMEOUT){}
//Disable the timer
MAP_TimerDisable(TIMERA0_BASE, TIMER_B);
//Disable Interrupt
MAP_TimerIntDisable(TIMERA0_BASE, TIMER_TIMB_TIMEOUT);
MAP_TimerIntUnregister(TIMERA0_BASE, TIMER_B);
}
//*****************************************************************************
void
PinMuxConfig(void)
{
//
// Enable Peripheral Clocks
//
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA3, PRCM_RUN_MODE_CLK);
//
// Configure PIN_55 for UART0 UART0_TX
//
MAP_PinTypeUART(PIN_55, PIN_MODE_3);
//
// Configure PIN_57 for UART0 UART0_RX
//
MAP_PinTypeUART(PIN_57, PIN_MODE_3);
//
// Configure PIN_58 for GPIOInput
//
MAP_PinTypeGPIO(PIN_58, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA0_BASE, 0x8, GPIO_DIR_MODE_IN);
//
// Configure PIN_64 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_64, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x2, GPIO_DIR_MODE_OUT);
//
// Configure PIN_15 for GPIO Input
//
MAP_PinTypeGPIO(PIN_15, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA2_BASE, 0x40, GPIO_DIR_MODE_IN);
//
// Configure PIN_02 for TIMERPWM7 GT_PWM07
//
MAP_PinTypeTimer(PIN_02, PIN_MODE_3);
}
//****************************************************************************
//
//! Implements Sleep followed by wakeup using GPT timeout
//!
//! \param none
//!
//! This function
//! 1. Implements Sleep followed by wakeup using GPT
//!
//! \return None.
//
//****************************************************************************
void PerformPRCMSleepGPTWakeup()
{
//
// Power On the GPT along with sleep clock
//
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
//
// Initialize the GPT as One Shot timer
//
Timer_IF_Init(PRCM_TIMERA0, TIMERA0_BASE, TIMER_CFG_ONE_SHOT, TIMER_BOTH, 0);
Timer_IF_IntSetup(TIMERA0_BASE, TIMER_BOTH, AppGPTCallBackHandler);
//
// Start timer with value in mSec
//
Timer_IF_Start(TIMERA0_BASE, TIMER_BOTH, 4000);
//
// Enable the Sleep Clock
//
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_SLP_MODE_CLK);
//
// Enter SLEEP...WaitForInterrupt ARM intrinsic
//
DBG_PRINT("GPT_SLEEP: Entering Sleep\n\r");
MAP_UtilsDelay(80000);
MAP_PRCMSleepEnter();
DBG_PRINT("GPT_SLEEP: Exiting Sleep\n\r");
//
// Disable the Sleep Clock
//
MAP_PRCMPeripheralClkDisable(PRCM_TIMERA0, PRCM_SLP_MODE_CLK);
//
// Deinitialize the GPT
//
Timer_IF_Stop(TIMERA0_BASE, TIMER_BOTH);
Timer_IF_DeInit(TIMERA0_BASE, TIMER_BOTH);
//
// PowerOff GPT
//
MAP_PRCMPeripheralClkDisable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
}
void TwoWire::begin(void)
{
MAP_PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
MAP_PinTypeI2C(PIN_01, PIN_MODE_1);
MAP_PinTypeI2C(PIN_02, PIN_MODE_1);
MAP_PRCMPeripheralReset(PRCM_I2CA0);
MAP_I2CMasterInitExpClk(I2C_BASE, F_CPU, true);
}
void cc3200_leds_init() {
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
MAP_PinTypeGPIO(PIN_64, PIN_MODE_0, false); /* Amber LED */
MAP_PinTypeGPIO(PIN_01, PIN_MODE_0, false); /* Red LED */
MAP_PinTypeGPIO(PIN_02, PIN_MODE_0, false); /* Green LED */
MAP_GPIODirModeSet(GPIOA1_BASE, RED | GREEN | AMBER, GPIO_DIR_MODE_OUT);
cc3200_leds(RED | GREEN | AMBER, OFF);
}
STATIC void pin_obj_configure (const pin_obj_t *self) {
uint32_t type;
if (self->mode == PIN_TYPE_ANALOG) {
type = PIN_TYPE_ANALOG;
} else {
type = self->pull;
uint32_t direction = self->mode;
if (direction == PIN_TYPE_OD || direction == GPIO_DIR_MODE_ALT_OD) {
direction = GPIO_DIR_MODE_OUT;
type |= PIN_TYPE_OD;
}
if (self->mode != GPIO_DIR_MODE_ALT && self->mode != GPIO_DIR_MODE_ALT_OD) {
// enable the peripheral clock for the GPIO port of this pin
switch (self->port) {
case PORT_A0:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A1:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A2:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
case PORT_A3:
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA3, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
break;
default:
break;
}
// set the pin value
if (self->value) {
MAP_GPIOPinWrite(self->port, self->bit, self->bit);
} else {
MAP_GPIOPinWrite(self->port, self->bit, 0);
}
// configure the direction
MAP_GPIODirModeSet(self->port, self->bit, direction);
}
// now set the alternate function
MAP_PinModeSet (self->pin_num, self->af);
}
MAP_PinConfigSet(self->pin_num, self->strength, type);
}
void motorSetup()
{
/* Set pin mode for Hbridge output pins */
MAP_PinTypeGPIO(AIN1, PIN_MODE_0, false); /* Ain 1 */
MAP_PinTypeGPIO(AIN2, PIN_MODE_0, false); /* Bin 1 */
MAP_PinTypeGPIO(BIN1, PIN_MODE_0, false); /* Bin 2 */
MAP_PinTypeGPIO(BIN2, PIN_MODE_0, false); /* Ain 2 */
/* Get port name and bin number from GPIO number (TI lookup table) */
GPIO_IF_GetPortNPin(AIN1x, &port_ain1, &pin_ain1);
GPIO_IF_GetPortNPin(AIN2x, &port_ain2, &pin_ain2);
GPIO_IF_GetPortNPin(BIN1x, &port_bin1, &pin_bin1);
GPIO_IF_GetPortNPin(BIN2x, &port_bin2, &pin_bin2);
/* Set pin direction */
GPIODirModeSet(port_ain1, pin_ain1, 1);
GPIODirModeSet(port_ain2, pin_ain2, 1);
GPIODirModeSet(port_bin1, pin_bin1, 1);
GPIODirModeSet(port_bin2, pin_bin2, 1);
/* Set value to write to PIN */
bitA1 = 1 << (AIN1x % 8);
bitA2 = 1 << (AIN2x % 8);
bitB1 = 1 << (BIN1x % 8);
bitB2 = 1 << (BIN2x % 8);
// Enable timer A peripheral
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralReset(PRCM_TIMERA0);
// Split channels and configure for periodic interrupts
MAP_TimerConfigure(TIMERA0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PERIODIC | TIMER_CFG_B_PERIODIC);
MAP_TimerPrescaleSet(TIMERA0_BASE, TIMER_A, 0);
MAP_TimerPrescaleSet(TIMERA0_BASE, TIMER_B, 0);
// Set compare interrupt
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMA_MATCH);
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMB_MATCH);
// Configure compare interrupt, start with 0 speed
MAP_TimerMatchSet(TIMERA0_BASE, TIMER_A, 0);
MAP_TimerMatchSet(TIMERA0_BASE, TIMER_B, 0);
// Set timeout interrupt
MAP_TimerIntRegister(TIMERA0_BASE, TIMER_A, TimerBaseIntHandlerA);
MAP_TimerIntRegister(TIMERA0_BASE, TIMER_B, TimerBaseIntHandlerB);
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMA_TIMEOUT);
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMB_TIMEOUT);
// Turn on timers
MAP_TimerLoadSet(TIMERA0_BASE, TIMER_A, MOTOR_PRESCALER);
MAP_TimerLoadSet(TIMERA0_BASE, TIMER_B, MOTOR_PRESCALER);
MAP_TimerEnable(TIMERA0_BASE, TIMER_A);
MAP_TimerEnable(TIMERA0_BASE, TIMER_B);
}
void PinMuxConfig1(void)
{
//
// Enable Peripheral Clocks
//
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA2, PRCM_RUN_MODE_CLK);
//
// Configure PIN_15 for GPIOOutput,
//
MAP_PinTypeGPIO(PIN_15, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA2_BASE, 0x40, GPIO_DIR_MODE_OUT);
MAP_PinTypeGPIO(PIN_57, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA0_BASE, 0x4, GPIO_DIR_MODE_OUT);
}
//*****************************************************************************
void
PinMuxConfig(void)
{
//
// Enable Peripheral Clocks
//
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
//
// Configure PIN_55 for UART0 UART0_TX
//
MAP_PinTypeUART(PIN_55, PIN_MODE_3);
//
// Configure PIN_57 for UART0 UART0_RX
//
MAP_PinTypeUART(PIN_57, PIN_MODE_3);
//
// Configure PIN_58 for GPIOInput
//
MAP_PinTypeGPIO(PIN_58, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA0_BASE, 0x8, GPIO_DIR_MODE_IN);
//
// Configure PIN_64 for PWM
//
MAP_PinTypeTimer(PIN_64, PIN_MODE_3);
//I2C
MAP_PinTypeI2C(PIN_01, PIN_MODE_1);
MAP_PinTypeI2C(PIN_02, PIN_MODE_1);
}
