STC PWM

/*************CMOD PCA工作模式寄存器**************/
// BIT 7 6 5 4 3 2 1 0
// CIDL X X X CPS2 CPS1 CPS1 ECF
// CIDL=0时,空闲模式下PCA计数器继续工作
// CIDL=1时,空闲模式下PCA计数器停止工作
// CPS2 CPS1 CPS1=000 0:系统时钟 SYSclk/12
// =001 1:系统时钟 SYSclk/2
// =010 2:定时器0的溢出脉冲。由于定时器0可以工作在1T模式,通过改变定时器0的溢出率实现可调频率PWM输出
// =011 3: ECI/P1.2(或P3.4或P2.4)脚输入的外部时钟,最大频率SYSclk/2
// =100 4: 系统时钟 SYSclk
// =101 5: 系统时钟 SYSclk/4
// =110 6: 系统时钟 SYSclk/6
// =111 7: 系统时钟 SYSclk/8
// ECF PCA计数溢出中断使能位 =0时禁止寄存器CCON中CF位的中断 =1时允许寄存器CCON中CF位的中断
/*************CCON PCA控制寄存器**************/
// BIT 7 6 5 4 3 2 1 0
// CF CR CCP2 CCP1 CCP0
// CF PCA计数器阵列溢出标志位,当PCA计数器溢出时,有硬件置位如果CMOD的ECF置位 则CF标志可以用来产生中断
// CR PCA计数器阵列运行控制位 启动和关闭PCA计数器阵列计数器
// CCP2 PCA模块2中断标志,当出现匹配和捕获时,由硬件置位,必须通过软件清零
// CCP1 PCA模块1中断标志,当出现匹配和捕获时,由硬件置位,必须通过软件清零
// CCP0 PCA模块0中断标志,当出现匹配和捕获时,由硬件置位,必须通过软件清零
/********PCA比较/捕获寄存器 CCAPM0 CCAPM1 CCAPM2*/
// BIT 7 6 5 4 3 2 1 0
// ECOM0 CAPP0 CAPN0 MAT0 TOG0 PWM0 ECCF0
// ECOM0允许比较器功能控制位,=1允许比较器功能
// CAPP0 正捕获控制位,=1允许上升沿捕获
// CAPN0 负捕获控制位,=1允许下升沿捕获
// MAT0匹配控制位 =1时,PCA的计数值与PCA比较/捕获寄存器的匹配将置位CCON寄存器的中断标志CCF0
// TOG0翻转控制位,当TOG0=1时,工作在PCA高速脉冲输出模式,PCA计数器的值与模块的比较/捕获寄存器匹配将使CCP0脚翻转
// PWM0 脉宽调节模式
// ECCF0 使能CCF0中断,使能寄存器CCON的比较/捕获标志CCP0,用来产生中断

