// ***************************************************************************** void initYaw (void) { // Register the handler for Port F into the vector table GPIOPortIntRegister (GPIO_PORTF_BASE, YawChangeIntHandler); // Enable and configure the port and pin used: input on PF5: Pin 27 & PF7: Pin 29 SysCtlPeripheralEnable (SYSCTL_PERIPH_GPIOF); GPIOPadConfigSet (GPIO_PORTF_BASE, GPIO_PIN_5 | GPIO_PIN_7, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // Set up the pin change interrupt (both edges) GPIOIntTypeSet (GPIO_PORTF_BASE, GPIO_PIN_5 | GPIO_PIN_7, GPIO_BOTH_EDGES); // Enable the pin change interrupt GPIOPinIntEnable (GPIO_PORTF_BASE, GPIO_PIN_5 | GPIO_PIN_7); IntEnable (INT_GPIOF); // Note: INT_GPIOF defined in inc/hw_ints.h //Registering Port D into the vector Table (Refwewnce point) GPIOPortIntRegister (GPIO_PORTD_BASE, referencePosIntHandler); GPIOPadConfigSet (GPIO_PORTD_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // // Set up the pin change interrupt (both edges) GPIOIntTypeSet (GPIO_PORTD_BASE, GPIO_PIN_0, GPIO_BOTH_EDGES); // // Enable the pin change interrupt for PD0 GPIOPinIntEnable (GPIO_PORTD_BASE, GPIO_PIN_0); }
void vs_init(void) { DEBUGOUT("VS: init\n"); vs_playing = 0; //reset vs buffer vs_bufreset(); //reset vs vs_reset(); //set volume, bass, treble vs_setvolume(DEFAULT_VOLUME); vs_setbassfreq(DEFAULT_BASSFREQ); vs_setbassamp(DEFAULT_BASSAMP); vs_settreblefreq(DEFAULT_TREBLEFREQ); vs_settrebleamp(DEFAULT_TREBLEAMP); //init pin interrupt GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_1, GPIO_HIGH_LEVEL); GPIOPortIntRegister(GPIO_PORTA_BASE, vs_requesthandler); return; }
/** * Configures the used button as input source * Registers gpio_c interrupt.. */ void button_init(){ GPIOPinTypeGPIOInput(BSP_BUTTON_BASE, BSP_USER_BUTTON); GPIOIntTypeSet(BSP_BUTTON_BASE,BSP_USER_BUTTON,GPIO_FALLING_EDGE); GPIOPortIntRegister(BSP_BUTTON_BASE,GPIO_C_Isr_Handler); GPIOPinIntClear(BSP_BUTTON_BASE, BSP_USER_BUTTON); GPIOPinIntEnable(BSP_BUTTON_BASE, BSP_USER_BUTTON); }
//Configures interrupt pin supported by ADS7843 controller static void touchIntPinInit() { ADS7843_PORT_INT_CLOCK(); ADS7843_INT_INPUT(); ADS7843_INT_CONFIG_AS_FALLING(); GPIOPortIntRegister(ADS7843_PORT_INT, TouchScreenIntHandler); ENABLE_ALL_INTERRUPTS(); touchIntPinInterruptEnable(true); }
static void RF22_IntPinInit() { RFM_22_PORT_INT_CLOCK(); RFM_22_INT_INPUT(); GPIOPortIntRegister(RFM_22_PORT_INT, RF22_PinIntHandler); RFM_22_INT_CONFIG_AS_FALLING(); RFM_22_INT_INTERRUPT_ENABLE(); ENABLE_ALL_INTERRUPTS(); }
void InitGPIO (void) { // GPIO test initialisation SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0 | SYSCTL_PERIPH_PWM); SysCtlPWMClockSet(SYSCTL_PWMDIV_1); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // airspeed output SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // transponder output SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); // airspeed response pin SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // transponder response pin // Configure airspeed input GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, UUT_AIRSPEED_RESPONSE_PIN_PE3); GPIOIntTypeSet(GPIO_PORTE_BASE, UUT_AIRSPEED_RESPONSE_PIN_PE3, GPIO_RISING_EDGE); GPIOPortIntRegister(GPIO_PORTE_BASE, &airspeed_response_isr); // Configure transponder input GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, UUT_TRANSPONDER_RESPONSE_PIN_PB3); GPIOIntTypeSet(GPIO_PORTB_BASE, UUT_TRANSPONDER_RESPONSE_PIN_PB3, GPIO_RISING_EDGE); GPIOPortIntRegister(GPIO_PORTB_BASE, &transponder_response_isr); // Configure airspeed pulse generation GPIOPinTypePWM(GPIO_PORTD_BASE, (1<<1)); // Airspeed output TODO: make pin macro PWMGenDisable(PWM0_BASE, PWM_GEN_0); PWMIntDisable(PWM0_BASE, PWM_GEN_0); PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN); PWMGenIntTrigEnable(PWM0_BASE, PWM_GEN_0, PWM_INT_CNT_LOAD); // configure pwm for end-of-cycle interrupt PWMGenIntRegister(PWM0_BASE, PWM_GEN_0, airspeed_pulse_isr); // Configure transponder pulse generation GPIOPinTypePWM(GPIO_PORTF_BASE, (1<<3)); // Transponder output TODO: make pin macro PWMGenDisable(PWM0_BASE, PWM_GEN_2); PWMIntDisable(PWM0_BASE, PWM_GEN_2); PWMGenConfigure(PWM0_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN); PWMGenIntTrigEnable(PWM0_BASE, PWM_GEN_2, PWM_INT_CNT_LOAD); // configure pwm for end-of-cycle interrupt PWMGenIntRegister(PWM0_BASE, PWM_GEN_2, transponder_pulse_isr); // Configure UUT reset signal SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_4); GPIOPinWrite(GPIO_PORTG_BASE, GPIO_PIN_4, GPIO_PIN_4); }
int main(void) { //set clock SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); //PB1 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIOPadConfigSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_STRENGTH_4MA,GPIO_PIN_TYPE_STD); GPIODirModeSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_DIR_MODE_IN); GPIOPortIntRegister(GPIO_PORTB_BASE, PortBIntHandler); GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_1, GPIO_BOTH_EDGES); GPIOPinIntEnable(GPIO_PORTB_BASE, GPIO_PIN_1); // Status SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_STRENGTH_4MA,GPIO_PIN_TYPE_STD); GPIODirModeSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_DIR_MODE_OUT); //UART SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); IntEnable(INT_UART0); UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); IntPrioritySet(INT_UART0, 0x7F); IntPrioritySet(INT_GPIOB,0x80); IntMasterEnable(); SysTickIntRegister(SysTickHandler); SysTickPeriodSet(SysCtlClockGet()/10000); // 0.1ms SysTickIntEnable(); waitTime = 0; // initialize waitTime2 = 0; SysTickEnable(); while(1) { } }
/*********************************************************************************** * @fn halRfRxInterruptConfig * * @brief Enable RX interrupt. * * @param none * * @return none */ void halRfRxInterruptConfig(ISR_FUNC_PTR pfISR) { // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_1); /* Default pin is Push-pull.*/ GPIOPadConfigSet(GPIO_PORTD_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD); GPIOIntTypeSet(GPIO_PORTD_BASE, GPIO_PIN_0, GPIO_RISING_EDGE); /* Rising edge is active.*/ GPIOPortIntRegister(GPIO_PORTD_BASE, pfISR); GPIOPinIntEnable(GPIO_PORTD_BASE, GPIO_PIN_0); CLEAR_EXC_RX_FRM_DONE(); /* And clear the exception.*/ }
void intButton (void) { SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // Register the handler for Port B into the vector table GPIOPortIntRegister (GPIO_PORTB_BASE, ButtPressIntHandler); //Initialising for buttons GPIOPinTypeGPIOInput (GPIO_PORTB_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6); GPIOPadConfigSet (GPIO_PORTB_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet (GPIO_PORTB_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6, GPIO_FALLING_EDGE); GPIOPinIntEnable (GPIO_PORTB_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6); }
// ******************************************************* // Initializes all five buttons and enables the respective ISR. void ButtonInit (void) { unsigned char ucPin = UP_B | DOWN_B | LEFT_B | RIGHT_B | SELECT_B; short i = 0; for (i = UP; i <= SELECT; i++) { button_t* button = &buttonPointer[i]; // Set the button_t values button->iState = BUT_OUT; // enable button //button->uiCntIn = 0; //button->uiCntOut = 0; button->ucPin = i; } //Enable GPIO module for decoder SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIO_B); // setup input pins GPIODirModeSet(PORT_BASE_B, ucPin, GPIO_DIR_MODE_IN); // disable internal pullups on decoder pins //GPIOPadConfigSet(PORT_BASE_B, ucPin, // GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); GPIOPinTypeGPIOInput(PORT_BASE_B, ucPin); #ifdef REAL_BUTTONS_ // want this if you're using the real buttons GPIOPadConfigSet(PORT_BASE_B, ucPin, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); #endif /* */ //GPIOIntTypeSet(PORT_BASE_B, ucPin, GPIO_RISING_EDGE); //GPIOIntTypeSet(GPIO_PORTG_BASE, PIN_2, GPIO_BOTH_EDGES); GPIOIntTypeSet(PORT_BASE_B, ucPin , GPIO_FALLING_EDGE); //GPIOIntTypeSet(GPIO_PORTF_BASE, PIN_1 | PIN_2 , GPIO_BOTH_EDGES); GPIOPortIntRegister(PORT_BASE_B, buttonISR); //IntPrioritySet( INT_GPIO_B , 0); GPIOPinIntEnable(PORT_BASE_B, ucPin); //GPIOPinIntEnable(GPIO_PORTF_BASE, PIN_2); }
int main(void) { /* Set the clocking to directly run from the crystal at 8MHz */ SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); /* Set the clock for the GPIO Port C and E */ SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); /* Set the type of the GPIO Pin */ GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7); GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0); /*Configure GPIO pad with internal pull-up enabled*/ GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); /* GPIO Pins 5, 6, 7 on PORT C initialized to 1 * All LEDs off. * */ GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7); /*Register Interrupt to call Interrupt Handler*/ GPIOPortIntRegister(GPIO_PORTE_BASE, Pin_Int); /*Clear interrupt register*/ GPIOPinIntClear(GPIO_PORTE_BASE, GPIO_PIN_0); /*Set interrupt triggering sequence*/ GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE); /*Enable interrupts on selected pin*/ GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_0); /*Enable interrupts on selected port*/ IntEnable(INT_GPIOE); /*Enable global interrupts*/ IntMasterEnable(); while(1) { } }
void protocol_init() { char_counter = 0; // Reset line input iscomment = false; report_init_message(); // Welcome message #ifdef PART_LM4F120H5QR // code for ARM SysCtlPeripheralEnable( PINOUT_PERIPH ); ///Enable the GPIO module for PINOUT port SysCtlDelay(26); ///give time delay 1 microsecond for GPIO module to start GPIOPinTypeGPIOInput( PINOUT_PORT, PINOUT_MASK ); // Set as input pins GPIOPadConfigSet( PINOUT_PORT, PINOUT_MASK, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); //Enable weak pull-ups GPIOPortIntRegister( PINOUT_PORT, pinout_interrupt ); //register a call-back funcion for interrupt GPIOIntTypeSet( PINOUT_PORT, PINOUT_MASK, GPIO_BOTH_EDGES ); // Enable specific pins of the Pin Change Interrupt GPIOPinIntEnable( PINOUT_PORT, PINOUT_MASK ); // Enable Pin Change Interrupt #else // code for AVR PINOUT_DDR &= ~(PINOUT_MASK); // Set as input pins PINOUT_PORT |= PINOUT_MASK; // Enable internal pull-up resistors. Normal high operation. PINOUT_PCMSK |= PINOUT_MASK; // Enable specific pins of the Pin Change Interrupt PCICR |= (1 << PINOUT_INT); // Enable Pin Change Interrupt #endif }
/* * prepares interrupt and pin for use with * the ping device * * peripheral - peripheral address * portBase - port base address * pin - pin mask for port * sampleHandler - callback to be called when sample is ready * * returns -1 if failed. this indicates there are no more slots left * returns a positive number which is the ID to be passed in to * the ping_sample function to get one sample */ INT ping_port_register(ULONG peripheral, ULONG portBase, ULONG pin, void (*sampleHandler)(ULONG)) { int status = StartCritical(); int i; if(pingHandlersCount == MAX_PING_HANDLERS) { EndCritical(status); return -1; } pingHandlersCount++; for(i=0;i<MAX_PING_HANDLERS;i++) { if(availableHandlers[i]) { availableHandlers[i] = 0; break; } } pingConfigs[i].peripheral = peripheral; pingConfigs[i].portBase = portBase; pingConfigs[i].pin = pin; pingConfigs[i].sampleHandler = sampleHandler; SysCtlPeripheralEnable(peripheral); GPIOPortIntRegister(portBase, pingInterruptHandlers[i]); GPIOIntTypeSet(portBase, pin, GPIO_BOTH_EDGES); EndCritical(status); return i; }
int main(void) { long dir; unsigned long vel, pos; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Set up low level I/O for printf() // llio_init(115200); // // Set up GPIO for LED // LED_INIT(); // // Set up QEI peripheral // SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); GPIOPinTypeQEI(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_6); QEIConfigure(QEI0_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_NO_RESET | QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP), 0xffffffff); QEIVelocityConfigure(QEI0_BASE, QEI_VELDIV_1, SysCtlClockGet() / 10); QEIEnable(QEI0_BASE); QEIVelocityEnable(QEI0_BASE); // // Set up GPIO for encoder push switch // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_5); GPIOPadConfigSet(GPIO_PORTC_BASE, GPIO_PIN_5, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(GPIO_PORTC_BASE, GPIO_PIN_5, GPIO_FALLING_EDGE); GPIOPortIntRegister(GPIO_PORTC_BASE, SW_IntHandler); GPIOPinIntEnable(GPIO_PORTC_BASE, GPIO_PIN_5); // // Set up the period for the SysTick timer. // SysTickPeriodSet(SysCtlClockGet() / 10); // 10Hz SysTick timer // // Enable the SysTick Interrupt. // SysTickIntEnable(); SysTickIntRegister(SysTickIntHandler); // // Enable SysTick. // SysTickEnable(); printf("\r\nEncoder example\r\n"); // // Loop forever. // while(1) { SysCtlSleep(); // sleep here till interrupt LED_TOGGLE(); dir = QEIDirectionGet(QEI0_BASE); vel = QEIVelocityGet(QEI0_BASE); pos = QEIPositionGet(QEI0_BASE); printf("%d,%d,%d\r\n", dir, vel, pos); } }
//***************************************************************************** // // Main Program // //***************************************************************************** int main(void) { unsigned long ulPeriod; // Set the clocking to run directly from the crystal. SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // Initialize the OLED display and write status. RIT128x96x4Init(1000000); // Enable the peripherals used by this application SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); // Set GPIO F0 and G1 as PWM pins. They are used to output the PWM0 and // PWM1 signals. GPIOPinTypePWM(GPIO_PORTG_BASE, GPIO_PIN_1); // Compute the PWM period based on the system clock. ulPeriod = SysCtlClockGet() / 440; // Set the PWM period to 440 (A) Hz. PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC); PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod); // Set PWM0 to a duty cycle of 25% and PWM1 to a duty cycle of 75%. PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, ulPeriod / 4); PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ulPeriod * 3 / 4); // Enable the PWM0 and PWM1 output signals. PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true); // Configure the 'up' button as input and enable the pin to interrupt on // the falling edge (i.e. when the push button is pressed). GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0); GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // Configure the 'down' button as input and enable the pin to interrupt on // the falling edge (i.e. when the push button is pressed). GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1); GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // Configure the 'left' button as input and enable the pin to interrupt on // the falling edge (i.e. when the push button is pressed). GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_2); GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // Configure the 'right' button as input and enable the pin to interrupt on // the falling edge (i.e. when the push button is pressed). GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_3); GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3, GPIO_FALLING_EDGE); GPIOPortIntRegister(GPIO_PORTE_BASE, GPIOEIntHandler); GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3); IntEnable(INT_GPIOE); // Configure the LED GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); // Configure the select buttons as input and enable the pin to interrupt on // the falling edge (i.e. when the push button is pressed). 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_FALLING_EDGE); GPIOPortIntRegister(GPIO_PORTF_BASE, GPIOFIntHandler); GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_1); IntEnable(INT_GPIOF); // Initial time to display static char pcInitTime[10]; usprintf(pcInitTime, "%d%d:%d%d AM", h2, h1, m2, m1); // Set the time between SysTick interrupts and register the interrupt handle SysTickPeriodSet(SysCtlClockGet()); SysTickIntRegister(SysTickIntHandler); // Begin a blinking display of the initial start message while (!start){ int a; for (a=0; a<300000; a++){ if (a%20000==0){ RIT128x96x4StringDraw(pcInitTime, 40, 40, a/20000); } } } // The clock has started so we can clear the message RIT128x96x4Clear(); // Loop forever while(1) { // Display the updated time DisplayTime(); // Check if we should sound the alarm TisA(); } }
void joystick_init(void) { // Register Joystick button isr GPIOPinTypeGPIOInput(JOY_PORT, JOY_MASK); GPIOPadConfigSet(JOY_PORT, JOY_MASK, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(JOY_PORT, JOY_MASK, GPIO_BOTH_EDGES); GPIOPortIntRegister(JOY_PORT, button_handler); GPIOPinIntEnable(JOY_PORT, JOY_MASK); // // The ADC0 peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); // // Select the analog ADC function for these pins. // GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0); GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_3); // Use sequences 0 and 1 for x and y. ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0); ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0); // Single ended sample on CH3 (X) and CH4 (Y). ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH3 | ADC_CTL_IE | ADC_CTL_END); ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_CH4 | ADC_CTL_IE | ADC_CTL_END); // Enable the sequences. ADCSequenceEnable(ADC0_BASE, 0); ADCSequenceEnable(ADC0_BASE, 1); // Register ISRs. ADCIntRegister(ADC0_BASE, 0, x_handler); ADCIntRegister(ADC0_BASE, 1, y_handler); ADCIntEnable(ADC0_BASE, 0); ADCIntEnable(ADC0_BASE, 1); // Trigger the first conversion (auto-center) ADCProcessorTrigger(ADC0_BASE, 0); ADCProcessorTrigger(ADC0_BASE, 1); // Configure timer SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER3); TimerConfigure(JOY_TIMER, TIMER_CFG_PERIODIC); // //Register Jog Z buttons // GPIOPinTypeGPIOInput(JOG_Z_PORT, JOG_Z_MASK); // GPIOIntTypeSet(JOG_Z_PORT, JOG_Z_MASK, GPIO_BOTH_EDGES); // GPIOPortIntRegister(JOG_Z_PORT, jog_z_handler); // GPIOPinIntEnable(JOG_Z_PORT, JOG_Z_MASK); // GPIOPadConfigSet(JOG_Z_PORT,JOG_Z_MASK,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD); // Create a 10ms timer callback TimerLoadSet64(JOY_TIMER, SysCtlClockGet() / 500); TimerIntRegister(JOY_TIMER, TIMER_A, joystick_isr); TimerIntEnable(JOY_TIMER, TIMER_TIMA_TIMEOUT); IntPrioritySet(INT_TIMER3A, CONFIG_JOY_PRIORITY); TimerEnable(JOY_TIMER, TIMER_A); }
/********************************************************************************************** * Main *********************************************************************************************/ void main(void) { //After tomorrow's test flight. FOR THE LOVE OF GOD MOVE THESE INITALIZATIONS TO FUNCTIONS /********************************************************************************************** * Local Variables *********************************************************************************************/ unsigned long ultrasonic = 0; // 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. FPULazyStackingEnable(); //Set the clock speed to 80MHz aka max speed SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); /*unsigned long test[2]; test[0] = 180; test[1] = 10; short bob[1]; bob[0] = ((char)test[0]<<8)|(char)test[1]; float jimmy = (short)(((char)test[0]<<8)|(char)test[1]); jimmy /= 26;*/ /********************************************************************************************** * Peripheral Initialization Awake *********************************************************************************************/ SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Turn on GPIO communication on F pins for switches SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //Turn on GPIO for ADC SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //Turn on GPIO for the PWM comms SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //Turn on GPIO for LED test SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); //Turn on GPIO for UART SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); //Turn on Timer for PWM SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); //Turn on Timer for PWM SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2); //Turn on Timer for PWM SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER3); //Turn on Timer for PWM SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C1); //Turn on I2C communication I2C slot 0 SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2); //Turn on the UART com SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG); //Turn on the watchdog timer. This is a risky idea but I think it's for the best. /********************************************************************************************** * Peripheral Initialization Sleep *********************************************************************************************/ /*SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF); //This sets what peripherals are still enabled in sleep mode while UART would be nice, it would require the clock operate at full speed which is :P SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOB); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER0); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER1); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER2); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_TIMER3); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_SSI0); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_I2C1); SysCtlPeripheralSleepDisable(SYSCTL_PERIPH_ADC); SysCtlPeripheralClockGating(true); //I'm not sure about this one maybe remove it */ /********************************************************************************************** * PWM Initialization *********************************************************************************************/ SysCtlDelay((SysCtlClockGet() / (1000 * 3))*100); //This shouldn't be needed will test to remove //PWM pin Setup //PWM 0 on GPIO PB6, PWM 1 on pin 4... etc GPIOPinConfigure(GPIO_PB6_T0CCP0); //Pitch - yaw + GPIOPinConfigure(GPIO_PB4_T1CCP0); //Pitch + yaw + GPIOPinConfigure(GPIO_PB0_T2CCP0); //Roll - yaw - GPIOPinConfigure(GPIO_PB2_T3CCP0); //Roll + yaw - GPIOPinTypeTimer(GPIO_PORTB_BASE, (GPIO_PIN_6|GPIO_PIN_4|GPIO_PIN_0|GPIO_PIN_2)); //Prescale the timers so they are slow enough to work with the ESC TimerPrescaleSet(TIMER0_BASE,TIMER_A,2); TimerPrescaleSet(TIMER1_BASE,TIMER_A,2); TimerPrescaleSet(TIMER2_BASE,TIMER_A,2); TimerPrescaleSet(TIMER3_BASE,TIMER_A,2); //Basic LED Out Test Not sure why this is here look into This just turns on an LED that I don't have plugged in. should remove later GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_3); GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_3,0xFF); //GPIOPinTypeGPIOOutputOD(GPIO_PORTB_BASE,GPIO_PIN_0); //Timers Setup for PWM and the load for the countdown TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM); TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod -1); TimerConfigure(TIMER1_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM); TimerLoadSet(TIMER1_BASE, TIMER_A, ulPeriod -1); TimerConfigure(TIMER2_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM); TimerLoadSet(TIMER2_BASE, TIMER_A, (ulPeriod -1)); TimerConfigure(TIMER3_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM); TimerLoadSet(TIMER3_BASE, TIMER_A, ulPeriod -1); //TimerPrescaleSet(TIMER2_BASE, TIMER_A, extender1); //TimerLoadSet(TIMER2_BASE, TIMER_A, period1); //Set the match which is when the thing will pull high TimerMatchSet(TIMER0_BASE, TIMER_A, 254); //Duty cycle = (1-%desired)*1000 note this means this number is percent low not percent high TimerMatchSet(TIMER1_BASE, TIMER_A, 254); TimerMatchSet(TIMER2_BASE, TIMER_A, 254); TimerMatchSet(TIMER3_BASE, TIMER_A, 254); //TimerPrescaleMatchSet(TIMER2_BASE, TIMER_A, extender2); //TimerMatchSet(TIMER2_BASE, TIMER_A, period2); //Enable the timers TimerEnable(TIMER0_BASE, TIMER_A); TimerEnable(TIMER1_BASE, TIMER_A); TimerEnable(TIMER2_BASE, TIMER_A); TimerEnable(TIMER3_BASE, TIMER_A); /********************************************************************************************** * onboard Chip interrupt Initialization *********************************************************************************************/ //These two buttons are used to reset the bluetooth module in case of disconnection GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); //RGB LED's GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x00); HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD; //Sw1 (PF4) is unaviable unless you make it only a GPIOF input via these commands HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x1; GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4); //Onboard buttons (PF0=Sw2,PF4=Sw1 GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0|GPIO_PIN_4, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); //This will make the buttons falling edge (a press pulls them low) //void (*functionPtr)(void) = &onBoardInteruptHandle; GPIOPortIntRegister(GPIO_PORTF_BASE, onBoardInteruptHandle); //set function to handle interupt GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4,GPIO_FALLING_EDGE); //Set the interrupt as falling edge GPIOPinIntEnable(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4); //Enable the interrupt //IntMasterEnable(); IntEnable(INT_GPIOF); /********************************************************************************************** * UART Initialization *********************************************************************************************/ //Unlock PD7 HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD; HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0x80; GPIOPinConfigure(GPIO_PD7_U2TX); //Set PD7 as TX GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_7); GPIOPinConfigure(GPIO_PD6_U2RX); //Set PD6 as RX GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6); UARTConfigSetExpClk(UART2_BASE,SysCtlClockGet(),115200,UART_CONFIG_WLEN_8|UART_CONFIG_STOP_ONE|UART_CONFIG_PAR_NONE); //I believe the Xbee defaults to no parity I do know it's 9600 baud though, changed to 115200 for bluetooth reasons UARTFIFOLevelSet(UART2_BASE,UART_FIFO_TX1_8,UART_FIFO_RX1_8); //Set's how big the fifo needs to be in order to call the interrupt handler, 2byte UARTIntRegister(UART2_BASE,Uart2IntHandler); //Regiester the interrupt handler UARTIntClear(UART2_BASE, UART_INT_TX | UART_INT_RX); //Clear the interrupt UARTIntEnable(UART2_BASE, UART_INT_TX | UART_INT_RX); //Enable the interrupt to trigger on both TX and RX event's. Could possibly remove TX UARTEnable(UART2_BASE); //Enable UART IntEnable(INT_UART2); //Second way to enable handler not sure if needed using anyway /********************************************************************************************** * I2C Initialization *********************************************************************************************/ //Serious credit to the man who made the Arduino version of this. he gave me addresses and equations. Sadly Arduino obfuscates what really is happening //Link posted on blog page //gyro address = 0x68 not 0x69 GPIOPinConfigure(GPIO_PA7_I2C1SDA); GPIOPinTypeI2C(GPIO_PORTA_BASE, GPIO_PIN_7); //Set GPA7 as SDA GPIOPinConfigure(GPIO_PA6_I2C1SCL); GPIOPinTypeI2CSCL(GPIO_PORTA_BASE, GPIO_PIN_6); //Set GPA6 as SCL I2CMasterInitExpClk(I2C1_MASTER_BASE,SysCtlClockGet(),false); //I think it operates at 100kbps I2CMasterEnable(I2C1_MASTER_BASE); //Initalize the accelerometer Address = 0x53 GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x02); UARTSend(0xAB); I2CTransmit(0x53,0x2D,0x00); I2CTransmit(0x53,0x2D,0x10); I2CTransmit(0x53,0x2D,0x08); //Initalize the gyroscope Address = 0x68 I2CTransmit(0x68,0x3E,0x00); I2CTransmit(0x68,0x15,0x07); I2CTransmit(0x68,0x16,0x1E); I2CTransmit(0x68,0x17,0x00); UARTSend(0xAC); /********************************************************************************************** * SysTick Initialization *********************************************************************************************/ SysTickIntRegister(SysTickIntHandler); SysTickIntEnable(); SysTickPeriodSet((SysCtlClockGet() / (1000 * 3))*timeBetweenCalculations); //This sets the period for the delay. the last num is the num of milliseconds SysTickEnable(); /********************************************************************************************** * Watchdog Initialization *********************************************************************************************/ WatchdogReloadSet(WATCHDOG_BASE, 0xFEEFEEFF); //Set the timer for a reset WatchdogIntRegister(WATCHDOG_BASE,WatchdogIntHandler); //Enable interrupt WatchdogIntClear(WATCHDOG_BASE); WatchdogIntEnable(WATCHDOG_BASE); WatchdogEnable(WATCHDOG_BASE); //Enable the actual timer IntEnable(INT_WATCHDOG); /********************************************************************************************** * Preflight motor inialization maybe not necessary not going to test *********************************************************************************************/ PWMSet(TIMER0_BASE,998); PWMSet(TIMER1_BASE,998); PWMSet(TIMER2_BASE,998); PWMSet(TIMER3_BASE,998); recievedCommands[0]=253; SysCtlDelay((SysCtlClockGet() / (1000 * 3))*100); //Very important to ensure motor see's a start high (998 makes 0 sense but it works so shhhh don't tell anyone) GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x06); while(1){ WatchdogReloadSet(WATCHDOG_BASE, 0xFEEFEEFF); //Feed the dog a new time //UARTSend(recievedCommands[0]); //SysCtlDelay(50000); //Set 4 PWM Outputs //Get Acc data I2CRead(0x53,0x32,6,quadAcc); //Address blah blah 2 for each axis rawAccToG(quadAcc,RwAcc); /*GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x04); //Blue //Get Gyro data /************************************** Gyro ITG-3200 I2C registers: temp MSB = 1B, temp LSB = 1C x axis MSB = 1D, x axis LSB = 1E y axis MSB = 1F, y axis LSB = 20 z axis MSB = 21, z axis LSB = 22 *************************************/ I2CRead(0x68,0x1B,8,quadGyro); //Address blah blah 2 for each axis + 2 for temperature. why. because why not rawGyroToDegsec(quadGyro,Gyro_ds); //GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x02); //Red //Get the actual angles in XYZ. Store them in RwEst //getInclination(RwAcc, RwEst, RwGyro, Gyro_ds, Awz); //After this function is called RwEst will hold the roll pitch and yaw //RwEst will be returned in PITCH, ROLL, YAW 0, 1, 2 remember this order very important. Little obvious but yaw is worthless /*if(RwEst[1]>0.5){ GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x06); //Red Blue, Correct data read in }else{ GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x0A); //Red Green, The correct data is not there }*/ /*GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x06); //Red Blue, Correct data read in float test=RwAcc[0]*100; //These two commands work char temp = (char)test; //UARTSend((char)(RwAcc[0])*100); //This one does not UARTSend(temp); //UARTSend((char)(RwAcc[1])*100); UARTSend(0xAA); SysCtlDelay((SysCtlClockGet() / (1000 * 3))*1); */ } }
void Startup(void) { //STEP 1: OLED and PWM setup unsigned long ulPeriod; //SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); SysCtlPWMClockSet(SYSCTL_PWMDIV_1); SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); GPIOPinTypePWM(GPIO_PORTG_BASE, GPIO_PIN_1); ulPeriod = SysCtlClockGet() / 400; PWMGenConfigure(PWM0_BASE, PWM_GEN_0,PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC); PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod); PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ulPeriod / 16); PWMGenEnable(PWM0_BASE, PWM_GEN_0); //STEP 2: Timer setup //SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); /*TimerState = 0; TimerIntUnregister(TIMER1_BASE, TIMER_A); TimerIntRegister(TIMER1_BASE, TIMER_A, IntTimer0); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC); TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet()); IntEnable(INT_TIMER1A); TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT); TimerEnable(TIMER1_BASE, TIMER_A);*/ // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); //STEP 3: Button pad setup TrainState = 0; GPIOPortIntUnregister(GPIO_PORTE_BASE); GPIOPortIntRegister(GPIO_PORTE_BASE,IntGPIOe); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 ); GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 , GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 , GPIO_FALLING_EDGE); GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 ); IntEnable(INT_GPIOE); IntPrioritySet( INT_GPIOE, configKERNEL_INTERRUPT_PRIORITY); //STEP 4: Frequency count setup tempCount = 0; frequencyCount = 0; SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_3); GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); GPIOPortIntUnregister(GPIO_PORTF_BASE); GPIOPortIntRegister(GPIO_PORTF_BASE,IntGPIOf); GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_RISING_EDGE); GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_3); IntEnable(INT_GPIOF); //STEP 5: UART setup SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); IntEnable(INT_UART0); UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); IntPrioritySet( INT_UART0, configKERNEL_INTERRUPT_PRIORITY); //STEP 6: pin setup /*SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, PORT_DATA);*/ //STEP 7: ADC SETUP SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); ADCSequenceDisable(ADC0_BASE,0); ADCSequenceDisable(ADC0_BASE,1); ADCSequenceDisable(ADC0_BASE,2); ADCSequenceDisable(ADC0_BASE,3); GPIOPinTypeADC(ADC0_BASE, 0xF); ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0); ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0); ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0); ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0); ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END); ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END); ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END); ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END); ADCSequenceEnable(ADC0_BASE, 0); ADCSequenceEnable(ADC0_BASE, 1); ADCSequenceEnable(ADC0_BASE, 2); ADCSequenceEnable(ADC0_BASE, 3); ADCIntClear(ADC0_BASE, 0); ADCIntClear(ADC0_BASE, 1); ADCIntClear(ADC0_BASE, 2); ADCIntClear(ADC0_BASE, 3); ADCIntEnable(ADC0_BASE, 0); ADCIntEnable(ADC0_BASE, 1); ADCIntEnable(ADC0_BASE, 2); ADCIntEnable(ADC0_BASE, 3); //IntEnable(INT_ADC0); //IntPrioritySet(INT_ADC, 50); //IntEnable(INT_ADC0); //ADCIntClear(ADC0_BASE, 0); return; }
int main(void) { display[0] = '\0'; display2[0] = '\0'; // Set the clocking to run directly from the crystal. SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // Initialize the OLED display and write status. RIT128x96x4Init(1000000); RIT128x96x4StringDraw("----------------------", 0, 50, 15); // Enable the peripherals used by this example. SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // Status SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_STRENGTH_4MA,GPIO_PIN_TYPE_STD); GPIODirModeSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_DIR_MODE_OUT); //PB1 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIOPadConfigSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_STRENGTH_4MA,GPIO_PIN_TYPE_STD); GPIODirModeSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_DIR_MODE_IN); GPIOPortIntRegister(GPIO_PORTB_BASE, PortBIntHandler); GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_1, GPIO_BOTH_EDGES); GPIOPinIntEnable(GPIO_PORTB_BASE, GPIO_PIN_1); IntPrioritySet(INT_GPIOB,0x80); SysTickIntRegister(SysTickHandler); SysTickPeriodSet(SysCtlClockGet()/10000); // 0.1ms SysTickIntEnable(); waitTime = 0; // initialize waitTime2 = 0; SysTickEnable(); // Enable processor interrupts. IntMasterEnable(); // Set GPIO A0 and A1 as UART pins. GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_2 | GPIO_PIN_3); // Configure the UART for 115,200, 8-N-1 operation. UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // Enable the UART interrupt. IntEnable(INT_UART0); UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); IntEnable(INT_UART1); UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT); while(1) { } }
int main(void) { ROM_FPUEnable(); ROM_FPULazyStackingEnable(); ROM_SysCtlClockSet( SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); SysTickPeriodSet(SysCtlClockGet() / TICKFREQ); //tickfreq in Hz SysTickIntEnable(); SysTickEnable(); #ifdef DEBUG InitConsole(); #endif ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_IntMasterEnable(); ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3); GPIOPinConfigure(GPIO_PC6_U3RX); GPIOPinConfigure(GPIO_PC7_U3TX); GPIOPinConfigure(GPIO_PB0_U1RX); GPIOPinConfigure(GPIO_PB1_U1TX); ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7); ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); ROM_UARTFIFOEnable(UART1_BASE); ROM_UARTFIFOEnable(UART3_BASE); ROM_UARTConfigSetExpClk(UART3_BASE, ROM_SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); ROM_UARTConfigSetExpClk(UART1_BASE, ROM_SysCtlClockGet(), 38400, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); ROM_IntEnable(INT_UART1); ROM_UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT); // ONLY recieve inturrupt ROM_IntEnable(INT_UART3); ROM_UARTIntEnable(UART3_BASE, UART_INT_RX | UART_INT_RT); // ONLY recieve inturrupt I2CSetup(I2C0_MASTER_BASE, true); setupServos(); UARTprintf("init"); nrf24l01p_init(3); nrf24l01p_setRADDR((uint8_t *) "Boat"); nrf24l01p_setPayLoad(DATA_BUFFER_MAX); nrf24l01p_setChannel(1); nrf24l01p_config(); nrf24l01p_setTADDR((uint8_t *) "Base"); // nrf24l01p_send((unsigned char *) &"Init"); GPIOPortIntRegister(GPIO_PORTA_BASE, portAIntHandler); GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_5, GPIO_FALLING_EDGE); GPIOPinIntEnable(GPIO_PORTA_BASE, GPIO_PIN_5); unsigned char p = 0; nrf24l01p_readRegister(0x00, &p, 1); UARTprintf(" "); while (1) { sortGPSSentence(); } }
/************************************************************************************************** * @fn npSpiInit * * @brief This function is called to set up the SPI interface. * * input parameters * * None. * * output parameters * * None. * * @return None. ************************************************************************************************** */ void npSpiInit(void) { uint32 ulDummy; if (ZNP_CFG1_UART == znpCfg1) { return; } /* Configure SRDY and deassert SRDY */ GPIOPinTypeGPIOOutput(HAL_SPI_SRDY_BASE, HAL_SPI_SRDY_PIN); GPIOPinWrite(HAL_SPI_SRDY_BASE, HAL_SPI_SRDY_PIN, HAL_SPI_SRDY_PIN); /* Configure MRDY and deassert MRDY */ GPIOPinTypeGPIOInput(HAL_SPI_MRDY_BASE, HAL_SPI_MRDY_PIN); GPIOPinWrite(HAL_SPI_MRDY_BASE, HAL_SPI_MRDY_PIN, HAL_SPI_MRDY_PIN); /* Enable SSI peripheral module */ SysCtrlPeripheralEnable(BSP_SPI_SSI_ENABLE_BM); /* Delay is essential for this customer */ SysCtrlDelay(32); /* Configure pin type */ GPIOPinTypeSSI(BSP_SPI_BUS_BASE, (BSP_SPI_MOSI | BSP_SPI_MISO | BSP_SPI_SCK | HAL_SPI_SS_PIN)); /* Map SSI signals to the correct GPIO pins and configure them as HW ctrl'd */ IOCPinConfigPeriphOutput(BSP_SPI_BUS_BASE, BSP_SPI_MISO, IOC_MUX_OUT_SEL_SSI0_TXD); IOCPinConfigPeriphInput(BSP_SPI_BUS_BASE, BSP_SPI_SCK, IOC_CLK_SSIIN_SSI0); IOCPinConfigPeriphInput(BSP_SPI_BUS_BASE, BSP_SPI_MOSI, IOC_SSIRXD_SSI0); IOCPinConfigPeriphInput(BSP_SPI_BUS_BASE, HAL_SPI_SS_PIN, IOC_SSIFSSIN_SSI0); /* Disable SSI function */ SSIDisable(BSP_SPI_SSI_BASE); /* Set system clock as SSI clock source */ SSIClockSourceSet(BSP_SPI_SSI_BASE, SSI_CLOCK_SYSTEM); /* Configure SSI module to Motorola/Freescale SPI mode 3 Slave: * Polarity = 1, observed in scope from MSP430 master * Phase = 1, observed in scope from MSP430 master * Word size = 8 bits * Clock = 2MHz, observed MSP430 master clock is 2049180Hz */ SSIConfigSetExpClk(BSP_SPI_SSI_BASE, SysCtrlClockGet(), SSI_FRF_MOTO_MODE_3, SSI_MODE_SLAVE, 2000000UL, 8); /* Register SPI uDMA complete interrupt */ SSIIntRegister(BSP_SPI_SSI_BASE, &npSpiUdmaCompleteIsr); /* Enable uDMA complete interrupt for SPI RX and TX */ SSIDMAEnable(BSP_SPI_SSI_BASE, SSI_DMA_RX | SSI_DMA_TX); /* Configure SPI priority */ IntPrioritySet(INT_SSI0, HAL_INT_PRIOR_SSI0); IntPrioritySet(INT_GPIOB, HAL_INT_PRIOR_SSI_MRDY); /* Enable the SSI function */ SSIEnable(BSP_SPI_SSI_BASE); GPIOIntTypeSet(HAL_SPI_MRDY_BASE, HAL_SPI_MRDY_PIN, GPIO_BOTH_EDGES); GPIOPortIntRegister(HAL_SPI_MRDY_BASE, *npSpiMrdyIsr); GPIOPinIntEnable(HAL_SPI_MRDY_BASE, HAL_SPI_MRDY_PIN); /* Initialize uDMA for SPI */ npSpiUdmaInit(); }