设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 51单片机台灯功能实现,求助
返回列表 发新帖
查看: 1164|回复: 10
收起左侧

51单片机台灯功能实现,求助

[复制链接]
ID:264640 发表于 2023-4-19 10:41 | 显示全部楼层 |阅读模式
按键1短按开关 长按调节亮度
按键2短按切换LED模式
模式：1.LED1亮 LED2灭
1.LED1灭 LED2亮
1.LED1亮 LED2亮



本人对于键值扫描完全没有头绪，如何区分长短按，求大神指导！！
回复

使用道具 举报

ID:332444 发表于 2023-4-19 15:26 | 显示全部楼层
这么简单的不用矩阵键盘,长按通过计数不同实现,模式也就是二进制而已简单得很.
回复

使用道具 举报

ID:332444 发表于 2023-4-19 16:45 | 显示全部楼层
如果要设计一个单片机控制风扇是依据这一天温度变动预报还是依据体温?
回复

使用道具 举报

ID:264640 发表于 2023-4-19 16:54 | 显示全部楼层
xianfajushi 发表于 2023-4-19 15:26
这么简单的不用矩阵键盘,长按通过计数不同实现,模式也就是二进制而已简单得很.

对于长按连加的键值扫描不是很懂
回复

使用道具 举报

ID:264640 发表于 2023-4-19 16:54 | 显示全部楼层
xianfajushi 发表于 2023-4-19 16:45
如果要设计一个单片机控制风扇是依据这一天温度变动预报还是依据体温?

目前只要LED亮度调节就行
回复

使用道具 举报

ID:857072 发表于 2023-4-19 22:09 来自手机 | 显示全部楼层
如果是真不会的话，可以看看天问51这种，按键应该都做好了直接用。因为他这个也直接支持C，想深入的话以后也可以直接转到C语言。
回复

使用道具 举报

ID:140489 发表于 2023-4-20 11:09 | 显示全部楼层
你要的这些功能，一个按键就可以做到
回复

使用道具 举报

ID:1072921 发表于 2023-4-20 11:22 | 显示全部楼层
用延时计数就行了
回复

使用道具 举报

