void MCInitPwm(uint32_t DutyCycle)
{
// Clock PWM peripheral at SysClk/PWMDIV
ROM_SysCtlPWMClockSet(SYSCTL_PWMDIV_64);
// Enable peripherals
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
// Configure pin PD0 as PWM output
ROM_GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0|GPIO_PIN_1);
ROM_GPIOPinConfigure(GPIO_PD0_M1PWM0);
ROM_GPIOPinConfigure(GPIO_PD1_M1PWM1);
// Calculate PWM clock
uint32_t PWMClock = SysCtlClockGet() / 64;
// Value from/to which PWM counter counts (subtract 1 becouse counter counts from 0). This is PWM period
LoadValue = (PWMClock/PWM_FREQUENCY) - 1;
// Configure PWM
ROM_PWMGenConfigure(PWM1_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN);
ROM_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_0, LoadValue);
// Set PWM signal width
ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_1, (DutyCycle*LoadValue)/DUTY_CYCLE_DIVIDER);
ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_0, (DutyCycle*LoadValue)/DUTY_CYCLE_DIVIDER);
// Enable PWM output 0 and 1
ROM_PWMOutputState(PWM1_BASE, PWM_OUT_0_BIT|PWM_OUT_1_BIT, true);
// Enable PWM generator
ROM_PWMGenEnable(PWM1_BASE, PWM_GEN_0);
}
int xMotorDriverInit()
{
SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R10 | SYSCTL_RCGCGPIO_R5;
vSemaphoreCreateBinary(changeSpeed);
ROM_GPIOPinTypePWM(MOTOR_L_PWM_PORT, MOTOR_L_PWM_PIN);
ROM_GPIOPinConfigure(GPIO_PF2_M0PWM2);
ROM_GPIOPinTypePWM(MOTOR_R_PWM_PORT, MOTOR_R_PWM_PIN);
ROM_GPIOPinConfigure(GPIO_PF3_M0PWM3);
GPIO_PORTL_DIR_R |= 0xF;
GPIO_PORTL_DEN_R |= 0xF;
PWM0_1_GENA_R = 0x8C;
PWM0_1_GENB_R = 0x8C;
ROM_PWMGenConfigure(PWM0_BASE, PWM_GEN_1, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_GEN_NO_SYNC);
ROM_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, 256);
ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2, 25);
ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3, 25);
ROM_PWMGenEnable(PWM0_BASE, PWM_GEN_1);
MOTOR_L_DIR1_PORT &= ~MOTOR_L_DIR1_PIN;
MOTOR_L_DIR2_PORT |= MOTOR_L_DIR2_PIN;
MOTOR_R_DIR1_PORT &= ~MOTOR_R_DIR1_PIN;
MOTOR_R_DIR2_PORT |= MOTOR_R_DIR2_PIN;
PWM0_1_CTL_R |= 0x5;
PWM0_ENABLE_R |= 0x4 | 0x8;
return 0;
}
// * svm_init *****************************************************************
// * setup pins and PWM hardware to talk to servomotors *
// * Assumes system clock already configured *
// ****************************************************************************
void svm_init(void)
{
ROM_SysCtlPeripheralEnable(SVM_OUTPUT_PORT); // enable clock to GPIO port
ROM_SysCtlPeripheralReset(SVM_OUTPUT_PORT); // reset to clear any previous config
// configure output pads
GPIOPinTypeGPIOOutput(SVM_OUTPUT_PORT_BASE, SVM_OUTPUT_PINS);
// configure PWM
ROM_SysCtlPeripheralEnable(SVM_PWM_MODULE); // enable clock to pwm module
ROM_SysCtlPWMClockSet(SVM_PWM_FPWM_DIV); // configure clock divider to derive Fpwm from Fsys
// wrap 16b PWM counter at 1041 for 3kHz pwm output
ROM_PWMDeadBandDisable(SVM_PWM_BASE, SVM_PWM_GEN); // allow PWM0, PWM1 to behave independently
ROM_PWMGenConfigure(SVM_PWM_BASE, SVM_PWM_GEN, // configure pwm generator
PWM_GEN_MODE_DOWN | // up/down count for center timed PWM
PWM_GEN_MODE_NO_SYNC); // outputs from generator behave independently
ROM_PWMGenPeriodSet(SVM_PWM_BASE, SVM_PWM_GEN, // sets period for generator to appropriate period
SVM_PWM_PERIOD_TICKS);
ROM_PWMPulseWidthSet(SVM_PWM_BASE, SVM_1_PWM, 0); // set initial pulse widths to 0 for safety
ROM_PWMPulseWidthSet(SVM_PWM_BASE, SVM_2_PWM, 0); // set initial pulse widths to 0 for safety
ROM_GPIOPinConfigure(SVM_1_PWM_MUX); // select mux for pwm output hbridge 1
ROM_GPIOPinConfigure(SVM_2_PWM_MUX); // select mux for pwm output hbridge 2
ROM_GPIOPinTypePWM(SVM_OUTPUT_PORT_BASE, SVM_1_PWM_PIN);// do some other step configuring pwm...
ROM_GPIOPinTypePWM(SVM_OUTPUT_PORT_BASE, SVM_2_PWM_PIN);// ...exact function is unknown
ROM_PWMOutputState(SVM_PWM_BASE, SVM_1_PWM_BIT | SVM_2_PWM_BIT, true);
// enable outputs from pwm generator to pins
ROM_PWMGenEnable(SVM_PWM_BASE, SVM_PWM_GEN); // enable pwm output generator
}
//*****************************************************************************
//
// This example demonstrates how to setup the PWM block to generate signals.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
unsigned long ulPeriod;
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
ROM_SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
//
// 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 = 14;
GrContextForegroundSet(&g_sContext, ClrDarkBlue);
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_pFontFixed6x8);
GrStringDrawCentered(&g_sContext, "pwmgen", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);
//
// Tell the user what is happening.
//
GrStringDrawCentered(&g_sContext, "Generating PWM on", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 56, 0);
GrStringDrawCentered(&g_sContext, "pins PWM0 and PWM1", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 68, 0);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Set GPIO F0 and F1 as PWM pins. They are used to output the PWM0 and
// PWM1 signals.
//
ROM_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_1,
GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD);
//
// Compute the PWM period based on the system clock.
//
ulPeriod = ROM_SysCtlClockGet() / 8000;
//
// Set the PWM period to 440 (A) Hz.
//
ROM_PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
ROM_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
//
// Set PWM0 to a duty cycle of 50% and PWM1 to a duty cycle of 80%.
//
ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, ((ulPeriod * 8) / 10));
ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ((ulPeriod * 2) / 10));
//
// Enable the PWM0 and PWM1 output signals.
//
ROM_PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
//
// Enable the PWM generator.
//
ROM_PWMGenEnable(PWM0_BASE, PWM_GEN_0);
//
// Loop forever while the PWM signals are generated.
//
while(1)
{
}
}
//*****************************************************************************
//
// This example application demonstrates the use of the different sleep modes
// and different power configuration options.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run from the MOSC with the PLL at 16MHz.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_320), 16000000);
//
// Set the clocking for Deep-Sleep.
// Power down the PIOSC & MOSC to save power and run from the
// internal 30kHz osc.
//
ROM_SysCtlDeepSleepClockConfigSet(1, (SYSCTL_DSLP_OSC_INT30 |
SYSCTL_DSLP_PIOSC_PD | SYSCTL_DSLP_MOSC_PD));
//
// Initialize the UART and write the banner.
// Indicate we are currently in Run Mode.
//
ConfigureUART();
UARTprintf("\033[2J\033[H");
UARTprintf("Sleep Modes example\n\n");
UARTprintf("Mode:\t\tClock Source:\tLED Toggle Source:");
UARTprintf("\nRun\t\tMOSC with PLL\tTimer");
//
// Initialize the buttons driver.
//
ButtonsInit();
//
// Enable the interrupt for the button.
//
ROM_GPIOIntEnable(GPIO_PORTJ_AHB_BASE, GPIO_INT_PIN_0);
//
// Enable the GPIO ports that are used for the on-board LEDs.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Set pad config.
//
MAP_GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_0,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
//
// Set direction.
//
ROM_GPIODirModeSet(GPIO_PORTJ_BASE, GPIO_PIN_0, GPIO_DIR_MODE_IN);
//
// Enable the interrupt for the button.
//
ROM_GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_INT_PIN_0);
//
// Enable interrupt to NVIC.
//
ROM_IntEnable(INT_GPIOJ);
//
// Enable the GPIO ports that are used for the on-board LEDs.
//
ROM_SysCtlPeripheralEnable(RUN_GPIO_SYSCTL);
ROM_SysCtlPeripheralEnable(SLEEP_GPIO_SYSCTL);
ROM_SysCtlPeripheralEnable(DSLEEP_GPIO_SYSCTL);
ROM_SysCtlPeripheralEnable(TOGGLE_GPIO_SYSCTL);
//
// Enable the GPIO pins for the LED.
//
ROM_GPIOPinTypeGPIOOutput(RUN_GPIO_BASE, RUN_GPIO_PIN);
ROM_GPIOPinTypeGPIOOutput(SLEEP_GPIO_BASE, SLEEP_GPIO_PIN);
ROM_GPIOPinTypeGPIOOutput(DSLEEP_GPIO_BASE, DSLEEP_GPIO_PIN);
ROM_GPIOPinTypeGPIOOutput(TOGGLE_GPIO_BASE, TOGGLE_GPIO_PIN);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Configure the 32-bit periodic timer.
//
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, g_ui32SysClock);
//
// Setup the interrupts for the timer timeout.
//
ROM_IntEnable(INT_TIMER0A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Configure the PWM0 to count down without synchronization.
// This will be used in Deep-Sleep.
//
ROM_PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
//
// Enable the PWM0 output signal.
//
ROM_PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, true);
//
// Set up the period to match the timer.
//
ROM_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, 65000);
//
// Configure the PWM for a 50% duty cycle.
//
ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, 65000 >> 1);
//
// Enable the timer.
//
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
//
// Enable the Timer in Sleep Mode.
//
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER0);
//
// Enable the PWM in Deep-Sleep Mode.
//
ROM_SysCtlPeripheralDeepSleepEnable(SYSCTL_PERIPH_PWM0);
//
// Enable the Button Port in Sleep & Deep-Sleep Mode.
//
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOJ);
ROM_SysCtlPeripheralDeepSleepEnable(SYSCTL_PERIPH_GPIOJ);
//
// Enable the LED Ports in Sleep & Deep-Sleep Mode.
//
ROM_SysCtlPeripheralSleepEnable(SLEEP_GPIO_SYSCTL);
ROM_SysCtlPeripheralDeepSleepEnable(DSLEEP_GPIO_SYSCTL);
ROM_SysCtlPeripheralSleepEnable(TOGGLE_GPIO_SYSCTL);
ROM_SysCtlPeripheralDeepSleepEnable(TOGGLE_GPIO_SYSCTL);
//
// Enable Auto Clock Gating Control.
//
ROM_SysCtlPeripheralClockGating(true);
//
// Set LDO to 1.15V in Sleep.
// Set LDO to 1.10V in Deep-Sleep.
//
SysCtlLDOSleepSet(SYSCTL_LDO_1_15V);
SysCtlLDODeepSleepSet(SYSCTL_LDO_1_10V);
//
// Set SRAM to Standby when in Sleep Mode.
// Set Flash & SRAM to Low Power in Deep-Sleep Mode.
//
SysCtlSleepPowerSet(SYSCTL_SRAM_STANDBY);
SysCtlDeepSleepPowerSet(SYSCTL_FLASH_LOW_POWER | SYSCTL_SRAM_LOW_POWER);
//
// Call to set initial LED power state.
//
PowerLEDsSet();
//
// Loop forever.
//
while(1)
{
//
// Handle going into the different sleep modes outside of
// interrupt context.
//
if (g_ui32SleepMode == 1)
{
//
// Go into Sleep Mode.
//
ROM_SysCtlSleep();
}
else if (g_ui32SleepMode == 2)
{
//
// Go into Deep-Sleep Mode.
//
ROM_SysCtlDeepSleep();
}
}
}
//*****************************************************************************
//
// 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.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
ROM_SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
//
// Initialize the UART.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
//
// Tell the user what is happening.
//
UARTprintf("\033[2JGenerating PWM on PD0 and PD1\n");
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Set GPIO D0 and D1 as PWM pins. They are used to output the PWM0 and
// PWM1 signals.
//
GPIOPinConfigure(GPIO_PD0_PWM0);
GPIOPinConfigure(GPIO_PD1_PWM1);
ROM_GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Compute the PWM period based on the system clock.
//
ulPeriod = ROM_SysCtlClockGet() / 440;
//
// Set the PWM period to 440 (A) Hz.
//
ROM_PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
ROM_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
//
// Set PWM0 to a duty cycle of 25% and PWM1 to a duty cycle of 75%.
//
ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, ulPeriod / 4);
ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, (ulPeriod * 3) / 4);
//
// Enable the PWM0 and PWM1 output signals.
//
ROM_PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
//
// Enable the PWM generator.
//
ROM_PWMGenEnable(PWM0_BASE, PWM_GEN_0);
//
// Loop forever while the PWM signals are generated.
//
while(1)
{
}
}
