C++ PWMOutputState函数代码示例

//******************************************************************
// 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);
}

void rampGenericPWM(bool rampDirection, uint32_t pwmBase, uint32_t pwm,
		uint32_t pwmBit, uint32_t delay) {

	// Start value is the current PWM pulse width regardless the ramp direction
	uint32_t i = PWMPulseWidthGet(pwmBase, pwm);

	if (rampDirection == PWM_RAMP_UP) {
		uint32_t targetPwmLoad = PWMGenPeriodGet(pwmBase, PWM_GEN_3);
		PWMOutputState(pwmBase, pwmBit, true);

		for (; i < targetPwmLoad; i += PWM_STEP)
		{
			PWMPulseWidthSet(pwmBase, pwm, i);
			SysCtlDelay(delay);
		}
	} else // rampDirection == PWM_RAMP_DOWN
	{
		for (; i > PWM_LOW; i -= PWM_STEP)
		{
			PWMPulseWidthSet(pwmBase, pwm, i);
			SysCtlDelay(delay);
		}

		PWMOutputState(pwmBase, pwmBit, false);
	}
}

//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);
  }
}

/* Act on select button pushes received from the ISR.
 * Toggle the helicopter rotor on and off with each push.
 */
static void vStartStopPWM ( void *pvParameters )
{
    /* Take the semaphore once to start with so the semaphore is empty before the
    infinite loop is entered.  The semaphore was created before the scheduler
    was started so before this task ran for the first time.*/
    xSemaphoreTake( xBinarySelectSemaphore, 0 );
    portBASE_TYPE flying = pdFALSE;

    for( ;; )
    {
        /* Use the semaphore to wait for the event. */
        xSemaphoreTake( xBinarySelectSemaphore, portMAX_DELAY );

        if (flying == pdFALSE) {
		    pid_init();
		    // Turn the main rotor on.
			PWMOutputState(PWM_BASE, PWM_OUT_1_BIT, true);
			// Reset the desired height
			desiredAltitude = INITIAL_ALT;
			flying = pdTRUE;
        } else {
        	// Turn the thing off.
        	while (desiredAltitude > 5) {
        		desiredAltitude -= 2;
        		vTaskDelay( 100 / portTICK_RATE_MS );
        	}
		    PWMOutputState(PWM_BASE, PWM_OUT_1_BIT, false);
        	flying = pdFALSE;
        }
    }
}

//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 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);
}

// Send bit pattern
// Start pulse first, then the bits, lsb first
void SendIRCode(uint32_t code) {

	// 1. send start pattern
	PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, true);
	delay_ms(T4);

	// 2. send code bit-by-bit
	int i;
	// UARTprintf("TX: sending %x\n", code);
	for (i = 0; i < IR_MAX_BITS_VAL; i++) {

		// transmit start of the bit (PWM off)
		PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, false);
		delay_ms(T1);

		// transmit end of the bit (PWM on)
		PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, true);
		// int bit = (code >> i) & 0x1; // LSB first
		int bit = (code >> ((IR_MAX_BITS_VAL - 1) - i)) & 0x1; // MSB first
		// UARTprintf("tx: bit %d - %d\n", i, bit);
		if (bit)
		{
			delay_ms(T2);
		} else
		{
			delay_ms(T1);
		}
	}

	// 3. Set the PWM off
	PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, false);

	// debug blink-out
	// blink_n(code);
}

int test_b_output_toggle(void)
{
	static int count = 0;
	static int state = 0;
	static int num_waits = 1;

	// generates 3 pulses, looks like 2 on a scope
	// but a very narrow pulse is generated on the cycle where
	// PWM is disabled, this is slightly hacky, but
	// the pulse is reliably recieved by the uut.
 	if (count >= 2 && state == 0)
	{
		state = 1;
		count = 0;

		PWMOutputState(PWM0_BASE, PWM_GEN_1_BIT, 0); //Disable PWM output

		return 0; // Because a pulse is still generated this cycle
	}
	else if (count > num_waits + 5 && state == 1)
	{
		num_waits = (num_waits * 283 + 23)%7; // make some pseudorandomness

		state = 0;
		count = 0;

		PWMOutputState(PWM0_BASE, PWM_GEN_1_BIT, 1); // Reenable output

	}

	count++;
	return state;
}

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);
	}

}

//*****************************************************************************
//
//! 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();
}

//*****************************************************************************
//
// 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;
			}
		}
	}
}

void bsp_lcd_bright_control(uint8 duty)
{
	 if(duty){
		  PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, 1);
		  PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, duty*PWMGenPeriodGet(PWM0_BASE,PWM_GEN_0)/100);
	 }else{
		  PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, 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);

	}
}

void SetA3906Logic(enum MOTOR motor, enum A3906Logic direction)
{
  unsigned long bit0,bit1;
  tBoolean b0,b1;
  switch (motor)
  {
    case PITCH_MOTOR:
      bit0 = PWM_OUT_0_BIT;
      bit1 = PWM_OUT_1_BIT;
      break;
    case ROLL_MOTOR:
      bit0 = PWM_OUT_2_BIT;
      bit1 = PWM_OUT_3_BIT;
      break;
  }
  switch (direction)
  {
    case A3906_FORWARD:
      b0 = true;
      b1 = false;
      break;
    case A3906_REVERSE:
      b0 = false;
      b1 = true;
      break;
    case A3906_BRAKE:
      b0 = true;
      b1 = true;
      break;
    case A3906_DISABLE:
      b0 = false;
      b1 = false;
      break;
  }

  if (motor == PITCH_MOTOR)
  {
	  PWMOutputState(PWM_BASE, bit0, b0);
	  PWMOutputState(PWM_BASE, bit1, b1);
  }
  else
  {
	  PWMOutputState(PWM1_BASE, bit0, b0);
	  PWMOutputState(PWM1_BASE, bit1, b1);
  }  
  
  
  
}