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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › 单片机0.8寸数码管时钟完整资料 程序+Gerber PCB文件
返回列表 发新帖
查看: 1046|回复: 9
收起左侧

单片机0.8寸数码管时钟完整资料 程序+Gerber PCB文件

  [复制链接]
ID:140489 发表于 2023-12-7 12:41 | 显示全部楼层 |阅读模式
/*
项目名称：0.8寸4位共阳数码管时钟
1.5个PNP三极管接在共阳极驱动数码管，这个数码管小数点都有，冒号是单独两个LED
2.设置方法：按k1键设置状态（小时位数码管闪烁），按K2键++，按K3键--，长按连加连减；
按K1键第二次，分钟位数码管闪烁，按K2键++，按K3键--，长按连加连减；
按K1键第三次，退出设置状态，回到正常走时界面。
3. P2.0-P2.4位驱动口，P1口为段驱动口；

4. 单片机=STC8H1K16（LQFP32封装） @11.0592MHz   时钟芯片=DS3231MZ(SOP-8封装)
2023/12/7 测试通过

测试中的问题：开始数码管有鬼影，以为程序有问题（这个程序以前驱动0.56寸数码管是没问题的），
单片机内部4.1K上拉打开不行，位驱动口设置成推挽都不行；单独驱动一个LED灯，LED只有亮暗变化，
不能完全关断；后来在PNP三极管基极加5.1K上拉电阻，三极管才能完全关断；上拉电阻加在单片机的IO端
都不行；
以前同型号的单片机不加这个上拉电阻是可以的；

单片机都是在某一个宝买的（两次不是在一家买的），这次买的有这个问题，以前的没有。
*/
程序只写了时钟的，温度，蜂鸣器没写；
附件里面有嘉立创EDA软件画的板子的gerber文件，可以直接在嘉立创免费打板，有兴趣的可以制作看看有没有我制作中出现的问题，制作时，Q1不用，R5用跳线短接。

制作出来的实物图如下：
实物.jpg

