//***************************************************************************** // //! Initialize LEDs //! //! \param none //! //! \return none //! //! \brief Initializes LED Ports and Pins // //***************************************************************************** void initLEDs() { // Enable use of PORTF to toggle LED and disable interrupt on this port MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // // Unlock PF0 so we can change it to a GPIO input // Once we have enabled (unlocked) the commit register then re-lock it // to prevent further changes. PF0 is muxed with NMI thus a special case. // HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD; HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01; HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0; MAP_GPIOPinIntDisable(GPIO_PORTF_BASE, 0xFF); // Configure Red LED MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_LOW); // Configure Blue LED MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_LOW); // Configure Green LED MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_LOW); // Button inputs ROM_GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_DIR_MODE_IN); ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); }
/* * @brief Initializes SPI unit. * * Enables peripherals * Configures GPIO * Sets radio, accelerometer, and LED as output * Sets word size as 0 * @returns void */ void SPIInit(void) { volatile unsigned long ulLoop; MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // configure SSI pins for peripheral control MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, (SPI_MOSI_PIN | SPI_MISO_PIN | SPI_CLK_PIN)); MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK); MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX); MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX); // Also, it may be better to just get rid of the pullups/downs entirely. -Jeremy MAP_GPIOPadConfigSet(GPIO_PORTA_BASE, (SPI_MOSI_PIN | SPI_MISO_PIN | SPI_CLK_PIN), GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); #if (defined(RONE_V12) || defined(RONE_V9)) // enable output enable peripheral for SPI MAP_SysCtlPeripheralEnable(SPI_ENABLE_PERIPH); // enable peripheral for three SPI pins MAP_SysCtlPeripheralEnable(SPI_SELECT_PERIPH); // drive select pins to correct values while they are still in input mode SPIDeselectISR(); // enable output enable pin for output MAP_GPIOPinTypeGPIOOutput(SPI_ENABLE_PORT, SPI_ENABLE_PIN); // enable A,B,C SPI pins for output MAP_GPIOPinTypeGPIOOutput(SPI_SELECT_PORT, SPI_SELECT_PINS); #endif // force the port to be enabled by the first call to SPIConfigure() SPIWordSize = 0; }
void configure_pin(struct header_pin *pin) { if(pin->config == CONFIG_INPUT) { MAP_GPIOPinTypeGPIOInput(pin->base, pin->pin); } else if( pin->config == CONFIG_OUTPUT) { MAP_GPIOPinTypeGPIOOutput(pin->base, pin->pin); } }
static void enc28j60_comm_init(void) { MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, ENC_CS | ENC_RESET); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, SRAM_CS); // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, ENC_CS | ENC_RESET | SRAM_CS); MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, ENC_INT); MAP_GPIOPinWrite(GPIO_PORTB_BASE, ENC_RESET, 0); MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS); MAP_GPIOPinWrite(GPIO_PORTA_BASE, SRAM_CS, SRAM_CS); SysCtlDelay(((SysCtlClockGet() / 3) / 10)); //100ms delay MAP_GPIOPinWrite(GPIO_PORTB_BASE, ENC_RESET, ENC_RESET); }
//***************************************************************************** // // 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); }
/** * Hardware setup * Initializes pins, clocks, etc */ void HAL_setup(void){/*{{{*/ //Configure clock to run at 120MHz //configCPU_CLOCK_HZ = 120MHz //Needs to be set for FreeRTOS g_syshz = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000L); MAP_SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ); //Enable all GPIOs MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOQ); init_ethernet(); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); //Configure reset pin for XBD MAP_GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, RESET_PIN); //Reset XBD xbd_reset(true); //Configure UART MAP_GPIOPinConfigure(GPIO_PA0_U0RX); MAP_GPIOPinConfigure(GPIO_PA1_U0TX); MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); MAP_UARTConfigSetExpClk(UART0_BASE, g_syshz, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // //Configure measurement stuff measure_setup(); //Configure xbd i2c comm i2c_comm_setup(); //Setup watchdog watchdog_setup(); //Unreset XBD xbd_reset(false); }/*}}}*/
static void enc28j60_comm_init(void) { MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, ENC_CS); MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, ENC_INT); MAP_GPIOPinWrite(ENC_CS_PORT, ENC_CS, ENC_CS); }
//***************************************************************************** // //! Initialize LEDs //! //! \param none //! //! \return none //! //! \brief Initializes LED Ports and Pins // //***************************************************************************** void initLEDs() { // Enable use of PORTF to toggle LED and disable interrupt on this port MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); MAP_GPIOPinIntDisable(GPIO_PORTF_BASE, 0xFF); // Configure Red LED MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, PIN_LOW); // Configure Blue LED MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, PIN_LOW); // Configure Green LED MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, PIN_LOW); }
// Pin config virtual void PinSetMode(MicroFlo::PinId pin, IO::PinMode mode) { MAP_SysCtlPeripheralEnable(peripheral(pin)); if (mode == IO::InputPin) { MAP_GPIOPinTypeGPIOInput(portBase(pin), pinMask(pin)); } else if (mode == IO::OutputPin) { MAP_GPIOPinTypeGPIOOutput(portBase(pin), pinMask(pin)); } else { MICROFLO_DEBUG(debug, DebugLevelError, DebugIoOperationNotImplemented); } }
uint8_t setPWMGenFreq(uint8_t generator, unsigned int freq) { config_done[generator - 1] = 0; if(generator <= MAX_PWM_GENERATORS && generator > 0) { if(freq > 0 && freq <= max_pwm_freq) { freq_pwm[generator - 1] = freq; max_count[generator -1] = max_pwm_freq * min_pwm_res / freq_pwm[generator - 1]; config_done[generator - 1] = 1; #ifdef UART_DEBUG UARTprintf(" max count %u", max_count[generator - 1] ); UARTprintf("Freq = %u, min_res = %u\n", max_pwm_freq, min_pwm_res); UARTprintf("port = %x, pin = %x\n", port_table[generator - 1], (1 << pin_table[(generator - 1) * 2]) | (1 << pin_table[(generator - 1) * 2 + 1])); #endif MAP_SysCtlPeripheralEnable(periph_table[generator - 1]); MAP_SysCtlGPIOAHBEnable(periph_table[generator - 1]); MAP_GPIOPinTypeGPIOOutput(port_table[generator - 1], (pin_table[(generator - 1) * 2]) | (pin_table[(generator - 1) * 2 + 1])); lookUp_pwm[(generator - 1) * 2] = (uint8_t *)malloc(max_count[generator - 1]); lookUp_pwm[(generator - 1) * 2 + 1] = (uint8_t *)malloc(max_count[generator - 1]); memset(lookUp_pwm[(generator - 1) * 2], 0, max_count[generator - 1]); memset(lookUp_pwm[(generator - 1) * 2 + 1], 0, max_count[generator - 1]); lastDutyCycle[(generator - 1) * 2] = 0; lastDutyCycle[(generator - 1) * 2 + 1] = 0; #ifdef UART_DEBUG UARTprintf("printing tab..."); for(i = 0; i < max_count[generator - 1]; i++) { UARTprintf("%d ", lookUp_pwm[(generator - 1) * 2 ][i]); } UARTprintf("pr \n"); for(i = 0; i < max_count[generator - 1]; i++) { UARTprintf("%d ", lookUp_pwm[(generator - 1) * 2 +1][i]); } UARTprintf("done\n"); #endif return 0; } else { return 1; } } else { return 2; } }
pio_type platform_pio_op( unsigned port, pio_type pinmask, int op ) { pio_type retval = 1, base = pio_base[ port ]; switch( op ) { case PLATFORM_IO_PORT_SET_VALUE: MAP_GPIOPinWrite( base, 0xFF, pinmask ); break; case PLATFORM_IO_PIN_SET: MAP_GPIOPinWrite( base, pinmask, pinmask ); break; case PLATFORM_IO_PIN_CLEAR: MAP_GPIOPinWrite( base, pinmask, 0 ); break; case PLATFORM_IO_PORT_DIR_INPUT: pinmask = 0xFF; case PLATFORM_IO_PIN_DIR_INPUT: MAP_GPIOPinTypeGPIOInput( base, pinmask ); break; case PLATFORM_IO_PORT_DIR_OUTPUT: pinmask = 0xFF; case PLATFORM_IO_PIN_DIR_OUTPUT: MAP_GPIOPinTypeGPIOOutput( base, pinmask ); break; case PLATFORM_IO_PORT_GET_VALUE: retval = MAP_GPIOPinRead( base, 0xFF ); break; case PLATFORM_IO_PIN_GET: retval = MAP_GPIOPinRead( base, pinmask ) ? 1 : 0; break; case PLATFORM_IO_PIN_PULLUP: case PLATFORM_IO_PIN_PULLDOWN: MAP_GPIOPadConfigSet( base, pinmask, GPIO_STRENGTH_8MA, op == PLATFORM_IO_PIN_PULLUP ? GPIO_PIN_TYPE_STD_WPU : GPIO_PIN_TYPE_STD_WPD ); break; case PLATFORM_IO_PIN_NOPULL: MAP_GPIOPadConfigSet( base, pinmask, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD ); break; default: retval = 0; break; } return retval; }
//***************************************************************************** // // Initialization function for the LXD display. This turns on the backlight // and sets the correct RGB mode. // //***************************************************************************** void InitLXDAndFormike(uint32_t ui32SysClk) { // // Convert PT2 & 3 back to a GPIO output (they were LCDDATA18/19) // HWREG(GPIO_PORTT_BASE + GPIO_O_PCTL) &= 0xFFFF00FF; MAP_GPIOPinTypeGPIOOutput(GPIO_PORTT_BASE, GPIO_PIN_2 | GPIO_PIN_3); // // Convert PS0 and 1 back to GPIO outputs (they were LCDDATA20/21) // HWREG(GPIO_PORTS_BASE + GPIO_O_PCTL) &= 0xFFFFFF00; MAP_GPIOPinTypeGPIOOutput(GPIO_PORTS_BASE, GPIO_PIN_1 | GPIO_PIN_0); // // Drive PS0/1 to set the display TL to BR scanning direction. // MAP_GPIOPinWrite(GPIO_PORTS_BASE, GPIO_PIN_1 | GPIO_PIN_0, GPIO_PIN_0); // // Write PT2 high to turn on the backlight. // MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_2, GPIO_PIN_2); // // Turn OE/DE off // MAP_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_6); // // Write PT3 low to set the display into RGB mode. // MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_3, 0); // // Write PT3 low to set the display into RGB mode. // MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_3, 0); }
void spi_init(unsigned long bitrate,unsigned long datawidth){ //SSI MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0); MAP_SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOA); MAP_SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOC); //CS Pin MAP_GPIOPinTypeGPIOOutput(CS_PIN_BASE,CS_PIN); //CE Pin MAP_GPIOPinTypeGPIOOutput(CE_PIN_BASE,CE_PIN); /* Configure the SSI0 port */ MAP_SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0,SSI_MODE_MASTER, bitrate, datawidth); /* Configure the appropriate pins to be SSI instead of GPIO */ MAP_GPIOPinTypeSSI(GPIO_PORTA_AHB_BASE, GPIO_PIN_2 |GPIO_PIN_4 | GPIO_PIN_5); MAP_SSIEnable(SSI0_BASE); ulClockMS = MAP_SysCtlClockGet() / (3 * 1000); }
//***************************************************************************** // // Initialization function for the Formike 800x480 display. This turns on the // backlight. // //***************************************************************************** void EnableBacklightOnPT2(uint32_t ui32SysClk) { // // Convert PT2 back to a GPIO output (it was LCDDATA18) // HWREG(GPIO_PORTT_BASE + GPIO_O_PCTL) &= 0xFFFFF0FF; MAP_GPIOPinTypeGPIOOutput(GPIO_PORTT_BASE, GPIO_PIN_2); // // Write the pin high to turn on the backlight. // MAP_GPIOPinWrite(GPIO_PORTT_BASE, GPIO_PIN_2, GPIO_PIN_2); }
void gpio_init(int pin, enum gpio_mode mode, int value) { uint32_t base = TO_BASE(pin); pin = 1 << (pin & 0x0F); switch (mode) { case GPIO_OUTPUT: MAP_GPIOPinTypeGPIOOutput(base, pin); gpio_set(pin, value); break; case GPIO_OUTPUT_SLOW: MAP_GPIOPinTypeGPIOOutput(base, pin); MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD); gpio_set(pin, value); break; case GPIO_INPUT: MAP_GPIOPinTypeGPIOInput(base, pin); break; case GPIO_INPUT_PD: MAP_GPIOPinTypeGPIOInput(base, pin); MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD_WPD); break; case GPIO_INPUT_PU: MAP_GPIOPinTypeGPIOInput(base, pin); MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD_WPU); break; case GPIO_ANALOG: MAP_GPIOPinTypeGPIOInput(base, pin); MAP_GPIOPadConfigSet(base, pin, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_ANALOG); break; } }
int main(){ // System clock set to run at 50 MHz from PLL with crystal ref. // With EK-TM4C123GXL Launchpad, no need to change SYSCTL_XTAL_16MHZ to anything else MAP_SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_BLUE|LED_GREEN); while(1){ MAP_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, LED_GREEN|LED_RED|LED_BLUE); // SysCtlDelay and ROM_SysCtlDelay behave differently, see http://e2e.ti.com/support/microcontrollers/tiva_arm/f/908/t/256106.aspx MAP_SysCtlDelay(2333333); // Number of loop iterations to perform @ 3 cycles/loop using ROM. Not Accurate. Input = (DesiredTime*ClockFrequency)/3 MAP_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, 0); MAP_SysCtlDelay(16333333); } }
void platform_init(void) { /* 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 clock to PLL at 50MHz */ MAP_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); /* Enable the GPIO pins for the LED (PF2 & PF3). */ MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3|GPIO_PIN_2); /* Enable the system tick. FIXME do we need this? */ MAP_SysTickPeriodSet(MAP_SysCtlClockGet() / SYSTICKS_PER_SECOND); MAP_SysTickIntEnable(); MAP_SysTickEnable(); }
//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); }
/* * Sets up the PWM pins for the IR beacon PWM control. */ void pwmInitializeBeacon(void) { MAP_SysCtlPeripheralEnable(IR_BEACON_PERIPH); //MAP_GPIOPinWrite(IR_BEACON_BASE, IR_BEACON_GPIO_BIT, 0); MAP_GPIOPinTypeGPIOOutput(IR_BEACON_BASE, IR_BEACON_GPIO_BIT); MAP_GPIOPinWrite(IR_BEACON_BASE, IR_BEACON_GPIO_BIT, IR_BEACON_GPIO_BIT); }
/* * ======== EK_TM4C123GXL_initGPIO ======== */ void EK_TM4C123GXL_initGPIO(void) { // /* Setup the LED GPIO pins used */ // GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); /* EK_TM4C123GXL_LED_RED */ // GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); /* EK_TM4C123GXL_LED_GREEN */ // GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3); /* EK_TM4C123GXL_LED_BLUE */ // // /* Setup the button GPIO pins used */ // GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4); /* EK_TM4C123GXL_GPIO_SW1 */ // GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU); // // /* PF0 requires unlocking before configuration */ // HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; // HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= GPIO_PIN_0; // GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0); /* EK_TM4C123GXL_GPIO_SW2 */ // GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU); // HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_M; //Init debug gpio pin/pins // MAP_GPIOPinTypeGPIOOutput(DEBUG_GPIO_PORT_1, DEBUG_GPIO_PIN_1); //debug pin //Init radio power enable pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_GPIO_EN_PORT, INEEDMD_RADIO_ENABLE_PIN); //radio power enable pin //Init radio command mode pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_GPIO_CMND_PORT, INEEDMD_RADIO_CMND_PIN); //radio command mode pin //Init radio reset pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_GPIO_RST_PORT, INEEDMD_RADIO_RESET_PIN); //radio reset pin //Init external clock enable pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_XTAL_PORT, INEEDMD_XTAL_ENABLE_PIN); //external clock enable pin //Init ADC power on pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_PWR_PIN); //Init ADC reset pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_RESET_PIN); // Init ADC interrupt pin // MAP_GPIOPinTypeGPIOInput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_INTERUPT_PIN); // Init ADC start pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_START_PIN); //Init ADC nCS pin // MAP_GPIOPinTypeGPIOOutput(INEEDMD_ADC_GPIO_PORT, INEEDMD_ADC_nCS_PIN); //Init USB unplug detect pin // HWREG(GPIO_PORTB_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTB_BASE + GPIO_O_CR) |= GPIO_PIN_4; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_4); MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_4, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPD); HWREG(GPIO_PORTB_BASE + GPIO_O_LOCK) = GPIO_LOCK_M; /* Once GPIO_init is called, GPIO_config cannot be changed */ GPIO_init(); }
//***************************************************************************** // //! 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); }
/******************* * Board Functions * *******************/ void GTBEA_initErrLED(void) { MAP_SysCtlPeripheralEnable(GTBEA_ERR_LED_GPIO_PERIPH); MAP_GPIOPinTypeGPIOOutput(GTBEA_ERR_LED_GPIO_BASE, GTBEA_ERR_LED_PIN); MAP_GPIOPinWrite(GTBEA_ERR_LED_GPIO_BASE, GTBEA_ERR_LED_PIN, 0); // turn off err LED }
//***************************************************************************** // // This function initializes the ADC hardware in preparation for data // acquisition. // //***************************************************************************** void AcquireInit(void) { uint32_t ui32Chan, ui32Base, ui32Seq, ui32ChCtl; // // Enable the ADC peripherals and the associated GPIO port // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC1); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP); // // Enabled LED GPIO // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_2); // // Configure the pins to be used as analog inputs. // MAP_GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_3); MAP_GPIOPinTypeADC(GPIO_PORTP_BASE, GPIO_PIN_0); // // Select the external reference for greatest accuracy. // MAP_ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V); MAP_ADCReferenceSet(ADC1_BASE, ADC_REF_EXT_3V); // // Apply workaround for erratum 6.1, in order to use the // external reference. // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); HWREG(GPIO_PORTB_BASE + GPIO_O_AMSEL) |= GPIO_PIN_6; // // Initialize both ADC peripherals using sequencer 0 and processor trigger. // MAP_ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0); MAP_ADCSequenceConfigure(ADC1_BASE, 0, ADC_TRIGGER_PROCESSOR, 0); // // Enter loop to configure all of the ADC sequencer steps needed to // acquire the data for the data logger. Multiple ADC and sequencers // will be used in order to acquire all the channels. // for(ui32Chan = 0; ui32Chan < NUM_ADC_CHANNELS; ui32Chan++) { // // If this is the first ADC then set the base for ADC0 // if(ui32Chan < 8) { ui32Base = ADC0_BASE; ui32Seq = 0; } else if(ui32Chan < 16) { // // Second ADC, set the base for ADC1 // ui32Base = ADC1_BASE; ui32Seq = 0; } // // Get the channel control for each channel. Test to see if it is the // last channel for the sequencer, and if so then also set the // interrupt and "end" flags. // ui32ChCtl = g_pui32ADCSeq[ui32Chan]; if((ui32Chan == 7) || (ui32Chan == 15) || (ui32Chan == (NUM_ADC_CHANNELS - 1))) { ui32ChCtl |= ADC_CTL_IE | ADC_CTL_END; } // // Configure the sequence step // MAP_ADCSequenceStepConfigure(ui32Base, ui32Seq, ui32Chan % 8, ui32ChCtl); } // // Erase the configuration in case there was a prior configuration. // g_psConfigState = 0; }
/* * initialize tm4c */ void init_satellite() { FPUEnable(); FPULazyStackingEnable(); /* * init clock */ MAP_SysCtlClockSet(SYSCTL_SYSDIV_3 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); //66.6..MHz MAP_IntMasterEnable(); /* * Enable peripherals */ MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //for LED indication MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //for UART MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //for IRQ and SW_EN MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //for SPI /* * configure */ MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, SIGNAL_LOW); //off MAP_GPIOPinConfigure(GPIO_PA0_U0RX); MAP_GPIOPinConfigure(GPIO_PA1_U0TX); MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioConfig(UART_PORT, UART_BAUDRATE, SysCtlClockGet()); MAP_GPIOIntDisable(GPIO_PORTB_BASE, SIGNAL_HIGH); //interrupt disable MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2); //IRQ as input MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); MAP_GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE); //enable interrupt MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_5); //sw enable MAP_GPIODirModeSet(GPIO_PORTB_BASE, GPIO_PIN_5, GPIO_DIR_MODE_OUT); MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_5, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD); MAP_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_5, SIGNAL_LOW); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_0); MAP_GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_0, SIGNAL_HIGH); //chip select MAP_GPIOIntEnable(GPIO_PORTB_BASE, GPIO_PIN_2); //enable interrupt for WLAN_IRQ pin SpiCleanGPIOISR(); //clear interrupt status MAP_IntEnable(INT_GPIOB); //spi init_worker(); setState(READY); }
//***************************************************************************** void PortFunctionInit(void) { // // Enable Peripheral Clocks // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // // Enable port PE5 for CAN0 CAN0TX // MAP_GPIOPinConfigure(GPIO_PE5_CAN0TX); MAP_GPIOPinTypeCAN(GPIO_PORTE_BASE, GPIO_PIN_5); // // Enable port PE4 for CAN0 CAN0RX // MAP_GPIOPinConfigure(GPIO_PE4_CAN0RX); MAP_GPIOPinTypeCAN(GPIO_PORTE_BASE, GPIO_PIN_4); // // Enable port PB0 for GPIOOutput // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0); // // Enable port PB6 for GPIOInput // MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_6); // // Enable port PF4 for GPIOInput // MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4); // // Enable port PF0 for GPIOInput // // //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_DD; HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x1; // //Now modify the configuration of the pins that we unlocked. // MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0); // // Enable port PF3 for GPIOOutput // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3); // // Enable port PF2 for GPIOOutput // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); // // Enable port PF1 for GPIOOutput // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); // // Enable port PA3 for SSI0 SSI0FSS // MAP_GPIOPinConfigure(GPIO_PA3_SSI0FSS); MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_3); // // Enable port PA2 for SSI0 SSI0CLK // MAP_GPIOPinConfigure(GPIO_PA2_SSI0CLK); MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2); // // Enable port PA4 for SSI0 SSI0RX // MAP_GPIOPinConfigure(GPIO_PA4_SSI0RX); MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_4); // // Enable port PA5 for SSI0 SSI0TX // MAP_GPIOPinConfigure(GPIO_PA5_SSI0TX); MAP_GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5); }
//***************************************************************************** // // 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)); } }
void pio_init() { // Board Initialization start // // // The FPU should be enabled because some compilers will use floating- // point registers, even for non-floating-point code. If the FPU is not // enabled this will cause a fault. This also ensures that floating- // point operations could be added to this application and would work // correctly and use the hardware floating-point unit. Finally, lazy // stacking is enabled for interrupt handlers. This allows floating- // point instructions to be used within interrupt handlers, but at the // expense of extra stack usage. // FPUEnable(); FPULazyStackingEnable(); //Init the device with 16 MHz clock. initClk(); /* Configure the system peripheral bus that IRQ & EN pin are map to */ MAP_SysCtlPeripheralEnable( SYSCTL_PERIPH_IRQ_PORT); // // Disable all the interrupts before configuring the lines // MAP_GPIOPinIntDisable(SPI_GPIO_IRQ_BASE, 0xFF); // // Cofigure WLAN_IRQ pin as input // MAP_GPIOPinTypeGPIOInput(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN); GPIOPadConfigSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // // Setup the GPIO interrupt for this pin // MAP_GPIOIntTypeSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_FALLING_EDGE); // // Configure WLAN chip // MAP_GPIOPinTypeGPIOOutput(SPI_GPIO_IRQ_BASE, SPI_EN_PIN); MAP_GPIODirModeSet( SPI_GPIO_IRQ_BASE, SPI_EN_PIN, GPIO_DIR_MODE_OUT ); MAP_GPIOPadConfigSet( SPI_GPIO_IRQ_BASE, SPI_EN_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD ); MAP_GPIOPinWrite(SPI_GPIO_IRQ_BASE, SPI_EN_PIN, PIN_LOW); SysCtlDelay(600000); SysCtlDelay(600000); SysCtlDelay(600000); // // Disable WLAN CS with pull up Resistor // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI_PORT); MAP_GPIOPinTypeGPIOOutput(SPI_CS_PORT, SPI_CS_PIN); GPIOPadConfigSet(SPI_CS_PORT, SPI_CS_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); MAP_GPIOPinWrite(SPI_CS_PORT, SPI_CS_PIN, PIN_HIGH); // // Enable interrupt for WLAN_IRQ pin // MAP_GPIOPinIntEnable(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN); // // Clear interrupt status // SpiCleanGPIOISR(); MAP_IntEnable(INT_GPIO_SPI); //init LED initLEDs(); }
//***************************************************************************** // // Initialization function for the InnoLux display. This turns on the backlight // after the required 200mS delay. // // VLED control - PD6 // LED_EN - PE5 // LED_PWM - PR2 or PE4 // //***************************************************************************** void InitInnoLux(uint32_t ui32SysClk) { // // Turn on GPIO Ports D, E and R. // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); #ifdef USE_PR2_FOR_PWM MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOR); #endif // // Configure PD6 (VLED) as an output. // HWREG(GPIO_PORTD_BASE + GPIO_O_PCTL) &= 0xF0FFFFFF; MAP_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_6); // // Configure PE5 and PR2 as outputs. // HWREG(GPIO_PORTE_BASE + GPIO_O_PCTL) &= 0xFF0FFFFF; MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_5); #ifdef USE_PR2_FOR_PWM HWREG(GPIO_PORTR_BASE + GPIO_O_PCTL) &= 0xFFFFF0FF; MAP_GPIOPinTypeGPIOOutput(GPIO_PORTR_BASE, GPIO_PIN_2); GPIOPadConfigSet(GPIO_PORTR_BASE, GPIO_PIN_2, GPIO_STRENGTH_12MA, GPIO_PIN_TYPE_STD); #else HWREG(GPIO_PORTE_BASE + GPIO_O_PCTL) &= 0xFFF0FFFF; MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_4); #endif // // Drive the enables low for now. // MAP_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_6, 0); #ifdef USE_PR2_FOR_PWM MAP_GPIOPinWrite(GPIO_PORTR_BASE, GPIO_PIN_2, 0); MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, 0); #else MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5 | GPIO_PIN_4, 0); #endif // // Wait 200mS. This delay is specified in the display datasheet. // MAP_SysCtlDelay((ui32SysClk / 5) / 3); // // Drive PD6 high to enable VLED to the display. // MAP_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_6, GPIO_PIN_6); // // Wait another 10mS before we turn on the PWM to set the display // backlight brightness. // MAP_SysCtlDelay((ui32SysClk / 100) / 3); // // Start the LED backlight signaling by asserting LED-PWM (PR2). // #ifdef USE_PR2_FOR_PWM MAP_GPIOPinWrite(GPIO_PORTR_BASE, GPIO_PIN_2, GPIO_PIN_2); #else MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, GPIO_PIN_4); #endif // // Wait another 10mS before returning to ensure that the raster is not // enabled too soon. // MAP_SysCtlDelay((ui32SysClk / 100) / 3); // // Enable the LED backlight by asserting LED-EN (PE5). // MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, GPIO_PIN_5); }
int main() { // // Make sure the main oscillator is enabled because this is required by // the PHY. The system must have a 25MHz crystal attached to the OSC // pins. The SYSCTL_MOSC_HIGHFREQ parameter is used when the crystal // frequency is 10MHz or higher. // SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ); // // Run from the PLL at 120 MHz. // g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // Configure the device pins. // PinoutSet(true, false); // // Configure UART. // //UARTStdioConfig(0, 115200, g_ui32SysClock); // // Clear the terminal and print banner. // //UARTprintf("\033[2J\033[H"); //UARTprintf("Ethernet lwIP example\n\n"); // // Configure Port N1 for as an output for the animation LED. // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0); MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); // // Initialize LED to OFF (0) // MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1); MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, ~GPIO_PIN_0); MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, ~GPIO_PIN_1); // // Configure SysTick for a periodic interrupt. // MAP_SysTickPeriodSet(g_ui32SysClock / SYSTICKHZ); MAP_SysTickEnable(); MAP_SysTickIntEnable(); // Init Onion Client client = new OnionClient("o8Ik6DuC","NfyGRECh3WSZw9xn"); client->registerFunction("/on",ledOn,0,0); client->registerFunction("/off",ledOff,0,0); char *params[1] = {"data"}; client->registerFunction("/pubTest",pubTest,params,1); client->init(g_ui32SysClock); // // Setup Onion Client // //httpd_init(); //client->begin(); // // Set the interrupt priorities. We set the SysTick interrupt to a higher // priority than the Ethernet interrupt to ensure that the file system // tick is processed if SysTick occurs while the Ethernet handler is being // processed. This is very likely since all the TCP/IP and HTTP work is // done in the context of the Ethernet interrupt. // MAP_IntPrioritySet(INT_EMAC0, ETHERNET_INT_PRIORITY); MAP_IntPrioritySet(FAULT_SYSTICK, SYSTICK_INT_PRIORITY); // // Loop forever. All the work is done in interrupt handlers. // uint32_t last_time = g_millis; bool led = false; while(1) { if ((g_millis - last_time) > 500) { if (led) { MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, ~GPIO_PIN_0); led = false; } else { MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, GPIO_PIN_0); led = true; } last_time = g_millis; } client->loop(); } return 0; }
//***************************************************************************** // // This example demonstrates how to send a string of data to the UART. // //***************************************************************************** int main(void) { uint32_t ui32_Period, ui32_PWM=0, ui32_PWM_step = 40, ui32_PWM_min=2000, ui32_PWM_max=4000; uint32_t ui32_sw1; uint32_t ui32_sw2; // // 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_FPUEnable(); //MAP_FPULazyStackingEnable(); // // Set the clocking to run directly from the crystal. // MAP_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Enable the GPIO port that is used for the on-board LED. // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // // Enable the GPIO pins for the LED (PF2). // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); // Configure UART InitConsole(); // ----------------------------------------------------------------- // Configure PWM for servo control // ----------------------------------------------------------------- // follow page 1240 of the datasheet: ui32_Period = (MAP_SysCtlClockGet()/8) / 50; //PWM frequency 50HZ, T=20ms // GOTO middle of servo in the beginning ui32_PWM = ui32_PWM_min + (ui32_PWM_max - ui32_PWM_min) / 2; ui32_PWM_max = ui32_Period*.1; ui32_PWM_min = ui32_Period*.05; //Configure PWM Clock to match system MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_8); // Enable system clock for PWM0 module MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0); // Enable the GPIO port that is used for the PWM outputs MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //Configure PB5,PB5 Pins as PWM MAP_GPIOPinConfigure(GPIO_PB4_M0PWM2); MAP_GPIOPinConfigure(GPIO_PB5_M0PWM3); MAP_GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_4); MAP_GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_5); //Configure PWM Options MAP_PWMGenConfigure(PWM0_BASE, PWM_GEN_1 , PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC); // // Set the PWM period to 50Hz. To calculate the appropriate parameter // use the following equation: N = (1 / f) * SysClk. Where N is the // function parameter, f is the desired frequency, and SysClk is the // system clock frequency. // In this case you get: (1 / 50Hz) * 16MHz/8div = 40000 cycles. Note that // the maximum period you can set is 2^16 - 1. // TODO: modify this calculation to use the clock frequency that you are // using. // PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, ui32_Period); //Set PWM duty - 25% and 75% PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2, ui32_PWM); PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3, ui32_PWM); // Enable the PWM generator MAP_PWMGenEnable(PWM0_BASE, PWM_GEN_1); // Turn on the Output pins MAP_PWMOutputState(PWM0_BASE, PWM_OUT_2_BIT | PWM_OUT_3_BIT, true); // ----------------------------------------------------------------- // Enable PORTF and Configure SW1 and SW2 as input // ----------------------------------------------------------------- MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIO_PORTF_LOCK_R = 0x4C4F434B; // unlock GPIO Port F GPIO_PORTF_CR_R = 0x1F; // allow changes to PF4-0 MAP_GPIOPadConfigSet(GPIO_PORTF_BASE, (GPIO_PIN_4 | GPIO_PIN_0), GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); MAP_GPIODirModeSet(GPIO_PORTF_BASE, (GPIO_PIN_4 | GPIO_PIN_0), GPIO_DIR_MODE_IN); // // Loop forever echoing data through the UART. // while(1) { // Get buttons: ui32_sw1 = MAP_GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4); ui32_sw2 = MAP_GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0); // if pressing SW1 on LaunchPad TM4C123G if( ui32_sw1 == 0 ) { if(ui32_PWM >= ui32_PWM_min+ui32_PWM_step) { ui32_PWM -= ui32_PWM_step; } } if( ui32_sw2 == 0 ) { if(ui32_PWM <= ui32_PWM_max-ui32_PWM_step) { ui32_PWM += ui32_PWM_step; } } UARTprintf("Period: %d, PWM: %d\n", ui32_Period, ui32_PWM); MAP_SysCtlDelay(2000000); MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2 , ui32_Period - ui32_PWM); MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3 , ui32_PWM); } }