void setup_buttonInterrupts(){ SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_4); GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_0); GPIOIntEnable(GPIO_PORTF_BASE, (GPIO_INT_PIN_1 | GPIO_INT_PIN_2 | GPIO_INT_PIN_4)); GPIOIntRegister(GPIO_PORTF_BASE, bHandler); GPIOIntTypeSet(GPIO_PORTF_BASE, (GPIO_PIN_1 | GPIO_PIN_2 | GPIO_INT_PIN_4) , GPIO_FALLING_EDGE); GPIOIntEnable(GPIO_PORTB_BASE, GPIO_INT_PIN_0); GPIOIntRegister(GPIO_PORTB_BASE, brakeHandler); GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE); }
int main(void) { SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); IntMasterEnable(); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5); GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7); GPIOPadConfigSet(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, 0, GPIO_PIN_TYPE_STD_WPU); GPIOIntRegister(GPIO_PORTC_BASE, decodeMatrixInput); GPIOIntTypeSet(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, GPIO_FALLING_EDGE); GPIOIntEnable(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7); GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5, 0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0); srand(time(NULL)); initLEDStrip(); activePattern = 15; // init active pattern to blank while (1) activatePattern(activePattern); }
void confGPIO(){ //Inicializa el puerto F (LEDs) --> No hace falta si usamos la libreria RGB // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); //ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 0); //LEDS APAGADOS ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOE); //Inicializa los LEDs usando libreria RGB RGBInit(1); SysCtlPeripheralSleepEnable(GREEN_TIMER_PERIPH); SysCtlPeripheralSleepEnable(BLUE_TIMER_PERIPH); RGBEnable(); //Inicializamos los botones y su interrupción SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ButtonsInit(); GPIOIntClear(GPIO_PORTF_BASE, GPIO_INT_PIN_0|GPIO_INT_PIN_4); GPIOIntRegister(GPIO_PORTF_BASE,ButtonHandler); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_INT_PIN_0|GPIO_INT_PIN_4, GPIO_BOTH_EDGES); GPIOIntEnable(GPIO_PORTF_BASE, GPIO_INT_PIN_0|GPIO_INT_PIN_4); SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF); }
void spi_gpio_init(uint8_t int_flag) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //F0-----MISO ----- INPUT ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0); //F1,F2,F3:MOSI,CLK,CSN ----- OUTPUT ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3); //CE-----PA6 ----- OUTPUT ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_6); //IRQ-----PA7 ----- INPUT ROM_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_7); if(int_flag == 1) //开引脚外部中断 { GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_FALLING_EDGE); GPIOIntEnable(GPIO_PORTA_BASE,GPIO_INT_PIN_7); //打开PA7外部中断进行数据读取 GPIOIntRegister(GPIO_PORTA_BASE, PA7_int_hander);//指定外部中断处理函数 } else { GPIOIntDisable(GPIO_PORTA_BASE,GPIO_INT_PIN_7); } }
void INT_SRDY_Setup(){ SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //GPIODirModeSet(SYSCTL_PERIPH_GPIOA, GPIO_PIN_7, GPIO_DIR_MODE_IN); GPIOPinTypeGPIOInput(GPIO_PORTA_BASE,GPIO_PIN_7); GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_7, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_7, GPIO_RISING_EDGE); GPIOIntRegister(GPIO_PORTA_BASE, POLL); }
void onButtonUp(void) { if (GPIOIntStatus(GPIO_PORTF_BASE, false) & GPIO_PIN_4) { // PF4 was interrupt cause printf("Button Up\n"); GPIOIntRegister(GPIO_PORTF_BASE, onButtonDown); // Register our handler function for port F GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE); // Configure PF4 for falling edge trigger GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); // Clear interrupt flag } }
void Interrupt_PB3Init(void) { GPIOIntRegister(GPIO_PORTB_BASE,Interrupt_PB3Handler); ROM_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_3); ROM_GPIOPadConfigSet(GPIO_PORTB_BASE,GPIO_PIN_3,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); GPIOIntDisable(GPIO_PORTB_BASE,GPIO_INT_PIN_3); GPIOIntClear(GPIO_PORTB_BASE,GPIO_INT_PIN_3); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_INT_PIN_3,GPIO_LOW_LEVEL); }
void GPIOIntInit(){ //Enables GPIO interrupt MAP_IntEnable(INT_GPIOA1); //Register GPIO interrup with the function GIOPIntHandler() GPIOIntRegister(GPIOA1_BASE, GPIOIntHandler); //Enables the GPIO interrupt GPIOIntEnable(GPIOA1_BASE, 0x10); //Set type to falling edge GPIOIntTypeSet(GPIOA1_BASE, 0x10, GPIO_FALLING_EDGE); }
extern "C" int main(void) { unsigned long ir_period; // 40 MHz system clock SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL| SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); ConfigureUART(); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // 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; HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01; HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0; // Interrupt on sw1 GPIODirModeSet(IR_PORT, IR_PIN, GPIO_DIR_MODE_IN); GPIOPadConfigSet(IR_PORT, IR_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); GPIOPinTypeGPIOInput(IR_PORT, IR_PIN); GPIOIntTypeSet(IR_PORT, IR_PIN, GPIO_FALLING_EDGE); GPIOIntRegister(IR_PORT, ir_input_isr); GPIOIntEnable(IR_PORT, IR_PIN ); IntMasterEnable(); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0); GPIOPinConfigure(GPIO_PF1_T0CCP1); GPIOPinTypeTimer(GPIO_PORTF_BASE, GPIO_PIN_1); // Configure timer ir_period = SysCtlClockGet() / (IR_CARRIER / 2); UARTprintf("ir_period:%d\n", ir_period); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_B_PWM); TimerLoadSet(TIMER0_BASE, TIMER_B, ir_period); TimerMatchSet(TIMER0_BASE, TIMER_B, ir_period / 2); // PWM TimerEnable(TIMER0_BASE, TIMER_B); unsigned long m = 0; while(1) { TimerMatchSet(TIMER0_BASE, TIMER_B, m++); // PWM if (m > ir_period) m = 0; int i = 0; while (i++ < 5000) if (!ir.empty()) UARTprintf("%u", ir.pop_front()); } }
void GPIO_Init() { //INPUTS: PB2 - ENABLE READ / PD1 - COUNT SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2); GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_1); //CONFIGURE GPIO INTERRUPT (PD1 RISE AND DOWN) GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_1,GPIO_BOTH_EDGES); GPIOIntRegister(GPIO_PORTD_BASE,GPIODIntHandler); GPIOIntEnable(GPIO_PORTD_BASE, GPIO_INT_PIN_1); }
void onButtonDown(void) { if (GPIOIntStatus(GPIO_PORTF_BASE, false) & GPIO_PIN_4) { /*The GPIOIntStatus returns the value of the GPIORIS register and in this case, AND's it with the Pin 4 mask. So if the condition for the interrupt has occurred for the Pin then the if statement is true.*/ // PF4 was interrupt cause printf("Button Down\n"); GPIOIntRegister(GPIO_PORTF_BASE, onButtonUp); // Register our handler function for port F GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_RISING_EDGE); // Configure PF4 for rising edge trigger GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); // Clear interrupt flag } }
void interrupt_setup(void) { // Interrupt setuü GPIOIntDisable(GPIO_PORTF_BASE, GPIO_PIN_4); // Disable interrupt for PF4 (in case it was enabled) GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); // Clear pending interrupts for PF4 GPIOIntRegister(GPIO_PORTF_BASE, onButtonDown); // Register our handler function for port F GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE); // Configure PF4 for falling edge trigger GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4); // Enable interrupt for PF4 }
//函数创建区 //----------------------------------------Start------------------------------------------- void Init_Timer() { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet()/100);//10ms周期中断,由100决定 如果为1为1s定时 GPIOIntRegister(INT_TIMER0A, Timer0AIntHandler); ROM_IntEnable(INT_TIMER0A); ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); ROM_TimerEnable(TIMER0_BASE, TIMER_A); ROM_IntMasterEnable(); }
int main() { //SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); //Enable Peripherals SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Start specific Pin Ports GPIOPinTypeGPIOOutput(port_A, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4); GPIOPinTypeGPIOOutput(port_C, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7); GPIOPinTypeGPIOOutput(port_D, GPIO_PIN_6); GPIOPinTypeGPIOOutput(port_E, GPIO_PIN_0); GPIOPinTypeGPIOOutput(port_F, GPIO_PIN_4 | GPIO_PIN_1); //Input Pins GPIOPinTypeGPIOInput(port_F, GPIO_PIN_2 | GPIO_PIN_3); //Enable pin for interrupt GPIOIntEnable(GPIO_PORTF_BASE, (GPIO_INT_PIN_2 | GPIO_INT_PIN_3)); //Set ISR GPIOIntRegister(GPIO_PORTF_BASE, scroll_button_isr); //Set interrupt type GPIOIntTypeSet(GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3) , GPIO_FALLING_EDGE); ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF); ROM_SysCtlPeripheralClockGating(true); //Initialize the display initializeDisplay(); //Write phrases write_phrases(); }
int main() { //Enable Peripherals SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); //Start specific Pin Ports GPIOPinTypeGPIOOutput(port_A, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4); GPIOPinTypeGPIOOutput(port_C, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7); GPIOPinTypeGPIOOutput(port_D, GPIO_PIN_6); GPIOPinTypeGPIOOutput(port_E, GPIO_PIN_0); GPIOPinTypeGPIOOutput(port_F, GPIO_PIN_4); GPIOPinTypeGPIOInput(port_F, GPIO_PIN_2 | GPIO_PIN_3); //Timer Configuration TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); TimerLoadSet(TIMER0_BASE, TIMER_A, frequency); TimerControlEvent(TIMER0_BASE, TIMER_A, TIMER_EVENT_POS_EDGE); TimerEnable(TIMER0_BASE, TIMER_A); //Enable pin for interrupt GPIOIntEnable(GPIO_PORTF_BASE, (GPIO_INT_PIN_2 | GPIO_INT_PIN_3)); //Set ISR GPIOIntRegister(GPIO_PORTF_BASE, the_taco_meter); //Set interrupt type GPIOIntTypeSet(GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3) , GPIO_BOTH_EDGES); //Initialize the display initializeDisplay(); //RS High GPIOPinWrite(port_C, GPIO_PIN_5, pin_5); write_string("Speed = #### RPM"); while(1) { taco_display(); } }
void Button_init(void) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x01; HWREG(GPIO_PORTF_BASE + GPIO_O_AFSEL) &= ~0x01; ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4); ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD_WPU); ROM_GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_FALLING_EDGE); GPIOIntRegister(GPIO_PORTF_BASE, &ButtonsISR); ROM_IntEnable(INT_GPIOF); GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4); GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4); }
int main(){ SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlDelay(3); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1); GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_BOTH_EDGES); GPIOIntRegister(GPIO_PORTF_BASE,PortFIntHandler); GPIOIntEnable(GPIO_PORTF_BASE, GPIO_INT_PIN_1); int i; for( i=0; i < size; i++) values[i] = 0; SysTickbegin(); SPIInit(); SendData(values,size); Wait(1000); while(1){ int i; Policia(); PadraoInit=0; MudaPadrao = 0; for(i=0; i < 3 && MudaPadrao==0; i++) Pattern3(); PadraoInit=0; MudaPadrao = 0; Ambulancia(); PadraoInit=0; MudaPadrao = 0; for(i=0; i < 3 && MudaPadrao==0; i++) Pattern2(); PadraoInit=0; MudaPadrao = 0; Pattern4(); PadraoInit=0; MudaPadrao = 0; } }
// Main void main(void) { mainSetup(); IntMasterEnable(); GPIOIntRegister(GPIO_PORTJ_BASE, interruptHandler); GPIOIntTypeSet(GPIO_PORTJ_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE); GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_PIN_0); //GPIOIntTypeSet(GPIO_PORTJ_BASE, GPIO_PIN_1, GPIO_FALLING_EDGE); //GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_PIN_1); SysTickEnable(); SysTickPeriodSet(currentFreq); SysTickIntRegister(timerstep); SysTickIntEnable(); while (true); }
int main(void) { SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); //Set up the general purpose I/Os SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);//1024hz = 15625 //Set up the input/output pins GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1); GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_5 | GPIO_PIN_6); //Set up the interrupt pins GPIOIntEnable(GPIO_PORTC_BASE, GPIO_INT_PIN_5 | GPIO_INT_PIN_6); GPIOIntRegister(GPIO_PORTC_BASE, interrupt_handler); GPIOIntTypeSet(GPIO_PORTC_BASE, (GPIO_PIN_5 | GPIO_PIN_6), GPIO_RISING_EDGE); //Just a quick toggle to make sure code is working toggle(); //Timer Configuration TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); TimerLoadSet(TIMER0_BASE, TIMER_A, frequency); TimerControlEvent(TIMER0_BASE, TIMER_A, TIMER_EVENT_POS_EDGE); TimerEnable(TIMER0_BASE, TIMER_A); //Timer Interrupt Enable TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); TimerIntRegister(TIMER0_BASE, TIMER_A, timer_interrupt); //Loop forever while(1){ // if(TimerValueGet(TIMER0_BASE, TIMER_A) == 0){ // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, pin_data); // pin_data^=0x04; // } } }
//-------------------------- IR pint init ---------------------------------- void ir_pin_init(void) { ROM_GPIOPinTypeGPIOInput(IR_PORT, IR_PIN); ROM_GPIOPadConfigSet( IR_PORT, IR_PIN, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD_WPU); // // Register the port-level interrupt handler. This handler is the // first level interrupt handler for all the pin interrupts. // GPIOIntRegister(IR_PORT, PortEIntHandler); // PORT E // // Make pin rising edge triggered interrupt. // ROM_GPIOIntTypeSet(IR_PORT, IR_PIN, GPIO_FALLING_EDGE); // GPIO_HIGH_LEVEL GPIO_RISING_EDGE GPIO_FALLING_EDGE GPIOIntClear(IR_PORT, IR_PIN); // // Enable the pin interrupts. // GPIOIntEnable(IR_PORT, IR_PIN); }
int main(void) { SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); //Configure System Clock //SSD SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); //Enable Port D SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //Enable Port B GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE,0x0F); GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE,0xFF); //S1 and S2 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Enable Port F //Mode 1 SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); //Enable ADC0 Module SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //Enable Port E GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_1); //Select ADC Function of PE 1 ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0); //Configure ADC0 Sequencer ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH2 | ADC_CTL_IE | ADC_CTL_END); //Configure the step of the sequencer //Mode 2 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); //Enable TIMER1 Module GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,GPIO_PIN_4); //Set PF4 as Input GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); //Configuring the PF4 GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_BOTH_EDGES); //Setting Interrupt to trigger on both edges TimerConfigure(TIMER1_BASE,TIMER_CFG_PERIODIC); //Configure TIMER1 into a Continuous Mode TimerIntRegister(TIMER1_BASE, TIMER_A, fast); //Register interrupt if PF4 pressed for more than 1s //Mode 3 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER4); //Enable TIMER4 Module SysCtlPeripheralEnable(SYSCTL_PERIPH_WTIMER0); //Enable WTIMER0 Module SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); //Enable Port C GPIOPinConfigure(GPIO_PC4_WT0CCP0); GPIOPinTypeTimer(GPIO_PORTC_BASE,GPIO_PIN_4); //Set PC4 as a Timer Capture pin TimerIntRegister(TIMER4_BASE,TIMER_A,freqfind); //Register a timer interrupt for TIMER4 TimerConfigure(TIMER4_BASE,TIMER_CFG_PERIODIC); //Configure Timer4 in continuous mode TimerConfigure(WTIMER0_BASE,TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_CAP_COUNT); TimerControlEvent(WTIMER0_BASE,TIMER_A,TIMER_EVENT_POS_EDGE); //Configure WTIMER0 for Positive Edge Capture IntMasterEnable(); GPIOPinWrite(GPIO_PORTB_BASE,0xFF,0x00); //Initialize SSD to 0x00 GPIOPinWrite(GPIO_PORTD_BASE, 0x0F, 0x00); //Turn off all the digits of the SSD SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); //Enable TIMER0 Module TimerConfigure(TIMER0_BASE,TIMER_CFG_PERIODIC); //Configure TIMER0 into a Continuous Mode TimerIntRegister(TIMER0_BASE, TIMER_A, ssdmux); //Register ISR for TIMER0 Interrupt to update SSD TimerLoadSet(TIMER0_BASE, TIMER_A,SysCtlClockGet()/3000); //Set the refresh rate of the SSD IntEnable(INT_TIMER0A); TimerIntEnable(TIMER0_BASE,TIMER_TIMA_TIMEOUT); //Enable the timer interrupt TimerEnable(TIMER0_BASE,TIMER_A); //Start the timer HWREG(GPIO_PORTF_BASE|GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTF_BASE|GPIO_O_CR) = GPIO_PIN_0; //Unlock PF0 from the NMI mode HWREG(GPIO_PORTF_BASE|GPIO_O_LOCK) = 0; ssdset(0); mode1set(); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0); //Setting PF0 to Input GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); //Configuring the pins GPIOIntRegister(GPIO_PORTF_BASE, modeselect); //Register Interrupt for Port F with ISR modeselect() GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_0); //Clear any existing interrupts GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE); //Setting Interrupt to trigger on falling edges GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_0); //Enable the GPIO Interrupts on Port F IntEnable(INT_GPIOF); //Enable Interrupts on Port F while(1){ switch(mode) //Select operation according to mode { case 1: mode1(); break; case 2: ssdsetHex(hex_count); if(fast_flag) { mode2(); SysCtlDelay(SysCtlClockGet()/300); } break; case 3: mode3(); break; case 4: mode1(); break; case 5: ssdsetHex(hex_count); if(fast_flag) { mode2(); SysCtlDelay(SysCtlClockGet()/300); } break; } SysCtlDelay(SysCtlClockGet()/3000); } return 0; }
int main(void) { // Status of Hibernation module uint32_t ui32Status = 0; // Length of time to hibernate uint32_t hibernationTime = 600; g_ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); //************************************************************************* //! I/O config and setup //************************************************************************* SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // UART SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7); // UART SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // UART0 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); // UART7 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // SSI SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION); // GPIO SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI2); // SSI SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK); // GPIO SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE);// Hibernation // UART0 and UART7 GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PC4_U7RX); GPIOPinConfigure(GPIO_PA1_U0TX); GPIOPinConfigure(GPIO_PC5_U7TX); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5); // LED indicators GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // SD Card Detect (PK3) and GPS Pulse Per Second (PK2) // GPIOPinTypeGPIOInput(GPIO_PORTK_BASE, GPIO_PIN_2|GPIO_PIN_3); // Pulse Per Second input pin config as weak pull-down GPIOPadConfigSet(GPIO_PORTK_BASE,GPIO_PIN_2,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD); // Pulse Per Second input pin config as rising edge triggered interrupt GPIOIntTypeSet(GPIO_PORTK_BASE,GPIO_PIN_2,GPIO_RISING_EDGE); // Register Port K as interrupt GPIOIntRegister(GPIO_PORTK_BASE, PortKIntHandler); // Enable Port K pin 2 interrupt GPIOIntEnable(GPIO_PORTK_BASE, GPIO_INT_PIN_2); // // Disable PPS pin interrupt by default // if(IntIsEnabled(INT_GPIOK)) { IntDisable(INT_GPIOK); } GPIOPinConfigure(GPIO_PD0_SSI2XDAT1); GPIOPinConfigure(GPIO_PD1_SSI2XDAT0); GPIOPinConfigure(GPIO_PD2_SSI2FSS); GPIOPinConfigure(GPIO_PD3_SSI2CLK); // SD Card Detect (CD) - weak pull-up input GPIOPadConfigSet(GPIO_PORTK_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // Debug UART output config UARTConfigSetExpClk(UART0_BASE, g_ui32SysClock, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // GPS UART input config UARTConfigSetExpClk(UART7_BASE, g_ui32SysClock, 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // // Configure SysTick for a 100Hz interrupt. // SysTickPeriodSet(g_ui32SysClock / 100); SysTickIntEnable(); SysTickEnable(); // // Floating point enable // FPUEnable(); FPULazyStackingEnable(); // // Clear user LEDs // GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, 0x00); //************************************************************************* //! Hibernation mode checks and setup //************************************************************************* // // Check to see if Hibernation module is already active, which could mean // that the processor is waking from a hibernation. // if(HibernateIsActive()) { // // Read the status bits to see what caused the wake. Clear the wake // source so that the device can be put into hibernation again. // ui32Status = HibernateIntStatus(0); HibernateIntClear(ui32Status); // // Wake was due to RTC match. // if(ui32Status & HIBERNATE_INT_RTC_MATCH_0) { // // TODO: add IMU check // } // // Wake was due to the External Wake pin. // else if(ui32Status & HIBERNATE_INT_PIN_WAKE) { // // Switch off low power mode // lowPowerOn = 0; } } // // Configure Hibernate module clock. // HibernateEnableExpClk(g_ui32SysClock); // // If the wake was not due to the above sources, then it was a system // reset. // if(!(ui32Status & (HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_RTC_MATCH_0))) { // // Configure the module clock source. // HibernateClockConfig(HIBERNATE_OSC_LOWDRIVE); } // // Enable PPS for a single data log. Interrupt on next PPS logic high. // ppsDataLog(); // // Enable RTC mode. // HibernateRTCEnable(); // // Loop forever // while(1) { // // If low power mode is set (default), hibernate again // If not, spin in nested while(1) for faster updates from PPS pin ints. // if(lowPowerOn) { lowPowerMode(hibernationTime); } else { if(!IntIsEnabled(INT_GPIOK)) { IntEnable(INT_GPIOK); } while(1) { } } } } // End function main
int main(void) { SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);//1024hz = 15625 GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7); GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_4 | GPIO_PIN_3 | GPIO_PIN_2); GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2); //Interrupt Enables GPIOIntEnable(GPIO_PORTB_BASE, GPIO_INT_PIN_2); GPIOIntRegister(GPIO_PORTB_BASE, interrupt_handler); GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE); ui8PinData = pin_2; while(1) { //a. Turn off the control signal for both 7-seg // b. Send the data to appear in the first 7-seg // c. Turn on the first 7-seg control signal // d. Delay loop // e. Turn off the control signal for both 7-seg // f. Send the data to appear in the second 7-seg // g. Turn on the second 7-seg control signal // h. Delay loop // i. Back to step a //GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_7, pin_7); if(isr_flag) { isr_flag = 0; system_delay -= 50000; } GPIOPinWrite(GPIO_PORTF_BASE, (GPIO_PIN_3 | GPIO_PIN_2), pin_2 + pin_3); //Send Data GPIOPinWrite(GPIO_PORTC_BASE, (GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7), (pin_6 + pin_4 + pin_7) ); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4, pin_4); //Turn on first 7-seg control signal GPIOPinWrite(GPIO_PORTF_BASE, (GPIO_PIN_3 | GPIO_PIN_2), pin_3); //Delay loop SysCtlDelay(system_delay); //Turn off control signal for both 7-seg GPIOPinWrite(GPIO_PORTF_BASE, (GPIO_PIN_3 | GPIO_PIN_2), pin_2 + pin_3); //Send Data GPIOPinWrite(GPIO_PORTC_BASE, (GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7), (pin_6 + pin_4 + pin_7)); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4, pin_4); //Turn on second 7-seg control signal GPIOPinWrite(GPIO_PORTF_BASE, (GPIO_PIN_3 | GPIO_PIN_2), pin_2); //Delay loop SysCtlDelay(system_delay); } }
int main() { //Set the Clock at 16MHZ SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); //Enable Timer Peripheral SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); //Enable Peripherals SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Initialize Output ports GPIOPinTypeGPIOOutput(port_A, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4); GPIOPinTypeGPIOOutput(port_C, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7); GPIOPinTypeGPIOOutput(port_D, GPIO_PIN_6); GPIOPinTypeGPIOOutput(port_E, GPIO_PIN_0); GPIOPinTypeGPIOOutput(port_F, (GPIO_PIN_4 | GPIO_PIN_1 | GPIO_PIN_3)); //Input Pins GPIOPinTypeGPIOInput(port_F, GPIO_PIN_2 | GPIO_PIN_3); //Interrupt Enables GPIOIntEnable(GPIO_PORTF_BASE, (GPIO_INT_PIN_2 | GPIO_INT_PIN_3)); GPIOIntRegister(GPIO_PORTF_BASE, interrupt_handler); GPIOIntTypeSet(GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3) , GPIO_FALLING_EDGE); //Timer Setup TimerLoadSet(TIMER0_BASE, TIMER_A, 0xFFFF); TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); TimerControlEvent(TIMER0_BASE, TIMER_A, TIMER_EVENT_NEG_EDGE); TimerEnable(TIMER0_BASE, TIMER_A); //Initialize the display initializeDisplay(); while(1) { if(display_flag == 1) { //Software Debouncing display_flag = 0; SysCtlDelay(160000); //Clear scree clear_screen(); //RS High for writing GPIOPinWrite(port_C, GPIO_PIN_5, pin_5); write_char_to_pins((char)(((int)'0')+ (0x00FF & TimerValueGet(TIMER0_BASE, TIMER_A))% 10)); //Back to Low GPIOPinWrite(port_C, GPIO_PIN_5, 0x0); } } }
int main(void) { // setup the system clock to run at 80 MHz from the external crystal: ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // enable peripherals to operate when CPU is in sleep: ROM_SysCtlPeripheralClockGating(true); // enable all of the GPIOs: ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF); // setup pins connected to RGB LED: ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3); //setup the UART console InitConsole(); // Test either the interrupts on a simple pushbutton to turn-on a led: // 1- interrupt with static allocation on the vector table // 2- interrupt with dynamic allocation on the vector table // 2- interrupt with dynamic allocation on the vector table // setup pin connected to SW1 and SW2 // 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; HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01; HWREG(GPIO_PORTF_BASE + GPIO_O_AFSEL) |= 0x000; HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0; //Configures pin(s) for use as GPIO inputs ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,GPIO_PIN_4 | GPIO_PIN_0); //Sets the pad configuration for the specified pin(s). ROM_GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_4 | GPIO_PIN_0,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); // Make PORT F pin 0,4 high level triggered interrupts. ROM_GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_4 | GPIO_PIN_0,GPIO_BOTH_EDGES); //dynamic allocation on the vector table of GPIO_PORTF_isr interrupt handler GPIOIntRegister(GPIO_PORTF_BASE, GPIO_PORTF_isr); //Enables the specified GPIO interrupt IntEnable(INT_GPIOF); GPIOIntEnable(GPIO_PORTF_BASE,GPIO_INT_PIN_4 | GPIO_INT_PIN_0); IntMasterEnable(); uint8_t PORTF_status; //uint32_t ui32Loop = 0; // // Loop forever // while(1) { uint8_t PORTF_status=GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0 | GPIO_PIN_4); /* if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)) { ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 ,0); } else { ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_1); } */ /* // // Turn on the red LED . // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_1); ROM_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_7, GPIO_PIN_7); // // Delay for a bit. // for(ui32Loop = 0; ui32Loop < 2000000; ui32Loop++) { } // // Turn on the green LED. // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_2); ROM_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_7, 0); // // Delay for a bit. // for(ui32Loop = 0; ui32Loop < 2000000; ui32Loop++) { } // // Turn on the blue LED. // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 , GPIO_PIN_3); // // Delay for a bit. // for(ui32Loop = 0; ui32Loop < 2000000; ui32Loop++) { } */ } }
//***************************************************************************** // //! Prepare a pin for use with a TOF sensor. //! //! \param GPIOPin is on the pin for the TOF sensor. //! //! This function initializes the GPIO interrupts and peripherals necessary //! to run the corresponding GPIO port. //! //! The \e GPIOPin parameter can take on the following values: //! //! - \b PA0 - Pin PA0 //! - \b PA1 - Pin PA1 //! - \b PA2 - Pin PA2 //! - \b PA3 - Pin PA3 //! - \b PA4 - Pin PA4 //! - \b PA5 - Pin PA5 //! - \b PA6 - Pin PA6 //! - \b PA7 - Pin PA7 //! - \b PB0 - Pin PB0 //! - \b PB1 - Pin PB1 //! - \b PB2 - Pin PB2 //! - \b PB3 - Pin PB3 //! - \b PB4 - Pin PB4 //! - \b PB5 - Pin PB5 //! - \b PB6 - Pin PB6 //! - \b PB7 - Pin PB7 //! - \b PC0 - Pin PC0 //! - \b PC1 - Pin PC1 //! - \b PC2 - Pin PC2 //! - \b PC3 - Pin PC3 //! - \b PC4 - Pin PC4 //! - \b PC5 - Pin PC5 //! - \b PC6 - Pin PC6 //! - \b PC7 - Pin PC7 //! - \b PD0 - Pin PD0 //! - \b PD1 - Pin PD1 //! - \b PD2 - Pin PD2 //! - \b PD3 - Pin PD3 //! - \b PD4 - Pin PD4 //! - \b PD5 - Pin PD5 //! - \b PD6 - Pin PD6 //! - \b PD7 - Pin PD7 //! - \b PE0 - Pin PE0 //! - \b PE1 - Pin PE1 //! - \b PE2 - Pin PE2 //! - \b PE3 - Pin PE3 //! - \b PE4 - Pin PE4 //! - \b PE5 - Pin PE5 //! - \b PE6 - Pin PE6 //! - \b PE7 - Pin PE7 //! - \b PF0 - Pin PF0 //! - \b PF1 - Pin PF1 //! - \b PF2 - Pin PF2 //! - \b PF3 - Pin PF3 //! - \b PF4 - Pin PF4 //! - \b PF5 - Pin PF5 //! - \b PF6 - Pin PF6 //! - \b PF7 - Pin PF7 //! //! \return None. //! //***************************************************************************** void TOFEchoInit(uint8_t GPIOPin) { // // Enable Peripheral Clocks // #ifdef USEPORTA MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); MAP_SysCtlDelay(3); #endif #ifdef USEPORTB MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); MAP_SysCtlDelay(3); #endif #ifdef USEPORTC MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); MAP_SysCtlDelay(3); #endif #ifdef USEPORTD MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); MAP_SysCtlDelay(3); #endif #ifdef USEPORTE MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); MAP_SysCtlDelay(3); #endif #ifdef USEPORTF MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); MAP_SysCtlDelay(3); #endif switch(GPIOPin){ #ifdef USEPORTA //Puerto A #ifdef USEPORTAPIN0 case PA0:{ if(!ConfigGPIO.GPIOS.PoA0){ // // Enable pin PA0 for GPIOInput // ConfigGPIO.GPIOS.PoA0 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_0); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_0; } break; } #endif #ifdef USEPORTAPIN1 case PA1:{ if(!ConfigGPIO.GPIOS.PoA1){ // // Enable pin PA1 for GPIOInput // ConfigGPIO.GPIOS.PoA1 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_1); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_1; } break; } #endif #ifdef USEPORTAPIN2 case PA2:{ if(!ConfigGPIO.GPIOS.PoA2){ // // Enable pin PA2 for GPIOInput // ConfigGPIO.GPIOS.PoA2 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_2); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_2; } break; } #endif #ifdef USEPORTAPIN3 case PA3:{ if(!ConfigGPIO.GPIOS.PoA3){ // // Enable pin PA3 for GPIOInput // ConfigGPIO.GPIOS.PoA3 = 1; GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_3); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_3; } break; } #endif #ifdef USEPORTAPIN4 case PA4:{ if(!ConfigGPIO.GPIOS.PoA4){ // // Enable pin PA4 for GPIOInput // ConfigGPIO.GPIOS.PoA4 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_4); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_4; } break; } #endif #ifdef USEPORTAPIN5 case PA5:{ if(!ConfigGPIO.GPIOS.PoA5){ // // Enable pin PA5 for GPIOInput // ConfigGPIO.GPIOS.PoA5 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_5); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_5; } break; } #endif #ifdef USEPORTAPIN6 case PA6:{ if(!ConfigGPIO.GPIOS.PoA6){ // // Enable pin PA6 for GPIOInput // ConfigGPIO.GPIOS.PoA6 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_6); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_6; } break; } #endif #ifdef USEPORTAPIN7 case PA7:{ if(!ConfigGPIO.GPIOS.PoA7){ // // Enable pin PA7 for GPIOInput // ConfigGPIO.GPIOS.PoA7 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_7); GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL); Mask[0] += GPIO_INT_PIN_7; } break; } #endif #endif #ifdef USEPORTB //Puerto B #ifdef USEPORTBPIN0 case PB0:{ if(!ConfigGPIO.GPIOS.PoB0){ // // Enable pin PB0 for GPIOInput // ConfigGPIO.GPIOS.PoB0 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_0); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL); Mask[1] += GPIO_INT_PIN_0; } break; } #endif #ifdef USEPORTBPIN1 case PB1:{ if(!ConfigGPIO.GPIOS.PoB1){ // // Enable pin PB1 for GPIOInput // ConfigGPIO.GPIOS.PoB1 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_1); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL); Mask[1] += GPIO_INT_PIN_0; } break; } #endif #ifdef USEPORTBPIN2 case PB2:{ if(!ConfigGPIO.GPIOS.PoB2){ // // Enable pin PB2 for GPIOInput // ConfigGPIO.GPIOS.PoB2 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL); Mask[1] += GPIO_INT_PIN_2; } break; } #endif #ifdef USEPORTBPIN3 case PB3:{ if(!ConfigGPIO.GPIOS.PoB3){ // // Enable pin PB3 for GPIOInput // ConfigGPIO.GPIOS.PoB3 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_3); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_3,GPIO_RISING_EDGE ); Mask[1] += GPIO_INT_PIN_3; } break; } #endif #ifdef USEPORTBPIN4 case PB4:{ if(!ConfigGPIO.GPIOS.PoB4){ // // Enable pin PB4 for GPIOInput // ConfigGPIO.GPIOS.PoB4 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_4); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL); Mask[1] += GPIO_INT_PIN_4; } break; } #endif #ifdef USEPORTBPIN5 case PB5:{ if(!ConfigGPIO.GPIOS.PoB5){ // // Enable pin PB5 for GPIOInput // ConfigGPIO.GPIOS.PoB5 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_5); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL); Mask[1] += GPIO_INT_PIN_5; } break; } #endif #ifdef USEPORTBPIN6 case PB6:{ if(!ConfigGPIO.GPIOS.PoB6){ // // Enable pin PB6 for GPIOInput // ConfigGPIO.GPIOS.PoB6 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_6); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL); Mask[1] += GPIO_INT_PIN_6; } break; } #endif #ifdef USEPORTBPIN7 case PB7:{ if(!ConfigGPIO.GPIOS.PoB7){ // // Enable pin PB7 for GPIOInput // ConfigGPIO.GPIOS.PoB7 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_7); GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL); Mask[1] += GPIO_INT_PIN_7; } break; } #endif #endif #ifdef USEPORTC //Puerto C #ifdef USEPORTCPIN4 case PC4:{ if(!ConfigGPIO.GPIOS.PoC4){ // // Enable pin PC4 for GPIOInput // ConfigGPIO.GPIOS.PoC4 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_4); GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL); Mask[2] += GPIO_INT_PIN_4; } break; } #endif #ifdef USEPORTCPIN5 case PC5:{ if(!ConfigGPIO.GPIOS.PoC5){ // // Enable pin PC5 for GPIOInput // ConfigGPIO.GPIOS.PoC5 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_5); GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL); Mask[2] += GPIO_INT_PIN_5; } break; } #endif #ifdef USEPORTCPIN6 case PC6:{ if(!ConfigGPIO.GPIOS.PoC6){ // // Enable pin PC6 for GPIOInput // ConfigGPIO.GPIOS.PoC6 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_6); GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL); Mask[2] += GPIO_INT_PIN_6; } break; } #endif #ifdef USEPORTCPIN7 case PC7:{ if(!ConfigGPIO.GPIOS.PoC7){ // // Enable pin PC7 for GPIOInput // ConfigGPIO.GPIOS.PoC7 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_7); GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL); Mask[2] += GPIO_INT_PIN_7; } break; } #endif #endif #ifdef USEPORTD //Puerto D #ifdef USEPORTDPIN0 case PD0:{ if(!ConfigGPIO.GPIOS.PoD0){ // // Enable pin PD0 for GPIOInput // ConfigGPIO.GPIOS.PoD0 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_0); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_0; } break; } #endif #ifdef USEPORTDPIN1 case PD1:{ if(!ConfigGPIO.GPIOS.PoD1){ // // Enable pin PD1 for GPIOInput // ConfigGPIO.GPIOS.PoD1 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_1); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_1; } break; } #endif #ifdef USEPORTDPIN2 case PD2:{ if(!ConfigGPIO.GPIOS.PoD2){ // // Enable pin PD2 for GPIOInput // ConfigGPIO.GPIOS.PoD2 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_2); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_2; } break; } #endif #ifdef USEPORTDPIN3 case PD3:{ if(!ConfigGPIO.GPIOS.PoD3){ // // Enable pin PD3 for GPIOInput // ConfigGPIO.GPIOS.PoD3 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_3); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_3; } break; } #endif #ifdef USEPORTDPIN4 case PD4:{ if(!ConfigGPIO.GPIOS.PoD4){ // // Enable pin PD4 for GPIOInput // ConfigGPIO.GPIOS.PoD4 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_4); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_4; } break; } #endif #ifdef USEPORTDPIN5 case PD5:{ if(!ConfigGPIO.GPIOS.PoD5){ // // Enable pin PD5 for GPIOInput // ConfigGPIO.GPIOS.PoD5 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_5); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_5; } break; } #endif #ifdef USEPORTDPIN6 case PD6:{ if(!ConfigGPIO.GPIOS.PoD6){ // // Enable pin PD6 for GPIOInput // ConfigGPIO.GPIOS.PoD6 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_6); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_6; } break; } #endif #ifdef USEPORTDPIN7 case PD7:{ if(!ConfigGPIO.GPIOS.PoD7){ // // Enable pin PD7 for GPIOInput // // //First open the lock and select the bits we want to modify in the GPIO commit register. // HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0x80; // //Now modify the configuration of the pins that we unlocked. // ConfigGPIO.GPIOS.PoD7 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_7); GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL); Mask[3] += GPIO_INT_PIN_7; } break; } #endif #endif #ifdef USEPORTE //Puerto E #ifdef USEPORTEPIN0 case PE0:{ if(!ConfigGPIO.GPIOS.PoE0){ // // Enable pin PE0 for GPIOInput // ConfigGPIO.GPIOS.PoE0 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0); GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL); Mask[4] += GPIO_INT_PIN_0; } break; } #endif #ifdef USEPORTEPIN1 case PE1:{ if(!ConfigGPIO.GPIOS.PoE1){ // // Enable pin PE1 for GPIOInput // ConfigGPIO.GPIOS.PoE1 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1); GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL); Mask[4] += GPIO_INT_PIN_1; } break; } #endif #ifdef USEPORTEPIN2 case PE2:{ if(!ConfigGPIO.GPIOS.PoE2){ // // Enable pin PE2 for GPIOInput // ConfigGPIO.GPIOS.PoE2 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_2); GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL); Mask[4] += GPIO_INT_PIN_2; } // break; } #endif #ifdef USEPORTEPIN3 case PE3:{ if(!ConfigGPIO.GPIOS.PoE3){ // Enable pin PE3 for GPIOInput // ConfigGPIO.GPIOS.PoE3 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_3); GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL); Mask[4] += GPIO_INT_PIN_3; } break; } #endif #ifdef USEPORTEPIN4 case PE4:{ if(!ConfigGPIO.GPIOS.PoE4){ // // Enable pin PE4 for GPIOInput // ConfigGPIO.GPIOS.PoE4 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_4); GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL); Mask[4] += GPIO_INT_PIN_4; } break; } #endif #ifdef USEPORTEPIN5 case PE5:{ if(!ConfigGPIO.GPIOS.PoE5){ // // Enable pin PE5 for GPIOInput // ConfigGPIO.GPIOS.PoE5 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_5); GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL); Mask[4] += GPIO_INT_PIN_5; } break; } #endif #endif #ifdef USEPORTF //Puerto F #ifdef USEPORTFPIN0 case PF0:{ if(!ConfigGPIO.GPIOS.PoF0){ // // Enable pin 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; HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x1; // //Now modify the configuration of the pins that we unlocked. // ConfigGPIO.GPIOS.PoF0 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL); Mask[5] += GPIO_INT_PIN_0; } break; } #endif #ifdef USEPORTFPIN1 case PF1:{ if(!ConfigGPIO.GPIOS.PoF1){ // // Enable pin PF1 for GPIOInput // ConfigGPIO.GPIOS.PoF1 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL); Mask[5] += GPIO_INT_PIN_1; } break; } #endif #ifdef USEPORTFPIN2 case PF2:{ if(!ConfigGPIO.GPIOS.PoF2){ // // Enable pin PF2 for GPIOInput // ConfigGPIO.GPIOS.PoF2 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_2); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL); Mask[5] += GPIO_INT_PIN_2; } break; } #endif #ifdef USEPORTFPIN3 case PF3:{ if(!ConfigGPIO.GPIOS.PoF3){ // // Enable pin PF3 for GPIOInput // ConfigGPIO.GPIOS.PoF3 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_3); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL); Mask[5] += GPIO_INT_PIN_3; } break; } #endif #ifdef USEPORTFPIN4 case PF4:{ if(!ConfigGPIO.GPIOS.PoF4){ // // Enable pin PF4 for GPIOInput // ConfigGPIO.GPIOS.PoF4 = 1; MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL); Mask[5] += GPIO_INT_PIN_4; } break; } #endif #endif default: break; } GPIOIntClear(GPIO_PORTA_BASE,0x0F); GPIOIntClear(GPIO_PORTB_BASE,0x0F); GPIOIntClear(GPIO_PORTC_BASE,0x0F); GPIOIntClear(GPIO_PORTD_BASE,0x0F); GPIOIntClear(GPIO_PORTE_BASE,0x0F); GPIOIntClear(GPIO_PORTF_BASE,0x0F); GPIOIntDisable(GPIO_PORTA_BASE,0x0F); GPIOIntDisable(GPIO_PORTB_BASE,0x0F); GPIOIntDisable(GPIO_PORTC_BASE,0x0F); GPIOIntDisable(GPIO_PORTD_BASE,0x0F); GPIOIntDisable(GPIO_PORTE_BASE,0x0F); GPIOIntDisable(GPIO_PORTF_BASE,0x0F); #ifdef USEPORTA //Habilitacion de las interrupciones: //Puerto A con algo configurado if(ConfigGPIO.PortGpio[0] >0){ //Primero deshabilita configura habilita //IntEnable(INT_GPIOA); GPIOIntEnable(GPIO_PORTA_BASE,Mask[0]); //GPIOPadConfigSet(GPIO_PORTA_BASE,Mask[0],GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD); GPIOIntRegister(GPIO_PORTA_BASE,TOFProcess); //GPIOIntTypeSet(GPIO_PORTA_BASE,Mask[0],GPIO_RISING_EDGE); } #endif #ifdef USEPORTB //Puerto B con algo configurado if(ConfigGPIO.PortGpio[1] >0){ // GPIOIntTypeSet(GPIO_PORTB_BASE,Mask[1],GPIO_PIN_TYPE_STD_WPD); GPIOIntRegister(GPIO_PORTB_BASE,TOFProcess); GPIOIntEnable(GPIO_PORTB_BASE,Mask[1]); } #endif #ifdef USEPORTC //Puerto C con algo configurado if(ConfigGPIO.PortGpio[2] >0){ GPIOIntEnable(GPIO_PORTC_BASE,Mask[2]); GPIOIntRegister(GPIO_PORTC_BASE,TOFProcess); } #endif #ifdef USEPORTD //Puerto D con algo configurado if(ConfigGPIO.PortGpio[3] >0){ GPIOIntEnable(GPIO_PORTD_BASE,Mask[3]); GPIOIntRegister(GPIO_PORTD_BASE,TOFProcess); } #endif #ifdef USEPORTE //Puerto E con algo configurado if(ConfigGPIO.PortGpio[4] >0){ GPIOIntEnable(GPIO_PORTE_BASE,Mask[4]); GPIOIntRegister(GPIO_PORTE_BASE,TOFProcess); } #endif #ifdef USEPORTF //Puerto F con algo configurado if(ConfigGPIO.PortGpio[5] >0){ GPIOIntEnable(GPIO_PORTF_BASE,Mask[5]); GPIOIntRegister(GPIO_PORTF_BASE,TOFProcess); } #endif // IntMasterEnable(); }
void InitClocksGPIOAndTimer() { uint32_t ui32PWMClock; // // 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. // ROM_FPULazyStackingEnable(); // // Set the clocking to run directly from the crystal. // ROM_SysCtlClockSet( SYSCTL_SYSDIV_40 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); ROM_SysCtlPWMClockSet(SYSCTL_PWMDIV_1); // PWM Setup SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); GPIOPinConfigure(GPIO_PC4_M0PWM6); GPIOPinTypePWM(GPIO_PORTC_BASE, GPIO_PIN_4); GPIOPinConfigure(GPIO_PC5_M0PWM7); GPIOPinTypePWM(GPIO_PORTC_BASE, GPIO_PIN_5); ui32PWMClock = SysCtlClockGet(); ui32Load = (ui32PWMClock / PWM_FREQUENCY) - 1; PWMGenConfigure(PWM0_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC); PWMGenPeriodSet(PWM0_BASE, PWM_GEN_3, ui32Load); PWMPulseWidthSet(PWM0_BASE, PWM_OUT_6, PWM_LOW); PWMPulseWidthSet(PWM0_BASE, PWM_OUT_7, PWM_LOW); // Started as not active PWMOutputState(PWM0_BASE, PWM_OUT_6_BIT, false); PWMOutputState(PWM0_BASE, PWM_OUT_7_BIT, false); PWMGenEnable(PWM0_BASE, PWM_GEN_3); // PWM Setup for IR LED SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIOPinConfigure(GPIO_PB6_M0PWM0); GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_6); PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC); PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, 1050/8); PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, 525/8); PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, false); PWMGenEnable(PWM0_BASE, PWM_GEN_0); // // Enable peripheral and register interrupt handler // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOIntRegister(GPIO_PORTA_BASE, GPIOMotionDetectorIsr); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); GPIOIntRegister(GPIO_PORTE_BASE, GPIOLightSwitchIsr); #ifdef RUN_AS_MASTER GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_5); GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_5, GPIO_BOTH_EDGES); #else GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_2); GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE); #endif GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_4); GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_4, GPIO_RISING_EDGE); // // Enable the pin interrupts. // GPIOIntEnable(GPIO_PORTA_BASE, GPIO_INT_PIN_2 | GPIO_INT_PIN_5); GPIOIntEnable(GPIO_PORTE_BASE, GPIO_INT_PIN_4); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); TimerConfigure(TIMER0_BASE, TIMER_CFG_A_ONE_SHOT); TimerConfigure(TIMER1_BASE, TIMER_CFG_A_ONE_SHOT); TimerIntRegister(TIMER0_BASE, TIMER_A, IRTimerIsr); TimerIntRegister(TIMER1_BASE, TIMER_A, IdleTimerIsr); ulPeriod = (SysCtlClockGet()); // once per second TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod); TimerLoadSet(TIMER1_BASE, TIMER_A, ulPeriod * LIGHTS_ON_PERIOD_SEC); TimerLoadSet(TIMER1_BASE, TIMER_B, ulPeriod * 3); IntEnable(INT_TIMER0A); IntEnable(INT_TIMER1A); TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT); // // Enable the GPIO port that is used for the on-board LED. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // // Enable the GPIO pin for blue LED component (PF2). // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); g_ulCountsPerMicrosecond = ROM_SysCtlClockGet() / 1000000; // 10ms = timeout delay g_ulIRPeriod = g_ulCountsPerMicrosecond * IR_TIMEOUT_VAL; }