// 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)); } }