ID:140489 发表于 2023-4-20 12:39 | 显示全部楼层
我这里有个实例，用的STC8H1K16,两路pwm驱动两个NMOS管控制双色灯带
  1. /*************  功能说明    **************
  2. 按键短按开灯，开灯后3秒内，短按开关切换色温(白光，黄光，自然光；切换色温功率不变)；
  3. 长按调亮度；超过3秒短按关灯。
  4. 设置的参数掉电保存；

  6. 高级PWM定时器 PWM1P/PWM1N,PWM2P/PWM2N,PWM3P/PWM3N,PWM4P/PWM4N 每个通道都可独立实现PWM输出，
  7. 或者两两互补对称输出.

  9. MCU: STC8H1K16  LQFP-32封装
  10. P1.1 P1.2驱动两路LED

  12. 2023/4/14 调试成功
  13. ******************************************/

  15. //#include    "reg51.h"       //包含此头文件后，里面声明的寄存器不需要再手动输入，避免重复定义
  16. #include    <stc8h.h>
  17. #include    "intrins.h"

  19. #define     MAIN_Fosc       11059200L   //定义主时钟

  21. #define PWM_PSCR    3     //设置分频        频率计算公式MAIN_Fosc/（PWM_PSCR+1）*（PWM_ARR+1）边沿对齐
  22. #define PWM_ARR  1023    //设置周期值          频率2.7KHz

  24. //#define PWM_PSCR  15     //设置分频        频率计算公式MAIN_Fosc/（PWM_PSCR+1）*（PWM_ARR+1）
  25. //#define PWM_ARR  254    //设置周期值          频率2.7KHz


  28. #define uchar unsigned char
  29. #define uint unsigned int
  30. typedef     unsigned char   u8;
  31. typedef     unsigned int    u16;
  32. typedef     unsigned long   u32;

  34. /****************************** 用户定义宏 ***********************************/

  36. #define Timer0_Reload   (65536UL -(MAIN_Fosc / 1000))       //Timer 0 中断频率, 1000次/秒
  37. /*****************************************************************************/

  39. #define PWM1_1      0x00        //P:P1.0  N:P1.1
  40. #define PWM1_2      0x01        //P:P2.0  N:P2.1
  41. #define PWM1_3      0x02        //P:P6.0  N:P6.1

  43. #define PWM2_1      0x00        //P:P1.2/P5.4  N:P1.3
  44. #define PWM2_2      0x04        //P:P2.2  N:P2.3
  45. #define PWM2_3      0x08        //P:P6.2  N:P6.3

  47. #define PWM3_1      0x00        //P:P1.4  N:P1.5
  48. #define PWM3_2      0x10        //P:P2.4  N:P2.5
  49. #define PWM3_3      0x20        //P:P6.4  N:P6.5

  51. #define PWM4_1      0x00        //P:P1.6  N:P1.7
  52. #define PWM4_2      0x40        //P:P2.6  N:P2.7
  53. #define PWM4_3      0x80        //P:P6.6  N:P6.7
  54. #define PWM4_4      0xC0        //P:P3.4  N:P3.3

  56. #define ENO1P       0x01
  57. #define ENO1N       0x02
  58. #define ENO2P       0x04
  59. #define ENO2N       0x08
  60. #define ENO3P       0x10
  61. #define ENO3N       0x20
  62. #define ENO4P       0x40
  63. #define ENO4N       0x80

  65. /*************  本地变量声明    **************/
  66. bit B_1ms;          //1ms标志

  68. u16 PWM1_Duty;
  69. u16 PWM2_Duty;
  70. u16 PWM2_Dutyv;
  71. u16 PWM1_Dutyv;

  73. //u16 PWM3_Duty;
  74. //u16 PWM4_Duty;

  76. uchar PWM2_Dutyv_L;
  77. uchar PWM2_Dutyv_M;

  79. uchar temp_PWM2_Dutyv_L;
  80. uchar temp_PWM2_Dutyv_M;


  83. bit PWM1_Flag;
  84. bit PWM2_Flag;
  85. bit PWM3_Flag;
  86. bit PWM4_Flag;

  88. void UpdatePwm(void);

  90. sbit k2=P3^2;//灯开关
  91. sbit led=P1^2;//灯
  92. uint k1_cont,k2_cont;//按键消抖计时
  93. uchar k1_lock,k2_lock;//按键锁
  94. uchar count1=10,count2=10;
  95. uint Long_cont=400;
  96. uint Long_cont1=200;
  97. uint Long_cont2=200;
  98. uchar PWM_Value;           //占空比 变量
  99. bit PWM_UP_Down_Flag;  //调光方向标志
  100. bit flag_short_k1,flag_short_k2;//按键短按标志
  101. bit flag_led_onoff;//led灯开关标志
  102. bit SaveFlag;                         //数据存储标志

  104. bit flag_qh,flag_qh1;//色温切换计时标志
  105. uint hcount,hcount1,hcount2;
  106. uchar led_qhcount;
  107. /////////////////////////
  108. void delay(uint ms)
  109. {
  110.         uint i,j;
  111.         for(i=0; i<ms; i++)
  112.                 for(j=0; j<930; j++);
  113. }
  114. //////////////////////
  115. /////////////////
  116. void IapIdle()        //禁用IAP功能
  117. {
  118.     IAP_CONTR = 0;                              //关闭IAP功能
  119.     IAP_CMD = 0;                                //清除命令寄存器
  120.     IAP_TRIG = 0;                               //清除触发寄存器
  121.     IAP_ADDRH = 0x80;                           //将地址设置到非IAP区域
  122.     IAP_ADDRL = 0;
  123. }

  125. char IapRead(int addr) //读EEPROM
  126. {
  127.     char dat;

  129.     IAP_CONTR = 0x80;                           //使能IAP
  130.     IAP_TPS = 12;                               //设置等待参数12MHz
  131.     IAP_CMD = 1;                                //设置IAP读命令
  132.     IAP_ADDRL = addr;                           //设置IAP低地址
  133.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  134.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  135.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  136.     _nop_();
  137.     dat = IAP_DATA;                             //读IAP数据
  138.     IapIdle();                                  //关闭IAP功能

  140.     return dat;
  141. }

  143. void IapProgram(int addr, char dat)        //写EEPROM
  144. {
  145.     IAP_CONTR = 0x80;                           //使能IAP
  146.     IAP_TPS = 12;                               //设置等待参数12MHz
  147.     IAP_CMD = 2;                                //设置IAP写命令
  148.     IAP_ADDRL = addr;                           //设置IAP低地址
  149.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  150.     IAP_DATA = dat;                             //写IAP数据
  151.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  152.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  153.     _nop_();
  154.     IapIdle();                                  //关闭IAP功能
  155. }

  157. void IapErase(int addr)          //擦除EEPROM
  158. {
  159.     IAP_CONTR = 0x80;                           //使能IAP
  160.     IAP_TPS = 12;                               //设置等待参数12MHz
  161.     IAP_CMD = 3;                                //设置IAP擦除命令
  162.     IAP_ADDRL = addr;                           //设置IAP低地址
  163.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  164.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  165.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  166.     _nop_();                                    //
  167.     IapIdle();                                  //关闭IAP功能
  168. }
  169. ///////////////////
  170. void keyscan()
  171. {
  172. //        if(tes_flag==0)        //非时钟设置状态
  173.         {
  174.        
  175.                 if(k2)
  176.                 {
  177.                         k2_lock=0;
  178.                         k2_cont=0;
  179.                         if(flag_short_k2)
  180.                         {
  181. //                                cmled2=!cmled2;//按键指示灯取反
  182.                                 flag_short_k2=0;//清零k2短按标志
  183. //                                flag_led_onoff=!flag_led_onoff;//开关灯标志取反
  184.                                 flag_qh1=1;

  186.                                 if(flag_qh)
  187.                                 {
  188.                                         flag_led_onoff=1;
  189.                                         led_qhcount++;
  190.                                         if(led_qhcount==3)
  191.                                         {
  192.                                                 led_qhcount=0;
  193.                                         }

  195. //                                        if(led_qhcount==0)        //两路亮
  196. //                                        {
  197. //                                        //        PWM2_Dutyv=PWM2_Dutyv>>1; //两路都亮的亮度是一路一半的亮度
  198. //                                                PWM2_Dutyv=PWM2_Dutyv/2;
  199. //                                        }
  200. //                                        if(led_qhcount==1)
  201. //                                        {
  202. //                                        //        PWM2_Dutyv=PWM2_Dutyv<<1; //单路亮度是双路亮度的2倍
  203. //                                                PWM2_Dutyv=PWM2_Dutyv*2;
  204. //                                        }
  205. //                                        if(led_qhcount==2)
  206. //                                        {
  207. //                                                PWM2_Dutyv=PWM2_Dutyv;
  208. //                                        }
  209.                                        

  211.                                         IapErase(0x1000);  //擦除EEPROM
  212.                                         IapProgram(0x1000, led_qhcount);//保存亮灯路数值


  215.                                         hcount=0;
  216.                                         hcount1=0;       
  217.                                 }
  218.                                 else
  219.                                 {
  220.                                         flag_led_onoff=!flag_led_onoff;//开关灯标志取反
  221.                                 }

  223.                         }

  225.                         if(SaveFlag)  //长按松手后，保存pwm数据
  226.                         {
  227.                                 PWM_UP_Down_Flag=!PWM_UP_Down_Flag;//调光方向标志取反
  228.                                 PWM2_Dutyv_L=PWM2_Dutyv%256;//将大于255的占空比值拆分成两个uchar的数值再保存
  229.                                 PWM2_Dutyv_M=PWM2_Dutyv/256;
  230.                                 IapErase(0x0001);  //擦除EEPROM
  231.                                 IapProgram(0x0001, PWM2_Dutyv_L);//将PWM_Value写入EEPROM
  232.                                 IapProgram(0x0002, PWM2_Dutyv_M);//将PWM_Value写入EEPROM

  234.                                 SaveFlag = 0;//保存数据后，保存标志清零       
  235.                         }       
  236.                                
  237.                 }
  238.                 else if(k2_lock==0)        //短按
  239.                 {
  240.                         k2_cont++;
  241.                 //        flag_k2=1;
  242.                         if(k2_cont>count2)
  243.                         {
  244.                                 k2_cont=0;
  245.                                 k2_lock=1;
  246.                                 flag_short_k2=1;
  247. //                                if(flag_qh)
  248. //                                {
  249. //                                        led_qhcount++;
  250. //                                        if(led_qhcount==3)
  251. //                                        {
  252. //                                                led_qhcount=0;
  253. //                                        }
  254. //                                        hcount=0;
  255. //                                        hcount1=0;       
  256. //                                }
  257.                         }       
  258.                 }
  259.                 else if(k2_cont<Long_cont2)        //长按
  260.                 {
  261.                         k2_cont++;
  262.                         if(k2_cont==Long_cont2)
  263.                         {
  264.                                 k2_cont=196;
  265.                                 flag_short_k2=0;//进入长按必须清短按标志，否则会触发一次短按
  266.                                 SaveFlag = 1;//进入长按，保存标志置1
  267.                                 if(flag_led_onoff)//开灯状态
  268.                                 {
  269.                                         if(PWM_UP_Down_Flag == 1) //亮度++
  270.                                         {
  271.                                                
  272.                                                
  273. //                                                if(PWM2_Dutyv < 1023)       
  274. //                                                {
  275. //                                                //        PWM2_Dutyv +=5;
  276. //                                                        if(led_qhcount==0)
  277. //                                                        {        PWM2_Dutyv +=3;
  278. //                                                                if(PWM2_Dutyv > 511)
  279. //                                                                {
  280. //                                                                        PWM2_Dutyv = 511;
  281. //                                                                }
  282. //                                                        }
  283. //                                                        else
  284. //                                                        {       
  285. //                                                                PWM2_Dutyv +=6;
  286. //                                                                if(PWM2_Dutyv > 1022)
  287. //                                                                {
  288. //                                                                        PWM2_Dutyv = 1022;
  289. //                                                                }
  290. //                                                        }
  291. //                                                }
  292. //                                       
  293. //                                        }
  294. //                                       
  295. //                                        if(PWM_UP_Down_Flag == 0)   //亮度--
  296. //                                        {
  297. //                               
  298. //                                       
  299. //                                                if(PWM2_Dutyv > 0)
  300. //                                                {
  301. //                                                        if(led_qhcount==0)
  302. //                                                        {PWM2_Dutyv -=3;}
  303. //                                                        else
  304. //                                                        {PWM2_Dutyv -=6;}
  305. //                                                        if(PWM2_Dutyv < 100)
  306. //                                                        {
  307. //                                                                PWM2_Dutyv = 100;                               
  308. //                                                        }
  309. //                                       
  310. //                                                }
  311. //                                        }                                       
  312.                                                 if(PWM2_Dutyv < 1023)        //亮度++
  313.                                                 {
  314.                                                                 PWM2_Dutyv +=5;
  315.                                                                 if(PWM2_Dutyv > 1022)
  316.                                                                 {
  317.                                                                         PWM2_Dutyv = 1022;
  318.                                                                 }
  319.                                                        
  320.                                                 }
  321.                                           
  322.                                         }
  323.                                        
  324.                                         if(PWM_UP_Down_Flag == 0)   //亮度--
  325.                                         {
  326.                                
  327.                                        
  328.                                                 if(PWM2_Dutyv > 0)
  329.                                                 {

  331.                                                         PWM2_Dutyv -=5;
  332.                                                         if(PWM2_Dutyv < 100)
  333.                                                         {
  334.                                                                 PWM2_Dutyv = 100;                               
  335.                                                         }
  336.                                        
  337.                                                 }
  338.                                         }                                       
  339.                                                                        
  340.                                 }                               
  341.                         }               
  342.                
  343.                 }
  344.         }
  345. }
  346. //////////////////////////
  347. void Timer0Init(void)                //2毫秒@11.0592MHz
  348. {
  349.         AUXR |= 0x80;                //定时器时钟1T模式
  350.         TMOD &= 0xF0;                //设置定时器模式 16位自动重载
  351.         TL0 = 0x9A;                //设置定时初始值
  352.         TH0 = 0xA9;                //设置定时初始值
  353.         TF0 = 0;                //清除TF0标志
  354.         TR0 = 1;                //定时器0开始计时
  355.         ET0=1;
  356.         EA=1;
  357. }


  360. //////////////////////////

  362. /******************** 主函数 **************************/
  363. void main(void)
  364. {

  366.         Timer0Init();
  367.     P0M1 = 0x00;   P0M0 = 0x00;   //设置为准双向口
  368.     P1M1 = 0x00;   P1M0 = 0x07;   //设置为准双向口 p12设为推挽输出
  369.     P2M1 = 0x00;   P2M0 = 0x00;   //设置为准双向口
  370.     P3M1 = 0x00;   P3M0 = 0x00;   //设置为准双向口
  371.     P4M1 = 0x00;   P4M0 = 0x00;   //设置为准双向口
  372.     P5M1 = 0x00;   P5M0 = 0x00;   //设置为准双向口
  373.     P6M1 = 0x00;   P6M0 = 0x00;   //设置为准双向口
  374.     P7M1 = 0x00;   P7M0 = 0x00;   //设置为准双向口

  376.                 PWM1_Flag = 0;
  377.                 PWM2_Flag = 0;
  378.                 PWM3_Flag = 0;
  379.                 PWM4_Flag = 0;
  380.        
  381. //                PWM1_Duty = 512;
  382. //                PWM2_Duty = 256;
  383. //                PWM2_Dutyv=2046;
  384. //                PWM3_Duty = 512;
  385. //                PWM4_Duty = 1024;

  387.    
  388.         PWM2_Dutyv_L=IapRead(0x0001);  //读出占空比值
  389.         PWM2_Dutyv_M=IapRead(0x0002);
  390.         if(PWM2_Dutyv_M==255)PWM2_Dutyv_M=3; //第一次上电读出的值是255，就给占空比赋初值
  391.         if(PWM2_Dutyv_L==255)PWM2_Dutyv_L=255;
  392.                                                                                          //占空比最大为PWM_ARR的值
  393.         PWM2_Dutyv=PWM2_Dutyv_M*256+PWM2_Dutyv_L;//两个uchar合并成uint,初始最大亮度值1024

  395.         led_qhcount=IapRead(0x1000);
  396.         if(led_qhcount==255)led_qhcount=2;

  398.                 P_SW2 |= 0x80;
  399.                
  400.     PWMA_CCER1 = 0x00; //写 CCMRx 前必须先清零 CCxE 关闭通道
  401.     PWMA_CCER2 = 0x00;
  402.     PWMA_CCMR1 = 0x60; //通道模式配置 设置CC1为PWMA输出模式，方向为输出
  403.     PWMA_CCMR2 = 0x60;
  404.     PWMA_CCMR3 = 0x60;
  405.     PWMA_CCMR4 = 0x60;
  406.     PWMA_CCER1 = 0x55; //配置通道输出使能和极性
  407.     PWMA_CCER2 = 0x55;

  409.         PWMA_PSCRH = (u8)(PWM_PSCR>>8);     //设置分频
  410.     PWMA_PSCRL = (u8)(PWM_PSCR);

  412. //    PWMA_ARRH = (u8)(PWM_ARR >> 8);  //设置周期时间
  413. //    PWMA_ARRL = (u8)PWM_ARR;
  414.     PWMA_ARRH = PWM_ARR/256;  //设置周期时间  右移8位等同256求模
  415.     PWMA_ARRL = PWM_ARR%256;
  416. /*
  417. 通俗的说，位移的实现是将数据转换成二进制后，进行左右移动的。如果左移，则右边补零，如果是右移，
  418. 则是左边补零，后边溢出的则去掉。因此，左移可以理解为整数的乘法，
  419. 而右移则是理解为整数的取整除法。

  421.   左移 (<<)

  423.   将第一个操作数向左移动第二个操作数指定的位数，空出的位置补0。
  424.   左移相当于乘. 左移一位相当于乘2;左移两位相当于乘4;左移三位相当于乘8。

  426.   x<<1= x*2
  427.   x<<2= x*4
  428.   x<<3= x*8
  429.   x<<4= x*16

  431.   同理, 右移即相反：

  433.   右移 (>>)
  434.   将第一个操作数向右移动第二个操作数所指定的位数，空出的位置补0。

  436.   右移相当于整除. 右移一位相当于除以2;右移两位相当于除以4;右移三位相当于除以8。
  437.   右移四位相当于除以16；右移8位相当于除以256.
  438.   x>>1= x/2
  439.   x>>2= x/4
  440.   x>>3= x/8
  441.   x>>4= x/16
  442. */

  444. //    PWMA_ARRH = 0x03; //设置周期时间  自动重装载高8位
  445. //    PWMA_ARRL = 0xff;//自动重装载低8位

  447.     PWMA_ENO = 0x00;
  448. //    PWMA_ENO |= ENO1P; //使能输出
  449.     PWMA_ENO |= ENO1N; //使能输出
  450.     PWMA_ENO |= ENO2P; //使能输出
  451. //    PWMA_ENO |= ENO2N; //使能输出
  452. //    PWMA_ENO |= ENO3P; //使能输出
  453. //    PWMA_ENO |= ENO3N; //使能输出
  454. //    PWMA_ENO |= ENO4P; //使能输出
  455. //    PWMA_ENO |= ENO4N; //使能输出

  457.                 PWMA_PS = 0x00;  //高级 PWM 通道输出脚选择位
  458.     PWMA_PS |= PWM1_1; //选择 PWM1_2 通道
  459.     PWMA_PS |= PWM2_1; //选择 PWM2_1 通道 p12口
  460. //    PWMA_PS |= PWM3_3; //选择 PWM3_3 通道
  461. //    PWMA_PS |= PWM4_3; //选择 PWM4_3 通道

  463.     PWMA_BKR = 0x80; //使能主输出
  464.     PWMA_CR1 |= 0x01; //开始计时
  465.                 P_SW2 &= 0x7f;
  466.     while (1)
  467.     {
  468.                 keyscan();
  469.                 delay(4);


  472.                
  473.                 if(flag_led_onoff==1)        //开灯
  474.                 {
  475.                         switch(led_qhcount)
  476.                         {
  477. //                                case 0: PWM2_Duty = PWM2_Dutyv; PWM1_Duty = PWM2_Dutyv; break;
  478. //
  479. //                                case 1: PWM2_Duty = 0; PWM1_Duty = PWM2_Dutyv; break;
  480. //
  481. //                                case 2: PWM2_Duty = PWM2_Dutyv; PWM1_Duty = 0; break;
  482.                                 case 0: PWM2_Duty = PWM2_Dutyv/2; PWM1_Duty = PWM2_Dutyv/2; break;

  484.                                 case 1: PWM2_Duty = 0; PWM1_Duty = PWM2_Dutyv; break;

  486.                                 case 2: PWM2_Duty = PWM2_Dutyv; PWM1_Duty = 0; break;
  487.                                 default: break;
  488.                         }
  489.                 }
  490.                 else //关灯
  491.                 {
  492.                         PWM2_Duty=0;
  493.                         PWM1_Duty = 0;
  494.                         flag_qh1=0;         //关灯将flag_qh1，hcount2这两个变量清零
  495.                         hcount2=0;         //否则关灯后再快速开灯会误切换色温
  496.                 }
  497.                
  498.                 UpdatePwm();
  499.                        
  500.         }
  501. }


  504. /********************** Timer0 1ms中断函数 ************************/
  505. void timer0(void) interrupt 1
  506. {
  507.         if(flag_qh1)
  508.         {
  509.                 hcount2++;
  510.                 if(hcount2==100)//0.2秒
  511.                 {
  512.                         hcount2=0;
  513.                         flag_qh1=0;
  514.                         flag_qh=1;       
  515.                 }       
  516.         }

  518.         if(flag_qh)
  519.         {
  520.                 hcount++;
  521.                 if(hcount==500)        //1秒
  522.                 {
  523.                         hcount=0;
  524.                         hcount1++;
  525.                         if(hcount1==3)
  526.                         {
  527.                                 hcount1=0;
  528.                                 flag_qh=0;
  529.                         }
  530.                 }
  531.         }       

  533. }


  536. //========================================================================
  537. // 函数: UpdatePwm(void)
  538. // 描述: 更新PWM占空比.
  539. // 参数: none.
  540. // 返回: none.
  541. // 版本: V1.0, 2012-11-22
  542. //========================================================================
  543. void UpdatePwm(void)
  544. {
  545.                 P_SW2 |= 0x80;
  546.           PWMA_CCR1H = (u8)(PWM1_Duty >> 8); //设置占空比时间
  547.     PWMA_CCR1L = (u8)(PWM1_Duty);
  548.           PWMA_CCR2H = (u8)(PWM2_Duty >> 8); //设置占空比时间
  549.     PWMA_CCR2L = (u8)(PWM2_Duty);
  550. //          PWMA_CCR3H = (u8)(PWM3_Duty >> 8); //设置占空比时间
  551. //    PWMA_CCR3L = (u8)(PWM3_Duty);
  552. //          PWMA_CCR4H = (u8)(PWM4_Duty >> 8); //设置占空比时间
  553. //    PWMA_CCR4L = (u8)(PWM4_Duty);
  554.                 P_SW2 &= 0x7f;
  555. }

复制代码
回复

使用道具 举报

ID:587810 发表于 2023-4-20 13:35 | 显示全部楼层
可以吧按键1和2接到P1.0和P1.1上，led1与led2接到P1.2与P1.3上，然后判断这两个引脚的按下的状态，在通过程序判断从而控制三个灯的亮灭
回复

使用道具 举报

ID:123289 发表于 2023-4-20 15:16 | 显示全部楼层
太为难你了。没事换个东西玩玩，别玩这个灯，烦人。
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表