电路原理图如下：
电路图.jpg
附件是完整资料
  1. /*
  2. 项目名称：0.8寸4位共阳数码管时钟
  3. 1.5个PNP三极管接在共阳极驱动数码管，这个数码管小数点都有，冒号是单独两个LED
  4. 2.设置方法：按k1键设置状态（小时位数码管闪烁），按K2键++，按K3键--，长按连加连减；
  5. 按K1键第二次，分钟位数码管闪烁，按K2键++，按K3键--，长按连加连减；
  6. 按K1键第三次，退出设置状态，回到正常走时界面。
  7. 3. P2.0-P2.4位驱动口，P1口为段驱动口；

  9. 4. 单片机=STC8H1K16（LQFP32封装） @11.0592MHz   时钟芯片=DS3231MZ(SOP-8封装)
  10. 2023/12/7 测试通过

  12. 测试中的问题：开始数码管有鬼影，以为程序有问题（这个程序以前驱动0.56寸数码管是没问题的），
  13. 单片机内部4.1K上拉打开不行，位驱动口设置成推挽都不行；单独驱动一个LED灯，LED只有亮暗变化，
  14. 不能完全关断；后来在PNP三极管基极加5.1K上拉电阻，三极管才能完全关断；上拉电阻加在单片机的IO端
  15. 都不行；
  16. 以前同型号的单片机不加这个上拉电阻是可以的；

  18. 单片机都是在某一个宝买的（两次不是在一家买的），这次买的有这个问题，以前的没有。
  19. */
  20. #include <STC8H.H>
  21. #include <intrins.h>

  23. #define uchar unsigned char
  24. #define uint unsigned int


  27. //typedef     unsigned char   u8;
  28. //typedef     unsigned int    u16;
  29. //typedef     unsigned long   u32;

  31. sbit k1=P0^0;//        按键1 设置 +
  32. sbit k2=P2^7;//        按键2  -
  33. sbit k3=P3^7;//        
  34. sbit k4=P2^5;
  35. sbit out = P3^2;          //输出端口
  36. sbit w1 = P2^0;          //设置位驱动口
  37. sbit w2 = P2^1;
  38. sbit w3 = P2^2;
  39. sbit w4 = P2^3;

  41. sbit w5 = P2^4;        //冒号控制

  43. sbit BZ = P0^3;//蜂鸣器控制口
  44. uint count,cont1,cont2,cont3;
  45. uint fen,fen_temp;
  46. uchar fen_L,fen_M,miao,num,num2;
  47. uchar Ledcount;
  48. uchar num;
  49. uchar k1_lock,k2_lock,k3_lock;//按键锁
  50. uchar knum;
  51. uint shan;//秒点闪烁 计时变量

  53. uint k1_time_count;          //K1消抖计数
  54. uint k2_time_count;          //K2消抖计数
  55. uint k3_time_count;          //K2消抖计数

  57. bit flag;        //计时启动标志
  58. bit flag1;        //按键消抖计数标志
  59. bit flag2;        //按键消抖计数标志
  60. bit save_flag;//数据保存标志
  61. bit save_flag1;//数据保存标志
  62. bit set_flag=0; //设置标志
  63. bit fm_flag;//蜂鸣器

  65. bit flag3;

  67. uchar hour,minute,second,year,month,day,date,week;
  68. uint TH3231;
  69. bit        ack;                //应答标志位

  71. uchar code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff,0x46,0xbf,0x8e};//共阳段码 （0--9、黑屏,C,-,F）
  72. uchar LedBuff[]={0xff,0xff,0xff,0xff};

  74. // ------------------------------------------------------------
  75. // IO口模拟I2C通信

  77. // ------------------------------------------------------------
  78. sbit SCL=P3^5; //串行时钟
  79. sbit SDA=P3^4; //串行数据

  81. /********************************************************************************************************
  82. **         DS3231常数定义
  83. ********************************************************************************************************/
  84. #define DS3231_WriteAddress 0xD0    //器件写地址
  85. #define DS3231_ReadAddress  0xD1    //器件读地址
  86. #define DS3231_SECOND       0x00    //秒
  87. #define DS3231_MINUTE       0x01    //分
  88. #define DS3231_HOUR         0x02    //时
  89. #define DS3231_WEEK         0x03    //星期
  90. #define DS3231_DAY          0x04    //日
  91. #define DS3231_MONTH        0x05    //月
  92. #define DS3231_YEAR         0x06    //年

  94. #define DS3231_TEMPERATUREH 0x11    //温度寄存器高字节(8位)        整数部分
  95. #define DS3231_TEMPERATUREL 0x12    //温度寄存器低字节(低2位) 小数部分



  99. #define NACK    1
  100. #define ACK     0
  101. /////////////////

  103. void        Delay5US()           //@12.000MHz           延时5us
  104. {
  105.    _nop_(); _nop_();        _nop_();_nop_();         _nop_();_nop_();//STC Y6指令 1T单片机用6个nop，12T用1个nop
  106. }

  108. void delay(uint x)
  109. {
  110.         uint y,z;
  111.         for(y=0; y<x; y--)
  112.                 for(z=0; z<1200; z--);

  114. }


  117. /**********************************************
  118. //IIC Start
  119. **********************************************/
  120. void IIC_Start()
  121. {
  122.    SCL = 1;               
  123.    SDA = 1;
  124.    SDA = 0;
  125.    SCL = 0;
  126. }

  128. /**********************************************
  129. //IIC Stop
  130. **********************************************/
  131. void IIC_Stop()
  132. {
  133.    SCL = 0;
  134.    SDA = 0;
  135.    SCL = 1;
  136.    SDA = 1;
  137. }

  139. /********************************************************************************************************
  140. **         3231
  141. ********************************************************************************************************/


  144. uchar        BCD2HEX(uchar val)//转10进制
  145. {
  146.         return        ((val>>4)*10)+(val&0x0f);
  147. }

  149. uchar        HEX2BCD(uchar val) //转16进制
  150. {
  151.         return        (((val%100)/10)<<4)|(val%10);
  152. }


  155. void SendByte(uchar c)
  156. {
  157.     uchar BitCnt;
  158.    
  159.     for(BitCnt=0;BitCnt<8;BitCnt++)         //要传送的数据长度为8位
  160.     {
  161.         if((c<<BitCnt)&0x80)
  162.             SDA=1;                          //判断发送位
  163.         else
  164.             SDA=0;     
  165.         SCL=1;                            //置时钟线为高，通知被控器开始接收数据位
  166.         Delay5US();                       //保证时钟高电平周期大于4μs   
  167.         SCL=0;
  168.     }
  169.     SDA=1;                                  //8位发送完后释放数据线，准备接收应答位
  170.     SCL=1;
  171.     Delay5US();
  172.     if(SDA==1)
  173.         ack=0;   
  174.     else
  175.         ack=1;                              //判断是否接收到应答信号
  176.     SCL=0;
  177.     Delay5US();
  178. }           

  180. uchar RcvByte()
  181. {
  182.    uchar retc;
  183.    uchar BitCnt;

  185.    retc=0;
  186.    SDA=1;                           //置数据线为输入方式
  187.    for(BitCnt=0;BitCnt<8;BitCnt++)
  188.    {
  189.         SCL=0;                      //置时钟线为低，准备接收数据位      
  190.         Delay5US();                 //时钟低电平周期大于4.7μs                       
  191.         SCL=1;                      //置时钟线为高使数据线上数据有效
  192.         Delay5US();
  193.         retc=retc<<1;
  194.         if(SDA==1)
  195.             retc=retc+1;            //读数据位,接收的数据位放入retc中
  196.         Delay5US();
  197.    }
  198.    SCL=0;
  199.    return(retc);
  200. }                           

  202. void Ack_I2C(bit a)
  203. {
  204.         SDA        =        a;  
  205.     SCL=1;                     
  206.     Delay5US();             //时钟低电平周期大于4us   
  207.     SCL=0;                  //清时钟线，钳住I2C总线以便继续接收
  208.     Delay5US();   
  209. }                                            

  211. uchar write_byte(uchar addr, uchar write_data)
  212. {
  213.     IIC_Start();
  214.     SendByte(DS3231_WriteAddress);
  215.     if (ack == 0)
  216.         return 0;
  217.    
  218.     SendByte(addr);   
  219.     if (ack == 0)
  220.         return 0;
  221.    
  222.     SendByte(write_data);
  223.     if (ack == 0)
  224.         return 0;
  225.    
  226.     IIC_Stop();
  227.     Delay5US();      
  228.     Delay5US();      
  229.     return 1;
  230. }                                          

  232. uchar read_current()
  233. {
  234.     uchar read_data;
  235.     IIC_Start();
  236.     SendByte(DS3231_ReadAddress);
  237.     if(ack==0)
  238.         return(0);              
  239.     read_data = RcvByte();
  240.     Ack_I2C(1);
  241.     IIC_Stop();
  242.     return read_data;
  243. }                                                

  245. uchar read_random(uchar random_addr)
  246. {
  247.     uchar Tmp;
  248.         IIC_Start();
  249.     SendByte(DS3231_WriteAddress);
  250.     if(ack==0)
  251.         return(0);            
  252.     SendByte(random_addr);
  253.     if(ack==0)
  254.         return(0);
  255.         Tmp=read_current();
  256.         if(random_addr==DS3231_HOUR)
  257.                 Tmp&=0x3f;
  258.                                             
  259.     return(BCD2HEX(Tmp));//都转10进制输出
  260. }

  262. /***********************/
  263. uchar read_random1(uchar random_addr)  //这个是读温度函数
  264. {
  265.     uchar Tmp;
  266. //        write_byte(0x0e,0x20);//0x0e寄存器的CONV位置1开启温度转换，要这句，温度实时刷新，这句不要，温度要64s才刷新1次
  267.                                                   //数码管显示不能要这句，否则温度值小数部分乱跳
  268.         IIC_Start();
  269.     SendByte(DS3231_WriteAddress);
  270.     if(ack==0)
  271.         return(0);            
  272.     SendByte(random_addr);
  273.     if(ack==0)
  274.         return(0);
  275.         Tmp=read_current();
  276.         return Tmp;
  277. }                                 

  279. void ModifyTime(uchar address,uchar num)
  280. {
  281.     uchar temp=0;
  282.            if(address>6 && address <0) return;
  283.     temp=HEX2BCD(num);
  284.         write_byte(address,temp);
  285. }



  289. ////////////////

  291. void IapIdle()
  292. {
  293.     IAP_CONTR = 0;                              //关闭IAP功能
  294.     IAP_CMD = 0;                                //清除命令寄存器
  295.     IAP_TRIG = 0;                               //清除触发寄存器
  296.     IAP_ADDRH = 0x80;                           //将地址设置到非IAP区域
  297.     IAP_ADDRL = 0;
  298. }

  300. char IapRead(int addr)
  301. {
  302.     char dat;

  304.     IAP_CONTR = 0x80;                           //使能IAP
  305.     IAP_TPS = 12;                               //设置等待参数12MHz
  306.     IAP_CMD = 1;                                //设置IAP读命令
  307.     IAP_ADDRL = addr;                           //设置IAP低地址
  308.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  309.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  310.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  311.     _nop_();
  312.     dat = IAP_DATA;                             //读IAP数据
  313.     IapIdle();                                  //关闭IAP功能

  315.     return dat;
  316. }

  318. void IapProgram(int addr, char dat)
  319. {
  320.     IAP_CONTR = 0x80;                           //使能IAP
  321.     IAP_TPS = 12;                               //设置等待参数12MHz
  322.     IAP_CMD = 2;                                //设置IAP写命令
  323.     IAP_ADDRL = addr;                           //设置IAP低地址
  324.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  325.     IAP_DATA = dat;                             //写IAP数据
  326.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  327.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  328.     _nop_();
  329.     IapIdle();                                  //关闭IAP功能
  330. }

  332. void IapErase(int addr)
  333. {
  334.     IAP_CONTR = 0x80;                           //使能IAP
  335.     IAP_TPS = 12;                               //设置等待参数12MHz
  336.     IAP_CMD = 3;                                //设置IAP擦除命令
  337.     IAP_ADDRL = addr;                           //设置IAP低地址
  338.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  339.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  340.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  341.     _nop_();                                    //
  342.     IapIdle();                                  //关闭IAP功能
  343. }
  344. ////////////////////
  345. void Timer0Init(void)                //2毫秒@11.0592MHz
  346. {
  347.         AUXR |= 0x80;                //定时器时钟1T模式
  348.         TMOD &= 0xF0;                //设置定时器模式  16位自动重载
  349.         TL0 = 0x9A;                //设置定时初始值
  350.         TH0 = 0xA9;                //设置定时初始值
  351.         TF0 = 0;                //清除TF0标志
  352.         TR0 = 1;                //定时器0开始计时
  353.         EA = 1;                        //开总中断
  354.         ET0 = 1;                //开T0中断
  355. }


  358. //void Timer0Init(void)                //5毫秒@11.0592MHz
  359. //{
  360. //        AUXR |= 0x80;                //定时器时钟1T模式
  361. //        TMOD &= 0xF0;                //设置定时器模式
  362. //        TL0 = 0x00;                //设置定时初始值
  363. //        TH0 = 0x28;                //设置定时初始值
  364. //        TF0 = 0;                //清除TF0标志
  365. //        TR0 = 1;                //定时器0开始计时
  366. //        EA = 1;                        //开总中断
  367. //        ET0 = 1;                //开T0中断
  368. //}
  369. /////////////////////////////
  370. void keyscan()
  371. {
  372.         uchar temp;
  373.         hour = read_random(DS3231_HOUR);
  374.         minute = read_random(DS3231_MINUTE) ;
  375.         second = read_random(DS3231_SECOND);

  377.         
  378.                 if(k1)        //
  379.                 {                                                //
  380.                         k1_time_count=0;
  381.                         k1_lock=0;
  382.                         flag1 = 0;
  383.                 }
  384.                 else if((k1_lock==0))
  385.                 {
  386.                         flag1 = 1; //按键按下 消抖计时标志置1 开始消抖计时
  387.                         if((k1_time_count==10))  //20微秒
  388.                         {
  389.                                 k1_time_count=0;
  390.                                 k1_lock=1;
  391.                                 knum++;
  392.                                 if(knum==3)
  393.                                 {
  394.                                         knum=0;
  395.                                         second=0;
  396.                                         write_byte(DS3231_SECOND, second); //秒写0
  397.                                 }
  398.                         }
  399.                 }

  401. /////////////////////////////
  402.         if(knum==1)  //设置 状态
  403.         {
  404.                 if(k2 ==1)                                   //++
  405.                 {
  406.                         k2_time_count=0;
  407.                         k2_lock=0;
  408.                         flag2 = 0;
  409.                 }
  410.                 else if(k2_lock==0)
  411.                 {
  412.                 //        flag = 0;
  413.                         flag2 = 1;
  414.                 //        save_flag = 1;
  415.                         if(k2_time_count==10)                //短按
  416.                         {
  417.                                 k2_time_count=0;
  418.                                 k2_lock=1;
  419.                                 hour++;
  420.                                 if(hour>23)
  421.                                         hour=0;
  422.                                 temp=HEX2BCD(hour);
  423.                                 write_byte(DS3231_HOUR, temp);
  424.                         }        
  425.                 }
  426.                 else if(k2_time_count==500)                 //长按
  427.                 {
  428.                    cont1=0; num=0;
  429.                    k1_time_count=450;
  430.                         hour++;
  431.                         if(hour>23)
  432.                                 hour=0;
  433.                         temp=HEX2BCD(hour);        //10进制转16进制
  434.                         write_byte(DS3231_HOUR, temp);

  436.                 }
  437. //////////////////////////
  438.                 if(k3 == 1)                                   //--
  439.                 {
  440.                         k3_time_count=0;
  441.                         k3_lock=0;
  442.                         flag3 = 0;
  443.                 }
  444.                 else if(k3_lock==0)
  445.                 {
  446.                
  447.                         flag3 = 1;
  448.                         save_flag1 = 1;
  449.                         if(k3_time_count==10)                //短按
  450.                         {
  451.                                 cont1=0; num=0;
  452.                                 k3_time_count=0;
  453.                                 k3_lock=1;
  454.                                 hour--;
  455.                                 if(hour==255)
  456.                                         hour=23;
  457.                                 temp=HEX2BCD(hour);
  458.                                 write_byte(DS3231_HOUR, temp);

  460.                         }
  461.                                 
  462.                 }
  463.                 else if(k3_time_count==500)                 //长按
  464.                 {
  465.                    cont1=0; num=0;  
  466.                    k3_time_count=450;
  467.                                 hour--;
  468.                         if(hour==255)
  469.                                 hour=23;
  470.                         temp=HEX2BCD(hour);
  471.                         write_byte(DS3231_HOUR, temp);

  473.                 }
  474.         }
  475.   ////////////////////////////////
  476.         if(knum==2)
  477.         {
  478.                 if(k2 ==1)                                   //++
  479.                 {
  480.                         k2_time_count=0;
  481.                         k2_lock=0;
  482.                         flag2 = 0;
  483.                 }
  484.                 else if(k2_lock==0)
  485.                 {
  486.                 //        flag = 0;
  487.                         flag2 = 1;
  488.                 //        save_flag = 1;
  489.                         if(k2_time_count==10)                //短按
  490.                         {
  491.                                 k2_time_count=0;
  492.                                 k2_lock=1;
  493.                                 minute++;
  494.                                 if(minute>59)
  495.                                         minute=0;
  496.                                 temp=HEX2BCD(minute);
  497.                                 write_byte(DS3231_MINUTE, temp);
  498.                         }        
  499.                 }
  500.                 else if(k2_time_count==500)                 //长按
  501.                 {
  502.                    cont1=0; num=0;
  503.                    k1_time_count=450;
  504.                         minute++;
  505.                         if(minute>59)
  506.                                 minute=0;
  507.                         temp=HEX2BCD(minute);
  508.                         write_byte(DS3231_MINUTE, temp);

  510.                 }
  511. //////////////////////////
  512.                 if(k3 == 1)                                   //--
  513.                 {
  514.                         k3_time_count=0;
  515.                         k3_lock=0;
  516.                         flag3 = 0;
  517.                 }
  518.                 else if(k3_lock==0)
  519.                 {
  520.                
  521.                         flag3 = 1;
  522.                         save_flag1 = 1;
  523.                         if(k3_time_count==10)                //短按
  524.                         {
  525.                                 cont1=0; num=0;
  526.                                 k3_time_count=0;
  527.                                 k3_lock=1;
  528.                                 minute--;
  529.                                 if(minute==255)
  530.                                         minute=59;
  531.                                 temp=HEX2BCD(minute);
  532.                                 write_byte(DS3231_MINUTE, temp);
  533.                         }
  534.                                 
  535.                 }
  536.                 else if(k3_time_count==500)                 //长按
  537.                 {
  538.                    cont1=0; num=0;  
  539.                    k3_time_count=450;
  540.                                 minute--;
  541.                                 if(minute==255)
  542.                                         minute=59;
  543.                                 temp=HEX2BCD(minute);
  544.                                 write_byte(DS3231_MINUTE, temp);
  545.                 }
  546.         }
  547. }

  549. ///////////////////////////////
  550. void display_sf() //显示 时分
  551. {
  552. //                        year = read_random(DS3231_YEAR);               
  553. //                    month = read_random(DS3231_MONTH);        
  554. //                    day = read_random(DS3231_DAY);        
  555. //                    week = read_random(DS3231_WEEK);
  556.         hour = read_random(DS3231_HOUR);
  557.         minute = read_random(DS3231_MINUTE) ;
  558.         second = read_random(DS3231_SECOND);
  559.         if(knum==0)
  560.         {
  561.                 LedBuff[0]= table[hour/10];
  562.                 LedBuff[1]= table[hour%10];
  563.                 LedBuff[2]= table[minute/10];
  564.                 LedBuff[3]= table[minute%10];
  565.         }
  566.         if(knum==1)
  567.         {
  568.                 if(shan>250)
  569.                 {
  570.                         LedBuff[0]= table[hour/10];
  571.                         LedBuff[1]= table[hour%10];
  572.                 }
  573.                 else
  574.                 {
  575.                         LedBuff[0]= table[10];
  576.                         LedBuff[1]= table[10];
  577.                
  578.                 }
  579.                 LedBuff[2]= table[minute/10];
  580.                 LedBuff[3]= table[minute%10];
  581.         }
  582.         if(knum==2)
  583.         {
  584.                
  585.                 LedBuff[0]= table[hour/10];
  586.                 LedBuff[1]= table[hour%10];
  587.                
  588.                 if(shan>250)
  589.                 {
  590.                         LedBuff[2]= table[minute/10];
  591.                         LedBuff[3]= table[minute%10];
  592.                 }
  593.                 else
  594.                 {
  595.                         LedBuff[2]= table[10];
  596.                         LedBuff[3]= table[10];               
  597.                 }
  598.         }
  599. }


  602. /*************数码管显示函数1***************/
  603. /*
  604. void Display1(uint num)   //显示时间程序
  605. {
  606.         uchar A1,A2,A3,A4;
  607.         A1 = num/1000;    //千位
  608.         A2 = num%1000/100;   //百位
  609.         A3 = num%100/10;    //十位
  610.         A4 = num%10;    //个位
  611.                 if(A1==0)
  612.                 LedBuff[0]= table[10];    //千位为0不显示
  613. //                else
  614. //                LedBuff[0]= table[A1];

  616.                 if((A2==0) && (A1==0))          //千位百位都为0百位不显示
  617.                 LedBuff[1]= table[10];    //
  618.                 else
  619.                 LedBuff[1]= table[A2];                //

  621.                 if((A2==0) && (A1==0) && (A3==0))          //千位百位十位都为0十位不显示
  622.                 LedBuff[2]= table[10];
  623.                 else
  624.                 LedBuff[2]= table[A3];

  626.                 if((shan>250) && (set_flag==0) && (flag==1))//非设置状态+计时状态，第4位数码管的小数点闪烁
  627.                 LedBuff[3]= table[A4]&0x7f;      //显示分个位
  628.                 else
  629.                 LedBuff[3]= table[A4];
  630. } */
  631. ////////////////////////
  632. //void Display() //显示off
  633. //{
  634. //        LedBuff[0]= table[10];
  635. //        LedBuff[1]= table[0];
  636. //        LedBuff[2]= table[13];
  637. //        LedBuff[3]= table[13];
  638. //}

  640. /////////////////////

  642. void main()
  643. {
  644.         Timer0Init();
  645.         P0M0 = 0x0f;   //
  646.     P0M1 = 0x00;   //
  647.     P1M0 = 0x00;   //
  648.         P1M1 = 0x00;
  649.     P2M0 = 0x1f;   //p2.0-p2.4 设为推挽输出
  650.     P2M1 = 0x00;
  651.     P3M0 = 0x04;  //P3.2设为推挽输出才能驱动继电器
  652.     P3M1 = 0x00;
  653.     P4M0 = 0x00;
  654.     P4M1 = 0x00;
  655.     P5M0 = 0x00;
  656.     P5M1 = 0x00;

  658. //        P2PU=0x10;
  659. //        P2DR=0X00;
  660. //        out = 0;

  662. //        fen_L = IapRead(0x0001);
  663. //        fen_M = IapRead(0x0002);
  664. //        if(fen_L==255)
  665. //                fen_L = 254;
  666. //        if(fen_M==255)
  667. //                fen_M = 0;
  668. //        fen = fen_M*256 + fen_L;
  669. //        fen_temp=fen;
  670. //
  671. //        w5=1;
  672.         while(1)
  673.         {
  674.                 display_sf();
  675.                 keyscan();

  677.                 if(shan>250)
  678.                 {w5=1;  BZ=1;}
  679.                 else {w5=0; BZ=0;}
  680.         }
  681. }

  683. void timer0() interrupt 1
  684. {
  685. //        if(flag3==0)
  686. //        {
  687. //                cont2++;
  688. //                if(cont2==500) //1秒
  689. //                {
  690. //                        cont2=0;
  691. //                        num2++;
  692. //                        if(num2==3)//开机延时3秒启动输出
  693. //                        {
  694. //                                num2=0;
  695. //                                flag=1;        //计时标志置1
  696. ////                                out = 1;//打开输出
  697. //                                fm_flag=1;//启动蜂鸣器
  698. //                                flag3=1;
  699. //                        }
  700. //                }
  701. //        }

  703.         if(fm_flag)
  704.         {
  705.                 BZ = 0;        //蜂鸣器开
  706.                 cont3++;
  707.                 if(cont3==100)//0.2秒
  708.                 {
  709.                         cont3=0;
  710.                         BZ = 1;         //蜂鸣器关
  711.                         fm_flag=0;        
  712.                 }        
  713.         }
  714.                                                                                                                                                                  
  715.         shan++;
  716.         if(shan==500)
  717.         {
  718.                 shan=0;
  719.         }

  721.         Ledcount++;
  722.         P1=0xff;   //消影
  723.         if(Ledcount==4)
  724.         {
  725.                 Ledcount=0;
  726.         }
  727.         switch(Ledcount)
  728.         {
  729.                 case 0: w2 = 1; w3 = 1; w4 = 1;w1 = 0; P1 = LedBuff[0];  break;
  730.                 case 1: w1 = 1; w3 = 1; w4 = 1;w2 = 0; P1 = LedBuff[1];  break;
  731.                 case 2: w1 = 1; w2 = 1; w4 = 1;w3 = 0; P1 = LedBuff[2];  break;
  732.                 case 3: w1 = 1; w2 = 1; w3 = 1;w4 = 0; P1 = LedBuff[3];  break;
  733.                 default: break;
  734.         }
  735.         


  738.         if(flag1) //按键消抖计时
  739.         {k1_time_count++;}

  741.         if(flag2) //按键消抖计时
  742.         {k2_time_count++;}

  744.         if(flag3) //按键消抖计时
  745.         {k3_time_count++;}


  748.    /*     if(set_flag) //无按键 3秒退出设置状态
  749.         {
  750.                 cont1++;
  751.                 if(cont1==500) //1秒到
  752.                 {
  753.                         cont1=0;
  754.                         num++;
  755.                         if(num==3)
  756.                         {
  757.                                 num=0;
  758.                                 set_flag=0;//设置标志清零，退出设置状态
  759.                                 flag=1;         //计时标志置1，开始计时
  760.                                 fm_flag=1;//启动蜂鸣器，响一下
  761.                         }               
  762.                 }
  763.         }*/
  764. }

