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);
}
//Task that plays a sound that gets within a range of 900 - 1200 distance within the distance sensor
void vTaskSpeaker(void *vParameters) {
while(1) {
//if the state is 5 or 6, this implies that the motor is not in standby(as determined from the menu options)
if((state == 5 || state == 6) && (dist0 > 600 || dist1 > 600 || dist2 > 600 || dist3 > 600)){
GPIO_PORTF_DEN_R |= 0x00000001;
//Set u1Period (4400 Hz) as the period of PWM0
// PWM_0_CMPA_R = 0x00012B;
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
//Set the output of the speaker to true, so sound is heard
PWMOutputState(PWM0_BASE, PWM_OUT_1_BIT, true);
//delay for 100 units, so sound can be heard
delay(100);
//Set u1Period (4400 Hz * 2) as the period of PWM0
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod*2);
//delay(100);
}else{
//if this is not in the range of the sensor, set output to false
//so sound is not heard anymore
// GPIO_PORTF_DEN_R ^= 0x1;
// PWM_0_CMPA_R = 0x0;
PWMOutputState(PWM0_BASE, PWM_OUT_1_BIT, false);
}
//delay task for 10 units
vTaskDelay(10);
}
}
//*****************************************************************************
//
//! Turns off all the PWM outputs.
//!
//! This function turns off all of the PWM outputs, preventing them from being
//! propagates to the gate drivers.
//!
//! \return None.
//
//*****************************************************************************
void
PWMOutputOff(void)
{
//
// Disable all six PWM outputs.
//
PWMOutputState(PWM_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
PWMOutputState(PWM1_BASE, PWM_OUT_2_BIT | PWM_OUT_3_BIT, true);
//
// Set the PWM duty cycles to 50%.
//
g_ulPWMDutyCycleRoll = 32768;
g_ulPWMDutyCyclePitch = 32768;
//
// Set the PWM period so that the ADC runs at 1 KHz.
//
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, PWMRATE / 1000);
PWMGenPeriodSet(PWM_BASE, PWM_GEN_1, PWMRATE / 1000);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_0, PWMRATE / 1000);
PWMGenPeriodSet(PWM1_BASE, PWM_GEN_1, PWMRATE / 1000);
//
// Update the PWM duty cycles.
//
PWMUpdateDutyCycle();
}
//*****************************************************************************
//
//! Turns off all the PWM outputs.
//!
//! This function turns off all of the PWM outputs, preventing them from being
//! propagates to the gate drivers.
//!
//! \return None.
//
//*****************************************************************************
void
PWMOutputOff(void)
{
//
// Disable all six PWM outputs.
//
PWMOutputState(PWM0_BASE, (PWM_OUT_0_BIT | PWM_OUT_1_BIT | PWM_OUT_2_BIT |
PWM_OUT_3_BIT | PWM_OUT_4_BIT | PWM_OUT_5_BIT),
false);
//
// Set the PWM duty cycles to 50%.
//
g_ulPWMDutyCycleA = 32768;
g_ulPWMDutyCycleB = 32768;
g_ulPWMDutyCycleC = 32768;
//
// Set the PWM period so that the ADC runs at 1 KHz.
//
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, PWM_CLOCK / 1000);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, PWM_CLOCK / 1000);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_2, PWM_CLOCK / 1000);
//
// Disable Deadband and update the PWM duty cycles.
//
PWMClearDeadBand();
PWMUpdateDutyCycle();
}
//*****************************************************************************
//
// 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");
}
/***********************************************
函数名：MotorPwmFlash(short MOTO1_PWM,short MOTO2_PWM,short MOTO3_PWM,short MOTO4_PWM)
功能：更新四路PWM值
输入参数：MOTO1_PWM,MOTO2_PWM,MOTO3_PWM,MOTO4_PWM
输出:无
描述：四路PWM由定时器2输出，输入范围0-999
备注：
***********************************************/
void MotorPwmFlash(short MOTO1_PWM,short MOTO2_PWM,short MOTO3_PWM,short MOTO4_PWM)
{
// 调整占空比
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, PERIOD_TIME);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, PERIOD_TIME);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, ((float)MOTO1_PWM/1000)*PERIOD_TIME);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ((float)MOTO2_PWM/1000)*PERIOD_TIME);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2, ((float)MOTO3_PWM/1000)*PERIOD_TIME);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3, ((float)MOTO4_PWM/1000)*PERIOD_TIME);
PWMSyncTimeBase(PWM0_BASE, PWM_GEN_0_BIT|PWM_GEN_1_BIT);
;
}
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);
}
}
//*****************************************************************************
//
// 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);
}
//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 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 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 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);
}
//*****************************************************************************
//
// Set PWM Duty Cycle
//
//*****************************************************************************
void
io_pwm_dutycycle(unsigned long ulDutyCycle)
{
unsigned long ulPWMClock;
//
// Get the PWM clock
//
ulPWMClock = SysCtlClockGet()/4;
//
// Set the global duty cycle
//
g_ulDutyCycle = ulDutyCycle;
//
// Set the period.
//
PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, ulPWMClock / g_ulFrequency);
//
// Set the pulse width of PWM1
//
PWMPulseWidthSet(PWM_BASE, PWM_OUT_1,
((ulPWMClock * g_ulDutyCycle)/100) / g_ulFrequency);
}
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);
}
}
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);
}
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 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 pwm_stepper::Move(uint32_t nSteps) {
m_nSteps = nSteps;
m_nSpeed = m_nStartSpeed;
m_nPhase = Phase_Accel;
PWMGenPeriodSet(Base, Generator, m_nSpeed);
PWMPulseWidthSet(Base, PWM_OUT_2, 64);
PWMGenEnable(Base, Generator);
}
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);
}
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 pwm_stepper::OnInterrupt() {
m_nSteps--;
if (0 >= m_nSteps) {
m_nSteps = 0;
m_nPhase = Phase_Stop;
}
if (m_bDirectionForward) {
m_nRelativeSteps++;
} else {
m_nRelativeSteps--;
}
switch (m_nPhase) {
case Phase_Accel:
m_nSpeed -= m_nAcceleration;
if (m_nTargetSpeed >= m_nSpeed) {
m_nSpeed = m_nTargetSpeed;
m_nPhase = Phase_Steady;
}
PWMGenPeriodSet(Base, Generator, m_nSpeed);
PWMPulseWidthSet(Base, PWM_OUT_2, 64);
PWMGenEnable(Base, Generator);
break;
case Phase_Steady:
if (m_nSteps <= ((Default_StartSpeed - m_nSpeed) / m_nDeceleration)) {
m_nPhase = Phase_Decel;
}
break;
case Phase_Decel:
m_nSpeed += m_nDeceleration;
if (Default_StartSpeed <= m_nSpeed) {
m_nSpeed = Default_StartSpeed;
m_nPhase = Phase_Stop;
}
PWMGenPeriodSet(Base, Generator, m_nSpeed);
PWMPulseWidthSet(Base, PWM_OUT_2, 64);
PWMGenEnable(Base, Generator);
break;
case Phase_Stop:
PWMGenDisable(Base, Generator);
break;
default:
break;
}
}
//*****************************************************************************
//
// 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 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);
}