void Atomizer_Init() { // Select shunt value based on hardware version switch(Dataflash_info.hwVersion) { case 101: case 108: Atomizer_shuntRes = 125; break; case 103: case 104: case 105: case 106: Atomizer_shuntRes = 110; break; case 107: case 109: Atomizer_shuntRes = 120; break; case 110: case 111: Atomizer_shuntRes = 105; break; case 100: case 102: default: Atomizer_shuntRes = 115; break; } // Setup control pins PC1 = 0; GPIO_SetMode(PC, BIT1, GPIO_MODE_OUTPUT); PC3 = 0; GPIO_SetMode(PC, BIT3, GPIO_MODE_OUTPUT); // Both channels powered down Atomizer_ConfigureConverters(0, 0); // Configure 150kHz PWM PWM_ConfigOutputChannel(PWM0, ATOMIZER_PWMCH_BUCK, 150000, 0); PWM_ConfigOutputChannel(PWM0, ATOMIZER_PWMCH_BOOST, 150000, 0); // Start PWM PWM_EnableOutput(PWM0, PWM_CH_0_MASK); PWM_EnableOutput(PWM0, PWM_CH_2_MASK); PWM_Start(PWM0, PWM_CH_0_MASK); PWM_Start(PWM0, PWM_CH_2_MASK); // Set duty cycle to zero PWM_SET_CMR(PWM0, ATOMIZER_PWMCH_BUCK, 0); PWM_SET_CMR(PWM0, ATOMIZER_PWMCH_BOOST, 0); Atomizer_targetVolts = 0; Atomizer_curCmr = 0; Atomizer_curState = POWEROFF; // Setup 5kHz timer for negative feedback cycle // This function should run during system init, so // the user hasn't had time to create timers yet. Timer_CreateTimer(5000, 1, Atomizer_TimerCallback, 0); }
/*---------------------------------------------------------------------------------------------------------*/ int32_t main(void) { /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART to 115200-8n1 for print message */ UART0_Init(); printf("\n\nCPU @ %dHz(PLL@ %dHz)\n", SystemCoreClock, PllClock); printf("PWM0 clock is from %s\n", (CLK->CLKSEL2 & CLK_CLKSEL2_PWM0SEL_Msk) ? "CPU" : "PLL"); printf("+------------------------------------------------------------------------+\n"); printf("| PWM Driver Sample Code |\n"); printf("| |\n"); printf("+------------------------------------------------------------------------+\n"); printf(" This sample code will output PWM0 channel 0~3 with different\n"); printf(" frequency and duty, enable dead zone function of all PWM0 pairs.\n"); printf(" And also enable/disable PWM output every 1 second.\n"); printf(" I/O configuration:\n"); printf(" waveform output pin: PWM0_CH0(PC.0), PWM0_CH1(PC.1), PWM0_CH2(PC.2), PWM0_CH3(PC.3)\n"); /*Set Pwm mode as complementary mode*/ PWM_ENABLE_COMPLEMENTARY_MODE(PWM0); // PWM0 channel 0 frequency is 100Hz, duty 30%, PWM_ConfigOutputChannel(PWM0, 0, 100, 30); SYS_UnlockReg(); PWM_EnableDeadZone(PWM0, 0, 400); SYS_LockReg(); // PWM0 channel 2 frequency is 300Hz, duty 50% PWM_ConfigOutputChannel(PWM0, 2, 300, 50); SYS_UnlockReg(); PWM_EnableDeadZone(PWM0, 2, 200); SYS_LockReg(); // Enable output of PWM0 channel 0~3 PWM_EnableOutput(PWM0, 0xF); // Enable PWM0 channel 0 period interrupt, use channel 0 to measure time. PWM_EnablePeriodInt(PWM0, 0, 0); NVIC_EnableIRQ(PWM0P0_IRQn); // Start PWM_Start(PWM0, 0xF); while(1); }
/*---------------------------------------------------------------------------------------------------------*/ int32_t PWM_DeadZone(void) { /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART to 115200-8n1 for print message */ UART_Open(UART0, 115200); printf("+------------------------------------------------------------------------+\n"); printf("| PWM Driver Sample Code |\n"); printf("| |\n"); printf("+------------------------------------------------------------------------+\n"); printf(" This sample code will output all PWMA channels with different\n"); printf(" frequency and duty, enable dead zone function of all PWMA pairs.\n"); printf(" And also enable/disable PWM output every 1 second.\n"); printf(" I/O configuration:\n"); printf(" waveform output pin: PWM0(P2.0), PWM1(P2.1), PWM2(P2.2), PWM3(P2.3)\n"); // PWM0 frequency is 100Hz, duty 30%, PWM_ConfigOutputChannel(PWMA, PWM_CH0, 100, 30); PWM_EnableDeadZone(PWMA, PWM_CH0, 400); // PWM2 frequency is 300Hz, duty 50% PWM_ConfigOutputChannel(PWMA, PWM_CH2, 300, 50); PWM_EnableDeadZone(PWMA, PWM_CH2, 200); // Enable output of all PWMA channels PWM_EnableOutput(PWMA, 0xF); // Enable PWMA channel 0 period interrupt, use channel 0 to measure time. PWM_EnablePeriodInt(PWMA, PWM_CH0, 0); NVIC_EnableIRQ(PWMA_IRQn); // Start PWM_Start(PWMA, 0xF); while(1); }
/** * @brief This function set PWM output frequence and duty to drive Buzzer module * @return None */ void Write_Buzzer(unsigned int frequence, unsigned int duty) { // Config PWM1 channel 1 PWM_ConfigOutputChannel(PWM1, 1, frequence, duty); // Enable PWM1 channel 1 to drive buzzer module PWM_EnableOutput(PWM1, 0x02); }
/*---------------------------------------------------------------------------------------------------------*/ int32_t main(void) { /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART to 115200-8n1 for print message */ UART0_Init(); printf("+------------------------------------------------------------------------+\n"); printf("| PWM Driver Sample Code |\n"); printf("| |\n"); printf("+------------------------------------------------------------------------+\n"); printf(" This sample code will use PWM0 channel 0 to output waveform\n"); printf(" I/O configuration:\n"); printf(" waveform output pin: PWM0 channel 0(PA.12)\n"); printf("\nUse double buffer feature.\n"); /* PWM0 channel 0 waveform of this sample shown below: |<- CNR + 1 clk ->| CNR + 1 = 399 + 1 CLKs |<-CMR+1 clk ->| CMR + 1 = 199 + 1 CLKs |<- CNR + 1 ->| CNR + 1 = 99 + 1 CLKs |<CMR+1>| CMR + 1 = 39 + 1 CLKs __ ______________ _______ |______200_____| 200 |____60__| 40 |_____PWM waveform */ /* Configure PWM0 channel 0 init period and duty. Period is __HXT / (prescaler * clock divider * (CNR + 1)) Duty ratio = (CMR + 1) / (CNR + 1) Period = 12 MHz / (2 * 1 * (199 + 1)) = 30000 Hz Duty ratio = (99 + 1) / (199 + 1) = 50% */ // PWM0 channel 0 frequency is 100Hz, duty 30%, PWM_ConfigOutputChannel(PWM0, 0, 30000, 30); // Enable output of PWM0 channel 0 PWM_EnableOutput(PWM0, PWM_CH_0_MASK); // Enable PWM0 channel 0 period interrupt, use channel 0 to measure time. PWM_EnablePeriodInt(PWM0, 0, 0); NVIC_EnableIRQ(PWM0_IRQn); // Start PWM_Start(PWM0, PWM_CH_0_MASK); while(1); }
// ---------------------------------------------------------------------------------------- // Start PWM Output // ---------------------------------------------------------------------------------------- void Buzzer_Alerm() { BuzzerExecuteFlag=1; /* set PWMB channel 0 output configuration */ PWM_ConfigOutputChannel(PWM0, 0, 1200, 20); /* Enable PWM Output path for PWMB channel 0 */ PWM_EnableOutput(PWM0, PWM_CH_0_MASK); // Start PWM_Start(PWM0, PWM_CH_0_MASK); }
int32_t PWM_DeadZone(void) { /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ SYS_Init(); /* Init UART to 115200-8n1 for print message */ UART0_Init(); printf("\nThis sample code will output PWM0 channel 0 to with different\n"); printf("frequency and duty, enable dead zone function of all PWM0 pairs.\n"); printf("And also enable/disable PWM0 output every 1 second.\n"); // PWM0 frequency is 100Hz, duty 30%, PWM_ConfigOutputChannel(PWM0, 0, 100, 30); PWM_EnableDeadZone(PWM0, 0, 400); // PWM2 frequency is 300Hz, duty 50% PWM_ConfigOutputChannel(PWM0, 2, 300, 50); PWM_EnableDeadZone(PWM0, 2, 200); // PWM4 frequency is 500Hz, duty 70% PWM_ConfigOutputChannel(PWM0, 4, 600, 70); PWM_EnableDeadZone(PWM0, 4, 100); // Enable complementary mode PWM_ENABLE_COMPLEMENTARY_MODE(PWM0); // Enable output of all PWM channels PWM_EnableOutput(PWM0, 0x3F); // Enable PWM channel 0 period interrupt, use channel 0 to measure time. PWM_EnablePeriodInt(PWM0, 0, 0); NVIC_EnableIRQ(PWM0CH0_IRQn); // Start PWM_Start(PWM0, 0x3F); while(1); }
void MotorPwmOutput(int16_t MOTO1_PWM,int16_t MOTO2_PWM,int16_t MOTO3_PWM,int16_t MOTO4_PWM) { if(MOTO1_PWM > 100) MOTO1_PWM = 100; if(MOTO2_PWM > 100) MOTO2_PWM = 100; if(MOTO3_PWM > 100) MOTO3_PWM = 100; if(MOTO4_PWM > 100) MOTO4_PWM = 100; if(MOTO1_PWM < 0) MOTO1_PWM = 0; if(MOTO2_PWM < 0) MOTO2_PWM = 0; if(MOTO3_PWM < 0) MOTO3_PWM = 0; if(MOTO4_PWM < 0) MOTO4_PWM = 0; //低于MOTOR_DEAD_ZONE if(MOTO1_PWM <= MOTOR_DEAD_ZONE) { MOTO1_PWM =0; } if(MOTO2_PWM <= MOTOR_DEAD_ZONE) { MOTO2_PWM =0; } if(MOTO3_PWM <= MOTOR_DEAD_ZONE) { MOTO3_PWM =0; } if(MOTO4_PWM <= MOTOR_DEAD_ZONE) { MOTO4_PWM =0; } PWM_ConfigOutputChannel(PWM, MOTOR_1, 100, MOTO1_PWM); PWM_ConfigOutputChannel(PWM, MOTOR_2, 100, MOTO2_PWM); PWM_ConfigOutputChannel(PWM, MOTOR_3, 100, MOTO3_PWM); PWM_ConfigOutputChannel(PWM, MOTOR_4, 100, MOTO4_PWM); motor1PWM = MOTO1_PWM; motor2PWM = MOTO2_PWM; motor3PWM = MOTO3_PWM; motor4PWM = MOTO4_PWM; }
//========================================================================= //----- (00005C4C) -------------------------------------------------------- __myevic__ void InitPWM() { PWM_ConfigOutputChannel( PWM0, BBC_PWMCH_BUCK, BBC_PWM_FREQ, 0 ); PWM_ConfigOutputChannel( PWM0, BBC_PWMCH_BOOST, BBC_PWM_FREQ, 0 ); PWM_EnableOutput( PWM0, 1 << BBC_PWMCH_BUCK ); PWM_EnablePeriodInt( PWM0, BBC_PWMCH_BUCK, 0 ); PWM_EnableOutput( PWM0, 1 << BBC_PWMCH_BOOST ); PWM_EnablePeriodInt( PWM0, BBC_PWMCH_BOOST, 0 ); PWM_Start( PWM0, 1 << BBC_PWMCH_BUCK ); PWM_Start( PWM0, 1 << BBC_PWMCH_BOOST ); BoostDuty = 0; PWM_SET_CMR( PWM0, BBC_PWMCH_BOOST, 0 ); BuckDuty = 0; PWM_SET_CMR( PWM0, BBC_PWMCH_BUCK, 0 ); if ( ISVTCDUAL || ISCUBOID || ISCUBO200 || ISRX200S || ISRX23 || ISRX300 ) { PWM_ConfigOutputChannel( PWM0, BBC_PWMCH_CHARGER, BBC_PWM_FREQ, 0 ); PWM_EnableOutput( PWM0, 1 << BBC_PWMCH_CHARGER ); PWM_Start( PWM0, 1 << BBC_PWMCH_CHARGER ); ChargerDuty = 0; PWM_SET_CMR( PWM0, BBC_PWMCH_CHARGER, 0 ); if ( ISCUBO200 || ISRX200S || ISRX23 || ISRX300 ) { MaxChargerDuty = 512; } else { MaxChargerDuty = 256; } } }
void Servo::write(int value) { if (value < 0) value = 0; else if (value > 180) value = 180; Servo_Val = value; value = map(value, 0, 180, Servo_MIN, Servo_MAX); //value = map(value, 0, 180, 5, 12); if(bpwm) BPWM_ConfigOutputChannel(BPWM_Desc[Servo_Pin].P, BPWM_Desc[Servo_Pin].ch, Servo_Freq, value); else PWM_ConfigOutputChannel(PWM_Desc[Servo_Pin].P,PWM_Desc[Servo_Pin].ch,Servo_Freq,value); }
int32_t main (void) { /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ SYS_Init(); /* Init UART to 115200-8n1 for print message */ UART_Open(UART0, 115200); printf("\nThis sample code demonstrate PWM channel 0 trigger ADC function\n"); /* Enable channel 5 */ ADC_Open(ADC, 0, 0, 0x01 << 5); /* Power on ADC */ ADC_POWER_ON(ADC); /* Enable PWM trigger */ ADC_EnableHWTrigger(ADC, ADC_TRIGGER_BY_PWM, ADC_FALLING_EDGE_TRIGGER); /* Enable ADC convert complete interrupt */ ADC_EnableInt(ADC, ADC_ADIF_INT); NVIC_EnableIRQ(ADC_IRQn); /* PWM frequency is 100Hz, duty 30% */ PWM_ConfigOutputChannel(PWM, 0, 100, 30); /* Enable output PWM channel 0 */ PWM_EnableOutput(PWM, 0x1); /* Set PWM channel 0 to center-aligned mode */ PWM_SET_ALIGNED_TYPE(PWM, 0, PWM_CENTER_ALIGNED); /* Enable PWM channel 0 center-triggered ADC */ PWM_EnableADCTrigger(PWM, 0, PWM_TRIGGER_ADC_CNTR_IS_CNR); /* PWM Start */ PWM_Start(PWM, 0x1); while(1); }
/*---------------------------------------------------------------------------------------------------------*/ int32_t main(void) { /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART0 for printf */ UART0_Init(); printf("+------------------------------------------------------------------------+\n"); printf("| PWM Driver Sample Code |\n"); printf("| |\n"); printf("+------------------------------------------------------------------------+\n"); printf(" This sample code will use PWMB channel 2 to capture\n the signal from PWMB channel 1.\n"); printf(" I/O configuration:\n"); printf(" PWM5(P2.5 PWMB channel 1) <--> PWM6(P2.6 PWMB channel 2)\n\n"); printf("Use PWMB Channel 2(P2.6) to capture the PWMB Channel 1(P2.5) Waveform\n"); while(1) { printf("Press any key to start PWM Capture Test\n"); getchar(); /*--------------------------------------------------------------------------------------*/ /* Set the PWMB Channel 1 as PWM output function. */ /*--------------------------------------------------------------------------------------*/ /* Assume PWM output frequency is 250Hz and duty ratio is 30%, user can calculate PWM settings by follows. duty ratio = (CMR+1)/(CNR+1) cycle time = CNR+1 High level = CMR+1 PWM clock source frequency = __HXT = 12000000 (CNR+1) = PWM clock source frequency/prescaler/clock source divider/PWM output frequency = 12000000/2/1/250 = 24000 (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.) CNR = 23999 duty ratio = 30% ==> (CMR+1)/(CNR+1) = 30% CMR = 7199 Prescale value is 1 : prescaler= 2 Clock divider is PWM_CSR_DIV1 : clock divider =1 */ /* set PWMB channel 1 output configuration */ PWM_ConfigOutputChannel(PWMB, PWM_CH1, 250, 30); /* Enable PWM Output path for PWMB channel 1 */ PWM_EnableOutput(PWMB, 0x2); /* Enable Timer for PWMB channel 1 */ PWM_Start(PWMB, 0x2); /*--------------------------------------------------------------------------------------*/ /* Set the PWMB channel 2 for capture function */ /*--------------------------------------------------------------------------------------*/ /* If input minimum frequency is 250Hz, user can calculate capture settings by follows. Capture clock source frequency = __HXT = 12000000 in the sample code. (CNR+1) = Capture clock source frequency/prescaler/clock source divider/minimum input frequency = 12000000/2/1/250 = 24000 (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.) CNR = 0xFFFF (Note: In capture mode, user should set CNR to 0xFFFF to increase capture frequency range.) */ /* set PWMB channel 2 capture configuration */ PWM_ConfigCaptureChannel(PWMB, PWM_CH2, 166, 0); /* Enable capture falling edge interrupt for PWMB channel 2 */ PWM_EnableCaptureInt(PWMB, PWM_CH2, PWM_CAPTURE_INT_FALLING_LATCH); /* Enable PWMB NVIC interrupt */ NVIC_EnableIRQ((IRQn_Type)(PWMB_IRQn)); /* Enable Timer for PWMB channel 2 */ PWM_Start(PWMB, 0x4); /* Enable Capture Function for PWMB channel 2 */ PWM_EnableCapture(PWMB, 0x4); /* Wait until PWMB channel 2 Timer start to count */ while(PWMB->PDR2 == 0); /* Capture the Input Waveform Data */ CalPeriodTime(PWMB, PWM_CH2); /*------------------------------------------------------------------------------------------------------*/ /* Stop PWMB channel 1 (Recommended procedure method 1) */ /* Set PWM Timer loaded value(CNR) as 0. When PWM internal counter(PDR) reaches to 0, disable PWM Timer */ /*------------------------------------------------------------------------------------------------------*/ /* Set PWMB channel 1 loaded value as 0 */ PWM_Stop(PWMB, 0x2); /* Wait until PWMB channel 1 Timer Stop */ while(PWMB->PDR1 != 0); /* Disable Timer for PWMB channel 1 */ PWM_ForceStop(PWMB, 0x2); /* Disable PWM Output path for PWMB channel 1 */ PWM_DisableOutput(PWMB, 0x2); /*------------------------------------------------------------------------------------------------------*/ /* Stop PWMB channel 2 (Recommended procedure method 1) */ /* Set PWM Timer loaded value(CNR) as 0. When PWM internal counter(PDR) reaches to 0, disable PWM Timer */ /*------------------------------------------------------------------------------------------------------*/ /* Disable PWMB NVIC */ NVIC_DisableIRQ((IRQn_Type)(PWMB_IRQn)); /* Set loaded value as 0 for PWMB channel 2 */ PWM_Stop(PWMB, 0x4); /* Wait until PWMB channel 2 current counter reach to 0 */ while(PWMB->PDR2 != 0); /* Disable Timer for PWMB channel 2 */ PWM_ForceStop(PWMB, 0x4); /* Disable Capture Function and Capture Input path for PWMB channel 2*/ PWM_DisableCapture(PWMB, 0x4); /* Clear Capture Interrupt flag for PWMB channel 2*/ PWM_ClearCaptureIntFlag(PWMB, PWM_CH2, PWM_CAPTURE_INT_FALLING_LATCH); } }
uint8_t Servo::attach(int ulPin, int min, int max, int freq) { uint32_t ulValue=0; bpwm = 0; #ifdef USE_BoardToPin if(ulPin > BoardToPin_MAX_COUNT) return 0; if(ulPin > 5 && ulPin < 10) { // BPWM pins - 6, 7, 8, 9 bpwm = 1; } if(ulPin > 17 && ulPin < 22) { // PWM at analog pins - A0, A1, A2, A3 ulPin = ulPin + 8; } if(BoardToPinInfo[ulPin].type!=PWM_TYPE) return 0; ulPin=BoardToPinInfo[ulPin].num; if(bpwm) { if(ulPin > BPWM_MAX_COUNT || BPWM_Desc[ulPin].P == NULL) return 0; } else { if(ulPin > PWM_MAX_COUNT || PWM_Desc[ulPin].P == NULL) return 0; } #else return 0; #endif if(bpwm) { BPWM_Config(BPWM_Desc[ulPin]); // Set Mutifunction pins BPWM_ConfigOutputChannel(BPWM_Desc[ulPin].P, BPWM_Desc[ulPin].ch, BPWM_Desc[ulPin].freq, ulValue); // Config BPWMs BPWM_EnableOutput(BPWM_Desc[ulPin].P, (1 << BPWM_Desc[ulPin].ch)); //Enable BPWM output BPWM_Start(BPWM_Desc[ulPin].P, (1 << BPWM_Desc[ulPin].ch)); //Start BPWM } else { PWM_Config(PWM_Desc[ulPin]); // Set Mutifunction pins PWM_ConfigOutputChannel(PWM_Desc[ulPin].P, PWM_Desc[ulPin].ch, PWM_Desc[ulPin].freq, ulValue); // Config PWMs PWM_EnableOutput(PWM_Desc[ulPin].P, (1 << PWM_Desc[ulPin].ch)); //Enable PWM output PWM_Start(PWM_Desc[ulPin].P, (1 << PWM_Desc[ulPin].ch)); //Start PWM } Servo_MAX = max; Servo_MIN = min; Servo_Pin = ulPin; Servo_Freq = freq; /* #if defined(__M451__) if(ulValue==100) { int32_t pin=PWM_Desc[ulPin].pintype.num; GPIO_Config(GPIO_Desc[pin]); GPIO_SetMode(GPIO_Desc[pin].P, GPIO_Desc[pin].bit, GPIO_MODE_OUTPUT); (GPIO_Desc[pin].P)->DOUT |= GPIO_Desc[pin].bit; pinEnabled[ulPin]= 0; fixValue[ulPin]=ulValue; //return 0; } #elif defined(__NUC240__) if(ulValue==0) { int32_t pin=PWM_Desc[ulPin].pintype.num; GPIO_Config(GPIO_Desc[pin]); GPIO_SetMode(GPIO_Desc[pin].P, GPIO_Desc[pin].bit, GPIO_PMD_OUTPUT); (GPIO_Desc[pin].P)->DOUT &= ~GPIO_Desc[pin].bit; pinEnabled[ulPin]= 0; fixValue[ulPin]=ulValue; //return 0; } #elif defined(__NANO100__) | defined(__NANO1X2__) if(ulValue==0) { int32_t pin=PWM_Desc[ulPin].pintype.num; GPIO_Config(GPIO_Desc[pin]); GPIO_SetMode(GPIO_Desc[pin].P, GPIO_Desc[pin].bit, GPIO_PMD_OUTPUT); (GPIO_Desc[pin].P)->DOUT &= ~GPIO_Desc[pin].bit; pinEnabled[ulPin]= 0; fixValue[ulPin]=ulValue; //return 0; } #elif defined(__NUC131__) if(ulValue==0) { uint32_t pin = PWM_Desc[ulPin].pintype.num; GPIO_Config(GPIO_Desc[pin]); GPIO_SetMode(GPIO_Desc[pin].P, GPIO_Desc[pin].bit, GPIO_PMD_OUTPUT); (GPIO_Desc[pin].P)->DOUT &= ~GPIO_Desc[pin].bit; pinEnabled[ulPin]= 0; fixValue[ulPin]=ulValue; //return 0; } #endif if (!pinEnabled[ulPin]){ //Set Mutifunction pins PWM_Config(PWM_Desc[ulPin]); //Config PWMs PWM_ConfigOutputChannel(PWM_Desc[ulPin].P,PWM_Desc[ulPin].ch,50,0); //Enable PWM output PWM_EnableOutput(PWM_Desc[ulPin].P,(1<<PWM_Desc[ulPin].ch)); //Start PWM PWM_Start(PWM_Desc[ulPin].P,(1<<PWM_Desc[ulPin].ch)); pinEnabled[ulPin] = 1; } //Config PWMs if(fixValue[ulPin]!=ulValue) { PWM_ConfigOutputChannel(PWM_Desc[ulPin].P,PWM_Desc[ulPin].ch,50,ulValue); fixValue[ulPin]=ulValue; } */ }
/*---------------------------------------------------------------------------------------------------------*/ int32_t main(void) { /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART to 115200-8n1 for print message */ UART0_Init(); printf("\n\nCPU @ %dHz(PLL@ %dHz)\n", SystemCoreClock, PllClock); printf("PWM0 clock is from %s\n", (CLK->CLKSEL2 & CLK_CLKSEL2_PWM0SEL_Msk) ? "CPU" : "PLL"); printf("+------------------------------------------------------------------------+\n"); printf("| PWM Driver Sample Code |\n"); printf("| |\n"); printf("+------------------------------------------------------------------------+\n"); printf(" This sample code will use PWM0 channel 0 to output waveform\n"); printf(" I/O configuration:\n"); printf(" waveform output pin: PWM0 channel 0(PC.0)\n"); printf("\nUse double buffer feature.\n"); /* PWM0 channel 0 waveform of this sample shown below: |<- CNR + 1 clk ->| CNR + 1 = 399 + 1 CLKs |<-CMR+1 clk ->| CMR + 1 = 199 + 1 CLKs |<- CNR + 1 ->| CNR + 1 = 99 + 1 CLKs |<CMR+1>| CMR + 1 = 39 + 1 CLKs __ ______________ _______ |______200_____| 200 |____60__| 40 |_____PWM waveform */ /* Configure PWM0 channel 0 init period and duty. Period is PLL / (prescaler * (CNR + 1)) Duty ratio = (CMR + 1) / (CNR + 1) Period = 72 MHz / (2 * (199 + 1)) = 180000 Hz Duty ratio = (99 + 1) / (199 + 1) = 50% */ // PWM0 channel 0 frequency is 180000Hz, duty 50%, PWM_ConfigOutputChannel(PWM0, 0, 180000, 50); // Enable output of PWM0 channel 0 PWM_EnableOutput(PWM0, PWM_CH_0_MASK); // Enable PWM0 channel 0 period interrupt, use channel 0 to measure time. PWM_EnablePeriodInt(PWM0, 0, 0); NVIC_EnableIRQ(PWM0P0_IRQn); // Start PWM_Start(PWM0, PWM_CH_0_MASK); while(1); }
/*---------------------------------------------------------------------------------------------------------*/ int32_t main(void) { /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART0 for printf */ UART0_Init(); printf("+------------------------------------------------------------------------+\n"); printf("| PWM Driver Sample Code |\n"); printf("| |\n"); printf("+------------------------------------------------------------------------+\n"); printf(" This sample code will use PWM0 channel 0 to capture\n the signal from PWM1 channel 0.\n"); printf(" I/O configuration:\n"); printf(" PWM0_CH0(PA.12 PWM0 channel 0) <--> PWM1_CH0(PA.2 PWM1 channel 0)\n\n"); printf("Use PWM0 Channel 0(PA.12) to capture the PWM1 Channel 0(PA.2) Waveform\n"); while(1) { printf("Press any key to start PWM Capture Test\n"); getchar(); /*--------------------------------------------------------------------------------------*/ /* Set the PWM1 Channel 0 as PWM output function. */ /*--------------------------------------------------------------------------------------*/ /* Assume PWM output frequency is 250Hz and duty ratio is 30%, user can calculate PWM settings by follows. duty ratio = (CMR+1)/(CNR+1) cycle time = CNR+1 High level = CMR+1 PWM clock source frequency = __HXT = 12000000 (CNR+1) = PWM clock source frequency/prescaler/clock source divider/PWM output frequency = 12000000/2/1/250 = 24000 (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.) CNR = 23999 duty ratio = 30% ==> (CMR+1)/(CNR+1) = 30% CMR = 7199 Prescale value is 1 : prescaler= 2 Clock divider is PWM_CSR_DIV1 : clock divider =1 */ /* set PWM1 channel 0 output configuration */ PWM_ConfigOutputChannel(PWM1, 0, 250, 30); /* Enable PWM Output path for PWM1 channel 0 */ PWM_EnableOutput(PWM1, PWM_CH_0_MASK); /* Enable Timer for PWM1 channel 0 */ PWM_Start(PWM1, PWM_CH_0_MASK); /*--------------------------------------------------------------------------------------*/ /* Set the PWM0 channel 0 for capture function */ /*--------------------------------------------------------------------------------------*/ /* If input minimum frequency is 250Hz, user can calculate capture settings by follows. Capture clock source frequency = __HXT = 12000000 in the sample code. (CNR+1) = Capture clock source frequency/prescaler/clock source divider/minimum input frequency = 12000000/2/1/250 = 24000 (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.) CNR = 0xFFFF (Note: In capture mode, user should set CNR to 0xFFFF to increase capture frequency range.) */ /* set PWM0 channel 0 capture configuration */ PWM_ConfigCaptureChannel(PWM0, 0, 166, 0); /* Enable capture falling edge interrupt for PWM0 channel 0 */ //PWM_EnableCaptureInt(PWM0, 0, PWM_CAPTURE_INT_FALLING_LATCH); /* Enable PWM0 NVIC interrupt */ //NVIC_EnableIRQ(PWM0_IRQn); /* Enable Timer for PWM0 channel 0 */ PWM_Start(PWM0, PWM_CH_0_MASK); /* Enable Capture Function for PWM0 channel 0 */ PWM_EnableCapture(PWM0, PWM_CH_0_MASK); /* Enable falling capture reload */ PWM0->CAPCTL |= PWM_CAPCTL_FCRLDEN0_Msk; /* Wait until PWM0 channel 0 Timer start to count */ while((PWM0->CNT[0]) == 0); /* Capture the Input Waveform Data */ CalPeriodTime(PWM0, 0); /*---------------------------------------------------------------------------------------------------------*/ /* Stop PWM1 channel 0 (Recommended procedure method 1) */ /* Set PWM Timer loaded value(Period) as 0. When PWM internal counter(CNT) reaches to 0, disable PWM Timer */ /*---------------------------------------------------------------------------------------------------------*/ /* Set PWM1 channel 0 loaded value as 0 */ PWM_Stop(PWM1, PWM_CH_0_MASK); /* Wait until PWM1 channel 0 Timer Stop */ while((PWM1->CNT[0] & PWM_CNT_CNT_Msk) != 0); /* Disable Timer for PWM1 channel 0 */ PWM_ForceStop(PWM1, PWM_CH_0_MASK); /* Disable PWM Output path for PWM1 channel 0 */ PWM_DisableOutput(PWM1, PWM_CH_0_MASK); /*---------------------------------------------------------------------------------------------------------*/ /* Stop PWM0 channel 0 (Recommended procedure method 1) */ /* Set PWM Timer loaded value(Period) as 0. When PWM internal counter(CNT) reaches to 0, disable PWM Timer */ /*---------------------------------------------------------------------------------------------------------*/ /* Disable PWM0 NVIC */ //NVIC_DisableIRQ(PWM0_IRQn); /* Set loaded value as 0 for PWM0 channel 0 */ PWM_Stop(PWM0, PWM_CH_0_MASK); /* Wait until PWM0 channel 0 current counter reach to 0 */ while((PWM0->CNT[0] & PWM_CNT_CNT_Msk) != 0); /* Disable Timer for PWM0 channel 0 */ PWM_ForceStop(PWM0, PWM_CH_0_MASK); /* Disable Capture Function and Capture Input path for PWM0 channel 0 */ PWM_DisableCapture(PWM0, PWM_CH_0_MASK); /* Clear Capture Interrupt flag for PWM0 channel 0 */ PWM_ClearCaptureIntFlag(PWM0, 0, PWM_CAPTURE_INT_FALLING_LATCH); } }