复制代码

程序和Gerber格式的PCB文件下载: 0.8寸数码管时钟.zip (542.14 KB, 下载次数: 35)

评分

参与人数 1黑币 +90 收起 理由
admin + 90 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:1085081 发表于 2023-12-9 21:20 | 显示全部楼层
这个资料好啊，多谢
回复

使用道具 举报

ID:140489 发表于 2023-12-11 12:55 | 显示全部楼层
重新做了一个，没有第一个的问题，看来的是第一个单片机有问题
回复

使用道具 举报

ID:140489 发表于 2023-12-11 15:50 | 显示全部楼层
这次制作有点不顺，ds3231（8脚封装）的，加0.22F的法拉电容，开始两天测试掉电能继续走时，过了两天再来测试，掉电重新上电，时间就乱了。手上有一个DS3231模块，把模块接在板上，掉电继续走时正常；看来ds3231（8脚封装）的这个时钟芯片也有问题
回复

使用道具 举报

ID:140489 发表于 2023-12-12 09:09 | 显示全部楼层
这是时间和温度轮流显示的程序
  1. /*
  2. 项目名称：0.8寸4位共阳数码管时钟
  3. 1.5个PNP三极管接在共阳极驱动数码管，这个数码管小数点都有，冒号是单独两个LED
  4. 2.设置方法：按k1键设置状态（小时位数码管闪烁），按K2键++，按K3键--，长按连加连减；
  5. 按K1键第二次，分钟位数码管闪烁，按K2键++，按K3键--，长按连加连减；
  6. 按K1键第三次，退出设置状态，回到正常走时界面。
  7. 3. P2.0-P2.4位驱动口，P1口为段驱动口；

  9. 4. 单片机=STC8H1K16（LQFP32封装） @11.0592MHz   时钟芯片=DS3231MZ(SOP-8封装)
  10. 测试通过
  11. 第一次发的程序按键长按有bug，也改好了。


  14. */
  15. #include <STC8H.H>
  16. #include <intrins.h>
  17. #include "ds18b20.h"
  18. //#include "delay.h"
  19. #define uchar unsigned char
  20. #define uint unsigned int


  23. //typedef     unsigned char   u8;
  24. //typedef     unsigned int    u16;
  25. //typedef     unsigned long   u32;

  27. sbit k1=P0^0;//        按键1 设置 +
  28. sbit k2=P2^7;//        按键2  -
  29. sbit k3=P3^7;//        
  30. sbit k4=P2^5;
  31. sbit out = P3^2;          //输出端口
  32. sbit w1 = P2^0;          //设置位驱动口
  33. sbit w2 = P2^1;
  34. sbit w3 = P2^2;
  35. sbit w4 = P2^3;

  37. sbit w5 = P2^4;        //冒号控制

  39. sbit BZ = P0^3;//蜂鸣器控制口
  40. uint count,cont1,cont2,cont3;
  41. uint fen,fen_temp;
  42. uchar fen_L,fen_M,miao,num,num2;
  43. uchar Ledcount;
  44. uchar num;
  45. uchar k1_lock,k2_lock,k3_lock;//按键锁
  46. uchar knum;
  47. uint shan,shan1;//秒点闪烁 计时变量

  49. uint k1_time_count;          //K1消抖计数
  50. uint k2_time_count;          //K2消抖计数
  51. uint k3_time_count;          //K3消抖计数

  53. bit flag;        //计时启动标志
  54. bit flag1;        //按键消抖计数标志
  55. bit flag2;        //按键消抖计数标志
  56. bit save_flag;//数据保存标志
  57. bit save_flag1;//数据保存标志
  58. bit set_flag=0; //设置标志
  59. bit fm_flag;//蜂鸣器

  61. bit flag3;
  62. bit qh_flag,qh_flag1;
  63. uchar hour,minute,second,year,month,day,date,week;
  64. uint TH3231;
  65. bit        ack;                //应答标志位

  67. uchar code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff,0xC6,0xbf,0x8e};//共阳段码 （0--9、黑屏,C,-,F）0X46 C带点，0xc6C不带点
  68. uchar LedBuff[]={0xff,0xff,0xff,0xff};

  70. // ------------------------------------------------------------
  71. // IO口模拟I2C通信

  73. // ------------------------------------------------------------
  74. sbit SCL=P3^5; //串行时钟
  75. sbit SDA=P3^4; //串行数据

  77. /********************************************************************************************************
  78. **         DS3231常数定义
  79. ********************************************************************************************************/
  80. #define DS3231_WriteAddress 0xD0    //器件写地址
  81. #define DS3231_ReadAddress  0xD1    //器件读地址
  82. #define DS3231_SECOND       0x00    //秒
  83. #define DS3231_MINUTE       0x01    //分
  84. #define DS3231_HOUR         0x02    //时
  85. #define DS3231_WEEK         0x03    //星期
  86. #define DS3231_DAY          0x04    //日
  87. #define DS3231_MONTH        0x05    //月
  88. #define DS3231_YEAR         0x06    //年

  90. #define DS3231_TEMPERATUREH 0x11    //温度寄存器高字节(8位)        整数部分
  91. #define DS3231_TEMPERATUREL 0x12    //温度寄存器低字节(低2位) 小数部分



  95. #define NACK    1
  96. #define ACK     0
  97. /////////////////

  99. //void        Delay5US()           //@12.000MHz           延时5us
  100. //{
  101. //   _nop_(); _nop_();        _nop_();_nop_();         _nop_();_nop_();//STC Y6指令 1T单片机用6个nop，12T用1个nop
  102. //}

  104. void Delay5US()                //@11.0592MHz         STC Y6指令
  105. {
  106.         unsigned char i;

  108.         _nop_();
  109.         i = 16;
  110.         while (--i);
  111. }


  114. void delay(uint x)
  115. {
  116.         uint y,z;
  117.         for(y=0; y<x; y--)
  118.                 for(z=0; z<1200; z--);

  120. }


  123. /**********************************************
  124. //IIC Start
  125. **********************************************/
  126. void IIC_Start()
  127. {
  128.    SCL = 1;               
  129.    SDA = 1;
  130.    SDA = 0;
  131.    SCL = 0;
  132. }

  134. /**********************************************
  135. //IIC Stop
  136. **********************************************/
  137. void IIC_Stop()
  138. {
  139.    SCL = 0;
  140.    SDA = 0;
  141.    SCL = 1;
  142.    SDA = 1;
  143. }

  145. /********************************************************************************************************
  146. **         3231
  147. ********************************************************************************************************/


  150. uchar        BCD2HEX(uchar val)//转10进制
  151. {
  152.         return        ((val>>4)*10)+(val&0x0f);
  153. }

  155. uchar        HEX2BCD(uchar val) //转16进制
  156. {
  157.         return        (((val%100)/10)<<4)|(val%10);
  158. }


  161. void SendByte(uchar c)
  162. {
  163.     uchar BitCnt;
  164.    
  165.     for(BitCnt=0;BitCnt<8;BitCnt++)         //要传送的数据长度为8位
  166.     {
  167.         if((c<<BitCnt)&0x80)
  168.             SDA=1;                          //判断发送位
  169.         else
  170.             SDA=0;     
  171.         SCL=1;                            //置时钟线为高，通知被控器开始接收数据位
  172.         Delay5US();                       //保证时钟高电平周期大于4μs   
  173.         SCL=0;
  174.     }
  175.     SDA=1;                                  //8位发送完后释放数据线，准备接收应答位
  176.     SCL=1;
  177.     Delay5US();
  178.     if(SDA==1)
  179.         ack=0;   
  180.     else
  181.         ack=1;                              //判断是否接收到应答信号
  182.     SCL=0;
  183.     Delay5US();
  184. }           

  186. uchar RcvByte()
  187. {
  188.    uchar retc;
  189.    uchar BitCnt;

  191.    retc=0;
  192.    SDA=1;                           //置数据线为输入方式
  193.    for(BitCnt=0;BitCnt<8;BitCnt++)
  194.    {
  195.         SCL=0;                      //置时钟线为低，准备接收数据位      
  196.         Delay5US();                 //时钟低电平周期大于4.7μs                       
  197.         SCL=1;                      //置时钟线为高使数据线上数据有效
  198.         Delay5US();
  199.         retc=retc<<1;
  200.         if(SDA==1)
  201.             retc=retc+1;            //读数据位,接收的数据位放入retc中
  202.         Delay5US();
  203.    }
  204.    SCL=0;
  205.    return(retc);
  206. }                           

  208. void Ack_I2C(bit a)
  209. {
  210.         SDA        =        a;  
  211.     SCL=1;                     
  212.     Delay5US();             //时钟低电平周期大于4us   
  213.     SCL=0;                  //清时钟线，钳住I2C总线以便继续接收
  214.     Delay5US();   
  215. }                                            

  217. uchar write_byte(uchar addr, uchar write_data)
  218. {
  219.     IIC_Start();
  220.     SendByte(DS3231_WriteAddress);
  221.     if (ack == 0)
  222.         return 0;
  223.    
  224.     SendByte(addr);   
  225.     if (ack == 0)
  226.         return 0;
  227.    
  228.     SendByte(write_data);
  229.     if (ack == 0)
  230.         return 0;
  231.    
  232.     IIC_Stop();
  233.     Delay5US();      
  234.     Delay5US();      
  235.     return 1;
  236. }                                          

  238. uchar read_current()
  239. {
  240.     uchar read_data;
  241.     IIC_Start();
  242.     SendByte(DS3231_ReadAddress);
  243.     if(ack==0)
  244.         return(0);              
  245.     read_data = RcvByte();
  246.     Ack_I2C(1);
  247.     IIC_Stop();
  248.     return read_data;
  249. }                                                

  251. uchar read_random(uchar random_addr)
  252. {
  253.     uchar Tmp;
  254.         IIC_Start();
  255.     SendByte(DS3231_WriteAddress);
  256.     if(ack==0)
  257.         return(0);            
  258.     SendByte(random_addr);
  259.     if(ack==0)
  260.         return(0);
  261.         Tmp=read_current();
  262.         if(random_addr==DS3231_HOUR)
  263.                 Tmp&=0x3f;
  264.                                             
  265.     return(BCD2HEX(Tmp));//都转10进制输出
  266. }

  268. /***********************/
  269. uchar read_random1(uchar random_addr)  //这个是读温度函数
  270. {
  271.     uchar Tmp;
  272. //        write_byte(0x0e,0x20);//0x0e寄存器的CONV位置1开启温度转换，要这句，温度实时刷新，这句不要，温度要64s才刷新1次
  273.                                                   //数码管显示不能要这句，否则温度值小数部分乱跳
  274.         IIC_Start();
  275.     SendByte(DS3231_WriteAddress);
  276.     if(ack==0)
  277.         return(0);            
  278.     SendByte(random_addr);
  279.     if(ack==0)
  280.         return(0);
  281.         Tmp=read_current();
  282.         return Tmp;
  283. }                                 

  285. void ModifyTime(uchar address,uchar num)
  286. {
  287.     uchar temp=0;
  288.            if(address>6 && address <0) return;
  289.     temp=HEX2BCD(num);
  290.         write_byte(address,temp);
  291. }



  295. ////////////////
  296. /*
  297. void IapIdle()
  298. {
  299.     IAP_CONTR = 0;                              //关闭IAP功能
  300.     IAP_CMD = 0;                                //清除命令寄存器
  301.     IAP_TRIG = 0;                               //清除触发寄存器
  302.     IAP_ADDRH = 0x80;                           //将地址设置到非IAP区域
  303.     IAP_ADDRL = 0;
  304. }

  306. char IapRead(int addr)
  307. {
  308.     char dat;

  310.     IAP_CONTR = 0x80;                           //使能IAP
  311.     IAP_TPS = 12;                               //设置等待参数12MHz
  312.     IAP_CMD = 1;                                //设置IAP读命令
  313.     IAP_ADDRL = addr;                           //设置IAP低地址
  314.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  315.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  316.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  317.     _nop_();
  318.     dat = IAP_DATA;                             //读IAP数据
  319.     IapIdle();                                  //关闭IAP功能

  321.     return dat;
  322. }

  324. void IapProgram(int addr, char dat)
  325. {
  326.     IAP_CONTR = 0x80;                           //使能IAP
  327.     IAP_TPS = 12;                               //设置等待参数12MHz
  328.     IAP_CMD = 2;                                //设置IAP写命令
  329.     IAP_ADDRL = addr;                           //设置IAP低地址
  330.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  331.     IAP_DATA = dat;                             //写IAP数据
  332.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  333.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  334.     _nop_();
  335.     IapIdle();                                  //关闭IAP功能
  336. }

  338. void IapErase(int addr)
  339. {
  340.     IAP_CONTR = 0x80;                           //使能IAP
  341.     IAP_TPS = 12;                               //设置等待参数12MHz
  342.     IAP_CMD = 3;                                //设置IAP擦除命令
  343.     IAP_ADDRL = addr;                           //设置IAP低地址
  344.     IAP_ADDRH = addr >> 8;                      //设置IAP高地址
  345.     IAP_TRIG = 0x5a;                            //写触发命令(0x5a)
  346.     IAP_TRIG = 0xa5;                            //写触发命令(0xa5)
  347.     _nop_();                                    //
  348.     IapIdle();                                  //关闭IAP功能
  349. }
  350. */
  351. ////////////////////
  352. void Timer0Init(void)                //2毫秒@11.0592MHz
  353. {
  354.         AUXR |= 0x80;                //定时器时钟1T模式
  355.         TMOD &= 0xF0;                //设置定时器模式  16位自动重载
  356.         TL0 = 0x9A;                //设置定时初始值
  357.         TH0 = 0xA9;                //设置定时初始值
  358.         TF0 = 0;                //清除TF0标志
  359.         TR0 = 1;                //定时器0开始计时
  360.         EA = 1;                        //开总中断
  361.         ET0 = 1;                //开T0中断
  362. }


  365. //void Timer0Init(void)                //5毫秒@11.0592MHz
  366. //{
  367. //        AUXR |= 0x80;                //定时器时钟1T模式
  368. //        TMOD &= 0xF0;                //设置定时器模式
  369. //        TL0 = 0x00;                //设置定时初始值
  370. //        TH0 = 0x28;                //设置定时初始值
  371. //        TF0 = 0;                //清除TF0标志
  372. //        TR0 = 1;                //定时器0开始计时
  373. //        EA = 1;                        //开总中断
  374. //        ET0 = 1;                //开T0中断
  375. //}
  376. /////////////////////////////
  377. void keyscan()
  378. {
  379.         uchar temp;
  380.         hour = read_random(DS3231_HOUR);
  381.         minute = read_random(DS3231_MINUTE) ;
  382.         second = read_random(DS3231_SECOND);

  384.         
  385.         if(k1)        //
  386.         {                                                //
  387.                 k1_time_count=0;
  388.                 k1_lock=0;
  389.                 flag1 = 0;
  390.         }
  391.         else if((k1_lock==0))
  392.         {
  393.                 flag1 = 1; //按键按下 消抖计时标志置1 开始消抖计时
  394.                 if((k1_time_count==10))  //20毫秒
  395.                 {
  396.                         k1_time_count=0;
  397.                         k1_lock=1;
  398.                         knum++;
  399.                         if(knum==3)
  400.                         {
  401.                                 knum=0;
  402.                                 second=0;
  403.                                 write_byte(DS3231_SECOND, second); //秒写0
  404.                         }
  405.                 }
  406.         }

  408. /////////////////////////////
  409.         if(knum==1)  //设置小时
  410.         {
  411.                 if(k2 ==1)                                   //++
  412.                 {
  413.                         k2_time_count=0;
  414.                         k2_lock=0;
  415.                         flag2 = 0;
  416.                 }
  417.                 else if(k2_lock==0)
  418.                 {
  419.                 //        flag = 0;
  420.                         flag2 = 1;
  421.                 //        save_flag = 1;
  422.                         if(k2_time_count==10)                //短按
  423.                         {
  424.                                 k2_time_count=0;
  425.                                 k2_lock=1;
  426.                                 hour++;
  427.                                 if(hour>23)
  428.                                         hour=0;
  429.                                 temp=HEX2BCD(hour);
  430.                                 write_byte(DS3231_HOUR, temp);
  431.                         }        
  432.                 }
  433.                 else if(k2_time_count>500)                 //长按
  434.                 {
  435.                   // cont1=0; num=0;
  436.                    k2_time_count=400;
  437.                         hour++;
  438.                         if(hour>23)
  439.                                 hour=0;
  440.                         temp=HEX2BCD(hour);        //10进制转16进制
  441.                         write_byte(DS3231_HOUR, temp);

  443.                 }
  444. //////////////////////////
  445.                 if(k3 == 1)                                   //--
  446.                 {
  447.                         k3_time_count=0;
  448.                         k3_lock=0;
  449.                         flag3 = 0;
  450.                 }
  451.                 else if(k3_lock==0)
  452.                 {
  453.                
  454.                         flag3 = 1;
  455.                 //        save_flag1 = 1;
  456.                         if(k3_time_count==10)                //短按
  457.                         {
  458.                         //        cont1=0; num=0;
  459.                                 k3_time_count=0;
  460.                                 k3_lock=1;
  461.                                 hour--;
  462.                                 if(hour==255)
  463.                                         hour=23;
  464.                                 temp=HEX2BCD(hour);
  465.                                 write_byte(DS3231_HOUR, temp);

  467.                         }
  468.                                 
  469.                 }
  470.                 else if(k3_time_count>500)                 //长按
  471.                 {
  472.                   // cont1=0; num=0;  
  473.                    k3_time_count=400;         //长按200ms连减
  474.                                 hour--;
  475.                         if(hour==255)
  476.                                 hour=23;
  477.                         temp=HEX2BCD(hour);
  478.                         write_byte(DS3231_HOUR, temp);

  480.                 }
  481.         }
  482.   ////////////////////////////////
  483.         if(knum==2)                 //设置分钟
  484.         {
  485.                 if(k2 ==1)                                   //++
  486.                 {
  487.                         k2_time_count=0;
  488.                         k2_lock=0;
  489.                         flag2 = 0;
  490.                 }
  491.                 else if(k2_lock==0)
  492.                 {
  493.                 //        flag = 0;
  494.                         flag2 = 1;
  495.                 //        save_flag = 1;
  496.                         if(k2_time_count==10)                //短按
  497.                         {
  498.                                 k2_time_count=0;
  499.                                 k2_lock=1;
  500.                                 minute++;
  501.                                 if(minute>59)
  502.                                         minute=0;
  503.                                 temp=HEX2BCD(minute);
  504.                                 write_byte(DS3231_MINUTE, temp);
  505.                         }        
  506.                 }
  507.                 else if(k2_time_count>500)                 //长按
  508.                 {
  509.                   // cont1=0; num=0;
  510.                    k2_time_count=400;
  511.                         minute++;
  512.                         if(minute>59)
  513.                                 minute=0;
  514.                         temp=HEX2BCD(minute);
  515.                         write_byte(DS3231_MINUTE, temp);

  517.                 }
  518. //////////////////////////
  519.                 if(k3 == 1)                                   //--
  520.                 {
  521.                         k3_time_count=0;
  522.                         k3_lock=0;
  523.                         flag3 = 0;
  524.                 }
  525.                 else if(k3_lock==0)
  526.                 {
  527.                
  528.                         flag3 = 1;
  529.                 //        save_flag1 = 1;
  530.                         if(k3_time_count==10)                //短按
  531.                         {
  532.                         //        cont1=0; num=0;
  533.                                 k3_time_count=0;
  534.                                 k3_lock=1;
  535.                                 minute--;
  536.                                 if(minute==255)
  537.                                         minute=59;
  538.                                 temp=HEX2BCD(minute);
  539.                                 write_byte(DS3231_MINUTE, temp);
  540.                         }
  541.                                 
  542.                 }
  543.                 else if(k3_time_count>500)                 //长按
  544.                 {
  545.                   // cont1=0; num=0;  
  546.                    k3_time_count=400;
  547.                         minute--;
  548.                         if(minute==255)
  549.                                 minute=59;
  550.                         temp=HEX2BCD(minute);
  551.                         write_byte(DS3231_MINUTE, temp);
  552.                 }
  553.         }
  554. }

  556. ///////////////////////////////
  557. void display_sf() //显示 时分
  558. {
  559. //                        year = read_random(DS3231_YEAR);               
  560. //                    month = read_random(DS3231_MONTH);        
  561. //                    day = read_random(DS3231_DAY);        
  562. //                    week = read_random(DS3231_WEEK);
  563.         hour = read_random(DS3231_HOUR);
  564.         minute = read_random(DS3231_MINUTE) ;
  565.         second = read_random(DS3231_SECOND);
  566.         if(knum==0)
  567.         {
  568.                 LedBuff[0]= table[hour/10];
  569.                 LedBuff[1]= table[hour%10];

  571.                 LedBuff[2]= table[minute/10];
  572.                 LedBuff[3]= table[minute%10];
  573.                 if(shan>250)
  574.                 {w5=1; }
  575.                 else {w5=0;}


  578.         }
  579.         if(knum==1)
  580.         {
  581.                 if(shan1>125)        
  582.                 {
  583.                         LedBuff[0]= table[hour/10];
  584.                         LedBuff[1]= table[hour%10];
  585.                 }
  586.                 else
  587.                 {
  588.                         LedBuff[0]= table[10];
  589.                         LedBuff[1]= table[10];
  590.                
  591.                 }
  592.                 LedBuff[2]= table[minute/10];
  593.                 LedBuff[3]= table[minute%10];
  594.         }
  595.         if(knum==2)
  596.         {
  597.                
  598.                 LedBuff[0]= table[hour/10];
  599.                 LedBuff[1]= table[hour%10];
  600.                
  601.                 if(shan1>125)
  602.                 {
  603.                         LedBuff[2]= table[minute/10];
  604.                         LedBuff[3]= table[minute%10];
  605.                 }
  606.                 else
  607.                 {
  608.                         LedBuff[2]= table[10];
  609.                         LedBuff[3]= table[10];               
  610.                 }
  611.         }
  612. }


  615. ///////////////////////

  617. void ds18b20disp(uint Value)
  618. {
  619.         if(s==0) //显示正温度
  620.         {
  621.                 if((Value/1000)>0)//大于100度显示最高位
  622.                         LedBuff[0]= table[Value/1000];               
  623.                 else                        
  624.                         LedBuff[0]=table[10];//小于100度不显示最高位
  625.         }else {LedBuff[0]=s;}//显示负号
  626.         LedBuff[1]=table[Value%1000/100];        //十位
  627.         LedBuff[2]=table[Value%100/10];//
  628.         LedBuff[3]=table[11];
  629. }  
  630. /////////////////////

  632. /////////////////////

  634. void main()
  635. {
  636.         Timer0Init();
  637.         P0M0 = 0x00;   //
  638.     P0M1 = 0x00;   //
  639.     P1M0 = 0x00;   //
  640.         P1M1 = 0x00;
  641.     P2M0 = 0x1f;   //p2.0-p2.4 设为推挽输出
  642.     P2M1 = 0x00;
  643.     P3M0 = 0x04;  //P3.2设为推挽输出才能驱动继电器
  644.     P3M1 = 0x00;
  645.     P4M0 = 0x00;
  646.     P4M1 = 0x00;
  647.     P5M0 = 0x10;
  648.     P5M1 = 0x00;

  650. //        P2PU=0x10;
  651. //        P2DR=0X00;
  652. //        w5=1;
  653.         while(1)
  654.         {
  655.                
  656.                 keyscan();
  657.                 if(qh_flag==0)
  658.                 {
  659.                         display_sf();
  660.                 }
  661.                 else
  662.                 {
  663.                         if(knum==0)
  664.                         {
  665.                                 read_temp();         //DS18B20温度
  666.                                 ds18b20disp(tvalue);
  667.                                 w5=1;
  668.                         }
  669.                 }

  671.                 if(knum!=0)
  672.                 {
  673.                         qh_flag=0;
  674.                 }
  675. //                if(shan>250)
  676. //                {BZ=1;}
  677. //                else {BZ=0;}
  678.                
  679. //                BZ=0;
  680. //                Delay_us(10);//实测11us（延时函数里面4个_nop_();@11.0592MHz）
  681. //                BZ=1;
  682. //                Delay_us(10);
  683.                  
  684.         }
  685. }

  687. void timer0() interrupt 1
  688. {

  690.         static uint i,j;
  691.         /*
  692.         if(fm_flag)
  693.         {
  694.                 BZ = 0;        //蜂鸣器开
  695.                 cont3++;
  696.                 if(cont3==100)//0.2秒
  697.                 {
  698.                         cont3=0;
  699.                         BZ = 1;         //蜂鸣器关
  700.                         fm_flag=0;        
  701.                 }        
  702.         } */
  703.                                                                                                                                                                  
  704.         shan++;
  705.         if(shan==500)
  706.         {
  707.                 shan=0;
  708.         }

  710.         if(knum != 0)
  711.         {
  712.                 shan1++;
  713.                 if(shan1==250)
  714.                         shan1=0;
  715.         }

  717.         Ledcount++;
  718.         P1=0xff;   //消影
  719.         if(Ledcount==4)
  720.         {
  721.                 Ledcount=0;
  722.         }
  723.         switch(Ledcount)
  724.         {
  725.                 case 0: w2 = 1; w3 = 1; w4 = 1;w1 = 0; P1 = LedBuff[0];  break;
  726.                 case 1: w1 = 1; w3 = 1; w4 = 1;w2 = 0; P1 = LedBuff[1];  break;
  727.                 case 2: w1 = 1; w2 = 1; w4 = 1;w3 = 0; P1 = LedBuff[2];  break;
  728.                 case 3: w1 = 1; w2 = 1; w3 = 1;w4 = 0; P1 = LedBuff[3];  break;
  729.                 default: break;
  730.         }
  731.         


  734.         if(flag1) //按键消抖计时
  735.         {k1_time_count++;}

  737.         if(flag2) //按键消抖计时
  738.         {k2_time_count++;}

  740.         if(flag3) //按键消抖计时
  741.         {k3_time_count++;}

  743.         if(qh_flag1==0 && knum==0)
  744.         {
  745.                 i++;
  746.                 if(i==500)
  747.                 {
  748.                         i=0;
  749.                         j++;
  750.                         if(j==7)
  751.                         {
  752.                                 j=0;
  753.                                 qh_flag=1;
  754.                                 qh_flag1=1;
  755.                         }
  756.                 }
  757.         }
  758.         else
  759.         {
  760.                 if(knum==0)
  761.                 {
  762.                         i++;
  763.                         if(i==500)
  764.                         {
  765.                                 i=0;
  766.                                 j++;
  767.                                 if(j==3)
  768.                                 {
  769.                                         j=0;
  770.                                         qh_flag=0;
  771.                                         qh_flag1=0;
  772.                                 }
  773.                         }
  774.                 }
  775.         }

  777. }

  779. [code]#ifndef __DS18B20_H__
  780. #define __DS18B20_H__

  782. //#include "delay.h"
  783. #define uchar unsigned char
  784. #define uint unsigned int

  786. /*定义DS18B20数据线*/
  787. sbit DQ = P0^1;
  788. //sbit DQ = P5^4;

  790. /*DS18B20驱动程序------------------------------------------------------------*/
  791. uchar data disdata[5];
  792. uint tvalue;//温度值
  793. uint s;
  794. void Delay_us(uchar i)        //us延时 STC  Y6指令 使用STC8系列
  795. {                                                 //@11.0592MHz
  796.          while(i--)
  797.          {        
  798.          _nop_();
  799.      _nop_();
  800.          _nop_();
  801.      _nop_();
  802.          ////////////
  803.          _nop_(); //_nop_();// _nop_();        _nop_();
  804.          }
  805. }  




  810. /*单总线初始化时序*/
  811. bit ds_init()
  812. {
  813.         bit i;
  814.         DQ = 1;
  815.         _nop_();_nop_();_nop_();_nop_();_nop_();
  816.         DQ = 0;
  817.         Delay_us(250); Delay_us(250);//拉低总线499.45us 挂接在总线上的18B20将会全部被复位
  818.         DQ = 1; //释放总线
  819.         Delay_us(38); //延时37.95us 等待18B20发回存在信号
  820.         i = DQ;
  821.         Delay_us(145); //141.95us
  822.         DQ = 1;
  823.         _nop_();
  824.         return (i);
  825. }
  826. /*写一个字节*/
  827. void write_byte_ds18b20(uchar dat)
  828. {
  829.         uchar i;
  830.         for(i=0;i<8;i++)
  831.         {
  832.                 DQ = 0;
  833.                 _nop_();//产生些时序
  834.                 DQ = dat & 0x01;
  835.                 Delay_us(78);//76.95us
  836.                 DQ = 1; //释放总线准备下一次数据写入
  837.                 _nop_();
  838.                 dat >>= 1;
  839.         }
  840. }

  842. uchar read_byte()
  843. {
  844.         uchar i, j, dat;
  845.         for(i=0;i<8;i++)
  846.         {
  847.                 DQ = 0;
  848.                 _nop_();//产生读时序
  849.                 DQ = 1;
  850.                 _nop_();//释放总线
  851.                 j = DQ;
  852.                 Delay_us(78);//76.95us
  853.                 DQ = 1;
  854.                 _nop_();
  855.                 dat = (j<<7)|(dat>>1);        
  856.         }
  857.         return (dat);
  858. }

  860. read_temp()
  861. {
  862. //        float tt;
  863.         uchar L,M;
  864.            ds_init();   
  865.            write_byte_ds18b20(0xcc);//*跳过读序列号*/
  866.            write_byte_ds18b20(0x44);//*启动温度转换*/
  867.                 Delay_us(100);
  868.            ds_init();   
  869.            write_byte_ds18b20(0xcc);//*跳过读序列号*/
  870.            write_byte_ds18b20(0xbe);//*读取温度*/
  871.                 Delay_us(100);
  872.            L=read_byte();
  873.            M=read_byte();
  874.            tvalue=M;
  875.            tvalue<<=8;
  876.            tvalue=tvalue|L;


  879. //        if(M >= 0x08)        //判断是否为负数
  880. //        {
  881. //                tvalue = ~tvalue + 1;//负数是以补码的形式存放的需要取反加1
  882. //                s = "-";  //显示负数符号
  883. //        }
  884. //        else s = 0;           //为正数则不显示负数符号


  887.            tvalue=tvalue*(0.625);//温度值扩大10倍，精确到1位小数
  888.         return(tvalue);
  889. }
  890. /*温度值显示-----------------------------------------------------------------*/
  891. /*
  892. void ds1820disp()
  893. {
  894.         disdata[0]=tvalue%1000/100+0x30;         //十位数
  895.         disdata[1]=tvalue%100/10+0x30;           //个位数
  896.         disdata[2]=tvalue%10+0x30;               //小数位   
  897.         if(disdata[0]==0x30) { disdata[0]=0x20; }//如果十位为0，不显示
  898.         set1616pic(5,4,0,1);                                         //显示"温度计图标"
  899.         write_com(0x30); write_com(0x06);        
  900.         write_com(0x9d);           //在液晶上显示温度起始位置："28.8°C
  901.         write_data(disdata[0]);    //显示十位         
  902.         write_data(disdata[1]);    //显示个位         
  903.         write_data(0x2e);          //显示小数点         
  904.         write_data(disdata[2]);    //显示小数位
  905.         set1616pic(8,4,0,0);           //在第8列第4行不反白的°C图标
  906. }  */
  907. /*---------------------------------------------------------------------------*/
  908. #endif
