找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 3043|回复: 1
打印 上一主题 下一主题
收起左侧

基于STM32ZGT6的闹钟定时器程序

[复制链接]
跳转到指定楼层
楼主
ID:506115 发表于 2019-7-2 18:51 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
l基本要求:实现具备闹钟功能的电子钟
使用STM32定时器功能实现,禁止使用RTC
基于STM32开发板和液晶屏幕实现功能
电子钟具备时间显示功能和闹钟功能
利用两个可以控制的LED指示闹钟1和闹钟2的状态
进阶要求:电子钟时间和闹钟修改以及LED渐变
利用板载三个按键实现修改时间和闹钟设定时间功能
实现LED灯1和LED灯2在点亮和熄灭时的渐变效果

单片机源程序如下:
  1. #include "sys.h"
  2. #include "delay.h"
  3. #include "usart.h"
  4. #include "led.h"
  5. #include "timer.h"
  6. #include "oled.h"
  7. #include "exti.h"
  8. #include "key.h"
  9. #include "pwm.h"
  10. struct time_format{
  11. short hour;
  12. short minute;
  13. short second;
  14. }time,alarm1,alarm2;
  15. extern short Flag_LED0_light;
  16. extern short Flag_LED1_light;
  17. extern void TIM14_PWM_Init(u32 arr,u32 psc);

  18. void OLED_update(struct time_format time,struct time_format alarm1,struct time_format alarm2)
  19. {
  20.                 OLED_Clear();

  21.                 OLED_ShowString(0,0,"Time");
  22.                 OLED_ShowString(0,2,"Alarm1");
  23.                 OLED_ShowString(0,4,"Alarm2");

  24.                 OLED_ShowNum(52,0,time.hour,2,16);
  25.                 OLED_ShowChar(67,0,':');
  26.                 OLED_ShowNum(74,0,time.minute,2,16);
  27.                 OLED_ShowChar(89,0,':');
  28.                 OLED_ShowNum(96,0,time.second,2,16);
  29.                
  30.                 OLED_ShowNum(52,2,alarm1.hour,2,16);
  31.                 OLED_ShowChar(67,2,':');
  32.                 OLED_ShowNum(74,2,alarm1.minute,2,16);
  33.                 OLED_ShowChar(89,2,':');
  34.                 OLED_ShowNum(96,2,alarm1.second,2,16);
  35.                
  36.                 OLED_ShowNum(52,4,alarm2.hour,2,16);
  37.                 OLED_ShowChar(67,4,':');
  38.                 OLED_ShowNum(74,4,alarm2.minute,2,16);
  39.                 OLED_ShowChar(89,4,':');
  40.                 OLED_ShowNum(96,4,alarm2.second,2,16);
  41. }

  42. void time_init()
  43. {
  44.         time.hour=22;
  45.         time.minute=33;
  46.         time.second=44;
  47.         /*
  48.         alarm1.hour=23;
  49.         alarm1.minute=00;
  50.         alarm1.second=00;
  51.        
  52.         alarm2.hour=01;
  53.         alarm2.minute=59;
  54.         alarm2.second=59;
  55.         */
  56.         alarm1.hour=22;
  57.         alarm1.minute=33;
  58.         alarm1.second=50;
  59.        
  60.         alarm2.hour=22;
  61.         alarm2.minute=33;
  62.         alarm2.second=55;
  63. }
  64. int time_compete(struct time_format time,struct time_format alarm)
  65. {
  66.         if(time.hour==alarm.hour&&time.minute==alarm.minute&&time.second==alarm.second)
  67.                 return 1;
  68.         else return 0;
  69.        
  70. }
  71. void time_update()
  72. {
  73.         if(time.second==60)
  74.         {
  75.                 time.minute++;
  76.                 time.second=00;
  77.                 if(time.minute==60)
  78.                 {
  79.                         time.minute=00;
  80.                         time.hour++;
  81.                         if(time.hour==24)
  82.                                 time.hour=0;
  83.                 }
  84.         }       
  85.         if(time.minute==60)
  86.                 {
  87.                         time.minute=00;
  88.                         time.hour++;
  89.                         if(time.hour==24)
  90.                                 time.hour=0;
  91.                 }
  92.         if(time.hour==24)
  93.                                 time.hour=0;

  94.        
  95.         if(alarm1.second==60)
  96.         {
  97.                 alarm1.minute++;
  98.                 alarm1.second=00;
  99.                 if(alarm1.minute==60)
  100.                 {
  101.                         alarm1.minute=00;
  102.                         alarm1.hour++;
  103.                         if(alarm1.hour==24)
  104.                                 alarm1.hour=0;
  105.                 }
  106.         }
  107.         if(alarm1.minute==60)
  108.                 {
  109.                         alarm1.minute=00;
  110.                         alarm1.hour++;
  111.                         if(alarm1.hour==24)
  112.                                 alarm1.hour=0;
  113.                 }
  114.         if(alarm1.hour==24)
  115.                         alarm1.hour=0;
  116.                
  117.        
  118.         if(alarm2.second==60)
  119.         {
  120.                 alarm2.minute++;
  121.                 alarm2.second=00;
  122.                 if(alarm2.minute==60)
  123.                 {
  124.                         alarm2.minute=00;
  125.                         alarm2.hour++;
  126.                         if(alarm2.hour==24)
  127.                                 alarm2.hour=0;
  128.                 }
  129.         }       
  130.         if(alarm2.minute==60)
  131.                 {
  132.                         alarm2.minute=00;
  133.                         alarm2.hour++;
  134.                         if(alarm2.hour==24)
  135.                                 alarm2.hour=0;
  136.                 }
  137.         if(alarm2.hour==24)
  138.                                 alarm2.hour=0;       
  139. }
  140. void LED_light(int a,int b)
  141. {
  142.         int t=0;
  143.         if(a==0)
  144.         {
  145.                 if(b==0)
  146.                 {
  147.                         t=0;
  148.                         while(t<25)
  149.                                 {
  150.                                         LED0=0;
  151.                                         delay_ms(t);
  152.                                         LED0=1;
  153.                                         delay_ms(25-t);
  154.                                         t++;
  155.                                 }
  156.                                 LED0=0;
  157.                 }
  158.                 else
  159.                 {
  160.                         t=25;
  161.                         while(t>0)
  162.                                 {
  163.                                         LED0=0;
  164.                                         delay_ms(t);
  165.                                         LED0=1;
  166.                                         delay_ms(25-t);
  167.                                         t--;
  168.                                 }
  169.                                 LED0=1;
  170.                 }
  171.         }
  172.         else
  173.         {
  174.                 if(b==0)
  175.                 {
  176.                         t=0;
  177.                         while(t<25)
  178.                                 {
  179.                                         LED1=0;
  180.                                         delay_ms(t);
  181.                                         LED1=1;
  182.                                         delay_ms(25-t);
  183.                                         t++;
  184.                                 }
  185.                                 LED1=0;
  186.                 }
  187.                 else
  188.                 {
  189.                         t=25;
  190.                         while(t>0)
  191.                                 {
  192.                                         LED1=0;
  193.                                         delay_ms(t);
  194.                                         LED1=1;
  195.                                         delay_ms(25-t);
  196.                                         t--;
  197.                                 }
  198.                                 LED1=1;
  199.                 }
  200.         }       
  201. }
  202. void LED_light_pwm(int a,int b)
  203. {
  204.         u16 led0pwmval=0;   
  205.         if(a==0)
  206.         {
  207.                 if(b==0)
  208.                 {
  209.                         led0pwmval=500;
  210.                         while(led0pwmval>0)
  211.                         {
  212.                                 delay_ms(10);
  213.                                 led0pwmval--;
  214.                                 TIM_SetCompare1(TIM14,led0pwmval);
  215.                         }
  216.                 }
  217.                 else
  218.                 {
  219.                         led0pwmval=0;
  220.                         while(led0pwmval<500)
  221.                         {
  222.                                 delay_ms(10);
  223.                                 led0pwmval++;
  224.                                 TIM_SetCompare1(TIM14,led0pwmval);
  225.                         }
  226.                 }
  227.         }
  228.         else
  229.         {
  230.                 if(b==0)
  231.                 {
  232.                        
  233.                 }
  234.                 else
  235.                 {
  236.                        
  237.                 }
  238.         }
  239. }
  240. int main(void)
  241. {
  242.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
  243.         delay_init(168);  //初始化延时函数
  244.         uart_init(115200);         //串口初始化
  245.         LED_Init();                //初始化LED端口
  246.         EXTIX_Init();       //初始化外部中断输入
  247.         time_init();//时间变量赋初值
  248.         OLED_Init();//OLED初始化
  249.         OLED_update(time,alarm1,alarm2);
  250.         TIM3_Int_Init(10000-1,8400-1);        //定时器时钟84M,分频系数8400,所以84M/8400=10Khz的计数频率
  251.         TIM14_PWM_Init(500-1,84-1);        //84M/84=1Mhz的计数频率,重装载值500,所以PWM频率为 1M/500=2Khz.
  252.         GPIO_SetBits(GPIOF,GPIO_Pin_9);//GPIOF9,F10设置高,灯灭
  253.         while(1)
  254.         {
  255.                 if(Flag_LED0_light==0)
  256.                 {
  257.                         LED_light_pwm(0,0);
  258.                         GPIO_SetBits(GPIOF,GPIO_Pin_9);//GPIOF9,F10设置高,灯灭
  259.                         LED0=0;
  260.                         Flag_LED0_light=-1;
  261.                 }
  262.                 if(Flag_LED0_light==1)
  263.                 {
  264.                         LED_light_pwm(0,1);
  265.                         Flag_LED0_light=-1;
  266.                 }
  267.                 if(Flag_LED1_light==0)
  268.                 {
  269.                         LED_light(1,0);
  270.                         Flag_LED1_light=-1;
  271.                 }
  272.                 if(Flag_LED1_light==1)
  273.                 {
  274.                         LED_light(1,1);
  275.                         Flag_LED1_light=-1;
  276.                 }       
  277.                 if(USART_RX_STA&0x8000)
  278.                 {
  279.                         u8 len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
  280.                         //USART_RX_BUF
  281.                         if(strstr((const char*)USART_RX_BUF,"set"))
  282.                         {
  283.                                 time.hour=(USART_RX_BUF[4]-48)*10+USART_RX_BUF[5]-48;
  284.                                 time.minute=(USART_RX_BUF[7]-48)*10+USART_RX_BUF[8]-48;
  285.                                 time.second=(USART_RX_BUF[10]-48)*10+USART_RX_BUF[11]-48;
  286.                                 printf("OK!\r\n");
  287.                         }
  288.                         USART_RX_STA=0;
  289.                 }
  290.         }
  291. }
复制代码
程序:
程序.7z (311.34 KB, 下载次数: 26)

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:1 发表于 2019-7-5 04:32 | 只看该作者
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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