/** * @brief Inicializa el clock del sistema. * * @return - * */ void CLOCK_inicializar_clock(){ SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); }
//***************************************************************************** // // Configure ADC0 for a single-ended input and a single sample. Once the // sample is ready, an interrupt flag will be set. Using a polling method, // the data will be read then displayed on the console via UART0. // //***************************************************************************** int main(void) { // // This array is used for storing the data read from the ADC FIFO. It // must be as large as the FIFO for the sequencer in use. This example // uses sequence 3 which has a FIFO depth of 1. If another sequence // was used with a deeper FIFO, then the array size must be changed. // uint32_t pui32ADC0Value[1]; // // Set the clocking to run at 20 MHz (200 MHz / 10) using the PLL. When // using the ADC, you must either use the PLL or supply a 16 MHz clock // source. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for ADC operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("ADC ->\n"); UARTprintf(" Type: Single Ended\n"); UARTprintf(" Samples: One\n"); UARTprintf(" Update Rate: 250ms\n"); UARTprintf(" Input Pin: AIN0/PE7\n\n"); // // The ADC0 peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); // // For this example ADC0 is used with AIN0 on port E7. // The actual port and pins used may be different on your part, consult // the data sheet for more information. GPIO port E needs to be enabled // so these pins can be used. // TODO: change this to whichever GPIO port you are using. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); // // Select the analog ADC function for these pins. // Consult the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using. // GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_7); // // Enable sample sequence 3 with a processor signal trigger. Sequence 3 // will do a single sample when the processor sends a signal to start the // conversion. Each ADC module has 4 programmable sequences, sequence 0 // to sequence 3. This example is arbitrarily using sequence 3. // ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0); // // Configure step 0 on sequence 3. Sample channel 0 (ADC_CTL_CH0) in // single-ended mode (default) and configure the interrupt flag // (ADC_CTL_IE) to be set when the sample is done. Tell the ADC logic // that this is the last conversion on sequence 3 (ADC_CTL_END). Sequence // 3 has only one programmable step. Sequence 1 and 2 have 4 steps, and // sequence 0 has 8 programmable steps. Since we are only doing a single // conversion using sequence 3 we will only configure step 0. For more // information on the ADC sequences and steps, reference the datasheet. // ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END); // // Since sample sequence 3 is now configured, it must be enabled. // ADCSequenceEnable(ADC0_BASE, 3); // // Clear the interrupt status flag. This is done to make sure the // interrupt flag is cleared before we sample. // ADCIntClear(ADC0_BASE, 3); // // Sample AIN0 forever. Display the value on the console. // while(1) { // // Trigger the ADC conversion. // ADCProcessorTrigger(ADC0_BASE, 3); // // Wait for conversion to be completed. // while(!ADCIntStatus(ADC0_BASE, 3, false)) { } // // Clear the ADC interrupt flag. // ADCIntClear(ADC0_BASE, 3); // // Read ADC Value. // ADCSequenceDataGet(ADC0_BASE, 3, pui32ADC0Value); // // Display the AIN0 (PE7) digital value on the console. // UARTprintf("AIN0 = %4d\r", pui32ADC0Value[0]); // // This function provides a means of generating a constant length // delay. The function delay (in cycles) = 3 * parameter. Delay // 250ms arbitrarily. // SysCtlDelay(SysCtlClockGet() / 12); } }
//***************************************************************************** // // Configure the CAN and enter a loop to transmit periodic CAN messages. // //***************************************************************************** int main(void) { tCANMsgObject sCANMessage; uint32_t ui32MsgData; uint8_t *pui8MsgData; pui8MsgData = (uint8_t *)&ui32MsgData; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for CAN operation. // InitConsole(); // // For this example CAN0 is used with RX and TX pins on port B4 and B5. // The actual port and pins used may be different on your part, consult // the data sheet for more information. // GPIO port B needs to be enabled so these pins can be used. // TODO: change this to whichever GPIO port you are using // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Configure the GPIO pin muxing to select CAN0 functions for these pins. // This step selects which alternate function is available for these pins. // This is necessary if your part supports GPIO pin function muxing. // Consult the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using // GPIOPinConfigure(GPIO_PB4_CAN0RX); GPIOPinConfigure(GPIO_PB5_CAN0TX); // // Enable the alternate function on the GPIO pins. The above step selects // which alternate function is available. This step actually enables the // alternate function instead of GPIO for these pins. // TODO: change this to match the port/pin you are using // GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_5); // // The GPIO port and pins have been set up for CAN. The CAN peripheral // must be enabled. // SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0); // // Initialize the CAN controller // CANInit(CAN0_BASE); // // Set up the bit rate for the CAN bus. This function sets up the CAN // bus timing for a nominal configuration. You can achieve more control // over the CAN bus timing by using the function CANBitTimingSet() instead // of this one, if needed. // In this example, the CAN bus is set to 500 kHz. In the function below, // the call to SysCtlClockGet() is used to determine the clock rate that // is used for clocking the CAN peripheral. This can be replaced with a // fixed value if you know the value of the system clock, saving the extra // function call. For some parts, the CAN peripheral is clocked by a fixed // 8 MHz regardless of the system clock in which case the call to // SysCtlClockGet() should be replaced with 8000000. Consult the data // sheet for more information about CAN peripheral clocking. // CANBitRateSet(CAN0_BASE, SysCtlClockGet(), 500000); // // Enable interrupts on the CAN peripheral. This example uses static // allocation of interrupt handlers which means the name of the handler // is in the vector table of startup code. If you want to use dynamic // allocation of the vector table, then you must also call CANIntRegister() // here. // // CANIntRegister(CAN0_BASE, CAN0_IRQHandler); // if using dynamic vectors // CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS); // // Enable the CAN interrupt on the processor (NVIC). // IntEnable(INT_CAN0); // // Enable the CAN for operation. // CANEnable(CAN0_BASE); // // Initialize the message object that will be used for sending CAN // messages. The message will be 4 bytes that will contain an incrementing // value. Initially it will be set to 0. // ui32MsgData = 0; sCANMessage.ui32MsgID = 1; sCANMessage.ui32MsgIDMask = 0; sCANMessage.ui32Flags = MSG_OBJ_TX_INT_ENABLE; sCANMessage.ui32MsgLen = sizeof(pui8MsgData); sCANMessage.pui8MsgData = pui8MsgData; // // Enter loop to send messages. A new message will be sent once per // second. The 4 bytes of message content will be treated as an uint32_t // and incremented by one each time. // while(1) { // // Print a message to the console showing the message count and the // contents of the message being sent. // UARTprintf("Sending msg: 0x%02X %02X %02X %02X", pui8MsgData[0], pui8MsgData[1], pui8MsgData[2], pui8MsgData[3]); // // Send the CAN message using object number 1 (not the same thing as // CAN ID, which is also 1 in this example). This function will cause // the message to be transmitted right away. // CANMessageSet(CAN0_BASE, 1, &sCANMessage, MSG_OBJ_TYPE_TX); // // Now wait 1 second before continuing // SimpleDelay(); // // Check the error flag to see if errors occurred // if(g_bErrFlag) { UARTprintf(" error - cable connected?\n"); } else { // // If no errors then print the count of message sent // UARTprintf(" total count = %u\n", g_ui32MsgCount); } // // Increment the value in the message data. // ui32MsgData++; } // // Return no errors // return(0); }
int main(void) { volatile uint32_t ui32Load; volatile uint32_t ui32PWMClock; volatile uint8_t ui8AdjustRed, ui8AdjustGreen, ui8AdjustBlue; ui8AdjustRed = 254; ui8AdjustGreen = 2; ui8AdjustBlue = 2; // Set the system clock to 40 MHz SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ); // Set the PWM Clock to 1/64 of the system clock i.e. 625 kHz SysCtlPWMClockSet(SYSCTL_PWMDIV_64); // Timer related intializations, time period is 10 ms. SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); uint32_t ui32Period; ui32Period = (SysCtlClockGet()/100)/ 2; TimerLoadSet(TIMER0_BASE, TIMER_A, ui32Period -1); IntEnable(INT_TIMER0A); TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); IntMasterEnable(); TimerEnable(TIMER0_BASE, TIMER_A); // Enable the PWM module 1 SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1); // Enable the GPIO Port F SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // PWM related initializations GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); GPIOPinConfigure(GPIO_PF1_M1PWM5); GPIOPinConfigure(GPIO_PF2_M1PWM6); GPIOPinConfigure(GPIO_PF3_M1PWM7); 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; GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_DIR_MODE_IN); GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); ui32PWMClock = SysCtlClockGet() / 64; ui32Load = (ui32PWMClock / PWM_FREQUENCY) - 1; PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN); PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN); PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load); PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, ui32Load); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8AdjustRed * ui32Load / 1000); PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true); PWMGenEnable(PWM1_BASE, PWM_GEN_2); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8AdjustBlue * ui32Load / 1000); PWMOutputState(PWM1_BASE, PWM_OUT_6_BIT, true); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8AdjustGreen * ui32Load / 1000); PWMOutputState(PWM1_BASE, PWM_OUT_7_BIT, true); PWMGenEnable(PWM1_BASE, PWM_GEN_3); // Detecting the phase while in the auto mode, RG, GB or BR. int autoLedState = 0; while(1) { if(mode==0) { if(autoLedState==0) { ui8AdjustRed--; ui8AdjustGreen++; if(ui8AdjustRed==2 && ui8AdjustGreen==254) autoLedState = 1; } else if(autoLedState==1) { ui8AdjustGreen--; ui8AdjustBlue++; if(ui8AdjustGreen==2 && ui8AdjustBlue==254) autoLedState = 2; } else if(autoLedState==2) { ui8AdjustBlue--; ui8AdjustRed++; if(ui8AdjustBlue==2 && ui8AdjustRed==254) autoLedState = 0; } PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8AdjustRed * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8AdjustBlue * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8AdjustGreen * ui32Load / 1000); SysCtlDelay(delay); } else { if(mode==1) { ui8AdjustBlue = 2; ui8AdjustGreen = 2; if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8AdjustRed--; if (ui8AdjustRed < 20) ui8AdjustRed = 20; } if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00) { ui8AdjustRed++; if (ui8AdjustRed > 254) ui8AdjustRed = 254; } } else if(mode==2) { ui8AdjustRed = 2; ui8AdjustGreen = 2; if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8AdjustBlue--; if (ui8AdjustBlue < 20) ui8AdjustBlue = 20; } if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00) { ui8AdjustBlue++; if (ui8AdjustBlue > 254) ui8AdjustBlue = 254; } } else if(mode==3) { ui8AdjustBlue = 2; ui8AdjustRed = 2; if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8AdjustGreen--; if (ui8AdjustGreen < 20) ui8AdjustGreen = 20; } if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00) { ui8AdjustGreen++; if (ui8AdjustGreen > 254) ui8AdjustGreen = 254; } } PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8AdjustRed * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8AdjustBlue * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8AdjustGreen * ui32Load / 1000); SysCtlDelay(100000); } } }
/** Initializes Oscillator: configures MCLK to 25MHz using internal PLL (SYSCTL_USE_PLL) calibrated * to 8MHz external crystal (SYSCTL_XTAL_8MHZ). * @note PLL native frequency = 200MHz, so divide by 8 (SYSCTL_SYSDIV_8) to get 25MHz * @note ADC requires either the PLL or a 16MHz clock source */ void oscInit() { SysCtlClockSet(SYSCTL_SYSDIV_8 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_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); } }
//***************************************************************************** // // This example application demonstrates the use of the timers to generate // periodic interrupts. // //***************************************************************************** int main(void) { unsigned long ulPeriod, dutyCycle; // En ejemplo // // 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_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | // SYSCTL_XTAL_16MHZ); // Agregado Ejemplo // 40 MHz system clock SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL| SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); ulPeriod = 1000; dutyCycle = 250; // Turn off LEDs SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 0); // Configure PB6 as T0CCP0 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIOPinConfigure(GPIO_PB6_T0CCP0); GPIOPinTypeTimer(GPIO_PORTB_BASE, GPIO_PIN_6); // Configure timer SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM); TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod -1); TimerMatchSet(TIMER0_BASE, TIMER_A, dutyCycle); // PWM TimerEnable(TIMER0_BASE, TIMER_A); // Fin Agregado // // Initialize the UART and write status. // ConfigureUART(); UARTprintf("\033[2JTimers example\n"); UARTprintf("T1: 0 T2: 0"); // // Enable the GPIO port that is used for the on-board LED. // // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // // Enable the GPIO pins for the LED (PF1 & PF2). // // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1); // // Enable the peripherals used by this example. // // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); // // Enable processor interrupts. // // ROM_IntMasterEnable(); // // Configure the two 32-bit periodic timers. // // ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); // ROM_TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC); // ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet()); // ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, ROM_SysCtlClockGet() / 2); // // Setup the interrupts for the timer timeouts. // // ROM_IntEnable(INT_TIMER0A); // ROM_IntEnable(INT_TIMER1A); // ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); // ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT); // // Enable the timers. // // ROM_TimerEnable(TIMER0_BASE, TIMER_A); // ROM_TimerEnable(TIMER1_BASE, TIMER_A); // // Loop forever while the timers run. // while(1) { } }
//***************************************************************************** // // Configure PWM0 for a 25% duty cycle signal running at 250Hz. This example // also shows how to invert the PWM signal every 5 seconds for 5 seconds. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set the PWM clock to the system clock. // SysCtlPWMClockSet(SYSCTL_PWMDIV_1); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for Timer operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("PWM ->\n"); UARTprintf(" Module: PWM0\n"); UARTprintf(" Pin: PD0\n"); UARTprintf(" Configured Duty Cycle: 25%%\n"); UARTprintf(" Inverted Duty Cycle: 75%%\n"); UARTprintf(" Features: PWM output inversion every 5 seconds.\n\n"); UARTprintf("Generating PWM on PWM0 (PD0) -> State = "); // // The PWM peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM); // // For this example PWM0 is used with PortD Pin0. The actual port and // pins used may be different on your part, consult the data sheet for // more information. // GPIO port D needs to be enabled so these pins can be used. // TODO: change this to whichever GPIO port you are using. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Configure the GPIO pin muxing to select PWM00 functions for these pins. // This step selects which alternate function is available for these pins. // This is necessary if your part supports GPIO pin function muxing. // Consult the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using. // GPIOPinConfigure(GPIO_PD0_PWM0); // // Configure the PWM function for this pin. // Consult the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using. // GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0); // // Configure the PWM0 to count up/down without synchronization. // PWMGenConfigure(PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC); // // Set the PWM period to 250Hz. To calculate the appropriate parameter // use the following equation: N = (1 / f) * SysClk. Where N is the // function parameter, f is the desired frequency, and SysClk is the // system clock frequency. // In this case you get: (1 / 250Hz) * 16MHz = 64000 cycles. Note that // the maximum period you can set is 2^16. // TODO: modify this calculation to use the clock frequency that you are // using. // PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 64000); // // Set PWM0 to a duty cycle of 25%. You set the duty cycle as a function // of the period. Since the period was set above, you can use the // PWMGenPeriodGet() function. For this example the PWM will be high for // 25% of the time or 16000 clock ticks (64000 / 4). // PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, PWMGenPeriodGet(PWM_BASE, PWM_OUT_0) / 4); // // Enable the PWM0 Bit0 (PD0) output signal. // PWMOutputState(PWM_BASE, PWM_OUT_0_BIT, true); // // Enable the PWM generator block. // PWMGenEnable(PWM_BASE, PWM_GEN_0); // // Loop forever while the PWM signals are generated. // while(1) { // // Print out that the level of PWM is normal. // UARTprintf("Normal \b\b\b\b\b\b\b\b"); // // This function provides a means of generating a constant length // delay. The function delay (in cycles) = 3 * parameter. Delay // 5 seconds arbitrarily. // SysCtlDelay((SysCtlClockGet() * 5) / 3); // // Invert PWM0 signal. // PWMOutputInvert(PWM_BASE, PWM_OUT_0_BIT, true); // // Print out that the level of PWM is inverted. // UARTprintf("Inverted\b\b\b\b\b\b\b\b"); // // This function provides a means of generating a constant length // delay. The function delay (in cycles) = 3 * parameter. Delay // 5 seconds arbitrarily. // SysCtlDelay((SysCtlClockGet() * 5) / 3); // // Switch PWM0 signal back to regular operation. // PWMOutputInvert(PWM_BASE, PWM_OUT_0_BIT, false); } }
//***************************************************************************** // // Toggle the JTAG pins between JTAG and GPIO mode with a push button selecting // between the two. // //***************************************************************************** int main(void) { unsigned long ulMode; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Enable the peripherals used by this application. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); // // Configure the push button as an input and enable the pin to interrupt on // the falling edge (i.e. when the push button is pressed). // GPIOPinTypeGPIOInput(GPIO_PORTG_BASE, GPIO_PIN_7); GPIOPadConfigSet(GPIO_PORTG_BASE, GPIO_PIN_7, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(GPIO_PORTG_BASE, GPIO_PIN_7, GPIO_FALLING_EDGE); GPIOPinIntEnable(GPIO_PORTG_BASE, GPIO_PIN_7); IntEnable(INT_GPIOG); // // Set the global and local indicator of pin mode to zero, meaning JTAG. // g_ulMode = 0; ulMode = 0; // // Initialize the OLED display. // RIT128x96x4Init(1000000); RIT128x96x4StringDraw("PB7/PC0-3 are", 30, 16, 15); RIT128x96x4StringDraw("JTAG", 48, 32, 15); // // Loop forever. This loop simply exists to display on the OLED display // the current state of PB7/PC0-3; the handling of changing the JTAG pins // to and from GPIO mode is done in GPIO Interrupt Handler. // while(1) { // // Wait until the pin mode changes. // while(g_ulMode == ulMode) { } // // Save the new mode locally so that a subsequent pin mode change can // be detected. // ulMode = g_ulMode; // // See what the new pin mode was changed to. // if(ulMode == 0) { // // Indicate that PB7 and PC0-3 are currently JTAG pins. // RIT128x96x4StringDraw("JTAG", 48, 32, 15); } else { // // Indicate that PB7 and PC0-3 are currently GPIO pins. // RIT128x96x4StringDraw("GPIO", 48, 32, 15); } } }
int main (void) { char read_buffer[32]; char kurve_buf[64]; char d1_buf[64]; char* str; char* id; char* value; char *pch; int i_value; int pos_value; int kurve=12; int d1 = 1; // Set the clocking to run directly from the crystal. SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); UARTStdioInit(0); // Initialize the OLED display. RIT128x96x4Init(1000000); //Display the constants RIT128x96x4StringDraw("Maschinensimulation!", 0, 0, 15); RIT128x96x4StringDraw("by Anzinger und Hahn", 0, 80, 15); UARTprintf("Hi UART\n;"); while(1){//wait until output is necassary UARTgets(&read_buffer, 32); id = &read_buffer; str = id+3; id=str; if(read_buffer[0] == '!' && read_buffer[1] == 'g'){ RIT128x96x4StringDraw("Wert get", 0, 50, 15); if(strcmp(id, "kurve") == 0) UARTprintf("%d", kurve); if(strcmp(id, "d1") == 0) UARTprintf("%d", d1); } if(read_buffer[0] == '!' && read_buffer[1] == 's'){ RIT128x96x4StringDraw("Wert set", 0, 50, 15); pos_value = findChar(str, '='); value = str + pos_value + 1; id[pos_value] = 0; i_value = atoi(value); if(strcmp(id, "kurve") == 0) kurve = i_value; if(strcmp(id, "d1") == 0) d1 = i_value; UARTprintf("%s=%d\n", id, i_value); } sprintf(&kurve_buf, "Wert Kurve: %d", kurve); sprintf(&d1_buf, "Wert d1: %d", d1); RIT128x96x4StringDraw(kurve_buf, 0, 60, 15); RIT128x96x4StringDraw(d1_buf, 0, 70, 15); } }
int main(void) { volatile uint32_t ui32Load; volatile uint32_t ui32PWMClock; // used in programming PWM color = 0; ui8Max = 254; ui8Min = 5; ui8R = ui8Max; ui8B = 0; ui8G = 0; SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ); SysCtlPWMClockSet(SYSCTL_PWMDIV_64); // setting the clock and PWM module SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1); // enable PWM1 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // enable GPIOF GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1); // pin 1 configured as a PWM output GPIOPinConfigure(GPIO_PF1_M1PWM5); GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_2); // pin 2 configured as a PWM output GPIOPinConfigure(GPIO_PF2_M1PWM6); GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_3); // pin 3 configured as a PWM output GPIOPinConfigure(GPIO_PF3_M1PWM7); HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; // ulocking the HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01; // GPIO HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0; // commit control register GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_DIR_MODE_IN); // configure PF0 and PF4 as inputs GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // configuring pull-up registers ui32PWMClock = SysCtlClockGet() / 64; ui32Load = (ui32PWMClock / PWM_FREQUENCY) - 1; // loading value into ui32Load PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN); // configuring generator 2 as a down-counter PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load); // setting the time period of the generator PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN); // configuring generator 3 as a down-counter PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, ui32Load); // PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8R * ui32Load / 1000); // setting pulse widths of red LED PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8B * ui32Load / 1000); // setting pulse widths of blue LED PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8G * ui32Load / 1000); // setting pulse widths of green LED PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true); // enabling the PWM output PWMOutputState(PWM1_BASE, PWM_OUT_6_BIT, true); PWMOutputState(PWM1_BASE, PWM_OUT_7_BIT, true); PWMGenEnable(PWM1_BASE, PWM_GEN_2); // enabling generators 2 & 3 PWMGenEnable(PWM1_BASE, PWM_GEN_3); delay = 100000; mode=0; while(1) { if(mode==0){ color = color + 1; if(color>=360){ color = 0; } if(color<120){ ui8G = ui8Min + color*ui8Max/120.0; ui8R = ui8Min + ui8Max - ui8G; ui8B = ui8Min; } else if (color<240){ ui8B = ui8Min+(color-120)*ui8Max/120.0; ui8G = ui8Min+ui8Max - ui8B; ui8R = ui8Min; } else if(color<360){ ui8R = ui8Min+(color-240)*ui8Max/120.0; ui8B = ui8Min+ui8Max - ui8R; ui8G = ui8Min; } if((GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)) delay = delay-1000; PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8R * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8B * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8G * ui32Load / 1000); SysCtlDelay(delay*10); } //n=0; while(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00){ if((GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)&&mode<4){ mode++; } delay = delay+1000; SysCtlDelay(delay*10); } if(mode==1){ // red LED control mode=0; ui8R = 127; ui8B = 5; ui8G = 5; while(1){ if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8R--; // decreasing the brightness of red LED if (ui8R < 5) { ui8R = 5; } } while(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00){ if((GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)&&mode<4){ mode++; } ui8R++; // increasing the brightness of red LED if (ui8R > 254) { ui8R = 254; } SysCtlDelay(delay*10); } PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8R * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8B * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8G * ui32Load / 1000); // setting pulse widths of LEDs if(mode>1) break; SysCtlDelay(delay); } } else if (mode==2){ // blue LED control mode=0; ui8B = 127; ui8R = 5; ui8G = 5; while(1){ if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) { ui8B--; // decreasing the brightness of blue LED if (ui8B < 5) { ui8B = 5; } } while(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00){ if((GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)&&mode<4){ mode++; } ui8B++; // increasing the brightness of blue LED if (ui8B > 254) { ui8B = 254; } SysCtlDelay(delay*10); } PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8R * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8B * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8G * ui32Load / 1000); // setting pulse widths of LEDs if(mode!=0) break; SysCtlDelay(delay); } } else if(mode>2){ // green LED control mode=0; ui8G = 127; ui8B = 5; ui8R = 5; while(1){ if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00) // decreasing the brightness of green LED { ui8G--; if (ui8G < 5) { ui8G = 5; } } while(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00){ if((GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)&&mode<4){ mode++; } ui8G++; // increasing the brightness of green LED if (ui8G > 254) { ui8G = 254; } SysCtlDelay(delay*10); } PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8R * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8B * ui32Load / 1000); PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8G * ui32Load / 1000); // setting pulse widths of LEDs if(mode!=0) break; SysCtlDelay(delay); } } } }
//***************************************************************************** // // Configure ADC0 for the temperature sensor input with a single sample. Once // the sample is done, an interrupt flag will be set, and the data will be // read then displayed on the console via UART0. // //***************************************************************************** int main(void) { // // This array is used for storing the data read from the ADC FIFO. It // must be as large as the FIFO for the sequencer in use. This example // uses sequence 3 which has a FIFO depth of 1. If another sequence // was used with a deeper FIFO, then the array size must be changed. // unsigned long ulADC0_Value[1]; // // These variables are used to store the temperature conversions for // Celsius and Fahrenheit. // unsigned long ulTemp_ValueC; unsigned long ulTemp_ValueF; // // Set the clocking to run at 20 MHz (200 MHz / 10) using the PLL. When // using the ADC, you must either use the PLL or supply a 16 MHz clock // source. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // //SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | // SYSCTL_XTAL_16MHZ); SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Set up the serial console to use for displaying messages. This is just // for this example program and is not needed for ADC operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("ADC ->\n"); UARTprintf(" Type: Internal Temperature Sensor\n"); UARTprintf(" Samples: One\n"); UARTprintf(" Update Rate: 250ms\n"); UARTprintf(" Input Pin: Internal temperature sensor\n\n"); // // The ADC0 peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); // // Enable sample sequence 3 with a processor signal trigger. Sequence 3 // will do a single sample when the processor sends a singal to start the // conversion. Each ADC module has 4 programmable sequences, sequence 0 // to sequence 3. This example is arbitrarily using sequence 3. // ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0); // // Configure step 0 on sequence 3. Sample the temperature sensor // (ADC_CTL_TS) and configure the interrupt flag (ADC_CTL_IE) to be set // when the sample is done. Tell the ADC logic that this is the last // conversion on sequence 3 (ADC_CTL_END). Sequence 3 has only one // programmable step. Sequence 1 and 2 have 4 steps, and sequence 0 has // 8 programmable steps. Since we are only doing a single conversion using // sequence 3 we will only configure step 0. For more information on the // ADC sequences and steps, reference the datasheet. // ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END); // // Since sample sequence 3 is now configured, it must be enabled. // ADCSequenceEnable(ADC0_BASE, 3); // // Clear the interrupt status flag. This is done to make sure the // interrupt flag is cleared before we sample. // ADCIntClear(ADC0_BASE, 3); // // Sample the temperature sensor forever. Display the value on the // console. // while(1) { // // Trigger the ADC conversion. // ADCProcessorTrigger(ADC0_BASE, 3); // // Wait for conversion to be completed. // while(!ADCIntStatus(ADC0_BASE, 3, false)) { } // // Read ADC Value. // ADCSequenceDataGet(ADC0_BASE, 3, ulADC0_Value); // // Use non-calibrated conversion provided in the data sheet. Make // sure you divide last to avoid dropout. // ulTemp_ValueC = ((1475 * 1023) - (2250 * ulADC0_Value[0])) / 10230; // // Get fahrenheit value. Make sure you divide last to avoid dropout. // ulTemp_ValueF = ((ulTemp_ValueC * 9) + 160) / 5; // // Display the temperature value on the console. // UARTprintf("Temperature = %3d*C or %3d*F\r", ulTemp_ValueC, ulTemp_ValueF); // // This function provides a means of generating a constant length // delay. The function delay (in cycles) = 3 * parameter. Delay // 250ms arbitrarily. // SysCtlDelay(SysCtlClockGet() / 12); } }
//***************************************************************************** // // Configure the CAN and enter a loop to transmit periodic CAN messages. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for CAN operation. // InitConsole(); // // For this example CAN0 is used with RX and TX pins on port D0 and D1. // The actual port and pins used may be different on your part, consult // the data sheet for more information. // GPIO port D needs to be enabled so these pins can be used. // TODO: change this to whichever GPIO port you are using // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Configure the GPIO pin muxing to select CAN0 functions for these pins. // This step selects which alternate function is available for these pins. // This is necessary if your part supports GPIO pin function muxing. // Consult the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using // GPIOPinConfigure(GPIO_PD0_CAN0RX); GPIOPinConfigure(GPIO_PD1_CAN0TX); // // Enable the alternate function on the GPIO pins. The above step selects // which alternate function is available. This step actually enables the // alternate function instead of GPIO for these pins. // TODO: change this to match the port/pin you are using // GPIOPinTypeCAN(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // The GPIO port and pins have been set up for CAN. The CAN peripheral // must be enabled. // SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0); // // Initialize the CAN controller // CANInit(CAN0_BASE); // // Set up the bit rate for the CAN bus. This function sets up the CAN // bus timing for a nominal configuration. You can achieve more control // over the CAN bus timing by using the function CANBitTimingSet() instead // of this one, if needed. // In this example, the CAN bus is set to 500 kHz. In the function below, // the call to SysCtlClockGet() is used to determine the clock rate that // is used for clocking the CAN peripheral. This can be replaced with a // fixed value if you know the value of the system clock, saving the extra // function call. For some parts, the CAN peripheral is clocked by a fixed // 8 MHz regardless of the system clock in which case the call to // SysCtlClockGet() should be replaced with 8000000. Consult the data // sheet for more information about CAN peripheral clocking. // CANBitRateSet(CAN0_BASE, SysCtlClockGet(), 500000); // // Enable interrupts on the CAN peripheral. This example uses static // allocation of interrupt handlers which means the name of the handler // is in the vector table of startup code. If you want to use dynamic // allocation of the vector table, then you must also call CANIntRegister() // here. // // CANIntRegister(CAN0_BASE, CANIntHandler); // if using dynamic vectors // CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS); // // Enable the CAN interrupt on the processor (NVIC). // IntEnable(INT_CAN0); // // Enable the CAN for operation. // CANEnable(CAN0_BASE); // // Initialize the message object that will be used for sending CAN // messages. The message will be 4 bytes that will contain an incrementing // value. Initially it will be set to 0. // // // Initialize message object 1 to be able to send CAN message 1. This // message object is not shared so it only needs to be initialized one // time, and can be used for repeatedly sending the same message ID. // g_sCANMsgObject1.ulMsgID = 0x1001; g_sCANMsgObject1.ulMsgIDMask = 0; g_sCANMsgObject1.ulFlags = MSG_OBJ_TX_INT_ENABLE; g_sCANMsgObject1.ulMsgLen = sizeof(g_ucMsg1); g_sCANMsgObject1.pucMsgData = g_ucMsg1; // // Initialize message object 2 to be able to send CAN message 2. This // message object is not shared so it only needs to be initialized one // time, and can be used for repeatedly sending the same message ID. // g_sCANMsgObject2.ulMsgID = 0x2001; g_sCANMsgObject2.ulMsgIDMask = 0; g_sCANMsgObject2.ulFlags = MSG_OBJ_TX_INT_ENABLE; g_sCANMsgObject2.ulMsgLen = sizeof(g_ucMsg2); g_sCANMsgObject2.pucMsgData = g_ucMsg2; // // Enter loop to send messages. Four messages will be sent once per // second. The contents of each message will be changed each time. // for(;;) { // // Send message 1 using CAN controller message object 1. This is // the only message sent using this message object. The // CANMessageSet() function will cause the message to be sent right // away. // PrintCANMessageInfo(&g_sCANMsgObject1, 1); CANMessageSet(CAN0_BASE, 1, &g_sCANMsgObject1, MSG_OBJ_TYPE_TX); // // Send message 2 using CAN controller message object 2. This is // the only message sent using this message object. The // CANMessageSet() function will cause the message to be sent right // away. // PrintCANMessageInfo(&g_sCANMsgObject2, 2); CANMessageSet(CAN0_BASE, 2, &g_sCANMsgObject2, MSG_OBJ_TYPE_TX); // // Load message object 3 with message 3. This is needs to be done each // time because message object 3 is being shared for two different // messages. // g_sCANMsgObject3.ulMsgID = 0x3001; g_sCANMsgObject3.ulMsgIDMask = 0; g_sCANMsgObject3.ulFlags = MSG_OBJ_TX_INT_ENABLE; g_sCANMsgObject3.ulMsgLen = sizeof(g_ucMsg3); g_sCANMsgObject3.pucMsgData = g_ucMsg3; // // Clear the flag that indicates that message 3 has been sent. This // flag will be set in the interrupt handler when a message has been // sent using message object 3. // g_bMsgObj3Sent = 0; // // Now send message 3 using CAN controller message object 3. This is // the first message sent using this message object. The // CANMessageSet() function will cause the message to be sent right // away. // PrintCANMessageInfo(&g_sCANMsgObject3, 3); CANMessageSet(CAN0_BASE, 3, &g_sCANMsgObject3, MSG_OBJ_TYPE_TX); // // Wait for the indication from the interrupt handler that message // object 3 is done, because we are re-using it for another message. // while(!g_bMsgObj3Sent) { } // // Load message object 3 with message 4. This is needed because // message object 3 is being shared for two different messages. // g_sCANMsgObject3.ulMsgID = 0x3002; g_sCANMsgObject3.ulMsgIDMask = 0; g_sCANMsgObject3.ulFlags = MSG_OBJ_TX_INT_ENABLE; g_sCANMsgObject3.ulMsgLen = sizeof(g_ucMsg4); g_sCANMsgObject3.pucMsgData = g_ucMsg4; // // Now send message 4 using CAN controller message object 3. This is // the second message sent using this message object. The // CANMessageSet() function will cause the message to be sent right // away. // PrintCANMessageInfo(&g_sCANMsgObject3, 3); CANMessageSet(CAN0_BASE, 3, &g_sCANMsgObject3, MSG_OBJ_TYPE_TX); // // Wait 1 second before continuing // SimpleDelay(); // // Check the error flag to see if errors occurred // if(g_bErrFlag) { UARTprintf(" error - cable connected?\n"); } else { // // If no errors then print the count of message sent // UARTprintf(" total count = %u\n", g_ulMsg1Count + g_ulMsg2Count + g_ulMsg3Count); } // // Change the value in the message data for each of the messages. // (*(unsigned long *)g_ucMsg1)++; (*(unsigned long *)g_ucMsg2)++; (*(unsigned long *)g_ucMsg3)++; (*(unsigned long *)&g_ucMsg4[0])++; (*(unsigned long *)&g_ucMsg4[4])--; } // // Return no errors // return(0); }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { tRectangle sRect; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Enable Clocking to the USB controller. // SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Configure the relevant pins such that UART0 owns them. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Open UART0 for debug output. // UARTStdioInit(0); // // Enable the USB mux GPIO. // SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH); // // The LM3S3748 board uses a USB mux that must be switched to use the // host connector and not the device connector. // GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN); GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST); // // Configure the power pins for host controller. // GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4); // // Turn on USB Phy clock. // SysCtlUSBPLLEnable(); // // Initialize the display driver. // Formike128x128x16Init(); // // Turn on the backlight. // Formike128x128x16BacklightOn(); // // Initialize the graphics context. // GrContextInit(&g_sContext, &g_sFormike128x128x16); // // Fill the top 15 rows of the screen with blue to create the banner. // sRect.sXMin = 0; sRect.sYMin = 0; sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1; sRect.sYMax = DISPLAY_BANNER_HEIGHT; GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG); GrRectFill(&g_sContext, &sRect); // // Put a white box around the banner. // GrContextForegroundSet(&g_sContext, ClrWhite); GrRectDraw(&g_sContext, &sRect); // // Put the application name in the middle of the banner. // GrContextFontSet(&g_sContext, &g_sFontFixed6x8); GrStringDrawCentered(&g_sContext, "usb_host_keyboard", -1, GrContextDpyWidthGet(&g_sContext) / 2, 7, 0); // // Calculate the number of characters that will fit on a line. // Make sure to leave a small border for the text box. // g_ulCharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 4) / GrFontMaxWidthGet(&g_sFontFixed6x8); // // Calculate the number of lines per usable text screen. This requires // taking off space for the top and bottom banners and adding a small bit // for a border. // g_ulLinesPerScreen = (GrContextDpyHeightGet(&g_sContext) - (2*(DISPLAY_BANNER_HEIGHT + 1)))/ GrFontHeightGet(&g_sFontFixed6x8); // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers); // // Open and instance of the keyboard class driver. // UARTprintf("Host Keyboard Application\n"); // // Open an instance of the keyboard driver. The keyboard does not need // to be present at this time, this just save a place for it and allows // the applications to be notified when a keyboard is present. // g_ulKeyboardInstance = USBHKeyboardOpen(KeyboardCallback, g_pucBuffer, KEYBOARD_MEMORY_SIZE); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USB_HOST_PWREN_HIGH); // // Initialize the host controller stack. // USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE); // // Call the main loop for the Host controller driver. // USBHCDMain(); // // Initial update of the screen. // UpdateStatus(); // // The main loop for the application. // while(1) { switch(g_eUSBState) { // // This state is entered when they keyboard is first detected. // case STATE_KEYBOARD_INIT: { // // Initialized the newly connected keyboard. // USBHKeyboardInit(g_ulKeyboardInstance); // // Proceed to the keyboard connected state. // g_eUSBState = STATE_KEYBOARD_CONNECTED; // // Update the screen now that the keyboard has been // initialized. // UpdateStatus(); break; } case STATE_KEYBOARD_UPDATE: { // // If the application detected a change that required an // update to be sent to the keyboard to change the modifier // state then call it and return to the connected state. // g_eUSBState = STATE_KEYBOARD_CONNECTED; USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers); break; } case STATE_KEYBOARD_CONNECTED: { // // Nothing is currently done in the main loop when the keyboard // is connected. // break; } case STATE_UNKNOWN_DEVICE: { // // Nothing to do as the device is unknown. // break; } case STATE_NO_DEVICE: { // // Nothing is currently done in the main loop when the keyboard // is not connected. // break; } default: { break; } } // // Periodic call the main loop for the Host controller driver. // USBHCDMain(); } }
void ConfigLib_CoreClock_Set80MHz(void) { SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); }
//***************************************************************************** // // Configure SoftSSI in SPI mode 0. This example will send out 3 bytes of // data, then wait for 3 bytes of data to come in. This will all be done using // the polling method. // //***************************************************************************** int main(void) { uint32_t pui32DataTx[NUM_SSI_DATA]; uint32_t pui32DataRx[NUM_SSI_DATA]; uint32_t ui32Index; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for SSI operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("SoftSSI ->\n"); UARTprintf(" Data: 8-bit\n\n"); // // For this example SoftSSI is used with PortA[5:2]. The actual port and // pins used may be different on your design based on the set of GPIO pins // available. GPIO port A needs to be enabled so these pins can be used. // TODO: change this to whichever GPIO port you are using. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Configure the SoftSSI module. The size of the FIFO buffers can be // changed to accommodate the requirements of your application. The GPIO // pins utilized can also be changed. // The pins are assigned as follows: // PA2 - SoftSSICLK // PA3 - SoftSSIFss // PA4 - SoftSSIRx // PA5 - SoftSSITx // TODO: change this to select the port/pin you are using. // TODO: change the buffer sizes to match your requirements. // memset(&g_sSoftSSI, 0, sizeof(g_sSoftSSI)); SoftSSIClkGPIOSet(&g_sSoftSSI, GPIO_PORTA_BASE, GPIO_PIN_2); SoftSSIFssGPIOSet(&g_sSoftSSI, GPIO_PORTA_BASE, GPIO_PIN_3); SoftSSIRxGPIOSet(&g_sSoftSSI, GPIO_PORTA_BASE, GPIO_PIN_4); SoftSSITxGPIOSet(&g_sSoftSSI, GPIO_PORTA_BASE, GPIO_PIN_5); SoftSSIRxBufferSet(&g_sSoftSSI, g_pui16RxBuffer, sizeof(g_pui16RxBuffer) / sizeof(g_pui16RxBuffer[0])); SoftSSITxBufferSet(&g_sSoftSSI, g_pui16TxBuffer, sizeof(g_pui16TxBuffer) / sizeof(g_pui16TxBuffer[0])); // // Configure the SoftSSI module. Use idle clock level low and active low // clock (mode 0) and 8-bit data. You can set the polarity of the SoftSSI // clock when the SoftSSI module is idle. You can also configure what // clock edge you want to capture data on. Please reference the datasheet // for more information on the different SPI modes. // SoftSSIConfigSet(&g_sSoftSSI, SOFTSSI_FRF_MOTO_MODE_0, 8); // // Enable the SoftSSI module. // SoftSSIEnable(&g_sSoftSSI); // // Configure SysTick to provide an interrupt at a 10 KHz rate. This is // used to control the clock rate of the SoftSSI module; the clock rate of // the SoftSSI Clk signal will be 1/2 the interrupt rate. // TODO: change this to a different timer if SysTick is not available. // TODO: change the interrupt rate to adjust the SoftSSI clock rate. // SysTickPeriodSet(SysCtlClockGet() / 10000); SysTickIntEnable(); SysTickEnable(); // // Initialize the data to send. // pui32DataTx[0] = 's'; pui32DataTx[1] = 'p'; pui32DataTx[2] = 'i'; // // Display indication that the SoftSSI is transmitting data. // UARTprintf("Sent:\n "); // // Send 3 bytes of data. // for(ui32Index = 0; ui32Index < NUM_SSI_DATA; ui32Index++) { // // Display the data that SSI is transferring. // UARTprintf("'%c' ", pui32DataTx[ui32Index]); // // Send the data using the "blocking" put function. This function // will wait until there is room in the send FIFO before returning. // This allows you to assure that all the data you send makes it into // the send FIFO. // SoftSSIDataPut(&g_sSoftSSI, pui32DataTx[ui32Index]); } // // Wait until SoftSSI is done transferring all the data in the transmit // FIFO. // while(SoftSSIBusy(&g_sSoftSSI)) { } // // Display indication that the SoftSSI is receiving data. // UARTprintf("\nReceived:\n "); // // Receive 3 bytes of data. // for(ui32Index = 0; ui32Index < NUM_SSI_DATA; ui32Index++) { // // Receive the data using the "blocking" Get function. This function // will wait until there is data in the receive FIFO before returning. // SoftSSIDataGet(&g_sSoftSSI, &pui32DataRx[ui32Index]); // // Since we are using 8-bit data, mask off the MSB. // pui32DataRx[ui32Index] &= 0x00FF; // // Display the data that SoftSSI received. // UARTprintf("'%c' ", pui32DataRx[ui32Index]); } // // Return no errors // return(0); }
//***************************************************************************** // // Configure the SysTick and SysTick interrupt with a period of 1 second. // //***************************************************************************** int main(void) { unsigned long ulPrevCount = 0; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for Systick operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("SysTick Firing Interrupt ->"); UARTprintf("\n Rate = 1sec\n\n"); // // Initialize the interrupt counter. // g_ulCounter = 0; // // Set up the period for the SysTick timer. The SysTick timer period will // be equal to the system clock, resulting in a period of 1 second. // SysTickPeriodSet(SysCtlClockGet()); // // Enable interrupts to the processor. // IntMasterEnable(); // // Enable the SysTick Interrupt. // SysTickIntEnable(); // // Enable SysTick. // SysTickEnable(); // // Loop forever while the SysTick runs. // while(1) { // // Check to see if systick interrupt count changed, and if so then // print a message with the count. // if(ulPrevCount != g_ulCounter) { // // Print the interrupt counter. // UARTprintf("Number of interrupts: %d\r", g_ulCounter); ulPrevCount = g_ulCounter; } } }
//***************************************************************************** // // Configure SSI0 in master TI mode. This example will send out 3 bytes of // data, then wait for 3 bytes of data to come in. This will all be done using // the polling method. // //***************************************************************************** int main(void) { unsigned long ulDataTx[NUM_SSI_DATA]; unsigned long ulDataRx[NUM_SSI_DATA]; unsigned long ulindex; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for SSI operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("SSI ->\n"); UARTprintf(" Mode: TI\n"); UARTprintf(" Data: 8-bit\n\n"); // // The SSI0 peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0); // // For this example SSI0 is used with PortA[5:2]. The actual port and // pins used may be different on your part, consult the data sheet for // more information. GPIO port A needs to be enabled so these pins can // be used. // TODO: change this to whichever GPIO port you are using. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Configure the pin muxing for SSI0 functions on port A2, A3, A4, and A5. // This step is not necessary if your part does not support pin muxing. // TODO: change this to select the port/pin you are using. // GPIOPinConfigure(GPIO_PA2_SSI0CLK); GPIOPinConfigure(GPIO_PA3_SSI0FSS); GPIOPinConfigure(GPIO_PA4_SSI0RX); GPIOPinConfigure(GPIO_PA5_SSI0TX); // // Configure the GPIO settings for the SSI pins. This function also gives // control of these pins to the SSI hardware. Consult the data sheet to // see which functions are allocated per pin. // The pins are assigned as follows: // PA5 - SSI0Tx // PA4 - SSI0Rx // PA3 - SSI0Fss // PA2 - SSI0CLK // TODO: change this to select the port/pin you are using. // GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 | GPIO_PIN_2); // // Configure and enable the SSI port for TI master mode. Use SSI0, system // clock supply, master mode, 1MHz SSI frequency, and 8-bit data. // SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_TI, SSI_MODE_MASTER, 1000000, 8); // // Enable the SSI0 module. // SSIEnable(SSI0_BASE); // // Read any residual data from the SSI port. This makes sure the receive // FIFOs are empty, so we don't read any unwanted junk. This is done here // because the TI SSI mode is full-duplex, which allows you to send and // receive at the same time. The SSIDataGetNonBlocking function returns // "true" when data was returned, and "false" when no data was returned. // The "non-blocking" function checks if there is any data in the receive // FIFO and does not "hang" if there isn't. // while(SSIDataGetNonBlocking(SSI0_BASE, &ulDataRx[0])) { } // // Initialize the data to send. // ulDataTx[0] = 't'; ulDataTx[1] = 'i'; ulDataTx[2] = '!'; // // Display indication that the SSI is transmitting data. // UARTprintf("Sent:\n "); // // Send 3 bytes of data. // for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++) { // // Display the data that SSI is transferring. // UARTprintf("'%c' ", ulDataTx[ulindex]); // // Send the data using the "blocking" put function. This function // will wait until there is room in the send FIFO before returning. // This allows you to assure that all the data you send makes it into // the send FIFO. // SSIDataPut(SSI0_BASE, ulDataTx[ulindex]); } // // Wait until SSI0 is done transferring all the data in the transmit FIFO. // while(SSIBusy(SSI0_BASE)) { } // // Display indication that the SSI is receiving data. // UARTprintf("\nReceived:\n "); // // Receive 3 bytes of data. // for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++) { // // Receive the data using the "blocking" Get function. This function // will wait until there is data in the receive FIFO before returning. // SSIDataGet(SSI0_BASE, &ulDataRx[ulindex]); // // Since we are using 8-bit data, mask off the MSB. // ulDataRx[ulindex] &= 0x00FF; // // Display the data that SSI0 received. // UARTprintf("'%c' ", ulDataRx[ulindex]); } // // Return no errors // return(0); }
//***************************************************************************** // // This example demonstrates how to configure MPU regions for different levels // of memory protection. The following memory map is set up: // // 0000.0000 - 0000.1C00 - rgn 0: executable read-only, flash // 0000.1C00 - 0000.2000 - rgn 0: no access, flash (disabled sub-region 7) // 2000.0000 - 2000.1000 - rgn 1: read-write, RAM // 2000.1000 - 2000.1400 - rgn 2: read-only, RAM (disabled sub-rgn 4 of rgn 1) // 2000.1400 - 2000.2000 - rgn 1: read-write, RAM // 4000.0000 - 4001.0000 - rgn 3: read-write, peripherals // 4001.0000 - 4002.0000 - rgn 3: no access (disabled sub-region 1) // 4002.0000 - 4006.0000 - rgn 3: read-write, peripherals // 4006.0000 - 4008.0000 - rgn 3: no access (disabled sub-region 6, 7) // E000.E000 - E000.F000 - rgn 4: read-write, NVIC // // The example code will attempt to perform the following operations and check // the faulting behavior: // // - write to flash (should fault) // - read from the disabled area of flash (should fault) // - read from the read-only area of RAM (should not fault) // - write to the read-only section of RAM (should fault) // //***************************************************************************** int main(void) { unsigned int bFail = 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. // Display96x16x1Init(false); Display96x16x1StringDraw("MPU example", 12, 0); // // Configure an executable, read-only MPU region for flash. It is an 8 KB // region with the last 1 KB disabled to result in a 7 KB executable // region. This region is needed so that the program can execute from // flash. // MPURegionSet(0, FLASH_BASE, MPU_RGN_SIZE_8K | MPU_RGN_PERM_EXEC | MPU_RGN_PERM_PRV_RO_USR_RO | MPU_SUB_RGN_DISABLE_7 | MPU_RGN_ENABLE); // // Configure a read-write MPU region for RAM. It is an 8 KB region. There // is a 1 KB sub-region in the middle that is disabled in order to open up // a hole in which different permissions can be applied. // MPURegionSet(1, SRAM_BASE, MPU_RGN_SIZE_8K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RW_USR_RW | MPU_SUB_RGN_DISABLE_4 | MPU_RGN_ENABLE); // // Configure a read-only MPU region for the 1 KB of RAM that is disabled in // the previous region. This region is used for demonstrating read-only // permissions. // MPURegionSet(2, SRAM_BASE + 0x1000, MPU_RGN_SIZE_1K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RO_USR_RO | MPU_RGN_ENABLE); // // Configure a read-write MPU region for peripherals. The region is 512 KB // total size, with several sub-regions disabled to prevent access to areas // where there are no peripherals. This region is needed because the // program needs access to some peripherals. // MPURegionSet(3, 0x40000000, MPU_RGN_SIZE_512K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RW_USR_RW | MPU_SUB_RGN_DISABLE_1 | MPU_SUB_RGN_DISABLE_6 | MPU_SUB_RGN_DISABLE_7 | MPU_RGN_ENABLE); // // Configure a read-write MPU region for access to the NVIC. The region is // 4 KB in size. This region is needed because NVIC registers are needed // in order to control the MPU. // MPURegionSet(4, NVIC_BASE, MPU_RGN_SIZE_4K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RW_USR_RW | MPU_RGN_ENABLE); // // Need to clear the NVIC fault status register to make sure there is no // status hanging around from a previous program. // g_ulFaultStatus = HWREG(NVIC_FAULT_STAT); HWREG(NVIC_FAULT_STAT) = g_ulFaultStatus; // // Enable the MPU fault. // IntEnable(FAULT_MPU); // // Enable the MPU. This will begin to enforce the memory protection // regions. The MPU is configured so that when in the hard fault or NMI // exceptions, a default map will be used. Neither of these should occur // in this example program. // MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to write to the flash. This should cause a protection fault due // to the fact that this region is read-only. // g_ulMPUFaultCount = 0; HWREG(0x100) = 0x12345678; // // Verify that the fault occurred, at the expected address. // if(!((g_ulMPUFaultCount == 1) && (g_ulFaultStatus == 0x82) && (g_ulMMAR == 0x100))) { bFail = 1; } // // The MPU was disabled when the previous fault occurred, so it needs to be // re-enabled. // MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to read from the disabled section of flash, the upper 1 KB of // the 8 KB region. // g_ulMPUFaultCount = 0; g_ulValue = HWREG(0x1C10); // // Verify that the fault occurred, at the expected address. // if(!((g_ulMPUFaultCount == 1) && (g_ulFaultStatus == 0x82) && (g_ulMMAR == 0x1C10))) { bFail = 1; } // // The MPU was disabled when the previous fault occurred, so it needs to be // re-enabled. // MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to read from the read-only area of RAM, the middle 1 KB of the // 8 KB region. // g_ulMPUFaultCount = 0; g_ulValue = HWREG(0x20001040); // // Verify that the RAM read did not cause a fault. // if(g_ulMPUFaultCount != 0) { bFail = 1; } // // The MPU should not have been disabled since the last access was not // supposed to cause a fault. But if it did cause a fault, then the MPU // will be disabled, so re-enable it here anyway, just in case. // MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to write to the read-only area of RAM, the middle 1 KB of the // 8 KB region. // g_ulMPUFaultCount = 0; HWREG(0x20001060) = 0xabcdef00; // // Verify that the RAM write caused a fault. // if(!((g_ulMPUFaultCount == 1) && (g_ulFaultStatus == 0x82) && (g_ulMMAR == 0x20001060))) { bFail = 1; } // // Display the results of the example program. // if(bFail) { Display96x16x1StringDraw("Failure!", 24, 1); } else { Display96x16x1StringDraw("Success!", 24, 1); } // // Disable the MPU, so there are no lingering side effects if another // program is run. // MPUDisable(); // // Finished. // while(1) { } }
/* * Function Name: setup() * Input: none * Output: none * Description: Set crystal frequency and enable GPIO Peripherals * Example Call: setup(); */ void setup(void) { SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); // 4? SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); }
//***************************************************************************** // // A simple demonstration of the features of the Stellaris Graphics Library. // //***************************************************************************** int main(void) { tContext sContext; tRectangle sRect; // // The FPU should be enabled because some compilers will use floating- // point registers, even for non-floating-point code. If the FPU is not // enabled this will cause a fault. This also ensures that floating- // point operations could be added to this application and would work // correctly and use the hardware floating-point unit. Finally, lazy // stacking is enabled for interrupt handlers. This allows floating- // point instructions to be used within interrupt handlers, but at the // expense of extra stack usage. // FPUEnable(); FPULazyStackingEnable(); // // Set the clock to 40Mhz derived from the PLL and the external oscillator // SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); // // Initialize the display driver. // Kentec320x240x16_SSD2119Init(); // // Initialize the graphics context. // GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119); // // Fill the top 24 rows of the screen with blue to create the banner. // sRect.i16XMin = 0; sRect.i16YMin = 0; sRect.i16XMax = GrContextDpyWidthGet(&sContext) - 1; sRect.i16YMax = 23; GrContextForegroundSet(&sContext, ClrDarkBlue); GrRectFill(&sContext, &sRect); // // Put a white box around the banner. // GrContextForegroundSet(&sContext, ClrWhite); GrRectDraw(&sContext, &sRect); // // Put the application name in the middle of the banner. // GrContextFontSet(&sContext, &g_sFontCm20); GrStringDrawCentered(&sContext, "grlib demo", -1, GrContextDpyWidthGet(&sContext) / 2, 8, 0); // // Configure and enable uDMA // SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA); SysCtlDelay(10); uDMAControlBaseSet(&sDMAControlTable[0]); uDMAEnable(); // // Initialize the touch screen driver and have it route its messages to the // widget tree. // TouchScreenInit(); TouchScreenCallbackSet(WidgetPointerMessage); // // Add the title block and the previous and next buttons to the widget // tree. // WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sPrevious); WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sTitle); WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sNext); // // Add the first panel to the widget tree. // g_ulPanel = 0; WidgetAdd(WIDGET_ROOT, (tWidget *)g_psPanels); CanvasTextSet(&g_sTitle, g_pcPanelNames[0]); // // Issue the initial paint request to the widgets. // WidgetPaint(WIDGET_ROOT); // // Loop forever handling widget messages. // while(1) { // // Process any messages in the widget message queue. // WidgetMessageQueueProcess(); } }
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) { } }
//***************************************************************************** // // Configure Timer0B as a 16-bit periodic counter with an interrupt // every 1ms. // //***************************************************************************** int main(void) { uint32_t ui32PrevCount = 0; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // The Timer0 peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for Timer operation. // InitConsole(); // // Display the example setup on the console. // UARTprintf("16-Bit Timer Interrupt ->"); UARTprintf("\n Timer = Timer0B"); UARTprintf("\n Mode = Periodic"); UARTprintf("\n Number of interrupts = %d", NUMBER_OF_INTS); UARTprintf("\n Rate = 1ms\n\n"); // // Configure Timer0B as a 16-bit periodic timer. // TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_B_PERIODIC); // // Set the Timer0B load value to 1ms. // TimerLoadSet(TIMER0_BASE, TIMER_B, SysCtlClockGet() / 1000); // // Enable processor interrupts. // IntMasterEnable(); // // Configure the Timer0B interrupt for timer timeout. // TimerIntEnable(TIMER0_BASE, TIMER_TIMB_TIMEOUT); // // Enable the Timer0B interrupt on the processor (NVIC). // IntEnable(INT_TIMER0B); // // Initialize the interrupt counter. // g_ui32Counter = 0; // // Enable Timer0B. // TimerEnable(TIMER0_BASE, TIMER_B); // // Loop forever while the Timer0B runs. // while(1) { // // If the interrupt count changed, print the new value // if(ui32PrevCount != g_ui32Counter) { // // Print the periodic interrupt counter. // UARTprintf("Number of interrupts: %d\r", g_ui32Counter); ui32PrevCount = g_ui32Counter; } } }
//***************************************************************************** // // This example demonstrates how to setup the PWM block to generate signals. // //***************************************************************************** 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_6MHZ); SysCtlPWMClockSet(SYSCTL_PWMDIV_1); // // Initialize the OLED display. // Display96x16x1Init(false); // // Clear the screen and thell the user what is happening. // Display96x16x1StringDraw("Generating PWM", 6, 0); Display96x16x1StringDraw("on PD0 and PD1", 6, 1); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Set GPIO D0 and D1 as PWM pins. They are used to output the PWM0 and // PWM1 signals. // GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Compute the PWM period based on the system clock. // ulPeriod = SysCtlClockGet() / 50000; // // Set the PWM period to 50 kHz. // 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); // // Enable the PWM generator. // PWMGenEnable(PWM0_BASE, PWM_GEN_0); // // Loop forever while the PWM signals are generated. // while(1) { } }
//***************************************************************************** // // Configure the CAN and enter a loop to receive CAN messages. // //***************************************************************************** int main(void) { tCANMsgObject sCANMessage; unsigned char ucMsgData[8]; // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal used on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set up the serial console to use for displaying messages. This is // just for this example program and is not needed for CAN operation. // InitConsole(); // // For this example CAN0 is used with RX and TX pins on port D0 and D1. // The actual port and pins used may be different on your part, consult // the data sheet for more information. // GPIO port D needs to be enabled so these pins can be used. // TODO: change this to whichever GPIO port you are using // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Configure the GPIO pin muxing to select CAN0 functions for these pins. // This step selects which alternate function is available for these pins. // This is necessary if your part supports GPIO pin function muxing. // Consult the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using // GPIOPinConfigure(GPIO_PD0_CAN0RX); GPIOPinConfigure(GPIO_PD1_CAN0TX); // // Enable the alternate function on the GPIO pins. The above step selects // which alternate function is available. This step actually enables the // alternate function instead of GPIO for these pins. // TODO: change this to match the port/pin you are using // GPIOPinTypeCAN(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // The GPIO port and pins have been set up for CAN. The CAN peripheral // must be enabled. // SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0); // // Initialize the CAN controller // CANInit(CAN0_BASE); // // Set up the bit rate for the CAN bus. This function sets up the CAN // bus timing for a nominal configuration. You can achieve more control // over the CAN bus timing by using the function CANBitTimingSet() instead // of this one, if needed. // In this example, the CAN bus is set to 500 kHz. In the function below, // the call to SysCtlClockGet() is used to determine the clock rate that // is used for clocking the CAN peripheral. This can be replaced with a // fixed value if you know the value of the system clock, saving the extra // function call. For some parts, the CAN peripheral is clocked by a fixed // 8 MHz regardless of the system clock in which case the call to // SysCtlClockGet() should be replaced with 8000000. Consult the data // sheet for more information about CAN peripheral clocking. // CANBitRateSet(CAN0_BASE, SysCtlClockGet(), 500000); // // Enable interrupts on the CAN peripheral. This example uses static // allocation of interrupt handlers which means the name of the handler // is in the vector table of startup code. If you want to use dynamic // allocation of the vector table, then you must also call CANIntRegister() // here. // // CANIntRegister(CAN0_BASE, CANIntHandler); // if using dynamic vectors // CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS); // // Enable the CAN interrupt on the processor (NVIC). // IntEnable(INT_CAN0); // // Enable the CAN for operation. // CANEnable(CAN0_BASE); // // Initialize a message object to receive CAN messages with ID 0x1001. // The expected ID must be set along with the mask to indicate that all // bits in the ID must match. // sCANMessage.ulMsgID = 0x1001; // CAN msg ID sCANMessage.ulMsgIDMask = 0xfffff; // mask, all 20 bits must match sCANMessage.ulFlags = MSG_OBJ_RX_INT_ENABLE | MSG_OBJ_USE_ID_FILTER | MSG_OBJ_EXTENDED_ID; sCANMessage.ulMsgLen = 8; // allow up to 8 bytes // // Now load the message object into the CAN peripheral message object 1. // Once loaded the CAN will receive any messages with this CAN ID into // this message object, and an interrupt will occur. // CANMessageSet(CAN0_BASE, 1, &sCANMessage, MSG_OBJ_TYPE_RX); // // Change the ID to 0x2001, and load into message object 2 which will be // used for receiving any CAN messages with this ID. Since only the CAN // ID field changes, we don't need to reload all the other fields. // sCANMessage.ulMsgID = 0x2001; CANMessageSet(CAN0_BASE, 2, &sCANMessage, MSG_OBJ_TYPE_RX); // // Change the ID to 0x3001, and load into message object 3 which will be // used for receiving any CAN messages with this ID. Since only the CAN // ID field changes, we don't need to reload all the other fields. // sCANMessage.ulMsgID = 0x3001; // CAN msg ID CANMessageSet(CAN0_BASE, 3, &sCANMessage, MSG_OBJ_TYPE_RX); // // Enter loop to process received messages. This loop just checks flags // for each of the 3 expected messages. The flags are set by the interrupt // handler, and if set this loop reads out the message and displays the // contents to the console. This is not a robust method for processing // incoming CAN data and can only handle one messages at a time per message // object. If many messages are being received close together using the // same message object, then some messages may be dropped. In a real // application, some other method should be used for queuing received // messages in a way to ensure they are not lost. You can also make use // of CAN FIFO mode which will allow messages to be buffered before they // are processed. // for(;;) { // // If the flag for message object 1 is set, that means that the RX // interrupt occurred and there is a message ready to be read from // this CAN message object. // if(g_bRXFlag1) { // // Reuse the same message object that was used earlier to configure // the CAN for receiving messages. A buffer for storing the // received data must also be provided, so set the buffer pointer // within the message object. This same buffer is used for all // messages in this example, but your application could set a // different buffer each time a message is read in order to store // different messages in different buffers. // sCANMessage.pucMsgData = ucMsgData; // // Read the message from the CAN. Message object number 1 is used // (which is not the same thing as CAN ID). The interrupt clearing // flag is not set because this interrupt was already cleared in // the interrupt handler. // CANMessageGet(CAN0_BASE, 1, &sCANMessage, 0); // // Clear the pending message flag so that the interrupt handler can // set it again when the next message arrives. // g_bRXFlag1 = 0; // // Print information about the message just received. // PrintCANMessageInfo(&sCANMessage, 1); } // // Check for message received on message object 2. If so then // read message and print information. // if(g_bRXFlag2) { sCANMessage.pucMsgData = ucMsgData; CANMessageGet(CAN0_BASE, 2, &sCANMessage, 0); g_bRXFlag2 = 0; PrintCANMessageInfo(&sCANMessage, 2); } // // Check for message received on message object 3. If so then // read message and print information. // if(g_bRXFlag3) { sCANMessage.pucMsgData = ucMsgData; CANMessageGet(CAN0_BASE, 3, &sCANMessage, 0); g_bRXFlag3 = 0; PrintCANMessageInfo(&sCANMessage, 3); } } // // Return no errors // return(0); }
int main(void) { unsigned long adc_result[16]; unsigned long cnt; float temperature; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Configure low-level I/O to use printf() // llio_init(115200); // // Configure ADC // SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC); SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS); // ADC sequence #0 - setup with 2 conversions ADCSequenceDisable(ADC_BASE, 0); ADCSequenceConfigure(ADC_BASE, 0, ADC_TRIGGER_TIMER, 0); ADCIntRegister(ADC_BASE, 0, ADCIntHandler); ADCIntEnable(ADC_BASE, 0); // sequence step 0 - channel 0 ADCSequenceStepConfigure(ADC_BASE, 0, 0, ADC_CTL_CH0); // sequence step 1 - internal temperature sensor. Generate Interrupt & End of Sequence ADCSequenceStepConfigure(ADC_BASE, 0, 1, ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END); ADCSequenceEnable(ADC_BASE, 0); // // Configure Timer to trigger ADC // SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); TimerConfigure( TIMER0_BASE, TIMER_CFG_32_BIT_PER ); TimerControlTrigger(TIMER0_BASE, TIMER_A, true); TimerLoadSet( TIMER0_BASE, TIMER_A, SysCtlClockGet() / 2 ); // 2Hz trigger TimerEnable( TIMER0_BASE, TIMER_A ); printf("\r\n\r\nADC 2 Channel Example\r\n"); // // Loop forever. // while(1) { cnt = ADCSequenceDataGet(ADC_BASE, 0, adc_result); if (cnt == 2) { // Calculate temperature temperature = (2.7 - (float)adc_result[1] * 3.0 / 1024.) * 75. - 55.; printf("%d,%d,%.1f\r\n", adc_result[0], adc_result[1], temperature); } SysCtlSleep(); } }
main() { uint8 option=0; uint8 key; SysCtlClockSet(SYSCTL_SYSDIV_4| SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ); Uart0Init(19200); Uart1Init(9600); Uart2Init(19200); IntMasterEnable(); SysLinearTimer =0; IoPortInit(); //IO口初始化 I2C1Init() ;//Fm31256 TimerInit(); xs6963_init(); PIN_TDA7367stand_Write(ETDA7367work_no); FlashUsecSet(49); //T1Init_LM331(); DPRINTF(("Bat=%d ,cha=%d ,Temp=%d \n",1,2,3)); Usb_Host_Init(); mainHandleinit(); signPWM_init(50.0); PWM_sign_stop(); /*LCD初始化*/ start_mune(); /* fm31256 eeprom 8 */ readbyte_much(setsto_addr,settype_nub,set.byte ); /*修正系数*/ modify_read(); /**/ Oiltempset.oilTwork=EOiltemp_Workon; /*lm331初始化 温度测量使用*/ T1Init_LM331(); /*系统节拍*/ SysLinearTimer=0; while(SysLinearTimer<3*TIMER_FREQ)//后台参数设置 { key=Keyset.keyEfficiency; if(key==key_modify) { while(Keyset.keyEfficiency==key_modify); option++; if(option>=4) { modify_read();//读取修正参数 TgC_read(); modify();//修正 } } } modifyK_js(); SysLinearTimer=0; rx_flag=0; option=0; mainset_go: key=Keyset.keyEfficiency; mainset_mune(); Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); while(1) { while(key==Keyset.keyEfficiency) { if(SysLinearTimer>(3*TIMER_FREQ/4)) { // Temp_account(); if(TRUE_z==Gandispose())//地线检测 { mainset_mune(); Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); } read_time(); { uint8 byte[12]; Clock_viewxs(byte) ; } SysLinearTimer=0; } } key=Keyset.keyEfficiency; /*按键处理*/ switch(key) { case key_no: case key_back: continue; case key_down: case key_up: Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); option=keyoption_js(option, key,4,Emune_key);// Reversepic(mainset_lin+option*mainset_high, mainset_column, mainset_high, 2*4); /* if(key==key_up) { PWM_sign_acc(0.0, 0.0); delay(0x80000); PIN_DCAC_pwm(EDC_power); PWM_sign_acc(0.0, 0.7); } else { PWM_sign_acc(0.0, 0.0); delay(0x80000); PIN_DCAC_pwm(EAC_power); PWM_sign_acc(50.0, 0.8); } */ break; case key_ok: switch(option) { case ELan_main://语言 set.mune.Langue++; set.mune.Langue&=0x01; //ShowtextLine(mainset_lin+option*mainset_high, mainset_column+0x10,Lanset_p[set.mune.Langue]); break; case EOilset_main://油样设置 oidset(); break; case EView_main://历史数据 Viewdata_Hander(); break; case EClock_main://时钟设置 clockset_mune(); break; } goto mainset_go ; case key_oil: Oilclear();//排油 break; } } }
//***************************************************************************** // // The main code for the application. It sets up the peripherals, displays the // splash screens, and then manages the interaction between the game and the // screen saver. // //***************************************************************************** int main(void) { // // If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is // a workaround to allow the PLL to operate reliably. // if(REVISION_IS_A2) { SysCtlLDOSet(SYSCTL_LDO_2_75V); } // // Set the clocking to run at 50MHz from the PLL. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); SysCtlPWMClockSet(SYSCTL_PWMDIV_8); // // Get the system clock speed. // g_ulSystemClock = SysCtlClockGet(); // // Enable the peripherals used by the application. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure the GPIOs used to read the state of the on-board push buttons. // 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); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1); GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // // Configure the LED, speaker, and UART GPIOs as required. // GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_1); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0, 0); // // Intialize the Ethernet Controller and TCP/IP Stack. // EnetInit(); // // Configure the first UART for 115,200, 8-N-1 operation. // UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); UARTEnable(UART0_BASE); // // Send a welcome message to the UART. // UARTCharPut(UART0_BASE, 'W'); UARTCharPut(UART0_BASE, 'e'); UARTCharPut(UART0_BASE, 'l'); UARTCharPut(UART0_BASE, 'c'); UARTCharPut(UART0_BASE, 'o'); UARTCharPut(UART0_BASE, 'm'); UARTCharPut(UART0_BASE, 'e'); UARTCharPut(UART0_BASE, '\r'); UARTCharPut(UART0_BASE, '\n'); // // Initialize the OSRAM OLED display. // RIT128x96x4Init(3500000); // // Initialize the PWM for generating music and sound effects. // AudioOn(); // // Configure SysTick to periodically interrupt. // SysTickPeriodSet(g_ulSystemClock / CLOCK_RATE); SysTickIntEnable(); SysTickEnable(); // // Delay for a bit to allow the initial display flash to subside. // Delay(CLOCK_RATE / 4); // // Play the intro music. // AudioPlaySong(g_pusIntro, sizeof(g_pusIntro) / 2); // // Display the Texas Instruments logo for five seconds (or twelve seconds // if built using gcc). // #if defined(gcc) DisplayLogo(g_pucTILogo, 120, 42, 12 * CLOCK_RATE); #else DisplayLogo(g_pucTILogo, 120, 42, 5 * CLOCK_RATE); #endif // // Display the Code Composer Studio logo for five seconds. // #if defined(ccs) DisplayLogo(g_pucCodeComposer, 128, 34, 5 * CLOCK_RATE); #endif // // Display the Keil/ARM logo for five seconds. // #if defined(rvmdk) || defined(__ARMCC_VERSION) DisplayLogo(g_pucKeilLogo, 128, 40, 5 * CLOCK_RATE); #endif // // Display the IAR logo for five seconds. // #if defined(ewarm) DisplayLogo(g_pucIarLogo, 102, 61, 5 * CLOCK_RATE); #endif // // Display the CodeSourcery logo for five seconds. // #if defined(sourcerygxx) DisplayLogo(g_pucCodeSourceryLogo, 128, 34, 5 * CLOCK_RATE); #endif // // Display the CodeRed logo for five seconds. // #if defined(codered) DisplayLogo(g_pucCodeRedLogo, 128, 32, 5 * CLOCK_RATE); #endif // // Throw away any button presses that may have occurred while the splash // screens were being displayed. // HWREGBITW(&g_ulFlags, FLAG_BUTTON_PRESS) = 0; // // Loop forever. // while(1) { // // Display the main screen. // if(MainScreen()) { // // The button was pressed, so start the game. // PlayGame(); } else { // // The button was not pressed during the timeout period, so start // the screen saver. // ScreenSaver(); } } }
//***************************************************************************** // // This example demonstrates how to send a string of data to the UART. // //***************************************************************************** int main(void) { // // 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("UART Echo", 36, 0, 15); RIT128x96x4StringDraw("Port: Uart 0", 12, 16, 15); RIT128x96x4StringDraw("Baud: 115,200 bps", 12, 24, 15); RIT128x96x4StringDraw("Data: 8 Bit", 12, 32, 15); RIT128x96x4StringDraw("Parity: None", 12, 40, 15); RIT128x96x4StringDraw("Stop: 1 Bit", 12, 48, 15); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable processor interrupts. // IntMasterEnable(); // // Set GPIO A0 and A1 as UART pins. // GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure the UART for 115,200, 8-N-1 operation. // UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200, (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); // // Prompt for text to be entered. // UARTSend((unsigned char *)"Enter text: ", 12); // // Loop forever echoing data through the UART. // while(1) { } }
//***************************************************************************** // // Configure the PWM0 block with dead-band generation. The example configures // the PWM0 block to generate a 25% duty cycle signal on PD0 with dead-band // generation. This will produce a complement of PD0 on PD1 (75% duty cycle). // The dead-band generator is set to have a 10us or 160 cycle delay // (160cycles / 16Mhz = 10us) on the rising and falling edges of the PD0 PWM // signal. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the external crystal/oscillator. // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the // crystal on your board. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Set the PWM clock to the system clock. // SysCtlPWMClockSet(SYSCTL_PWMDIV_1); // // Set up the serial console to use for displaying messages. This is just // for this example program and is not needed for PWM operation. // InitConsole(); // // Display the setup on the console. // UARTprintf("PWM ->\n"); UARTprintf(" Module: PWM0\n"); UARTprintf(" Pin(s): PD0 and PD1\n"); UARTprintf(" Features: Dead-band Generation\n"); UARTprintf(" Duty Cycle: 25%% on PD0 and 75%% on PD1\n"); UARTprintf(" Dead-band Length: 160 cycles on rising and falling edges\n\n"); UARTprintf("Generating PWM on PWM0 (PD0) -> "); // // The PWM peripheral must be enabled for use. // SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM); // // For this example PWM0 is used with PortD Pins 0 and 1. The actual port // and pins used may be different on your part, consult the data sheet for // more information. GPIO port D needs to be enabled so these pins can be // used. // TODO: change this to whichever GPIO port you are using. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Configure the GPIO pin muxing to select PWM functions for these pins. // This step selects which alternate function is available for these pins. // This is necessary if your part supports GPIO pin function muxing. // Consult the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using. // GPIOPinConfigure(GPIO_PD0_PWM0); GPIOPinConfigure(GPIO_PD1_PWM1); // // Configure the GPIO pad for PWM function on pins PD0 and PD1. Consult // the data sheet to see which functions are allocated per pin. // TODO: change this to select the port/pin you are using. // GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0); GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_1); // // Configure the PWM0 to count up/down without synchronization. // Note: Enabling the dead-band generator automatically couples the 2 // outputs from the PWM block so we don't use the PWM synchronization. // PWMGenConfigure(PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC); // // Set the PWM period to 250Hz. To calculate the appropriate parameter // use the following equation: N = (1 / f) * SysClk. Where N is the // function parameter, f is the desired frequency, and SysClk is the // system clock frequency. // In this case you get: (1 / 250Hz) * 16MHz = 64000 cycles. Note that // the maximum period you can set is 2^16 - 1. // TODO: modify this calculation to use the clock frequency that you are // using. // PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 64000); // // Set PWM0 PD0 to a duty cycle of 25%. You set the duty cycle as a // function of the period. Since the period was set above, you can use the // PWMGenPeriodGet() function. For this example the PWM will be high for // 25% of the time or 16000 clock cycles (64000 / 4). // PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, PWMGenPeriodGet(PWM_BASE, PWM_OUT_0) / 4); // // Enable the dead-band generation on the PWM0 output signal. PWM bit 0 // (PD0), will have a duty cycle of 25% (set above) and PWM bit 1 will have // a duty cycle of 75%. These signals will have a 10us gap between the // rising and falling edges. This means that before PWM bit 1 goes high, // PWM bit 0 has been low for at LEAST 160 cycles (or 10us) and the same // before PWM bit 0 goes high. The dead-band generator lets you specify // the width of the "dead-band" delay, in PWM clock cycles, before the PWM // signal goes high and after the PWM signal falls. For this example we // will use 160 cycles (or 10us) on both the rising and falling edges of // PD0. Reference the datasheet for more information on dead-band // generation. // PWMDeadBandEnable(PWM_BASE, PWM_GEN_0, 160, 160); // // Enable the PWM0 Bit 0 (PD0) and Bit 1 (PD1) output signals. // PWMOutputState(PWM_BASE, PWM_OUT_1_BIT | PWM_OUT_0_BIT, true); // // Enables the counter for a PWM generator block. // PWMGenEnable(PWM_BASE, PWM_GEN_0); // // Loop forever while the PWM signals are generated. // while(1) { // // Print out indication on the console that the program is running. // PrintRunningDots(); } }