int main(void)
{
volatile uint32_t ui32Load;
volatile uint32_t ui32PWMClock;
volatile uint8_t ui8Adjust;
ui8Adjust = 254;
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
SysCtlPWMClockSet(SYSCTL_PWMDIV_64);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPinConfigure(GPIO_PF1_M1PWM5);
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);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_2);
while(1)
{
if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)
{
ui8Adjust--;
if (ui8Adjust < 10)
{
ui8Adjust = 10;
}
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
}
if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00)
{
ui8Adjust++;
if (ui8Adjust > 254)
{
ui8Adjust = 254;
}
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
}
SysCtlDelay(100000);
}
}
//******************************************************************
// Initialise the PWM generator (PWM1 & PWM4)
//******************************************************************
void
initPWMchan (void)
{
unsigned long period;
SysCtlPeripheralEnable (SYSCTL_PERIPH_PWM);
//
// Compute the PWM period based on the system clock.
//
SysCtlPWMClockSet (PWM_DIV_CODE);
PWMGenConfigure (PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenConfigure (PWM_BASE, PWM_GEN_2, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
period = SysCtlClockGet () / PWM_DIVIDER / MOTOR_RATE_HZ;
PWMGenPeriodSet (PWM_BASE, PWM_GEN_0, period);
PWMGenPeriodSet (PWM_BASE, PWM_GEN_2, period);
PWMPulseWidthSet (PWM_BASE, PWM_OUT_1, period * main_duty / 100);
PWMPulseWidthSet (PWM_BASE, PWM_OUT_4, period * tail_duty / 100);
//
// Enable the PWM output signal.
//
PWMOutputState (PWM_BASE, PWM_OUT_1_BIT, false);
PWMOutputState (PWM_BASE, PWM_OUT_4_BIT, false);
//
// Enable the PWM generator.
//
PWMGenEnable (PWM_BASE, PWM_GEN_0);
PWMGenEnable (PWM_BASE, PWM_GEN_2);
}
//*****************************************************************************
//
// Interrupt handlers
//
//*****************************************************************************
void
SysTickIntHandler(void){
// Handle state changes
if (done){
tick++;
if (tick>1){
if (lose){
// Turn off the noise
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, false);
PWMGenDisable(PWM0_BASE, PWM_GEN_0);
unsigned long ulPeriod = SysCtlClockGet() / 220;
// Set the PWM period to 220 (A) Hz.
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
// Make some noise again
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
}
}
if (tick>2){
if (lose){
// Turn off the noise
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, false);
PWMGenDisable(PWM0_BASE, PWM_GEN_0);
unsigned long ulPeriod = SysCtlClockGet() / 440;
// Set the PWM period to 440 (A) Hz. again
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
lose = 0;
}
if (state==1){
startClassic();
tick = 0;
done = 0;
}
else if(state==2){
if(tick>4){
RIT128x96x4Clear();
initMain();
state = 0;
pointer = 0;
tick = 0;
done = 0;
}
}
else if (state==3){
startContinuous();
tick = 0;
done = 0;
}
}
}
}
int main(void)
{
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // Enable the GPIO A ports
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); // Enable the GPIO E ports
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
GPIOPinConfigure(GPIO_PB6_M0PWM0);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_6);
GPIOPinConfigure(GPIO_PB7_M0PWM1);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_7);
PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, 6400000);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, PWMGenPeriodGet(PWM0_BASE, PWM_GEN_0) / 1.25);
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, true);
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
PWMGenConfigure(PWM0_BASE, PWM_GEN_1, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, 6400000);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, PWMGenPeriodGet(PWM0_BASE, PWM_GEN_1) / 1.25);
PWMOutputState(PWM0_BASE, PWM_OUT_1_BIT, true);
PWMGenEnable(PWM0_BASE, PWM_GEN_1);
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_6|GPIO_PIN_7); // Set pin 7 as the output port
GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_1|GPIO_PIN_2);
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_5);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6|GPIO_PIN_7,64); // Give '1' to pin 7
GPIOPinWrite(GPIO_PORTE_BASE,GPIO_PIN_1|GPIO_PIN_2,4);
while(1)
{
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6|GPIO_PIN_7,64); // Give '1' to pin 7
GPIOPinWrite(GPIO_PORTE_BASE,GPIO_PIN_1|GPIO_PIN_2,4);
SysCtlDelay(4000000*10);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6|GPIO_PIN_7,0); // Give '1' to pin 7
GPIOPinWrite(GPIO_PORTE_BASE,GPIO_PIN_1|GPIO_PIN_2,0);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_5,32);
SysCtlDelay(400000);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_5,0);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6|GPIO_PIN_7,128); // Give '1' to pin 7
GPIOPinWrite(GPIO_PORTE_BASE,GPIO_PIN_1|GPIO_PIN_2,2);
SysCtlDelay(4000000*10);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6|GPIO_PIN_7,0); // Give '1' to pin 7
GPIOPinWrite(GPIO_PORTE_BASE,GPIO_PIN_1|GPIO_PIN_2,0);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_5,32);
SysCtlDelay(400000);
GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_5,0);
}
}
// Summary: Initializes the appropriate PWMs for servo output
// Note: Always call this function before any other servo-related functions
void InitializeServos(void)
{
unsigned long ulServoPeriod;
//
// Enable the peripherals used by the servos.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // servos 0 & 1
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // servos 2 & 3
//
// Set GPIO B0, B1, D0, and D1 as PWM pins.
// They are used to output the PWM0, PWM2, PWM3, and PWM3 signals.
//
GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Compute the PWM period based on the system clock.
//
ulServoPeriod = g_ulPWMTicksPerSecond / 50;
//
// Set the PWM period to 50 Hz = 20ms.
//
PWMGenConfigure(PWM_BASE, PWM_GEN_0,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, ulServoPeriod);
PWMGenConfigure(PWM_BASE, PWM_GEN_1,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM_BASE, PWM_GEN_1, ulServoPeriod);
us600 = ulServoPeriod * 3 / 100; // 20 ms * 3 / 100 = 600 us
us2400 = us600 * 4; // 600 us * 4 = 2400 us
//
// Enable the PWM0, PWM1, PWM2, and PWM3 output signals.
//
PWMOutputState(PWM_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT | PWM_OUT_2_BIT | PWM_OUT_3_BIT, true);
//
// Enable the PWM generator.
//
PWMGenEnable(PWM_BASE, PWM_GEN_0);
PWMGenEnable(PWM_BASE, PWM_GEN_1);
// Default to center
SetServoPosition(SERVO_0, SERVO_NEUTRAL_POSITION);
SetServoPosition(SERVO_1, SERVO_NEUTRAL_POSITION);
SetServoPosition(SERVO_2, SERVO_NEUTRAL_POSITION);
SetServoPosition(SERVO_3, SERVO_NEUTRAL_POSITION);
}
void MotorInit(uint8_t report)
{
SystickInit(1);
// 设置PWM时钟和系统时钟一致
SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
// 使能PWM外设
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
// 使能外设端口
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//设置对应管脚的PWM信号功能
GPIOPinConfigure(GPIO_PB4_M0PWM2);
GPIOPinConfigure(GPIO_PB5_M0PWM3);
GPIOPinConfigure(GPIO_PB6_M0PWM0);
GPIOPinConfigure(GPIO_PB7_M0PWM1);
//设置PWM信号端口
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
//PWM生成器配置
PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenConfigure(PWM0_BASE, PWM_GEN_1, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//设置PWM信号周期
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, PERIOD_TIME);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, PERIOD_TIME);
//设置PWM信号占空比
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, 0);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, 0);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2, 0);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3, 0);
// 使能PWM输出端口
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT|PWM_OUT_1_BIT|PWM_OUT_2_BIT|PWM_OUT_3_BIT, true);
// 使能PWM生成器
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
PWMGenEnable(PWM0_BASE, PWM_GEN_1);
// 使能PWm生成器模块的及时功能.
PWMSyncTimeBase(PWM0_BASE, PWM_GEN_0);
PWMSyncTimeBase(PWM0_BASE, PWM_GEN_1);
if(report)
UARTprintf("PWM初始化完成！\r\n");
}
int main(void)
{
volatile uint32_t ui32Load;
volatile uint32_t ui32PWMClock;
uint32_t ui32Period;
setup();
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, red * ui32Load / 240); // RED
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, green * ui32Load / 240); // GREEN
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, blue * ui32Load / 240); // BLUE
PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT | PWM_OUT_6_BIT | PWM_OUT_7_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_2);
PWMGenEnable(PWM1_BASE, PWM_GEN_3);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
ui32Period = (SysCtlClockGet() / 100) ;
TimerLoadSet(TIMER0_BASE, TIMER_A, ui32Period - 1); // Change here
IntEnable(INT_TIMER0A);
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
IntMasterEnable();
TimerEnable(TIMER0_BASE, TIMER_A);
while(1)
{
if(mode == 0)
{
angle = angle + incAngle;
changeColor();
}
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, red * ui32Load / 240); // RED
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, green * ui32Load / 240); // GREEN
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, blue * ui32Load / 240); // BLUE
SysCtlDelay(1000000);
}
}
void motors_init(void) {
int i;
uint8_t pin_mask;
uint32_t motor_per;
// Set Pins to output/PWM in GPIO
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
GPIOPinConfigure(GPIO_PF2_M1PWM6);
GPIOPinConfigure(GPIO_PF3_M1PWM7);
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_3);
// Configure the pin for standby control
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6);
SysCtlPWMClockSet(SYSCTL_PWMDIV_64);
// Configure the PWM for each pin:
// Turn on the generators and set the PW to 0
// The output is still OFF. Turn on with set_motor_pwm_state
for (i = 0; i < NUM_MOTORS; i++) {
PWMGenConfigure(motors[i].pwm_base_module, motors[i].pwm_generator, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
motor_per = calc_cycles(MOTOR_PERIOD);
PWMGenPeriodSet(motors[i].pwm_base_module, motors[i].pwm_generator, motor_per);
PWMPulseWidthSet(motors[i].pwm_base_module, motors[i].pwm_pin, 0);
PWMGenEnable(motors[i].pwm_base_module, motors[i].pwm_generator);
pin_mask = 1 << (0x0000000F & motors[i].pwm_pin);
PWMOutputState(motors[i].pwm_base_module, pin_mask, 0);
}
}
void DRV8833_InitMotorA(){
if(!SysCtlPeripheralReady(SYSCTL_PERIPH_PWM0))
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
if(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOB))
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlDelay(3);
GPIOPinConfigure(GPIO_PB6_M0PWM0);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_6);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_6,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
PWMClockSet(PWM0_BASE, PWM_SYSCLK_DIV_1);
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
uint32_t duty = 0;
PWMOutputUpdateMode(PWM0_BASE,PWM_OUT_0_BIT|PWM_OUT_1_BIT,PWM_OUTPUT_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, freq);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, duty);
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, true);
GPIOPinConfigure(GPIO_PB7_M0PWM1);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_7);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_7,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, duty);
PWMOutputState(PWM0_BASE, PWM_OUT_1_BIT, true);
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
}
//PWM³õʼ»¯
void initPWM()
{
//³õʼ»¯ÍâÉè¶Ë¿Ú
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM);
//ÉèÖÃPWMÐźÅʱÖÓ
SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
//ÉèÖÃPG2ºÍPD1ΪPWMÊä³ö
GPIOPinConfigure(GPIO_PG2_PWM0);
GPIOPinConfigure(GPIO_PD1_PWM1);
GPIOPinTypePWM(GPIO_PORTG_BASE, PWM_L);
GPIOPinTypePWM(GPIO_PORTD_BASE, PWM_R);
//ÅäÖÃPWM·¢ÉúÄ£¿é1
PWMGenConfigure(PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN|PWM_GEN_MODE_NO_SYNC);
//PWMGenConfigure(PWM_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN|PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 1000);
//PWMGenPeriodSet(PWM_BASE, PWM_GEN_3, 800);
// PWMPulseWidthSet(PWM_BASE, PWM_OUT_0,700);//×ó
// PWMPulseWidthSet(PWM_BASE, PWM_OUT_1,500);//ÓÒ
PWMPulseWidthSet(PWM_BASE, PWM_OUT_0,banlanceL);//×ó
PWMPulseWidthSet(PWM_BASE, PWM_OUT_1,banlanceR);//ÓÒ
//ʹÄÜPWM2Êä³ö
PWMOutputState(PWM_BASE,PWM_OUT_0_BIT,true);
//ʹÄÜPWM3Êä³ö
PWMOutputState(PWM_BASE,PWM_OUT_1_BIT,true);
PWMGenEnable(PWM_BASE, PWM_GEN_0);
}
void DRV8833_InitMotorB(){
if(!SysCtlPeripheralReady(SYSCTL_PERIPH_PWM0))
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
if(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOB))
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlDelay(3);
GPIOPinConfigure(GPIO_PB4_M0PWM2);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_4);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_4,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
PWMClockSet(PWM0_BASE, PWM_SYSCLK_DIV_1);
PWMGenConfigure(PWM0_BASE, PWM_GEN_1,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
uint32_t duty = 0;
PWMOutputUpdateMode(PWM0_BASE,PWM_OUT_2_BIT|PWM_OUT_3_BIT,PWM_OUTPUT_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, freq);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2, duty);
PWMOutputState(PWM0_BASE, PWM_OUT_2_BIT, true);
GPIOPinConfigure(GPIO_PB5_M0PWM3);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_5);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_5,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3, duty);
PWMOutputState(PWM0_BASE, PWM_OUT_3_BIT, true);
HWREG(GPIO_PORTB_BASE+GPIO_O_AFSEL) &= ~0x30;
PWMGenEnable(PWM0_BASE, PWM_GEN_1);
}
void PWM_Setup()
{
SysCtlPWMClockSet(PWM_SYSCLK_DIV_64);
//
// Configure the PWM generator for count down mode with immediate updates
// to the parameters.
//
PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
// Set the period. For a 50 KHz frequency, the period = 1/50,000, or 20
// microseconds. For a 20 MHz clock, this translates to 400 clock ticks.
// Use this value to set the period.
//
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, MAXPERIOD);
//
// Set the pulse width of PWM1 for a 75% duty cycle.
//
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, 0);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, 0);
// 50MHZ is to fast
PWMClockSet(PWM1_BASE,PWM_SYSCLK_DIV_64);
//
// Start the timers in generator 3.
//
PWMGenEnable(PWM1_BASE, PWM_GEN_3);
//
// Enable the outputs.
//
PWMOutputState(PWM1_BASE, PWM_OUT_6_BIT , true);
}
void motor(int hastighed)
{
unsigned long ulPeriod;
//
//! Compute the PWM period based on the system clock.
//
ulPeriod = SysCtlClockGet() / hastighed;//! line 99 if the @param hastighed is 100 there is 100 hz on pin PWM 1 with 200 there is 200 hz aso.
//
// Set the PWM0 period to 440 (A) Hz if on hastighed=100
//
PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
//
//! line 109 and 110 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);
if(hastighed > 0)//! line 112 to turn on PWM if they a set to a speed
{
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
}
if(hastighed == 0)//! line 116 to turn of PWM and set the port to 0 so they a not run some thing on the motors
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, false);
}
}
//*****************************************************************************
//
// Set up the PWM0 output to be used as a signal source for the CCP1 input
// pin. This example application uses PWM0 as the signal source in order
// to demonstrate the CCP usage and also to provide a predictable timing
// source that will produce known values for the capture timer. In a real
// application some external signal would be used as the signal source for
// the CCP input.
//
//*****************************************************************************
static void
SetupSignalSource(void)
{
//
// Enable the GPIO port used for PWM0 output.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Enable the PWM peripheral and configure the GPIO pin
// used for PWM0. GPIO pin D0 is used for PWM0 output.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM);
GPIOPinConfigure(GPIO_PD0_PWM0);
GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0);
//
// Configure the PWM0 output to generate a 50% square wave with a
// period of 5000 processor cycles.
//
PWMGenConfigure(PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, TIMEOUT_VAL);
PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, TIMEOUT_VAL / 2);
PWMOutputState(PWM_BASE, PWM_OUT_0_BIT, 1);
PWMGenEnable(PWM_BASE, PWM_GEN_0);
}
//--------------------------------
void pwm_stepper::Initialize() {
g_pTheStepper = this;
SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA6_M1PWM2);
GPIOPinTypePWM(GPIO_PORTA_BASE, GPIO_PIN_6);
PWMGenConfigure(Base, Generator, PWM_GEN_MODE_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.
PWMGenPeriodSet(Base, Generator, Default_StartSpeed);
PWMPulseWidthSet(Base, PWM_OUT_2, 64);
// Allow PWM1 generated interrupts. This configuration is done to
// differentiate fault interrupts from other PWM1 related interrupts.
PWMIntEnable(Base, PWM_INT_GEN_1);
// Enable the PWM1 LOAD interrupt on PWM1.
PWMGenIntTrigEnable(Base, Generator, PWM_INT_CNT_LOAD);
// Enable the PWM1 interrupts on the processor (NVIC).
IntEnable(INT_PWM1_1);
// Enable the PWM1 output signal (PA6).
// PWMOutputInvert(Base, PWM_OUT_2_BIT, true);
PWMOutputState(Base, PWM_OUT_2_BIT, true);
}
void ConfiguracionPWM(uint8_t Ancho){
PWMClock = SysCtlClockGet() / 64;
Load = (PWMClock / Frecuencia) - 1;
PWMGenConfigure(PWM1_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_0, Load);
PWMOutputState(PWM1_BASE, PWM_OUT_0_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_0);
}
void GreenSetup(volatile uint8_t ui8Adjust){
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_3);
GPIOPinConfigure(GPIO_PF3_M1PWM7);
PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, ui32Load);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8Adjust * ui32Load / 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_7_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_3);
}
void RedSetup(volatile uint8_t ui8Adjust){
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPinConfigure(GPIO_PF1_M1PWM5);
PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_2);
}
//*****************************************************************************
//
// Esta tarefa faz o ponteiro do servo se movimentar para a esquerda ou direita.
// O usuario seleciona o lado a partir dos botoes SW1 ou SW2
//
//*****************************************************************************
static void
TarefaServo(void *pvParameters)
{
// Variaveis para programar PWM (Tipo volateis: compilador nao elimina-as)
volatile uint32_t ui32Load;
volatile uint32_t ui32PWMClock;
volatile uint8_t ui8Adjust;
ui8Adjust = 83; //83: posicao central pra criar um pulso de 1.5mS do PWM.
uint8_t i8Message;
ui32PWMClock = SysCtlClockGet() / 64; // divisor 64 roda o clock a 625kHz.
ui32Load = (ui32PWMClock / PWM_FREQUENCY) - 1;
PWMGenConfigure(PWM1_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_0, ui32Load);
ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_0, ui8Adjust * ui32Load / 1000);
ROM_PWMOutputState(PWM1_BASE, PWM_OUT_0_BIT, true);
ROM_PWMGenEnable(PWM1_BASE, PWM_GEN_0);
while(1)
{
if(xQueueReceive(g_FilaServo, &i8Message, 0) == pdPASS)
{
if(i8Message == LEFT_BUTTON)
{
//Movimento sendo definido PWM
ui8Adjust += 15;
if (ui8Adjust > 155) ui8Adjust = 155;
// Ajuste do tamanho do pulso PWM
ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_0, ui8Adjust * ui32Load / 1000);
xSemaphoreTake(g_pUARTSemaphore, portMAX_DELAY);
UARTprintf("Servo moveu-se para a posicao %d.\n\n", ui8Adjust);
xSemaphoreGive(g_pUARTSemaphore);
}
if(i8Message == RIGHT_BUTTON)
{
// Movimento sendo definido PWM
ui8Adjust -= 15;
if (ui8Adjust < 40) ui8Adjust = 40;
// Ajuste do tamanho do pulso PWM
ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_0, ui8Adjust * ui32Load / 1000);
//
// Proteger o MUTEX do UART
xSemaphoreTake(g_pUARTSemaphore, portMAX_DELAY);
UARTprintf("Servo moveu-se para a posicao %d.\n\n", ui8Adjust);
xSemaphoreGive(g_pUARTSemaphore);
}
}
}
}
void motors_initialize(void)
{
/*
ui32PWMClock = SysCtlClockGet() /2;
ui32Load = (ui32PWMClock / 20000) - 1;
GPIOPinConfigure(GPIO_PF1_M1PWM5);
GPIOPinConfigure(GPIO_PE4_M0PWM4);
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_5);
GPIOPinTypePWM(GPIO_PORTE_BASE, GPIO_PIN_5);// change values
PWMGenConfigure(PWM1_BASE, PWM_GEN_1, PWM_GEN_MODE_DOWN);
PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_1,ui32Load);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load);
PWMGenEnable(PWM1_BASE, PWM_GEN_1);
PWMGenEnable(PWM1_BASE, PWM_GEN_2);
PWMOutputState(PWM1_BASE, PWM_OUT_1_BIT, true);
PWMOutputState(PWM1_BASE, PWM_OUT_2_BIT, true);
*/
ROM_SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
ROM_SysCtlPWMClockSet(SYSCTL_PWMDIV_2);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypePWM(GPIO_PORTE_BASE, GPIO_PIN_4);
ROM_GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
ROM_GPIOPinConfigure(GPIO_PE4_M1PWM2);
ROM_GPIOPinConfigure(GPIO_PF1_M1PWM5);
ui32PWMClock = SysCtlClockGet() / 2;
ui32Load = (ui32PWMClock / PWM_FREQUENCY) - 1;
PWMGenConfigure(PWM1_BASE, PWM_GEN_1, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_1, ui32Load);
//ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, ui8Adjust * ui32Load / 1000);
ROM_PWMOutputState(PWM1_BASE, PWM_OUT_2_BIT, true);
ROM_PWMGenEnable(PWM1_BASE, PWM_GEN_1);
PWMGenConfigure(PWM1_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load);
//ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust * ui32Load / 1000);
ROM_PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
ROM_PWMGenEnable(PWM1_BASE, PWM_GEN_2);
}
void InitGPIO (void)
{
// GPIO test initialisation
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0 | SYSCTL_PERIPH_PWM);
SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // airspeed output
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // transponder output
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); // airspeed response pin
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // transponder response pin
// Configure airspeed input
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, UUT_AIRSPEED_RESPONSE_PIN_PE3);
GPIOIntTypeSet(GPIO_PORTE_BASE, UUT_AIRSPEED_RESPONSE_PIN_PE3, GPIO_RISING_EDGE);
GPIOPortIntRegister(GPIO_PORTE_BASE, &airspeed_response_isr);
// Configure transponder input
GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, UUT_TRANSPONDER_RESPONSE_PIN_PB3);
GPIOIntTypeSet(GPIO_PORTB_BASE, UUT_TRANSPONDER_RESPONSE_PIN_PB3, GPIO_RISING_EDGE);
GPIOPortIntRegister(GPIO_PORTB_BASE, &transponder_response_isr);
// Configure airspeed pulse generation
GPIOPinTypePWM(GPIO_PORTD_BASE, (1<<1)); // Airspeed output TODO: make pin macro
PWMGenDisable(PWM0_BASE, PWM_GEN_0);
PWMIntDisable(PWM0_BASE, PWM_GEN_0);
PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN);
PWMGenIntTrigEnable(PWM0_BASE, PWM_GEN_0, PWM_INT_CNT_LOAD); // configure pwm for end-of-cycle interrupt
PWMGenIntRegister(PWM0_BASE, PWM_GEN_0, airspeed_pulse_isr);
// Configure transponder pulse generation
GPIOPinTypePWM(GPIO_PORTF_BASE, (1<<3)); // Transponder output TODO: make pin macro
PWMGenDisable(PWM0_BASE, PWM_GEN_2);
PWMIntDisable(PWM0_BASE, PWM_GEN_2);
PWMGenConfigure(PWM0_BASE, PWM_GEN_2, PWM_GEN_MODE_DOWN);
PWMGenIntTrigEnable(PWM0_BASE, PWM_GEN_2, PWM_INT_CNT_LOAD); // configure pwm for end-of-cycle interrupt
PWMGenIntRegister(PWM0_BASE, PWM_GEN_2, transponder_pulse_isr);
// Configure UUT reset signal
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_4);
GPIOPinWrite(GPIO_PORTG_BASE, GPIO_PIN_4, GPIO_PIN_4);
}
void Init_PWM() {
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM);
SysCtlPWMClockSet(SYSCTL_PWMDIV_2);
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_0);
PWMGenConfigure(PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 400);
PWMGenEnable(PWM_BASE, PWM_GEN_0);
PWMOutputState(PWM_BASE, PWM_OUT_0_BIT, true);
}
void Init_PWM() {
//PWM
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM); //Will use PWM
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_0); // change GPIO port F, pin 0 as PWM0
PWMGenConfigure(PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN); //Create PWM gen 0
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 402); // Set the period for PWM Generator0
PWMGenEnable(PWM_BASE, PWM_GEN_0); // Enable the PWM Generator0
PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, 1); //Set PWM width
PWMOutputState(PWM_BASE, PWM_OUT_0_BIT, true);
}
void manualSetup(void)
{
led = 0;
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, led);
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
SysCtlPWMClockSet(SYSCTL_PWMDIV_64);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_2);
GPIOPinTypePWM(GPIO_PORTF_BASE, 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);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_2, ui32Load);
PWMGenConfigure(PWM1_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_3, ui32Load);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_5, ui8Adjust_red * ui32Load / 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_5_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_2);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_6, ui8Adjust_blue * ui32Load / 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_6_BIT, true);
PWMPulseWidthSet(PWM1_BASE, PWM_OUT_7, ui8Adjust_green * ui32Load / 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_7_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_3);
}
void pwmInit(void) {
SysCtlPWMClockSet(SYSCTL_PWMDIV_64);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_1);
GPIOPinConfigure(GPIO_PD1_M1PWM1);
PWMGenConfigure(PWM1_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_0, 1000);
PWMOutputState(PWM1_BASE, PWM_OUT_1_BIT, true);
PWMGenEnable(PWM1_BASE, PWM_GEN_0);
}
void Init_PWM() {
//PWM 0
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM); //PWM Device Set
SysCtlPWMClockSet(SYSCTL_PWMDIV_2); // PWM Generation clock Set
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Enable the GPIO port F
GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_0); // GPIO port F, pin 0 a PWM0
PWMGenConfigure(PWM_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN); // Configuration the PWM gen0
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 400); // Set the Period of the PWM Generator0
PWMGenEnable(PWM_BASE, PWM_GEN_0); // Enable the PWM Generator0
PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, 399); //Set PWM width
PWMOutputState(PWM_BASE, PWM_OUT_0_BIT, true); //Start PWM
//PWM 2
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //Enable the GPIO port B
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_0); // GPIO port B, pin 0 a PWM2
PWMGenConfigure(PWM_BASE, PWM_GEN_1, PWM_GEN_MODE_DOWN); // Configuration the PWM gen0
PWMGenPeriodSet(PWM_BASE, PWM_GEN_1, 400); // Set the Period of the PWM Generator0
PWMGenEnable(PWM_BASE, PWM_GEN_1); // Enable the PWM Generator0
PWMPulseWidthSet(PWM_BASE, PWM_OUT_2, 399); //Set PWM width
PWMOutputState(PWM_BASE, PWM_OUT_2_BIT, true); //Start PWM
}
/* *************************************************
* Function: PWM_SetFreq
*
* Inputs: PWM Generator, Frequency
*
* Outputs: None
*
* Date: 7/11/2013
*
* Description: This function takes in a pwm
* generator 0 and a user frequency and
* sets the PWM frequency of the corrseponding
* PWM generator.
* ********************************************** */
void PWM_SetFreq(unsigned long frequency)
{
unsigned long ulPeriod;
// Set global frequency variable to the frequency of pwm generator
freq = frequency;
// Compute the PWM period based on the system clock.
ulPeriod = SysCtlClockGet() / frequency;
// Configure the PWM generator 0 for UP/DOWN and NO SYNC mode
PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
// Set the PWM period to 'frequency' (A) Hz.
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
}
//*****************************************************************************
//
// This example demonstrates how to setup the PWM block to generate signals.
//
//*****************************************************************************
void F_PWM_init(void)
{
//!setting up PWN
volatile unsigned long ulLoop;
//
// Set the clocking to run directly from the crystal.
//
SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
//
// Enable the peripherals used by this example.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//
//! Set GPIO B0 and B1 as PWM pins. They are used to output the PWM0 and
//! PWM1 signals.
//
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
//! Enable the PWM2 and PWM3 output signals if true.
//
PWMOutputState(PWM0_BASE,PWM_OUT_2_BIT|PWM_OUT_3_BIT, false);
//
//! Enable the PWM generator.
//
PWMGenEnable(PWM0_BASE, PWM_GEN_1);
//
//! Compute the PWM period based on the system clock.
//
ulPeriod = SysCtlClockGet() / PWMperiedset;
//
// Set the PWM2 period
//
PWMGenConfigure(PWM0_BASE, PWM_GEN_1, PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC | PWM_GEN_MODE_DBG_RUN);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, ulPeriod);
}
//this initializes the speaker on the Stellaris board.
//Speaker is hooked up to PWM0
void speakerInit(){
//enable the speaker peripheral that is connected to PWM0
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM);
//Set GPIO Port: G Enabled
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
//Tell Port G, Pin 1, to take input from PWM 0
GPIOPinTypePWM(GPIO_PORTG_BASE, GPIO_PIN_1);
//Set a 4400 Hz frequency as u1Period
ulPeriod = SysCtlClockGet() / (4440);
//Configure PWM0 in up-down count mode, no sync to clock
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
//Set u1Period (4400 Hz) as the period of PWM0
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
//Set PWM0, output 1 to a duty cycle of 1/8
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ulPeriod / 16);
//Activate PWM0
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
}
void bsp_pwm0_init(void)
{
/*Enable device*/
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
/*Set clock divider*/
PWMClockSet(PWM0_BASE,PWM_SYSCLK_DIV_64);
/*Enable PWM pin*/
GPIOPinConfigure(LCD_PWM_CHANNEL);
GPIOPinTypePWM(LCD_PWM_PORT, LCD_PWM_PIN);
/*Configure PWM generator*/
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,(PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC));
/*Set PWM timer period*/
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0,gSysClock/10000);
/*Set width for PWM0*/
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, 50*PWMGenPeriodGet(PWM0_BASE,PWM_GEN_0)/100);
/*Enable output*/
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, 0);
/*Enable Generator*/
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
}