/*************************************************/
void PCAInit()
{
CMOD=0x05; // PCA 计数器时钟位 系统时钟 允许CCON中的CF位中断
CCON=0x00; // 初始化 寄存器
CCAPM0=0x11; // 下降沿捕获 使能CCF0 中断
CL=0;
CH=0; // 初始化 计数器
CR=1; // 允许PCA 模块运行
}
/********中断服务程序***************************/
void PCA_isr() interrupt 7
{
CCF0=0; // 清除中断标志位
count++;
if(count==100)
{
count=0;
P32=!P32; //P10 取反
P31=~P31; //P10 取反
}
}
/*************************************************/
void main( ) /*主程序开始*/
{
TMOD&=0xF0; //设置定时器模式
TL0=0x00; //设置定时初始值
TH0=0x28; //设置定时初始值
ET0=1;
TF0=1; //清除TF0标志
TR0=1; //定时器0开始计时
EA=1; //
P3M0=0XFF; //强推挽
P3M1=0X00;
MOTORRUN_L=0; //
MOTORRUN_R=0; //
reset_io(); //
Initial_LY096BG30(); //初始化显示屏
Delay_50ms(2);
cleardisp(); //清除显示
Diswait(); //显示待机
red_eeprom(); //
dis_Val1(time1); //
dis_Val2(time1); //
PCAInit();

PCA 模拟多位PWM输出 范例程序
功能: 使用STC内带的PCA做9~16位的PWM。在PWMn.h中选择是STC12C5201AD系列还是STC12C5A60S2系列。
原理说明：
本示例程序介绍在一些应用中所需要的高于8位分辨率的9~16位PWM，而8位的PWM可以直接使用STC的硬件PWM，请参考有关的的(Datasheet)。
本应用所需要资源：PCA可编程计数器阵列，捕获寄存器，匹配中断向量。
程序用到两个16位变量:
PWM_high 保存PWM输出高电平的PCA时钟数。
PWM_low 保存PWM输出低电平的PCA时钟数。
PWM的周期 = PWM_HIGH + PWM_LOW。
PCA时钟源有8种选择。
PCA模块被配置为16位高速输出方式，当PCA计数值与捕获寄存器数值匹配时，将CCP0输出取反，同时发生比较匹配中断。
比较匹配中断里判断高速输出的电平，如果是高电平，则向捕获寄存器装入高电平的PCA时钟数。如果是低电平，则装入低电平的PCA时钟数。
由于中断处理需要一点时间，所以输出的占空比不能到0%或100%，所以对PWM_high有最小和最大值，中断处理绝对时间大约为100个SYSCLK。
本示例程序的测试是基于如下假设：
PCA时基信号为系统时钟Fosc，PCA中断优先级为最高。
提示：其它中断服务开销很长时间时，有可能会影响本程序的正常运行。
本示例程序用户可以在"用户配置宏"中选择以下参数：
PCA_IDLE_DISABLE 在IDLE模式是否禁止PCA工作，选择1: MCU在IDLE模式时禁止PCA工作， 选择0: MCU在IDLE模式时允许PCA工作。
PCA_SOURCE_SELECT 选择PCA的基准时钟源，本示例使用系统时钟Fosc做PCA时钟源。
PWM_DUTY 定义PWM的周期，数值为PCA所选择的时钟脉冲个数，用户只需要装载PWM_high，PWM_low是根据这个周期计算出来的。
PWM_HIGH_MAX 限制PWM输出的最大占空比，原因如前所述。如果装载PWM_high大于此数值，将返回错误。
PWM_HIGH_MIN 限制PWM输出的最小占空比，原因如前所述。如果装载PWM_high小于此数值，将返回错误。
*/
#include "reg51.h"
#define MAIN_Fosc 24576000L //定义时钟
#define PCA_IDLE_DISABLE 0 //1: MCU在IDLE模式时禁止PCA工作。 0: MCU在IDLE模式时允许PCA工作。
#define PCA_SOURCE_SELECT 4 //选择PCA的基准时钟源。
//0：系统时钟Fosc/12。
//1：系统时钟Fosc/2。
//2：定时器0的溢出。
//3：ECI/P3.4脚的外部时钟输入（最大=Fosc/2）。
//4：系统时钟Fosc。
//5：系统时钟Fosc/4。
//6：系统时钟Fosc/6。
//7：系统时钟Fosc/8。
#define PWM_DUTY 4096 //定义PWM的周期，数值为PCA所选择的时钟脉冲个数。
/**********************************************************************************************************/
sfr P_SW1 = 0xA2; //外设功能切换寄存器1
#define CCP_S0 0x10 //P_SW1.4
#define CCP_S1 0x20 //P_SW1.5
sfr CCON = 0xD8; //PCA控制寄存器
sbit CCF0 = CCON^0; //PCA模块0中断标志
sbit CCF1 = CCON^1; //PCA模块1中断标志
sbit CR = CCON^6; //PCA定时器运行控制位
sbit CF = CCON^7; //PCA定时器溢出标志
sfr CMOD = 0xD9; //PCA模式寄存器
sfr CL = 0xE9; //PCA定时器低字节
sfr CH = 0xF9; //PCA定时器高字节
sfr CCAPM0 = 0xDA; //PCA模块0模式寄存器
sfr CCAP0L = 0xEA; //PCA模块0捕获寄存器 LOW
sfr CCAP0H = 0xFA; //PCA模块0捕获寄存器 HIGH
sfr CCAPM1 = 0xDB; //PCA模块1模式寄存器
sfr CCAP1L = 0xEB; //PCA模块1捕获寄存器 LOW
sfr CCAP1H = 0xFB; //PCA模块1捕获寄存器 HIGH
sfr CCAPM2 = 0xDC; //PCA模块2模式寄存器
sfr CCAP2L = 0xEC; //PCA模块2捕获寄存器 LOW
sfr CCAP2H = 0xFC; //PCA模块2捕获寄存器 HIGH
sfr PCA_PWM0 = 0xf2; //PCA模块0的PWM寄存器
sfr PCA_PWM1 = 0xf3; //PCA模块1的PWM寄存器
sfr PCA_PWM2 = 0xf4; //PCA模块2的PWM寄存器
sfr P1M0 = 0x92;
sfr P1M1 = 0x91;
sbit CCP0 = P1^1;
sbit CCP1 = P1^0;
#define PWM_HIGH_MAX PWM_DUTY-32 //限制PWM输出的最大占空比。
#define PWM_HIGH_MIN 32 //限制PWM输出的最小占空比。
/************* 本地变量声明 **************/
unsigned int pwm; //定义用户操作的PWM变量
/************* 本地函数声明 **************/
void delay_ms(unsigned char ms);
/**************** 外部函数声明和外部变量声明 *****************/
extern unsigned int PWM_high; //PWM空比寄存器，即PWM输出高电平的PCA时钟脉冲个数（占空比写入变量）。
void PWMn_SetHighReg(unsigned int high);
void PWMn_init(unsigned int high);
/******************** 主函数 **************************/
//========================================================================
// 函数: void main(void)
// 描述: 不断更新PWM值，用示波器观察占空比变化。
// 参数: 无。
// 返回: 无。
// 版本: VER1.0
// 日期: 2011-4-11
// 备注:
//========================================================================
void main(void)
{
pwm = 1000; //pwm初值
pwm = PWM_HIGH_MIN; //pwm初值
PWMn_init(pwm); //初始化pwm
while (1)
{
delay_ms(10); //延时
pwm += 10;
if(pwm >= PWM_HIGH_MAX) pwm = PWM_HIGH_MIN;
PWMn_SetHighReg(pwm); //更新PWM的占空比
}
}
/**********************************************/
//========================================================================
// 函数: void delay_ms(unsigned char ms)
// 描述: 延时函数。
// 参数: ms,要延时的ms数.
// 返回: none.
// 版本: VER1.0
// 日期: 2010-12-15
// 备注:
//========================================================================
void delay_ms(unsigned char ms)
{
unsigned int i;
do
{
i = MAIN_Fosc / 14000L; //1T
while(--i) ;
}while(--ms);
}
unsigned int PWM_high; //定义PWM占空比寄存器，即PWM输出高电平的PCA时钟脉冲个数（占空比写入变量）。
unsigned int PWM_low; //定义PWM输出低电平的PCA时钟脉冲个数。
unsigned int CCAP0_tmp; //定义CCAP0重装载影射寄存器。
//

接上楼
========================================================================
// 函数: void PWMn_SetHighReg(unsigned int high)
// 描述: 写入占空比数据。
// 参数: high: 占空比数据，即PWM输出高电平的PCA时钟脉冲个数。
// 返回: 无
// 版本: VER1.0
// 日期: 2009-12-30
// 备注:
//========================================================================
void PWMn_SetHighReg(unsigned int high)
{
if(high > PWM_HIGH_MAX) high = PWM_HIGH_MAX; //如果写入大于最大占空比数据，强制为最大占空比。
if(high < PWM_HIGH_MIN) high = PWM_HIGH_MIN; //如果写入小于最小占空比数据，则返回错误代码2。
CR = 0; //停止PCA。
PWM_high = high; //数据在正确范围，则装入占空比寄存器。
PWM_low = PWM_DUTY - high; //计算并保存PWM输出低电平的PCA时钟脉冲个数。
CR = 1; //启动PCA。
}
//========================================================================
// 函数: void PWMn_init(unsigned int high)
// 描述: 初始化程序。
// 参数: high: 初始化占空比数据，即PWM输出高电平的PCA时钟脉冲个数。
// 返回: 无
// 版本: VER1.0
// 日期: 2009-12-30
// 备注:
//========================================================================
void PWMn_init(unsigned int high)
{
ACC = P_SW1;
ACC &= ~(CCP_S0 | CCP_S1); //CCP_S0=0 CCP_S1=0
P_SW1 = ACC; //(P1.2/ECI, P1.1/CCP0, P1.0/CCP1, P3.7/CCP2)
// ACC = P_SW1;
// ACC &= ~(CCP_S0 | CCP_S1); //CCP_S0=1 CCP_S1=0
// ACC |= CCP_S0; //(P3.4/ECI_2, P3.5/CCP0_2, P3.6/CCP1_2, P3.7/CCP2_2)
// P_SW1 = ACC;
//
// ACC = P_SW1;
// ACC &= ~(CCP_S0 | CCP_S1); //CCP_S0=0 CCP_S1=1
// ACC |= CCP_S1; //(P2.4/ECI_3, P2.5/CCP0_3, P2.6/CCP1_3, P2.7/CCP2_3)
// P_SW1 = ACC;
P1M1 &= ~0x02, P1M0 |= 0x02; //CCAP0使用PUSH-PULL输出模式
CCON = 0; //清除CF、CR、CCF0、CCF1
CMOD = (PCA_IDLE_DISABLE << 7) | (PCA_SOURCE_SELECT << 1); //初始化PCA模式寄存器，这两项在PWMn.h中选择。
CCAPM0 = 0x4D; //高速输出模式，允许比较匹配中断(ECCF0=1)。
CL = 0; //清空PCA基本计数器。
CH = 0;
CCAP0_tmp = 0; //清空CCAP0重装载影射寄存器。
PWMn_SetHighReg(high); //初始化占空比数据。
CR = 1; //启动PCA。
EA = 1; //允许总中断
}
//========================================================================
// 函数: void PCA_interrupt (void) interrupt 7
// 描述: PCA中断服务程序。
// 参数: 无。
// 返回: 无。
// 版本: VER1.0
// 日期: 2009-12-30
// 备注:
//========================================================================
void PCA_interrupt (void) interrupt 7
{
if(CCF0 == 1) //PCA模块0中断
{
CCF0 = 0; //清PCA模块0中断标志
if(CCP0 == 1) CCAP0_tmp += PWM_high; //输出为高电平，则给影射寄存器装载高电平时间长度
else CCAP0_tmp += PWM_low; //输出为低电平，则给影射寄存器装载低电平时间长度
CCAP0L = (unsigned char)CCAP0_tmp; //将影射寄存器写入捕获寄存器，先写CCAP0L
CCAP0H = (unsigned char)(CCAP0_tmp >> 8); //后写CCAP0H
}
/*
else if(CCF1 == 1) //PCA模块1中断
{
CCF1 = 0; //清PCA模块1中断标志
}
else if(CF == 1) //PCA溢出中断
{
CF = 0; //清PCA溢出中断标志
}
*/
}

void PWM0_config(void)
{
EAXSFR(); //访问XFR. 头文件中的宏.
PWMCFG01 &= 0xf0;
PWMSET |= ENPWM0; //允许P0(P0.0~P0.7)做PWM
PWM0CKS = CKS_2T; //选择PWM0时钟, CKS_TIMER2, CKS_1T ~ CKS_16T
PWM0C = 4096; //设置PWM0周期
P00 = 0;
P0n_push_pull(1<<0); //PWM输出口设置为推挽输出
PWM00T1 = 0; //T1输出低电平时刻
PWM00T2 = 2450; //T2输出高电平时刻
PWM00HLD = PWM_Normal; //三种模式 PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM00CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
P01 = 0;
P0n_push_pull(1<<1); //PWM输出口设置为推挽输出
PWM01T1 = 0; //T1输出低电平时刻
PWM01T2 = 2450; //T2输出高电平时刻
PWM01HLD = PWM_Normal; //PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM01CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
P02 = 0;
P0n_push_pull(1<<2); //PWM输出口设置为推挽输出
PWM02T1 = 0; //T1输出低电平时刻
PWM02T2 = 2450; //T2输出高电平时刻
PWM02HLD = PWM_Normal; //PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM02CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
P03 = 0;
P0n_push_pull(1<<3); //PWM输出口设置为推挽输出
PWM03T1 = 0; //T1输出低电平时刻
PWM03T2 = 2450; //T2输出高电平时刻
PWM03HLD = PWM_Normal; //PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM03CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
P04 = 0;
P0n_push_pull(1<<4); //PWM输出口设置为推挽输出
PWM04T1 = 0; //T1输出低电平时刻
PWM04T2 = 2450; //T2输出高电平时刻
PWM04HLD = PWM_Normal; //PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM04CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
P05 = 0;
P0n_push_pull(1<<5); //PWM输出口设置为推挽输出
PWM05T1 = 0; //T1输出低电平时刻
PWM05T2 = 2450; //T2输出高电平时刻
PWM05HLD = PWM_Normal; //三种模式 PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM05CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
P06 = 0;
P0n_push_pull(1<<6); //PWM输出口设置为推挽输出
PWM06T1 = 0; //T1输出低电平时刻
PWM06T2 = 2450; //T2输出高电平时刻
PWM06HLD = PWM_Normal; //PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM06CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
P07 = 0;
P0n_push_pull(1<<7); //PWM输出口设置为推挽输出
PWM07T1 = 0; //T1输出低电平时刻
PWM07T2 = 2450; //T2输出高电平时刻
PWM07HLD = PWM_Normal; //PWM正常输出, (PWM_KeepHigh: PWM强制输出高电平, PWM_KeepLow: PWM强制输出低电平)
PWM07CR = ENO; //ENO:允许PWM输出, INI: 初始电平为高电平. ENI:允许匹配中断, ENT2I:允许上升沿(T2匹配)中断, ENT1I:允许下降沿(T1匹配)中断
PWMCFG01 |= PWM0CEN; //启动计数器, 开始PWM输出, 初始化最后执行的语句
}

官方例程
STC8H系列 输出任意周期和占空比的波形
#include "reg51.h"
#include "intrins.h"
sfr P_SW2 = 0xba;
#define PWMA_CCER1 (*(unsigned char volatile xdata *)0xfecc)
#define PWMA_CCMR1 (*(unsigned char volatile xdata *)0xfec8)
#define PWMA_ENO (*(unsigned char volatile xdata *)0xfeb1)
#define PWMA_BKR (*(unsigned char volatile xdata *)0xfedd)
#define PWMA_CCR1 (*(unsigned int volatile xdata *)0xfed5)
#define PWMA_ARR (*(unsigned int volatile xdata *)0xfed2)
#define PWMA_CR1 (*(unsigned char volatile xdata *)0xfec0)
sfr P0M1 = 0x93;
sfr P0M0 = 0x94;
sfr P1M1 = 0x91;
sfr P1M0 = 0x92;
sfr P2M1 = 0x95;
sfr P2M0 = 0x96;
sfr P3M1 = 0xb1;
sfr P3M0 = 0xb2;
sfr P4M1 = 0xb3;
sfr P4M0 = 0xb4;
sfr P5M1 = 0xc9;
sfr P5M0 = 0xca;
void main()
{
P0M0 = 0x00;
P0M1 = 0x00;
P1M0 = 0x00;
P1M1 = 0x00;
P2M0 = 0x00;
P2M1 = 0x00;
P3M0 = 0x00;
P3M1 = 0x00;
P4M0 = 0x00;
P4M1 = 0x00;
P5M0 = 0x00;
P5M1 = 0x00;
P_SW2 = 0x80;
PWMA_CCER1 = 0x00; //写CCMRx前必须先清零CCERx关闭通道
PWMA_CCMR1 = 0x60; //设置CC1为PWMA输出模式
PWMA_CCER1 = 0x01; //使能CC1通道
PWMA_CCR1 = 100; //设置占空比时间
PWMA_ARR = 500; //设置周期时间
PWMA_ENO = 0x01; //使能PWM1P端口输出
PWMA_BKR = 0x80; //使能主输出
PWMA_CR1 = 0x01; //开始计时
while (1);
}

定时器占空比输出
uchar time 设定值
uchar val 计数值
PWM=0
val++; //计数加
if(val<time); //time=20
{
PWM=0;
}
else if(val>time&&val<99)
{
PWM=1;
val=0;
}
else if(val>99)
{
PWM=0;
val=0;
}

/**************定时中断*************************/
void timer0() interrupt 1
{
aa++; //timeA
if(aa>=10)
{
aa=0;
OUT_A=~OUT_A;
}
val++; //计数加
if(val<time) //time=20
{
PWM=0;
}
else if(val>time&&val<99)
{
PWM=1;
val=0;
}
else if(val>99)
{
PWM=0;
val=0;
}
}
/*********************************************************/
void main(void) //
{
P1M0=0X00;
P1M1=0X00;
P3M0=0X00;
P3M1=0X00;
P5M0=0X00;
P5M1=0X00;
Initial_LY096BG30(); //初始化显示屏
cleardisp();
reset_io();
Delay_50ms(2);
delay1(2);
DisModel();
Diswait();
Disval(1);
AUXR |= 0x80; //定时器时钟1T模式
TMOD &= 0xF0; //设置定时器模式
TL0 = 0xA0; //设置定时初始值 5mS 12MHZ
TH0 = 0x15; //设置定时初始值 5mS 12MHZ
TF0 = 0; //清除TF0标志
TR0 = 1; //定时器0开始计时
EA=1;
ET0=1;
time=80; //

/************* 功能说明 **************
本例程基于STC8H8K64U核心实验板（开天斧）进行编写测试。
高级PWM定时器 PWM1P/PWM1N,PWM2P/PWM2N,PWM3P/PWM3N,PWM4P/PWM4N 每个通道都可独立实现PWM输出，或者两两互补对称输出.
8个通道PWM设置对应P2的8个端口.
通过P2口上连接的8个LED灯，利用PWM实现呼吸灯效果.
PWM周期和占空比可以根据需要自行设置，最高可达65535.
此外程序演示两种复位进入USB下载模式的方法：
1. 通过每1毫秒执行一次“KeyResetScan”函数，实现长按P3.2口按键触发MCU复位，进入USB下载模式。
(如果不希望复位进入USB下载模式的话，可在复位代码里将 IAP_CONTR 的bit6清0，选择复位进用户程序区)
2. 通过加载“stc_usb_hid_8h.lib”库函数，实现使用STC-ISP软件发送指令触发MCU复位，进入USB下载模式并自动下载。
下载时, 选择时钟 24MHZ (用户可自行修改频率).
******************************************/
#include "../comm/STC8h.h" //包含此头文件后，不需要再包含"reg51.h"头文件
#include "../comm/usb.h" //USB调试及复位所需头文件
#include "intrins.h"
/****************************** 用户定义宏 ***********************************/
#define MAIN_Fosc 24000000L //定义主时钟
#define Timer0_Reload (65536UL -(MAIN_Fosc / 1000)) //Timer 0 中断频率, 1000次/秒
/*****************************************************************************/
#define PWM1_1 0x00 //P:P1.0 N:P1.1
#define PWM1_2 0x01 //P:P2.0 N:P2.1
#define PWM1_3 0x02 //P:P6.0 N:P6.1
#define PWM2_1 0x00 //P:P1.2/P5.4 N:P1.3
#define PWM2_2 0x04 //P:P2.2 N:P2.3
#define PWM2_3 0x08 //P:P6.2 N:P6.3
#define PWM3_1 0x00 //P:P1.4 N:P1.5
#define PWM3_2 0x10 //P:P2.4 N:P2.5
#define PWM3_3 0x20 //P:P6.4 N:P6.5
#define PWM4_1 0x00 //P:P1.6 N:P1.7
#define PWM4_2 0x40 //P:P2.6 N:P2.7
#define PWM4_3 0x80 //P:P6.6 N:P6.7
#define PWM4_4 0xC0 //P:P3.4 N:P3.3
#define ENO1P 0x01
#define ENO1N 0x02
#define ENO2P 0x04
#define ENO2N 0x08
#define ENO3P 0x10
#define ENO3N 0x20
#define ENO4P 0x40
#define ENO4N 0x80
#define PWM_PERIOD 1023 //设置周期值
/************* 本地变量声明 **************/
bit B_1ms; //1ms标志
u16 PWM1_Duty;
u16 PWM2_Duty;
u16 PWM3_Duty;
u16 PWM4_Duty;
bit PWM1_Flag;
bit PWM2_Flag;
bit PWM3_Flag;
bit PWM4_Flag;
//USB调试及复位所需定义
char *USER_DEVICEDESC = NULL;
char *USER_PRODUCTDESC = NULL;
char *USER_STCISPCMD = "@STCISP#"; //设置自动复位到ISP区的用户接口命令
//P3.2口按键复位所需变量
bit Key_Flag;
u16 Key_cnt;
void UpdatePwm(void);
void KeyResetScan(void);
/******************** 主函数 **************************/
void main(void)
{
P_SW2 |= 0x80; //扩展寄存器(XFR)访问使能
RSTFLAG |= 0x04; //设置硬件复位后需要检测P3.2的状态选择运行区域，否则硬件复位后进入USB下载模式
P0M1 = 0x00; P0M0 = 0x00; //设置为准双向口
P1M1 = 0x00; P1M0 = 0x00; //设置为准双向口
P2M1 = 0x00; P2M0 = 0x00; //设置为准双向口
P3M1 = 0x00; P3M0 = 0x00; //设置为准双向口
P4M1 = 0x00; P4M0 = 0x00; //设置为准双向口
P5M1 = 0x00; P5M0 = 0x00; //设置为准双向口
P6M1 = 0x00; P6M0 = 0x00; //设置为准双向口
P7M1 = 0x00; P7M0 = 0x00; //设置为准双向口
PWM1_Flag = 0;
PWM2_Flag = 0;
PWM3_Flag = 0;
PWM4_Flag = 0;
PWM1_Duty = 0;
PWM2_Duty = 256;
PWM3_Duty = 512;
PWM4_Duty = 1024;
//USB调试及复位所需代码-----
P3M0 &= ~0x03;
P3M1 |= 0x03;
IRC48MCR = 0x80;
while (!(IRC48MCR & 0x01));
usb_init();
//-------------------------
// Timer0初始化
TMOD &= 0xf0;//16 bits timer auto-reload
AUXR |= 0x80;//Timer0 set as 1T
TH0 = (u8)(Timer0_Reload / 256);
TL0 = (u8)(Timer0_Reload % 256);
ET0 = 1; //Timer0 interrupt enable
TR0 = 1; //Tiner0 run
PWMA_CCER1 = 0x00; //写 CCMRx 前必须先清零 CCxE 关闭通道
PWMA_CCER2 = 0x00;
PWMA_CCMR1 = 0x68; //通道模式配置
PWMA_CCMR2 = 0x68;
PWMA_CCMR3 = 0x68;
PWMA_CCMR4 = 0x68;
PWMA_CCER1 = 0x55; //配置通道输出使能和极性
PWMA_CCER2 = 0x55;
PWMA_ARRH = (u8)(PWM_PERIOD >> 8); //设置周期时间
PWMA_ARRL = (u8)PWM_PERIOD;
PWMA_ENO = 0x00;
PWMA_ENO |= ENO1P; //使能输出
PWMA_ENO |= ENO1N; //使能输出
PWMA_ENO |= ENO2P; //使能输出
PWMA_ENO |= ENO2N; //使能输出
PWMA_ENO |= ENO3P; //使能输出
PWMA_ENO |= ENO3N; //使能输出
PWMA_ENO |= ENO4P; //使能输出
PWMA_ENO |= ENO4N; //使能输出
PWMA_PS = 0x00; //高级 PWM 通道输出脚选择位
PWMA_PS |= PWM1_2; //选择 PWM1_2 通道
PWMA_PS |= PWM2_2; //选择 PWM2_2 通道
PWMA_PS |= PWM3_2; //选择 PWM3_2 通道
PWMA_PS |= PWM4_2; //选择 PWM4_2 通道
PWMA_BKR = 0x80; //使能主输出
PWMA_CR1 |= 0x81; //ARR预装载，开始计时
IE2 |= 0x80; //IE2相关的中断位操作使能后，需要重新设置EUSB
EA = 1; //打开总中断
while (1)
{
if (bUsbOutReady) //USB调试及复位所需代码
{
// memcpy(UsbInBuffer, UsbOutBuffer, 64); //原路返回, 用于测试HID
// usb_IN();
usb_OUT_done();
}
}
}
/********************** Timer0 1ms中断函数 ************************/
void timer0(void) interrupt 1
{
if(!PWM1_Flag)
{
PWM1_Duty++;
if(PWM1_Duty > PWM_PERIOD) PWM1_Flag = 1;
}
else
{
PWM1_Duty--;
if(PWM1_Duty <= 0) PWM1_Flag = 0;
}
if(!PWM2_Flag)
{
PWM2_Duty++;
if(PWM2_Duty > PWM_PERIOD) PWM2_Flag = 1;
}
else
{
PWM2_Duty--;
if(PWM2_Duty <= 0) PWM2_Flag = 0;
}
if(!PWM3_Flag)
{
PWM3_Duty++;
if(PWM3_Duty > PWM_PERIOD) PWM3_Flag = 1;
}
else
{
PWM3_Duty--;
if(PWM3_Duty <= 0) PWM3_Flag = 0;
}
if(!PWM4_Flag)
{
PWM4_Duty++;
if(PWM4_Duty > PWM_PERIOD) PWM4_Flag = 1;
}
else
{
PWM4_Duty--;
if(PWM4_Duty <= 0) PWM4_Flag = 0;
}
UpdatePwm();
KeyResetScan(); //P3.2口按键触发软件复位，进入USB下载模式，不需要此功能可删除本行代码
}
//========================================================================
// 函数: UpdatePwm(void)
// 描述: 更新PWM占空比.
// 参数: none.
// 返回: none.
// 版本: V1.0, 2012-11-22
//========================================================================
void UpdatePwm(void)
{
PWMA_CCR1H = (u8)(PWM1_Duty >> 8); //设置占空比时间
PWMA_CCR1L = (u8)(PWM1_Duty);
PWMA_CCR2H = (u8)(PWM2_Duty >> 8); //设置占空比时间
PWMA_CCR2L = (u8)(PWM2_Duty);
PWMA_CCR3H = (u8)(PWM3_Duty >> 8); //设置占空比时间
PWMA_CCR3L = (u8)(PWM3_Duty);
PWMA_CCR4H = (u8)(PWM4_Duty >> 8); //设置占空比时间
PWMA_CCR4L = (u8)(PWM4_Duty);
}
//========================================================================
// 函数: void delay_ms(u8 ms)
// 描述: 延时函数。
// 参数: ms,要延时的ms数, 这里只支持1~255ms. 自动适应主时钟.
// 返回: none.
// 版本: VER1.0
// 日期: 2022-6-3
// 备注:
//========================================================================
void delay_ms(u8 ms)
{
u16 i;
do{
i = MAIN_Fosc / 10000;
while(--i); //10T per loop
}while(--ms);
}
//========================================================================
// 函数: void KeyResetScan(void)
// 描述: P3.2口按键长按1秒触发软件复位，进入USB下载模式。
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2022-6-11
// 备注:
//========================================================================
void KeyResetScan(void)
{
if(!P32)
{
if(!Key_Flag)
{
Key_cnt++;
if(Key_cnt >= 1000) //连续1000ms有效按键检测
{
Key_Flag = 1; //设置按键状态，防止重复触发
USBCON = 0x00; //清除USB设置
USBCLK = 0x00;
IRC48MCR = 0x00;
delay_ms(10);
IAP_CONTR = 0x60; //触发软件复位，从ISP开始执行
while (1);
}
}
}
else
{
Key_cnt = 0;
Key_Flag = 0;
}
}

用T0定时器完成PWM输出，脉宽固定，T1来决定高平的宽带来进行PWM调制
具体程序如下：
其中晶振12M，载波频率20KHZ，直接用P0.1来驱动直流电机，直流电机正极接电源正，单片机低平驱动，这样灌电流大。
#include < reg51.h >
#include < intrins.h >
sbit K1 =P1^4 ; //增加键
sbit K2 =P1^5 ; //减少键
sbit P00 =P0^1;
sbit BEEP =P3^7 ; //蜂鸣器
unsigned char PWM=0xe7; //赋初值
void Beep();
void delayms(unsigned char ms);
void delay(unsigned char t);
/*********************************************************/
void main()
{
P1=0xff;
TMOD=0x21 ;
TH0=0xff ; //50us延时常数
TL0=0xce ; //频率调节
TH1=PWM ; //脉宽调节
TL1=0 ;
EA=1;
ET0=1;
ET1=1;
TR0=1 ;
while(1)
{
do{
if(PWM!=0xff)
{PWM++ ;delayms(10);}
else Beep() ;
}
while(K1==0);
do{
if(PWM!=0xce)
{PWM-- ;delayms(10);}
else Beep() ;
}
while(K2==0);
}
}
void timer0() interrupt 1
{
TR1=0 ;
TH0=0xff ;
TL0=0xce ;
TH1=PWM ;
TR1=1 ;
P00=0 ; //启动输出
}
void timer1() interrupt 3
{
TR1=0 ;
P00=1 ; //结束输出
}
/*********************************************************/
//蜂鸣器子程序
/*********************************************************/
void Beep()
{
unsigned char i ;
for (i=0 ;i<100 ;i++)
{
delay(100) ;
BEEP=!BEEP ; //Beep取反
}
BEEP=1 ; //关闭蜂鸣器
delayms(100);
}
/*********************************************************/
// 延时子程序
/*********************************************************/
void delay(unsigned char t)
{
while(t--) ;
}
/*********************************************************/
// 延时子程序
/*********************************************************/
void delayms(unsigned char ms)
{
unsigned char i ;
while(ms--)
{
for(i = 0 ; i < 120 ; i++) ;
}
}
/*********************************************************/