// Serial
virtual void SerialBegin(uint8_t serialDevice, int baudrate) {
if (serialDevice == 0) {
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
UARTEnable(UART0_BASE);
}
}
u32 platform_can_setup( unsigned id, u32 clock )
{
MAP_GPIOPinConfigure(GPIO_PD0_CAN0RX);
MAP_GPIOPinConfigure(GPIO_PD1_CAN0TX);
MAP_GPIOPinTypeCAN(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1);
MAP_CANDisable(CAN0_BASE);
MAP_CANBitRateSet(CAN0_BASE, LM3S_CAN_CLOCK, clock );
MAP_CANEnable(CAN0_BASE);
return clock;
}
static void uart_init(void) {
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// Configure PD0 and PD1 for UART
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
/*UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), 115200,
UART_CONFIG_WLEN_8| UART_CONFIG_STOP_ONE| UART_CONFIG_PAR_NONE);*/
UARTStdioInitExpClk(0, 115200);
}
void configureUART(){
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Set GPIO A0 and A1 as UART pins.
//
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioConfig(0,115200,MAP_SysCtlClockGet());
}
void purpinsMotors::configurePWM(){
//Configure PWM Clock
MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_2);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
pwmPeriod = MAP_SysCtlClockGet() / 2 / PWM_FREQUENCY; //PWM frequency
MAP_GPIOPinConfigure(GPIO_PF1_M1PWM5);
MAP_GPIOPinConfigure(GPIO_PF2_M1PWM6);
MAP_GPIOPinConfigure(GPIO_PF3_M1PWM7);
MAP_GPIOPinConfigure(GPIO_PC4_M0PWM6);
MAP_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
MAP_GPIOPinTypePWM(GPIO_PORTC_BASE, GPIO_PIN_4);
//gen 3 for m0pwm6
MAP_PWMGenConfigure(PWM0_BASE, PWM_GEN_3, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//gen 3 for m1pwm6 and m1pwm7
MAP_PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//gen 2 for m1pwm5
MAP_PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//Set the Period (expressed in clock ticks)
MAP_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_3, pwmPeriod);
MAP_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, pwmPeriod);
MAP_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, pwmPeriod);
//Set PWM duty-0%
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5 , 0);
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6 , 0);
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7 , 0);
MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_6 , 0);
// Enable the PWM generators
MAP_PWMGenEnable(PWM1_BASE, PWM_GEN_2);
MAP_PWMGenEnable(PWM1_BASE, PWM_GEN_3);
MAP_PWMGenEnable(PWM0_BASE, PWM_GEN_3);
// Turn on the Output pins
MAP_PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
MAP_PWMOutputState(PWM1_BASE, PWM_OUT_6_BIT, true);
MAP_PWMOutputState(PWM1_BASE, PWM_OUT_7_BIT, true);
MAP_PWMOutputState(PWM0_BASE, PWM_OUT_6_BIT, true);
}
static void spis_init()
{
unsigned i;
#if defined( ELUA_BOARD_SOLDERCORE )
MAP_GPIOPinConfigure( GPIO_PH4_SSI1CLK );
MAP_GPIOPinConfigure( GPIO_PF4_SSI1RX );
MAP_GPIOPinConfigure( GPIO_PF5_SSI1TX );
#endif
for( i = 0; i < NUM_SPI; i ++ )
MAP_SysCtlPeripheralEnable( spi_sysctl[ i ] );
}
void ConfigUART(uint32_t baud)
{
// Enable the GPIO Peripheral used by the UART.
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// Enable UART0
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
// Configure GPIO Pins for UART mode.
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
// Use the internal 16MHz oscillator as the UART clock source.
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
UARTStdioConfig(0, baud, 16000000);
}
void GPS_init()
{
dbg_printf("Initializing GPS module...");
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART);
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
MAP_UARTConfigSetExpClk(UART_BASE, MAP_SysCtlClockGet(), UART_SPEED, UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE);
MAP_UARTDisable(UART_BASE);
MAP_UARTTxIntModeSet(UART_BASE, UART_TXINT_MODE_EOT);
MAP_UARTIntEnable(UART_BASE, UART_INT_RX | UART_INT_TX);
MAP_IntEnable(INT_UART);
MAP_UARTEnable(UART_BASE);
MAP_UARTFIFODisable(UART_BASE);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
//
MAP_IntEnable(INT_GPIOG);
// Настроить прерывания на PPS
MAP_GPIOIntTypeSet(GPIO_PORTG_BASE, GPIO_PIN_7, GPIO_FALLING_EDGE);
MAP_GPIOPinIntEnable(GPIO_PORTG_BASE, GPIO_PIN_7);
//
if (tn_task_create(&task_GPS_tcb, &task_GPS_func, TASK_GPS_PRI,
&task_GPS_stk[TASK_GPS_STK_SZ - 1], TASK_GPS_STK_SZ, 0,
TN_TASK_START_ON_CREATION) != TERR_NO_ERR)
{
dbg_puts("tn_task_create(&task_GPS_tcb) error");
goto err;
}
// Настроить прерывания на PPS
//MAP_IntEnable(INT_GPIOG);
//MAP_GPIOIntTypeSet(GPIO_PORTG_BASE, GPIO_PIN_7, GPIO_FALLING_EDGE);
//MAP_GPIOPinIntEnable(GPIO_PORTG_BASE, GPIO_PIN_7);
dbg_puts("[done]");
return;
err:
dbg_trace();
tn_halt();
}
static void spi_init(void) {
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
// Configure SSI1 for SPI RAM usage
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI2);
MAP_GPIOPinConfigure(GPIO_PB4_SSI2CLK);
MAP_GPIOPinConfigure(GPIO_PB6_SSI2RX);
MAP_GPIOPinConfigure(GPIO_PB7_SSI2TX);
MAP_GPIOPinTypeSSI(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_6 | GPIO_PIN_7);
MAP_SSIConfigSetExpClk(SSI2_BASE, MAP_SysCtlClockGet(), SSI_FRF_MOTO_MODE_0,
SSI_MODE_MASTER, 1000000, 8);
MAP_SSIEnable(SSI2_BASE);
unsigned long b;
while(MAP_SSIDataGetNonBlocking(SSI2_BASE, &b)) {}
}
//*****************************************************************************
// This function sets up UART0 to be used for a console to display information
// as the example is running.
//*****************************************************************************
void
InitConsole(void)
{
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
MAP_UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioConfig(0, 115200, 16000000);
}
void purpinsMotors::configureQEI() {
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI1);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Set GPIO C5 and C6 as QEI pins.
//
MAP_GPIOPinConfigure(GPIO_PC5_PHA1);
MAP_GPIOPinConfigure(GPIO_PC6_PHB1);
MAP_GPIOPinTypeQEI(GPIO_PORTC_BASE, GPIO_PIN_5 | GPIO_PIN_6);
//
// Set GPIO D6 and D7 as QEI pins.
//
MAP_GPIOPinConfigure(GPIO_PD6_PHA0);
MAP_GPIOPinConfigure(GPIO_PD7_PHB0);
MAP_GPIOPinTypeQEI(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);
MAP_QEIConfigure(QEI0_BASE,
(QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP
| QEI_CONFIG_NO_RESET), 1200);
MAP_QEIConfigure(QEI1_BASE,
(QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP
| QEI_CONFIG_NO_RESET), 1200);
MAP_QEIEnable(QEI0_BASE);
MAP_QEIEnable(QEI1_BASE);
MAP_QEIVelocityConfigure(QEI0_BASE, QEI_VELDIV_1,
MAP_SysCtlClockGet() / QEILOOPFREQUENCY);
MAP_QEIVelocityConfigure(QEI1_BASE, QEI_VELDIV_1,
MAP_SysCtlClockGet() / QEILOOPFREQUENCY);
QEIIntRegister(QEI1_BASE, motorsRightQEIHandler);
QEIIntRegister(QEI0_BASE, motorsLeftQEIHandler);
MAP_IntEnable(INT_QEI0);
MAP_IntEnable(INT_QEI1);
MAP_QEIIntEnable(QEI0_BASE, QEI_INTTIMER);
MAP_QEIIntEnable(QEI1_BASE, QEI_INTTIMER);
MAP_QEIVelocityEnable(QEI0_BASE);
MAP_QEIVelocityEnable(QEI1_BASE);
}
/**
* Initializes the UART
*
* \param SysClkFreq - clock frequency of the system
*
* \param baudRate - baud rate of the UART e.g. 115200 to connect to PC
*
* \note UART is connected to the stellaris virtual serial port through the USB connection
*
* \note Configuration:
* 8 data bits
* one stop bit
* no parity
**/
void twe_initUART(uint32_t SysClkFreq, uint32_t baudRate) {
MAP_SysCtlPeripheralEnable(TWE_UART_COMM_PERIPH);
MAP_SysCtlPeripheralEnable(TWE_UART_COMM_GPIO_PERIPH);
MAP_GPIOPinConfigure(TWE_UART_COMM_RX_PIN_CONFIG);
MAP_GPIOPinConfigure(TWE_UART_COMM_TX_PIN_CONFIG);
MAP_GPIOPinTypeUART(TWE_UART_COMM_GPIO_BASE, TWE_UART_COMM_RX_PIN | TWE_UART_COMM_TX_PIN);
/*
MAP_UARTConfigSetExpClk(TWE_UART_COMM_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
MAP_UARTConfigSetExpClk(TWE_UART_COMM_BASE, SysClkFreq, 4608000,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
*/
MAP_UARTConfigSetExpClk(TWE_UART_COMM_BASE, SysClkFreq, baudRate,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
}
u32 platform_uart_setup( unsigned id, u32 baud, int databits, int parity, int stopbits )
{
u32 config;
if( id < NUM_UART )
{
MAP_GPIOPinConfigure( uart_gpiofunc[ id << 1 ] );
MAP_GPIOPinConfigure( uart_gpiofunc[ ( id << 1 ) + 1 ] );
MAP_GPIOPinTypeUART( uart_gpio_base[ id ], uart_gpio_pins[ id ] );
switch( databits )
{
case 5:
config = UART_CONFIG_WLEN_5;
break;
case 6:
config = UART_CONFIG_WLEN_6;
break;
case 7:
config = UART_CONFIG_WLEN_7;
break;
default:
config = UART_CONFIG_WLEN_8;
break;
}
config |= ( stopbits == PLATFORM_UART_STOPBITS_1 ) ? UART_CONFIG_STOP_ONE : UART_CONFIG_STOP_TWO;
if( parity == PLATFORM_UART_PARITY_EVEN )
config |= UART_CONFIG_PAR_EVEN;
else if( parity == PLATFORM_UART_PARITY_ODD )
config |= UART_CONFIG_PAR_ODD;
else if( parity == PLATFORM_UART_PARITY_MARK )
config |= UART_CONFIG_PAR_ONE;
else if( parity == PLATFORM_UART_PARITY_SPACE )
config |= UART_CONFIG_PAR_ZERO;
else
config |= UART_CONFIG_PAR_NONE;
MAP_UARTConfigSetExpClk( uart_base[ id ], MAP_SysCtlClockGet(), baud, config );
MAP_UARTConfigGetExpClk( uart_base[ id ], MAP_SysCtlClockGet(), &baud, &config );
MAP_UARTEnable( uart_base[ id ] );
}
return baud;
}
void rgb_init(void)
{
/* Set PWM clock to system clock */
MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
/* Make sure thet all required peripherals are enabled */
if (!MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF))
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
if (!MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_PWM1))
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
/* Configure pins to PWM output function */
MAP_GPIOPinConfigure(GPIO_PF1_M1PWM5);
MAP_GPIOPinConfigure(GPIO_PF2_M1PWM6);
MAP_GPIOPinConfigure(GPIO_PF3_M1PWM7);
MAP_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
MAP_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_2);
MAP_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_3);
/* Configure PWM module */
MAP_PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN |
PWM_GEN_MODE_GEN_SYNC_LOCAL);
MAP_PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN |
PWM_GEN_MODE_GEN_SYNC_LOCAL);
MAP_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, RGB_PWM_PERIOD);
MAP_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, RGB_PWM_PERIOD);
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, 0);
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, 0);
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, 0);
//PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT|PWM_OUT_6_BIT|PWM_OUT_7_BIT, true);
MAP_PWMGenEnable(PWM1_BASE, PWM_GEN_2);
MAP_PWMGenEnable(PWM1_BASE, PWM_GEN_3);
MAP_PWMSyncTimeBase(PWM1_BASE, PWM_GEN_2_BIT|PWM_GEN_3_BIT);
g_rgb_data.c = 0;
g_rgb_data.i = 0;
}
static inline void ti_arm_mcu_pin_mode_i2c(int pin, int scl, int i2c_af)
{
ti_arm_mcu_periph_enable(ti_arm_mcu_gpio_periph(pin));
if (i2c_af)
MAP_GPIOPinConfigure(i2c_af);
MAP_GPIOPinTypeI2C(ti_arm_mcu_gpio_base(pin), GPIO_BIT(pin));
if (scl)
ti_arm_mcu_pin_config(pin, GPIO_PIN_TYPE_STD_WPU);
else
ti_arm_mcu_pin_config(pin, GPIO_PIN_TYPE_OD);
}
/**
* Initializes the QSSI_COMM port to transmit or receive a data transmission
*
* \param RXmode - true - initialize QSSI_COMM to read as a slave
* false - initialize QSSI_COMM to write as a master
**/
void twe_initQSSI(uint32_t SysClkFreq, bool RXmode) {
// Enable Peripherals
MAP_SysCtlPeripheralEnable(twe_QSSI_COMM_PERIPH);
MAP_SysCtlPeripheralEnable(twe_QSSI_COMM_CLK_FSS_GPIO_PERIPH);
MAP_SysCtlPeripheralEnable(twe_QSSI_COMM_XDAT01_GPIO_PERIPH);
MAP_SysCtlPeripheralEnable(twe_QSSI_COMM_XDAT23_GPIO_PERIPH);
// Set the pin muxing
MAP_GPIOPinConfigure(twe_QSSI_COMM_CLK_PIN_CONFIG);
MAP_GPIOPinConfigure(twe_QSSI_COMM_FSS_PIN_CONFIG);
MAP_GPIOPinConfigure(twe_QSSI_COMM_DAT0_PIN_CONFIG);
MAP_GPIOPinConfigure(twe_QSSI_COMM_DAT1_PIN_CONFIG);
MAP_GPIOPinConfigure(twe_QSSI_COMM_DAT2_PIN_CONFIG);
MAP_GPIOPinConfigure(twe_QSSI_COMM_DAT3_PIN_CONFIG);
MAP_GPIOPinTypeSSI(twe_QSSI_COMM_CLK_FSS_GPIO_BASE, twe_QSSI_COMM_CLK_PIN | twe_QSSI_COMM_FSS_PIN);
MAP_GPIOPinTypeSSI(twe_QSSI_COMM_XDAT01_GPIO_BASE, twe_QSSI_COMM_DAT0_PIN | twe_QSSI_COMM_DAT1_PIN);
MAP_GPIOPinTypeSSI(twe_QSSI_COMM_XDAT23_GPIO_BASE, twe_QSSI_COMM_DAT2_PIN | twe_QSSI_COMM_DAT3_PIN);
// Must be in SPI Mode0 for QSSI (Advanced) mode
if(RXmode) {
MAP_SSIConfigSetExpClk(twe_QSSI_COMM_BASE, SysClkFreq, SSI_FRF_MOTO_MODE_0,
SSI_MODE_SLAVE, twe_QSSI_COMM_BAUD, 8);
SSIAdvModeSet(twe_QSSI_COMM_BASE, SSI_ADV_MODE_QUAD_READ);
SSIDataPut(twe_QSSI_COMM_BASE,0x00);
}
else {
SSIConfigSetExpClk(twe_QSSI_COMM_BASE, SysClkFreq, SSI_FRF_MOTO_MODE_0,
SSI_MODE_MASTER, twe_QSSI_COMM_BAUD, 8);
SSIAdvModeSet(twe_QSSI_COMM_BASE, SSI_ADV_MODE_QUAD_WRITE);
}
// Enable SSI
MAP_SSIEnable(twe_QSSI_COMM_BASE);
//SSIDMAEnable(ADC_SSI_BASE, SSI_DMA_RX); // Enable SSI uDMA
}
/*
* ======== EK_TM4C123GXL_initI2C ========
*/
void EK_TM4C123GXL_initI2C(void)
{
//Enable the peripheral funcitonality for the GPIO port
//
MAP_SysCtlPeripheralEnable(INEEDMD_LED_SYSCTL_PRIPH_GPIO);
// Enable the I2C peripheral
//
MAP_SysCtlPeripheralEnable(INEEDMD_LED_SYSCTL_PRIPH_I2C);
// Configure the alternate function for the I2C SCL pin and tie it to the I2C
MAP_GPIOPinTypeI2CSCL(INEEDMD_LED_GPIO_PORT, INEEDMD_LED_I2CSCL_PIN);
MAP_GPIOPinConfigure(INEEDMD_LED_GPIO_I2CSCL);
//Configure the alternate function for the I2C SDA pin and tie it to the I2C
MAP_GPIOPinTypeI2C(INEEDMD_LED_GPIO_PORT, INEEDMD_LED_I2CSDA_PIN);
MAP_GPIOPinConfigure(INEEDMD_LED_GPIO_I2CSDA);
I2C_init();
return;
}
//*****************************************************************************
//
//! Configures the device pins for the customer specific usage.
//!
//! \return None.
//
//*****************************************************************************
void
PinoutSet(void)
{
//
// Enable Peripheral Clocks
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Configure the GPIO Pin Mux for PA0
// for U0RX
//
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0);
//
// Configure the GPIO Pin Mux for PA1
// for U0TX
//
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_1);
}
/*
* ======== EK_TM4C123GXL_initUART ========
*/
void EK_TM4C123GXL_initUART(void)
{
// Enable and configure the peripherals used by the radio uart
//
MAP_SysCtlPeripheralEnable(INEEDMD_RADIO_SYSCTL_PERIPH_UART);
// Configure the alternate function for UART RTS pin
MAP_GPIOPinConfigure(INEEDMD_GPIO_UARTRTS);
MAP_GPIOPinTypeUART(INEEDMD_RADIO_RTS_PORT, INEEDMD_RADIO_RTS_PIN);
// Configure the alternate function for UART CTS pin
MAP_GPIOPinConfigure(INEEDMD_GPIO_UARTCTS);
MAP_GPIOPinTypeUART(INEEDMD_RADIO_CTS_PORT, INEEDMD_RADIO_CTS_PIN);
// Configure the alternate function for UART TX and RX pins
MAP_GPIOPinConfigure(INEEDMD_GPIO_UARTTX);
MAP_GPIOPinConfigure(INEEDMD_GPIO_UARTRX);
// Set the TX and RX pin type for the radio uart
MAP_GPIOPinTypeUART(INEEDMD_GPIO_TX_PORT, INEEDMD_GPIO_TX_PIN);
MAP_GPIOPinTypeUART(INEEDMD_GPIO_RX_PORT, INEEDMD_GPIO_RX_PIN);
//Set the UART clock source to internal
//
// MAP_UARTClockSourceSet(INEEDMD_RADIO_UART, UART_CLOCK_PIOSC);
//Config the uart speed, len, stop bits and parity
//
// MAP_UARTConfigSetExpClk( INEEDMD_RADIO_UART, INEEDMD_RADIO_UART_CLK, INEEDMD_RADIO_UART_BAUD, ( UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE ));
//Enable and configure the peripherals used by the debug uart
//
MAP_SysCtlPeripheralEnable(DEBUG_SYSCTL_PERIPH_UART);
// Configure the debug port pins
MAP_GPIOPinConfigure(DEBUG_TX_PIN_MUX_MODE);
MAP_GPIOPinConfigure(DEBUG_RX_PIN_MUX_MODE);
// Set the debug uart pin types
MAP_GPIOPinTypeUART(DEBUG_UART_PIN_PORT, DEBUG_TX_PIN);
MAP_GPIOPinTypeUART(DEBUG_UART_PIN_PORT, DEBUG_RX_PIN);
//Set the clock source for the debug uart
// UARTClockSourceSet(DEBUG_UART, UART_CLOCK_PIOSC);
/* Initialize the UART driver */
UART_init();
}
//PWM = PF1/M1PWM5 & PC4/M0PWM6
void configurePWM(void)
{
//Configure PWM Clock to match system
MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_2);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
//PD6 & PD7 for direction
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE,GPIO_INT_PIN_6 |GPIO_INT_PIN_7);
MAP_GPIOPinWrite(GPIO_PORTD_BASE,GPIO_INT_PIN_6 |GPIO_INT_PIN_7,0);
ulPeriod = MAP_SysCtlClockGet() / 2 / PWM_FREQUENCY; //PWM frequency
MAP_GPIOPinConfigure(GPIO_PF1_M1PWM5);
MAP_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
MAP_PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//Set the Period (expressed in clock ticks)
MAP_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ulPeriod);
//Set PWM duty-0%
MAP_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5 , 0);
// Enable the PWM generator
MAP_PWMGenEnable(PWM1_BASE, PWM_GEN_2);
// Turn on the Output pins
MAP_PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
}
void spi_init(void) {
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_5);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_GPIOPinConfigure(GPIO_PF2_SSI1CLK);
MAP_GPIOPinConfigure(GPIO_PF1_SSI1TX);
MAP_GPIOPinTypeSSI(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_GPIOPinConfigure(GPIO_PB4_SSI2CLK);
MAP_GPIOPinConfigure(GPIO_PB7_SSI2TX);
MAP_GPIOPinTypeSSI(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_7);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_GPIOPinConfigure(GPIO_PD0_SSI3CLK);
MAP_GPIOPinConfigure(GPIO_PD3_SSI3TX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_3);
/* Configure SSI0..3 for the ws2801's SPI-like protocol */
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI1);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI2);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI3);
MAP_SSIConfigSetExpClk(SSI0_BASE, MAP_SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, SPI_SPEED, 16);
MAP_SSIConfigSetExpClk(SSI1_BASE, MAP_SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, SPI_SPEED, 16);
MAP_SSIConfigSetExpClk(SSI2_BASE, MAP_SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, SPI_SPEED, 16);
MAP_SSIConfigSetExpClk(SSI3_BASE, MAP_SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, SPI_SPEED, 16);
/* Configure the µDMA controller for use by the SPI interface */
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
MAP_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UDMA);
// FIXME what do we need this for? IntEnable(INT_UDMAERR); // Enable µDMA error interrupt
MAP_uDMAEnable();
MAP_uDMAControlBaseSet(ucControlTable);
MAP_uDMAChannelAssign(UDMA_CH11_SSI0TX);
MAP_uDMAChannelAssign(UDMA_CH25_SSI1TX);
MAP_uDMAChannelAssign(UDMA_CH13_SSI2TX);
MAP_uDMAChannelAssign(UDMA_CH15_SSI3TX);
ssi_udma_channel_config(11);
ssi_udma_channel_config(25);
ssi_udma_channel_config(13);
ssi_udma_channel_config(15);
MAP_SSIDMAEnable(SSI0_BASE, SSI_DMA_TX);
MAP_SSIDMAEnable(SSI1_BASE, SSI_DMA_TX);
MAP_SSIDMAEnable(SSI2_BASE, SSI_DMA_TX);
MAP_SSIDMAEnable(SSI3_BASE, SSI_DMA_TX);
/* Enable the SSIs after configuring anything around them. */
MAP_SSIEnable(SSI0_BASE);
MAP_SSIEnable(SSI1_BASE);
MAP_SSIEnable(SSI2_BASE);
MAP_SSIEnable(SSI3_BASE);
}
//*****************************************************************************
void
PortFunctionInit(void)
{
//
// Enable Peripheral Clocks
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable pin PA7 for GPIOInput
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_7);
//
// Enable pin PA6 for GPIOInput - SPI Current Word is Header Word
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_6);
//
// Enable pin PF2 for GPIOInput
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_2);
//
// Enable pin PF3 for GPIOInput
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_3);
//
// Enable pin PF1 for GPIOOutputOD
//
MAP_GPIOPinTypeGPIOOutputOD(GPIO_PORTF_BASE, GPIO_PIN_1);
//
// Enable pin PA5 for SSI0 SSI0TX
//
MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5);
//
// Enable pin PA4 for SSI0 SSI0RX
//
MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_4);
//
// Enable pin PA2 for SSI0 SSI0CLK
//
MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2);
//
// Enable pin PA3 for SSI0 SSI0FSS
//
MAP_GPIOPinConfigure(GPIO_PA3_SSI0FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_3);
//
// Enable pin PA0 for UART0 U0RX
//
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0);
//
// Enable pin PA1 for UART0 U0TX
//
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_1);
//
// Enable pin PD4 for USB0 USB0DM
//
MAP_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_4);
//
// Enable pin PD5 for USB0 USB0DP
//
MAP_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_5);
}
void enc28_InitSPI(uint32_t ui32_bitrate, uint32_t ui32_SSI_Base)
{
uint32_t ui32_RxData;
uint32_t ui32_SysCtl_Periph_SSI;
uint32_t ui32_SysCtl_Periph_GPIO;
ui32_SSIx = ui32_SSI_Base;
switch(ui32_SSIx) {
case SSI1_BASE:
ui32_SysCtl_Periph_SSI = SYSCTL_PERIPH_SSI1;
ui32_SysCtl_Periph_GPIO = SYSCTL_PERIPH_GPIOF;
break;
case SSI2_BASE:
ui32_SysCtl_Periph_SSI = SYSCTL_PERIPH_SSI2;
ui32_SysCtl_Periph_GPIO = SYSCTL_PERIPH_GPIOB;
break;
case SSI3_BASE:
ui32_SysCtl_Periph_SSI = SYSCTL_PERIPH_SSI3;
ui32_SysCtl_Periph_GPIO = SYSCTL_PERIPH_GPIOD;
break;
case SSI0_BASE:
default:
ui32_SysCtl_Periph_SSI = SYSCTL_PERIPH_SSI0;
ui32_SysCtl_Periph_GPIO = SYSCTL_PERIPH_GPIOA;
break;
};
#ifdef UART_STDIO
UARTprintf("Configuring MASTER SSI%d, data 16-bit, (0,0) mode, %d bit rate.\n", 0, ui32_bitrate);
#endif // UART_STDIO
// Enable Periphericals in SysCtl
MAP_SysCtlPeripheralEnable(ui32_SysCtl_Periph_SSI);
MAP_SysCtlPeripheralEnable(ui32_SysCtl_Periph_GPIO);
// Enable alternate GPIO functions
// Configures pin(s) for use by the SSI peripheral
switch(ui32_SSIx) {
case SSI1_BASE:
MAP_GPIOPinConfigure(GPIO_PF2_SSI1CLK);
MAP_GPIOPinConfigure(GPIO_PF3_SSI1FSS);
MAP_GPIOPinConfigure(GPIO_PF0_SSI1RX);
MAP_GPIOPinConfigure(GPIO_PF1_SSI1TX);
MAP_GPIOPinTypeSSI(GPIO_PORTF_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1 |
GPIO_PIN_0);
break;
case SSI2_BASE:
MAP_GPIOPinConfigure(GPIO_PB4_SSI2CLK);
MAP_GPIOPinConfigure(GPIO_PB5_SSI2FSS);
MAP_GPIOPinConfigure(GPIO_PB6_SSI2RX);
MAP_GPIOPinConfigure(GPIO_PB7_SSI2TX);
MAP_GPIOPinTypeSSI(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 |
GPIO_PIN_7);
break;
case SSI3_BASE:
MAP_GPIOPinConfigure(GPIO_PD0_SSI3CLK);
MAP_GPIOPinConfigure(GPIO_PD1_SSI3FSS);
MAP_GPIOPinConfigure(GPIO_PD2_SSI3RX);
MAP_GPIOPinConfigure(GPIO_PD3_SSI3TX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 |
GPIO_PIN_3);
break;
case SSI0_BASE:
default:
MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
MAP_GPIOPinConfigure(GPIO_PA3_SSI0FSS);
MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX);
MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 |
GPIO_PIN_2);
break;
};
// Configures the SSI operation mode
MAP_SSIConfigSetExpClk(ui32_SSIx, MAP_SysCtlClockGet(), SSI_FRF_MOTO_MODE_0,
SSI_MODE_MASTER, ui32_bitrate, 16);
// Enables SSI
MAP_SSIEnable(ui32_SSIx);
while(MAP_SSIDataGetNonBlocking(ui32_SSIx, &ui32_RxData));
}
/**
* Creates task to feed data from interrupt to lwIP,
* initializes EMAC0, then initializes lwIP
*/
void init_ethernet(void){/*{{{*/
{ // Enable Ethernet hardware/*{{{*/
uint32_t user0, user1;
/**
* Enable ethernet
* See page 160 of spmu298a
*/
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_EMAC0);
MAP_SysCtlPeripheralReset(SYSCTL_PERIPH_EMAC0);
//Enable internal PHY
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_EPHY0);
MAP_SysCtlPeripheralReset(SYSCTL_PERIPH_EPHY0);
// Set Ethernet LED pinouts
// See Page 269 of spmu298a.pdf
MAP_GPIOPinConfigure(GPIO_PF0_EN0LED0);
MAP_GPIOPinConfigure(GPIO_PF4_EN0LED1);
GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_0|GPIO_PIN_4);
// Busy wait until MAC ready
while(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_EMAC0) == 0);
//Using builtin PHY, so don't need to call GPIOPinTypeEthernetMII()
MAP_EMACPHYConfigSet(EMAC0_BASE, EMAC_PHY_TYPE_INTERNAL|EMAC_PHY_INT_MDIX_EN|EMAC_PHY_AN_100B_T_FULL_DUPLEX);
// Initialize MAC (see spmu363a.pdf)
// Maybe should optimize burst size
MAP_EMACInit(EMAC0_BASE, g_syshz, EMAC_BCONFIG_MIXED_BURST|EMAC_BCONFIG_PRIORITY_FIXED, 4, 4, 0);
// Set options
// Tune parameters
MAP_EMACConfigSet(EMAC0_BASE, (EMAC_CONFIG_FULL_DUPLEX |
EMAC_CONFIG_CHECKSUM_OFFLOAD |
EMAC_CONFIG_7BYTE_PREAMBLE |
EMAC_CONFIG_IF_GAP_96BITS |
EMAC_CONFIG_USE_MACADDR0 |
EMAC_CONFIG_SA_FROM_DESCRIPTOR |
EMAC_CONFIG_100MBPS|
EMAC_CONFIG_BO_LIMIT_1024),
(EMAC_MODE_RX_STORE_FORWARD |
EMAC_MODE_TX_STORE_FORWARD |
EMAC_MODE_TX_THRESHOLD_64_BYTES |
EMAC_MODE_RX_THRESHOLD_64_BYTES), 0);
//Mac Address saved in user0 and user1 by default
MAP_FlashUserGet(&user0, &user1);
mac_addr[0] = user0 & 0xFF;
mac_addr[1] = user0 >> 8 & 0xFF;
mac_addr[2] = user0 >> 16 & 0xFF;
mac_addr[3] = user1 & 0xFF;
mac_addr[4] = user1 >> 8 & 0xFF;
mac_addr[5] = user1 >> 16 & 0xFF;
MAP_EMACAddrSet(EMAC0_BASE, 0, mac_addr );
//Explicitly Disable PTP
EMACTimestampDisable(EMAC0_BASE);
}/*}}}*/
// Lower priority of ISR so *FromISR functions can be safely called
MAP_IntPrioritySet(INT_EMAC0, ETH_ISR_PRIO);
tcpip_init(tcpip_init_cb, NULL);
}/*}}}*/
//*****************************************************************************
void
PortFunctionInit(void)
{
//
// Enable Peripheral Clocks
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI3);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI1);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable pin PA2 for GPIOInput
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_2);
//
// Enable pin PF3 for SSI1 SSI1FSS
//
MAP_GPIOPinConfigure(GPIO_PF3_SSI1FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTF_BASE, GPIO_PIN_3);
//
// Enable pin PF0 for SSI1 SSI1RX
// First open the lock and select the bits we want to modify in the GPIO commit register.
//
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x1;
//
// Now modify the configuration of the pins that we unlocked.
//
MAP_GPIOPinConfigure(GPIO_PF0_SSI1RX);
MAP_GPIOPinTypeSSI(GPIO_PORTF_BASE, GPIO_PIN_0);
//
// Enable pin PF1 for SSI1 SSI1TX
//
MAP_GPIOPinConfigure(GPIO_PF1_SSI1TX);
MAP_GPIOPinTypeSSI(GPIO_PORTF_BASE, GPIO_PIN_1);
//
// Enable pin PF2 for SSI1 SSI1CLK
//
MAP_GPIOPinConfigure(GPIO_PF2_SSI1CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTF_BASE, GPIO_PIN_2);
//
// Enable pin PD3 for SSI3 SSI3TX
//
MAP_GPIOPinConfigure(GPIO_PD3_SSI3TX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_3);
//
// Enable pin PD2 for SSI3 SSI3RX
//
MAP_GPIOPinConfigure(GPIO_PD2_SSI3RX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_2);
//
// Enable pin PD0 for SSI3 SSI3CLK
//
MAP_GPIOPinConfigure(GPIO_PD0_SSI3CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_0);
//
// Enable pin PD1 for SSI3 SSI3FSS
//
MAP_GPIOPinConfigure(GPIO_PD1_SSI3FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_1);
}
//*****************************************************************************
//
// Initialize and operate the data logger.
//
//*****************************************************************************
int
main(void)
{
tContext sDisplayContext, sBufferContext;
uint32_t ui32HibIntStatus, ui32SysClock, ui32LastTickCount;
bool bSkipSplash;
uint8_t ui8ButtonState, ui8ButtonChanged;
uint_fast8_t ui8X, ui8Y;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
MAP_FPULazyStackingEnable();
//
// Set the clocking to run at 50 MHz.
//
MAP_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ |
SYSCTL_OSC_MAIN);
ui32SysClock = MAP_SysCtlClockGet();
//
// Initialize locals.
//
bSkipSplash = false;
ui32LastTickCount = 0;
//
// Initialize the data acquisition module. This initializes the ADC
// hardware.
//
AcquireInit();
//
// Enable access to the hibernate peripheral. If the hibernate peripheral
// was already running then this will have no effect.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE);
//
// Check to see if the hiberate module is already active and if so then
// read the saved configuration state. If both are okay, then proceed
// to check and see if we are logging data using sleep mode.
//
if(HibernateIsActive() && !GetSavedState(&g_sConfigState))
{
//
// Read the status of the hibernate module.
//
ui32HibIntStatus = HibernateIntStatus(1);
//
// If this is a pin wake, that means the user pressed the select
// button and we should terminate the sleep logging. In this case
// we will fall out of this conditional section, and go through the
// normal startup below, but skipping the splash screen so the user
// gets immediate response.
//
if(ui32HibIntStatus & HIBERNATE_INT_PIN_WAKE)
{
//
// Clear the interrupt flag so it is not seen again until another
// wake.
//
HibernateIntClear(HIBERNATE_INT_PIN_WAKE);
bSkipSplash = true;
}
//
// Otherwise if we are waking from hibernate and it was not a pin
// wake, then it must be from RTC match. Check to see if we are
// sleep logging and if so then go through an abbreviated startup
// in order to collect the data and go back to sleep.
//
else if(g_sConfigState.ui32SleepLogging &&
(ui32HibIntStatus & HIBERNATE_INT_RTC_MATCH_0))
{
//
// Start logger and pass the configuration. The logger should
// configure itself to take one sample.
//
AcquireStart(&g_sConfigState);
g_iLoggerState = eSTATE_LOGGING;
//
// Enter a forever loop to run the acquisition. This will run
// until a new sample has been taken and stored.
//
while(!AcquireRun())
{
}
//
// Getting here means that a data acquisition was performed and we
// can now go back to sleep. Save the configuration and then
// activate the hibernate.
//
SetSavedState(&g_sConfigState);
//
// Set wake condition on pin-wake or RTC match. Then put the
// processor in hibernation.
//
HibernateWakeSet(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC);
HibernateRequest();
//
// Hibernating takes a finite amount of time to occur, so wait
// here forever until hibernate activates and the processor
// power is removed.
//
for(;;)
{
}
}
//
// Otherwise, this was not a pin wake, and we were not sleep logging,
// so just fall out of this conditional and go through the normal
// startup below.
//
}
else
{
//
// In this case, either the hibernate module was not already active, or
// the saved configuration was not valid. Initialize the configuration
// to the default state and then go through the normal startup below.
//
GetDefaultState(&g_sConfigState);
}
//
// Enable the Hibernate module to run.
//
HibernateEnableExpClk(SysCtlClockGet());
//
// The hibernate peripheral trim register must be set per silicon
// erratum 2.1
//
HibernateRTCTrimSet(0x7FFF);
//
// Start the RTC running. If it was already running then this will have
// no effect.
//
HibernateRTCEnable();
//
// In case we were sleep logging and are now finished (due to user
// pressing select button), then disable sleep logging so it doesnt
// try to start up again.
//
g_sConfigState.ui32SleepLogging = 0;
SetSavedState(&g_sConfigState);
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the buttons driver.
//
ButtonsInit();
//
// Pass the restored state to the menu system.
//
MenuSetState(&g_sConfigState);
//
// Enable the USB peripheral
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Configure the required pins for USB operation.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
MAP_GPIOPinConfigure(GPIO_PG4_USB0EPEN);
MAP_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
MAP_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
MAP_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Erratum workaround for silicon revision A1. VBUS must have pull-down.
//
if(CLASS_IS_BLIZZARD && REVISION_IS_A1)
{
HWREG(GPIO_PORTB_BASE + GPIO_O_PDR) |= GPIO_PIN_1;
}
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, eUSBModeOTG, ModeCallback);
//
// Initialize the stack to be used with USB stick.
//
USBStickInit();
//
// Initialize the stack to be used as a serial device.
//
USBSerialInit();
//
// Initialize the USB controller for dual mode operation with a 2ms polling
// rate.
//
USBOTGModeInit(0, 2000, g_pui8HCDPool, HCD_MEMORY_SIZE);
//
// Initialize the menus module. This module will control the user
// interface menuing system.
//
MenuInit(WidgetActivated);
//
// Configure SysTick to periodically interrupt.
//
g_ui32TickCount = 0;
MAP_SysTickPeriodSet(ui32SysClock / CLOCK_RATE);
MAP_SysTickIntEnable();
MAP_SysTickEnable();
//
// Initialize the display context and another context that is used
// as an offscreen drawing buffer for display animation effect
//
GrContextInit(&sDisplayContext, &g_sCFAL96x64x16);
GrContextInit(&sBufferContext, &g_sOffscreenDisplayA);
//
// Show the splash screen if we are not skipping it. The only reason to
// skip it is if the application was in sleep-logging mode and the user
// just waked it up with the select button.
//
if(!bSkipSplash)
{
const uint8_t *pui8SplashLogo = g_pui8Image_TI_Black;
//
// Draw the TI logo on the display. Use an animation effect where the
// logo will "slide" onto the screen. Allow select button to break
// out of animation.
//
for(ui8X = 0; ui8X < 96; ui8X++)
{
if(ButtonsPoll(0, 0) & SELECT_BUTTON)
{
break;
}
GrImageDraw(&sDisplayContext, pui8SplashLogo, 95 - ui8X, 0);
}
//
// Leave the logo on the screen for a long duration. Monitor the
// buttons so that if the user presses the select button, the logo
// display is terminated and the application starts immediately.
//
while(g_ui32TickCount < 400)
{
if(ButtonsPoll(0, 0) & SELECT_BUTTON)
{
break;
}
}
//
// Extended splash sequence
//
if(ButtonsPoll(0, 0) & UP_BUTTON)
{
for(ui8X = 0; ui8X < 96; ui8X += 4)
{
GrImageDraw(&sDisplayContext,
g_ppui8Image_Splash[(ui8X / 4) & 3],
(int32_t)ui8X - 96L, 0);
GrImageDraw(&sDisplayContext, pui8SplashLogo, ui8X, 0);
MAP_SysCtlDelay(ui32SysClock / 12);
}
MAP_SysCtlDelay(ui32SysClock / 3);
pui8SplashLogo = g_ppui8Image_Splash[4];
GrImageDraw(&sDisplayContext, pui8SplashLogo, 0, 0);
MAP_SysCtlDelay(ui32SysClock / 12);
}
//
// Draw the initial menu into the offscreen buffer.
//
SlideMenuDraw(&g_sMenuWidget, &sBufferContext, 0);
//
// Now, draw both the TI logo splash screen (from above) and the initial
// menu on the screen at the same time, moving the coordinates so that
// the logo "slides" off the display and the menu "slides" onto the
// display.
//
for(ui8Y = 0; ui8Y < 64; ui8Y++)
{
GrImageDraw(&sDisplayContext, pui8SplashLogo, 0, -ui8Y);
GrImageDraw(&sDisplayContext, g_pui8OffscreenBufA, 0, 63 - ui8Y);
}
}
//
// Add the menu widget to the widget tree and send an initial paint
// request.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sMenuWidget);
WidgetPaint(WIDGET_ROOT);
//
// Set the focus handle to the menu widget. Any button events will be
// sent to this widget
//
g_ui32KeyFocusWidgetHandle = (uint32_t)&g_sMenuWidget;
//
// Forever loop to run the application
//
while(1)
{
//
// Each time the timer tick occurs, process any button events.
//
if(g_ui32TickCount != ui32LastTickCount)
{
//
// Remember last tick count
//
ui32LastTickCount = g_ui32TickCount;
//
// Read the debounced state of the buttons.
//
ui8ButtonState = ButtonsPoll(&ui8ButtonChanged, 0);
//
// Pass any button presses through to the widget message
// processing mechanism. The widget that has the button event
// focus (probably the menu widget) will catch these button events.
//
if(BUTTON_PRESSED(SELECT_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_SELECT);
}
if(BUTTON_PRESSED(UP_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_UP);
}
if(BUTTON_PRESSED(DOWN_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_DOWN);
}
if(BUTTON_PRESSED(LEFT_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT);
}
if(BUTTON_PRESSED(RIGHT_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_RIGHT);
}
}
//
// Tell the OTG library code how much time has passed in milliseconds
// since the last call.
//
USBOTGMain(GetTickms());
//
// Call functions as needed to keep the host or device mode running.
//
if(g_iCurrentUSBMode == eUSBModeDevice)
{
USBSerialRun();
}
else if(g_iCurrentUSBMode == eUSBModeHost)
{
USBStickRun();
}
//
// If in the logging state, then call the logger run function. This
// keeps the data acquisition running.
//
if((g_iLoggerState == eSTATE_LOGGING) ||
(g_iLoggerState == eSTATE_VIEWING))
{
if(AcquireRun() && g_sConfigState.ui32SleepLogging)
{
//
// If sleep logging is enabled, then at this point we have
// stored the first data item, now save the state and start
// hibernation. Wait for the power to be cut.
//
SetSavedState(&g_sConfigState);
HibernateWakeSet(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC);
HibernateRequest();
for(;;)
{
}
}
//
// If viewing instead of logging then request a repaint to keep
// the viewing window updated.
//
if(g_iLoggerState == eSTATE_VIEWING)
{
WidgetPaint(WIDGET_ROOT);
}
}
//
// If in the saving state, then save data from flash storage to
// USB stick.
//
if(g_iLoggerState == eSTATE_SAVING)
{
//
// Save data from flash to USB
//
FlashStoreSave();
//
// Return to idle state
//
g_iLoggerState = eSTATE_IDLE;
}
//
// If in the erasing state, then erase the data stored in flash.
//
if(g_iLoggerState == eSTATE_ERASING)
{
//
// Save data from flash to USB
//
FlashStoreErase();
//
// Return to idle state
//
g_iLoggerState = eSTATE_IDLE;
}
//
// If in the flash reporting state, then show the report of the amount
// of used and free flash memory.
//
if(g_iLoggerState == eSTATE_FREEFLASH)
{
//
// Report free flash space
//
FlashStoreReport();
//
// Return to idle state
//
g_iLoggerState = eSTATE_IDLE;
}
//
// If we are exiting the clock setting widget, that means that control
// needs to be given back to the menu system.
//
if(g_iLoggerState == eSTATE_CLOCKEXIT)
{
//
// Give the button event focus back to the menu system
//
g_ui32KeyFocusWidgetHandle = (uint32_t)&g_sMenuWidget;
//
// Send a button event to the menu widget that means the left
// key was pressed. This signals the menu widget to deactivate
// the current child widget (which was the clock setting wigdet).
// This will cause the menu widget to slide the clock set widget
// off the screen and resume control of the display.
//
SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT);
g_iLoggerState = eSTATE_IDLE;
}
//
// Process any new messages that are in the widget queue. This keeps
// the user interface running.
//
WidgetMessageQueueProcess();
}
}
//*****************************************************************************
//
//! Configures the device pins for the customer specific usage.
//!
//! \return None.
//
//*****************************************************************************
void
PinoutSet(void)
{
//
// Enable Peripheral Clocks
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Configure the GPIO Pin Mux for PB6
// for GPIO_PB6
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_6);
//
// Configure the GPIO Pin Mux for PB7
// for GPIO_PB7
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_7);
//
// Configure the GPIO Pin Mux for PB0
// for GPIO_PB0
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0);
//
// Configure the GPIO Pin Mux for PB1
// for GPIO_PB1
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_1);
//
// Configure the GPIO Pin Mux for PB2
// for GPIO_PB2
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_2);
//
// Configure the GPIO Pin Mux for PB3
// for GPIO_PB3
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_3);
//
// Configure the GPIO Pin Mux for PB4
// for GPIO_PB4
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_4);
//
// Configure the GPIO Pin Mux for PB5
// for GPIO_PB5
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_5);
//
// Configure the GPIO Pin Mux for PF4
// for GPIO_PF4
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4);
//
// Unlock the Port Pin and Set the Commit Bit
//
HWREG(GPIO_PORTF_BASE+GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE+GPIO_O_CR) |= GPIO_PIN_0;
HWREG(GPIO_PORTF_BASE+GPIO_O_LOCK) = 0x0;
//
// Configure the GPIO Pin Mux for PF0
// for GPIO_PF0
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
//
// Configure the GPIO Pin Mux for PD2
// for SSI3RX
//
MAP_GPIOPinConfigure(GPIO_PD2_SSI3RX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_2);
//
// Configure the GPIO Pin Mux for PD1
// for SSI3FSS
//
MAP_GPIOPinConfigure(GPIO_PD1_SSI3FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_1);
//
// Configure the GPIO Pin Mux for PD3
// for SSI3TX
//
MAP_GPIOPinConfigure(GPIO_PD3_SSI3TX);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_3);
//
// Configure the GPIO Pin Mux for PD0
// for SSI3CLK
//
MAP_GPIOPinConfigure(GPIO_PD0_SSI3CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_0);
//
// Configure the GPIO Pin Mux for PA4
// for SSI0RX
//
MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_4);
//
// Configure the GPIO Pin Mux for PA3
// for SSI0FSS
//
MAP_GPIOPinConfigure(GPIO_PA3_SSI0FSS);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_3);
//
// Configure the GPIO Pin Mux for PA5
// for SSI0TX
//
MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5);
//
// Configure the GPIO Pin Mux for PA2
// for SSI0CLK
//
MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK);
MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2);
}
//*****************************************************************************
//
// Initialize the I2C, MPU9150 and Gesture systems.
//
//*****************************************************************************
void
MotionInit(void)
{
//
// Enable port S used for motion interrupt.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOS);
//
// The I2C3 peripheral must be enabled before use.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
//
// Configure the pin muxing for I2C3 functions on port G4 and G5.
//
MAP_GPIOPinConfigure(GPIO_PG4_I2C3SCL);
MAP_GPIOPinConfigure(GPIO_PG5_I2C3SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
MAP_GPIOPinTypeI2CSCL(GPIO_PORTG_BASE, GPIO_PIN_4);
MAP_GPIOPinTypeI2C(GPIO_PORTG_BASE, GPIO_PIN_5);
//
// Configure and Enable the GPIO interrupt. Used for INT signal from the
// MPU9150
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_2);
MAP_GPIOIntEnable(GPIO_PORTS_BASE, GPIO_PIN_2);
MAP_GPIOIntTypeSet(GPIO_PORTS_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE);
MAP_IntEnable(INT_GPIOS);
//
// Enable interrupts to the processor.
//
MAP_IntMasterEnable();
//
// Initialize I2C3 peripheral.
//
I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff,
g_ui32SysClock);
//
// Set the motion state to initializing.
//
g_ui8MotionState = MOTION_STATE_INIT;
//
// Initialize the MPU9150 Driver.
//
MPU9150Init(&g_sMPU9150Inst, &g_sI2CInst, MPU9150_I2C_ADDRESS,
MotionCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MotionI2CWait(__FILE__, __LINE__);
//
// Write application specifice sensor configuration such as filter settings
// and sensor range settings.
//
g_sMPU9150Inst.pui8Data[0] = MPU9150_CONFIG_DLPF_CFG_94_98;
g_sMPU9150Inst.pui8Data[1] = MPU9150_GYRO_CONFIG_FS_SEL_250;
g_sMPU9150Inst.pui8Data[2] = (MPU9150_ACCEL_CONFIG_ACCEL_HPF_5HZ |
MPU9150_ACCEL_CONFIG_AFS_SEL_2G);
MPU9150Write(&g_sMPU9150Inst, MPU9150_O_CONFIG, g_sMPU9150Inst.pui8Data, 3,
MotionCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MotionI2CWait(__FILE__, __LINE__);
//
// Configure the data ready interrupt pin output of the MPU9150.
//
g_sMPU9150Inst.pui8Data[0] = (MPU9150_INT_PIN_CFG_INT_LEVEL |
MPU9150_INT_PIN_CFG_INT_RD_CLEAR |
MPU9150_INT_PIN_CFG_LATCH_INT_EN);
g_sMPU9150Inst.pui8Data[1] = MPU9150_INT_ENABLE_DATA_RDY_EN;
MPU9150Write(&g_sMPU9150Inst, MPU9150_O_INT_PIN_CFG,
g_sMPU9150Inst.pui8Data, 2, MotionCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MotionI2CWait(__FILE__, __LINE__);
//
// Initialize the DCM system.
//
CompDCMInit(&g_sCompDCMInst, 1.0f / ((float) MOTION_SAMPLE_FREQ_HZ),
DCM_ACCEL_WEIGHT, DCM_GYRO_WEIGHT, DCM_MAG_WEIGHT);
//
// Initialize the gesture instance and establish a initial state estimate.
//
GestureInit(&g_sGestureInst, g_pfInitProb, g_ppfPath, g_ppfTransitionProb,
g_ppfEmitProb, GESTURE_PATH_LENGTH, GESTURE_NUM_STATES,
GESTURE_STATE_IDLE);
}
//*****************************************************************************
//
// Initializes the SSI port and determines if the TRF79x0 is available.
//
// This function must be called prior to any other function offered by the
// TRF79x0. It configures the SSI port to run in Motorola/Freescale
// mode.
//
// \return None.
//
//*****************************************************************************
void
SSITRF79x0Init(void)
{
//
// Enable the peripherals used to drive the TRF79x0 on SSI.
//
MAP_SysCtlPeripheralEnable(TRF79X0_SSI_PERIPH);
//
// Enable the GPIO peripherals associated with the SSI.
//
MAP_SysCtlPeripheralEnable(TRF79X0_CLK_PERIPH);
MAP_SysCtlPeripheralEnable(TRF79X0_RX_PERIPH);
MAP_SysCtlPeripheralEnable(TRF79X0_TX_PERIPH);
MAP_SysCtlPeripheralEnable(TRF79X0_CS_PERIPH);
//
// Configure the appropriate pins to be SSI instead of GPIO. The CS
// is configured as GPIO to support TRF79x0 SPI requirements for R/W
// access.
//
MAP_GPIOPinConfigure(TRF79X0_CLK_CONFIG);
MAP_GPIOPinConfigure(TRF79X0_RX_CONFIG);
MAP_GPIOPinConfigure(TRF79X0_TX_CONFIG);
MAP_GPIOPinTypeSSI(TRF79X0_CLK_BASE, TRF79X0_CLK_PIN);
MAP_GPIOPinTypeSSI(TRF79X0_RX_BASE, TRF79X0_RX_PIN);
MAP_GPIOPinTypeSSI(TRF79X0_TX_BASE, TRF79X0_TX_PIN);
MAP_GPIOPinTypeGPIOOutput(TRF79X0_CS_BASE, TRF79X0_CS_PIN);
MAP_GPIOPadConfigSet(TRF79X0_CLK_BASE, TRF79X0_CLK_PIN,
GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPadConfigSet(TRF79X0_RX_BASE, TRF79X0_RX_PIN,
GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPadConfigSet(TRF79X0_TX_BASE, TRF79X0_TX_PIN,
GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
//
// Deassert the SSI chip selects TRF79x0.
//
MAP_GPIOPinWrite(TRF79X0_CS_BASE, TRF79X0_CS_PIN, TRF79X0_CS_PIN);
//
// Configure the SSI port for 2MHz operation.
//
MAP_SSIConfigSetExpClk(TRF79X0_SSI_BASE, g_ui32SysClk,
SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, SSI_CLK_RATE,
8);
if(RF_DAUGHTER_TRF7970)
{
//
// Switch from SPH=0 to SPH=1. Required for TRF7970.
//
HWREG(TRF79X0_SSI_BASE + SSI_O_CR0) |= SSI_CR0_SPH;
}
//
// Enable the SSI controller.
//
MAP_SSIEnable(TRF79X0_SSI_BASE);
}
//*****************************************************************************
//
// Main 'C' Language entry point.
//
//*****************************************************************************
int
main(void)
{
float fTemperature, fPressure, fAltitude;
int32_t i32IntegerPart;
int32_t i32FractionPart;
tContext sContext;
uint32_t ui32SysClock;
char pcBuf[15];
//
// Setup the system clock to run at 40 Mhz from PLL with crystal reference
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 40000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "bmp180");
//
// Flush any cached drawing operations.
//
GrFlush(&sContext);
//
// Enable UART0
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 115200, ui32SysClock);
//
// Print the welcome message to the terminal.
//
UARTprintf("\033[2JBMP180 Example\n");
//
// The I2C3 peripheral must be enabled before use.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
//
// Configure the pin muxing for I2C3 functions on port G4 and G5.
// This step is not necessary if your part does not support pin muxing.
//
MAP_GPIOPinConfigure(GPIO_PG4_I2C3SCL);
MAP_GPIOPinConfigure(GPIO_PG5_I2C3SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
MAP_GPIOPinTypeI2CSCL(GPIO_PORTG_BASE, GPIO_PIN_4);
MAP_GPIOPinTypeI2C(GPIO_PORTG_BASE, GPIO_PIN_5);
//
// Enable interrupts to the processor.
//
MAP_IntMasterEnable();
//
// Initialize I2C3 peripheral.
//
I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff,
ui32SysClock);
//
// Initialize the BMP180
//
BMP180Init(&g_sBMP180Inst, &g_sI2CInst, BMP180_I2C_ADDRESS,
BMP180AppCallback, &g_sBMP180Inst);
//
// Wait for initialization callback to indicate reset request is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for I2C Transactions to complete.
//
}
//
// Reset the data ready flag
//
g_vui8DataFlag = 0;
//
// Enable the system ticks at 10 hz.
//
MAP_SysTickPeriodSet(ui32SysClock / (10 * 3));
MAP_SysTickIntEnable();
MAP_SysTickEnable();
//
// Configure PQ4 to control the blue LED.
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_4);
//
// Print temperature, pressure and altitude labels once on the LCD.
//
GrStringDraw(&sContext, "Temperature", 11,
((GrContextDpyWidthGet(&sContext) / 2) - 96),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
GrStringDraw(&sContext, "Pressure", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 63),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
GrStringDraw(&sContext, "Altitude", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 59),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
//
// Begin the data collection and printing. Loop Forever.
//
while(1)
{
//
// Read the data from the BMP180 over I2C. This command starts a
// temperature measurement. Then polls until temperature is ready.
// Then automatically starts a pressure measurement and polls for that
// to complete. When both measurement are complete and in the local
// buffer then the application callback is called from the I2C
// interrupt context. Polling is done on I2C interrupts allowing
// processor to continue doing other tasks as needed.
//
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
while(g_vui8DataFlag == 0)
{
//
// Wait for the new data set to be available.
//
}
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Get a local copy of the latest temperature data in float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fTemperature;
i32FractionPart =(int32_t) (fTemperature * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print temperature with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%03d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
UARTprintf("Temperature %3d.%03d\t\t", i32IntegerPart,
i32FractionPart);
//
// Get a local copy of the latest air pressure data in float format.
//
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fPressure;
i32FractionPart =(int32_t) (fPressure * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print Pressure with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, -1,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
UARTprintf("Pressure %3d.%03d\t\t", i32IntegerPart, i32FractionPart);
//
// Calculate the altitude.
//
fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
1.0f / 5.255f));
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fAltitude;
i32FractionPart =(int32_t) (fAltitude * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print altitude with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
UARTprintf("Altitude %3d.%03d", i32IntegerPart, i32FractionPart);
//
// Print new line.
//
UARTprintf("\n");
//
// Delay to keep printing speed reasonable. About 100 milliseconds.
//
MAP_SysCtlDelay(ui32SysClock / (10 * 3));
}
}