复制代码
回复

使用道具 举报

ID:140489 发表于 2023-12-21 15:16 | 显示全部楼层
ds3231（8脚封装）买了两家的，都是掉电走时有问题，重新买了ds3231（16脚封装）的掉电走时很好，看来ds3231（8脚封装）掉电走时是有问题的
回复

使用道具 举报

ID:95809 发表于 2023-12-23 20:25 | 显示全部楼层
lids 发表于 2023-12-21 15:16
ds3231（8脚封装）买了两家的，都是掉电走时有问题，重新买了ds3231（16脚封装）的掉电走时很好，看来ds323 ...

我用的就是8脚的，没发现问题。秒点不需要单独用三极管驱动，公共端接在gon第二个个的公共端就行了，我都是这样处理的。
回复

使用道具 举报

ID:140489 发表于 2023-12-27 15:21 | 显示全部楼层
掉电走时，重新上电时间会乱的问题解决了，原因是I2C总线的上拉电阻要接在单片机的IO口，并且要上拉到5V，时钟芯片是3.3V供电（DS3231芯片3.3V供电比5V供电走时精度高些），时钟芯片SDA  SCL的上拉不用
回复

使用道具 举报

ID:95809 发表于 2024-1-5 16:31 来自手机 | 显示全部楼层
把第三个数码管倒过来，利用点来模拟秒点闪烁，我都是这样做的。DS3231直接利用5V供电精度没问题，
回复

使用道具 举报

ID:140489 发表于 2024-1-8 11:27 | 显示全部楼层
bxyyhan 发表于 2024-1-5 16:31
把第三个数码管倒过来，利用点来模拟秒点闪烁，我都是这样做的。DS3231直接利用5V供电精度没问题，

我这数码管是一体的，不是单独的四个。数码管倒过来那种我做过的，两个秒点有点丑，才做这种四位一体带秒点的数码管的
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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