标题: 抛砖之六“自娱自乐--指针式数字钟” [打印本页]
作者: tianxing    时间: 2017-3-30 21:24
标题: 抛砖之六“自娱自乐--指针式数字钟”
突发奇想，用贴片三色LED设计了一台数字钟，不废话了，直接上菜。

  1. /*********************************************************************/
  2. /*  DS1302                                          */
  3. /*********************************************************************/
  4. #include <reg52.h>
  5. #include <intrins.h>

  7. /*********************************************************************/
  8. /*                函数宏定义定义                                     */
  9. /*********************************************************************/
  10. #define INT8U unsigned char
  11. #define INT16U unsigned int

  13. /*********************************************************************/
  14. /*                DS1302引脚定义                                     */
  15. /*********************************************************************/
  16. sbit SCLK = P1^5;     //控制数据时钟
  17. sbit IO =   P1^6;     //数据口
  18. sbit RST =  P1^7;     //使能端、复位端

  20. /*********************************************************************/
  21. /*                 按键引脚定义                                      */
  22. /*********************************************************************/
  23. sbit KEY_set  = P2^4;         //按键 选择
  24. sbit KEY_dec  = P2^5;         //按键 减
  25. sbit KEY_add  = P2^6;         //按键 加
  26. sbit KEY4     = P2^7;         //备用
  27. sbit KEY_int0 = P3^2;         //INT0

  29. /*********************************************************************/
  30. /*                红蓝绿三色引脚定义                                 */
  31. /*********************************************************************/
  32. sbit B_LED = P3^5;                          //蓝色使能
  33. sbit G_LED = P3^6;                          //绿色使能
  34. sbit R_LED = P3^7;                          //红色使能

  36. /*********************************************************************/
  37. /*                74HC164引脚定义                                    */
  38. /*********************************************************************/
  39. sbit DATA=P1^0;
  40. sbit CLK=P1^1;

  42. #define BLED_ON() B_LED=1;G_LED=0;R_LED=0
  43. #define GLED_ON() B_LED=0;G_LED=1;R_LED=0
  44. #define RLED_ON() B_LED=0;G_LED=0;R_LED=1

  46. /*********************************************************************/
  47. /*                蜂鸣器引脚定义                                     */
  48. /*********************************************************************/
  49. sbit BUZZER = P2^0;

  51. INT8U LED_array[] = //
  52. {
  53.     0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
  54.     0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01  //
  55. };

  57. INT8U BRGLED_array[] = //
  58. {
  59.     0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00, 0x00  //
  60. };

  62. /*********************************************************************/
  63. /*                写时分秒地址                                       */
  64. /*********************************************************************/
  65. #define write_miao 0x80
  66. #define write_fen  0x82
  67. #define write_shi  0x84

  69. /*********************************************************************/
  70. /*                读时分秒地址                                       */
  71. /*********************************************************************/
  72. #define read_miao 0x81
  73. #define read_fen  0x83
  74. #define read_shi  0x85

  76. //bit miao_flag;
  77. INT8U  flag, NUM=15, n;//
  78. INT8U s, knum=0, snum, fnum, mnum, g;
  79. INT16U t;
  80. //INT8U miao_num;
  81. //INT8U Dmiao;
  82. char shi, fen, miao;  //读出DS1302时分秒数据存储变量

  84. /*********************************************************************/
  85. /*                毫秒级延时函数                                     */
  86. /*********************************************************************/
  87. void delay_ms(INT16U ms)
  88. {                        
  89.         INT16U x, y;
  90.         for(x=0; x<ms; x++)
  91.                 for(y=0; y<110; y++);
  92. }

  94. /*********************************************************************/
  95. /*                  74HC164函数                                      */
  96. /*********************************************************************/
  97. void HC164(INT8U dat)
  98. {
  99.     INT8U i;
  100.     for(i = 0; i < 8; i ++)
  101.     {
  102.         if(dat & 0x80)
  103.             DATA = 1;
  104.         else
  105.             DATA = 0;
  106.         dat <<= 1;
  107.         CLK  = 1;
  108.         CLK  = 0;
  109.     }
  110. }

  112. /*********************************************************************/
  113. /*                无源蜂鸣器函数                                     */
  114. /*********************************************************************/
  115. void FMQ(INT8U g, INT16U t)          //可以选择鸣响次数和时间
  116. {
  117.         INT8U h,j;
  118.         INT16U i ;
  119.         for(h=0; h<g; h++)
  120.         {
  121.                 for(i=0; i<t; i++)
  122.                 {
  123.                         BUZZER =~ BUZZER;              //BUZZER取反
  124.                         for(j=0 ;j<90 ;j++);   //需要产生方波，调节音频
  125.                 }
  126.                 delay_ms(100);                         //间隔时间
  127.         }
  128.         BUZZER = 1;                      //PNP-0;NPN-1关闭蜂鸣器
  129. }

  131. /*********************************************************************/
  132. /*                定时器0初始化函数                                  */
  133. /*********************************************************************/
  134. /*void TIMER0_init(void)  
  135. {
  136.         TMOD = 0x01;
  137.         TH0  = (65536-50000)/256;        //定时50ms一个中断
  138.         TL0  = (65536-50000)%256;
  139.         EA   = 1;
  140.         ET0  = 1;
  141.         TR0  = 1;
  142. } */

  144. /*********************************************************************/
  145. /*                DS1302读函数                                       */
  146. /*********************************************************************/
  147. INT8U read_1302(INT8U add) //
  148. {
  149.         INT8U i, date;
  150.         RST = 0;   //禁止读写数据
  151.         for(i=0; i<8; i++)
  152.         {
  153.                 RST  = 1;
  154.                 SCLK = 0;
  155.                 IO   = add&0x01;
  156.                 add  >>= 1;
  157.                 SCLK = 1;
  158.         }
  159.         for(i=0; i<8; i++)
  160.         {
  161.                 if(IO)
  162.                         date = date|0x80;
  163.                 else
  164.                         date = date|0x00;
  165.                 SCLK = 1;
  166.                 date >>=1;
  167.                 SCLK = 0;
  168.         }
  169.         RST = 0;
  170.         date = date/16*10 + date%16;//进制转换 16转10进制
  171.         IO  = 0;     //数据读完后，IO口必须为0，不然小时一直显示85
  172.         return date;
  173. }

  175. /*********************************************************************/
  176. /*                DS1302写函数                                       */
  177. /*********************************************************************/
  178. void write_1302(INT8U add, INT8U dat)  //
  179. {
  180.         INT8U i;
  181.         RST  = 0;     //禁止读写数据
  182.         SCLK = 0;   
  183.         for(i=0; i<8; i++)    //写地址
  184.         {
  185.                 RST  = 1;     //允许读写数据
  186.                 SCLK = 0;
  187.                 IO   = add&0x01;  
  188.                 add  >>= 1;
  189.                 SCLK = 1;
  190.         }
  191.         for(i=0; i<8; i++)    //写数据
  192.         {
  193.                 RST  = 1;    //允许读写数据
  194.                 SCLK = 0;
  195.                 IO   = dat&0x01;
  196.                 dat  >>= 1;
  197.                 SCLK = 1;
  198.         }
  199.         RST = 0;
  200. }

  202. /*********************************************************************/
  203. /*             DS1302初始化函数(设置初始时间时使用)                  */
  204. /*********************************************************************/
  205. /*void DS1302_init(void)
  206. {
  207.         flag = read_1302(0x81);
  208.         if(flag&0x80)
  209.         write_1302(0x8E,       0x00);   //保护取消，可以进行读写操作
  210.         write_1302(write_miao, 0x00);   // 设置时间
  211.         write_1302(write_fen,  0x03);
  212.         write_1302(write_shi,  0x04);
  213.         write_1302(0x90,       0xA5);
  214.         write_1302(0xC0,       0xF0);   //判断是否初始化一次标识写入
  215.         write_1302(0x8E,       0x80);   //保护启动，不能进行读写操作
  216. } */

  218. /*********************************************************************/
  219. /*                 显示时间函数                                      */
  220. /*********************************************************************/
  221. void display(INT8U shi, INT8U fen, INT8U miao)   //
  222. {
  223.         for(n=0; n<30; n++)
  224.         {
  225.             if(miao/8==0)
  226.                 {
  227.                         GLED_ON();
  228.             HC164(0x00);
  229.             HC164(0x00);
  230.             HC164(0x00);
  231.             HC164(0x00);
  232.             HC164(0x00);
  233.             HC164(0x00);
  234.             HC164(0x00);
  235.             HC164(LED_array[miao]);
  236.                         delay_ms(NUM);
  237.                 }
  238.             else if(miao/8==1)
  239.                 {
  240.                         GLED_ON();
  241.             HC164(0x00);
  242.             HC164(0x00);
  243.             HC164(0x00);
  244.             HC164(0x00);
  245.             HC164(0x00);
  246.             HC164(0x00);
  247.             HC164(LED_array[miao-8]);
  248.             HC164(0x00);
  249.                         delay_ms(NUM);
  250.                 }
  251.             else if(miao/8==2)
  252.                 {
  253.                         GLED_ON();
  254.             HC164(0x00);
  255.             HC164(0x00);
  256.             HC164(0x00);
  257.             HC164(0x00);
  258.             HC164(0x00);
  259.             HC164(LED_array[miao-16]);
  260.             HC164(0x00);
  261.             HC164(0x00);
  262.                         delay_ms(NUM);
  263.                 }
  264.             else if(miao/8==3)
  265.                 {
  266.                         GLED_ON();
  267.             HC164(0x00);
  268.             HC164(0x00);
  269.             HC164(0x00);
  270.             HC164(0x00);
  271.             HC164(LED_array[miao-24]);
  272.             HC164(0x00);
  273.             HC164(0x00);
  274.             HC164(0x00);
  275.                         delay_ms(NUM);
  276.                 }
  277.             else if(miao/8==4)
  278.                 {
  279.                         GLED_ON();
  280.             HC164(0x00);
  281.             HC164(0x00);
  282.             HC164(0x00);
  283.             HC164(LED_array[miao-32]);
  284.             HC164(0x00);
  285.             HC164(0x00);
  286.             HC164(0x00);
  287.             HC164(0x00);
  288.                         delay_ms(NUM);
  289.                 }
  290.             else if(miao/8==5)
  291.                 {
  292.                         GLED_ON();
  293.             HC164(0x00);
  294.             HC164(0x00);
  295.             HC164(LED_array[miao-40]);
  296.             HC164(0x00);
  297.             HC164(0x00);
  298.             HC164(0x00);
  299.             HC164(0x00);
  300.             HC164(0x00);
  301.                         delay_ms(NUM);
  302.                 }
  303.             else if(miao/8==6)
  304.                 {
  305.                         GLED_ON();
  306.             HC164(0x00);
  307.             HC164(LED_array[miao-48]);
  308.             HC164(0x00);
  309.             HC164(0x00);
  310.             HC164(0x00);
  311.             HC164(0x00);
  312.             HC164(0x00);
  313.             HC164(0x00);
  314.                         delay_ms(NUM);
  315.                 }
  316.             else if(miao/8==7)
  317.                 {
  318.                         GLED_ON();
  319.             HC164(LED_array[miao-56]);
  320.             HC164(0x00);
  321.             HC164(0x00);
  322.             HC164(0x00);
  323.             HC164(0x00);
  324.             HC164(0x00);
  325.             HC164(0x00);
  326.             HC164(0x00);
  327.                         delay_ms(NUM);
  328.                 }  
  329. /////////////////////////////////////////////////////////////////////////////////////////////////////
  330.             if(fen/8==0)
  331.                 {
  332.                         BLED_ON();
  333.             HC164(0x00);
  334.             HC164(0x00);
  335.             HC164(0x00);
  336.             HC164(0x00);
  337.             HC164(0x00);
  338.             HC164(0x00);
  339.             HC164(0x00);
  340.             HC164(LED_array[fen]);
  341.                         delay_ms(NUM);
  342.                 }
  343.             else if(fen/8==1)
  344.                 {
  345.                         BLED_ON();
  346.             HC164(0x00);
  347.             HC164(0x00);
  348.             HC164(0x00);
  349.             HC164(0x00);
  350.             HC164(0x00);
  351.             HC164(0x00);
  352.             HC164(LED_array[fen-8]);
  353.             HC164(0x00);
  354.                         delay_ms(NUM);
  355.                 }
  356.             else if(fen/8==2)
  357.                 {
  358.                         BLED_ON();
  359.             HC164(0x00);
  360.             HC164(0x00);
  361.             HC164(0x00);
  362.             HC164(0x00);
  363.             HC164(0x00);
  364.             HC164(LED_array[fen-16]);
  365.             HC164(0x00);
  366.             HC164(0x00);
  367.                         delay_ms(NUM);
  368.                 }
  369.             else if(fen/8==3)
  370.                 {
  371.                         BLED_ON();
  372.             HC164(0x00);
  373.             HC164(0x00);
  374.             HC164(0x00);
  375.             HC164(0x00);
  376.             HC164(LED_array[fen-24]);
  377.             HC164(0x00);
  378.             HC164(0x00);
  379.             HC164(0x00);
  380.                         delay_ms(NUM);
  381.                 }
  382.             else if(fen/8==4)
  383.                 {
  384.                         BLED_ON();
  385.             HC164(0x00);
  386.             HC164(0x00);
  387.             HC164(0x00);
  388.             HC164(LED_array[fen-32]);
  389.             HC164(0x00);
  390.             HC164(0x00);
  391.             HC164(0x00);
  392.             HC164(0x00);
  393.                         delay_ms(NUM);
  394.                 }
  395.             else if(fen/8==5)
  396.                 {
  397.                         BLED_ON();
  398.             HC164(0x00);
  399.             HC164(0x00);
  400.             HC164(LED_array[fen-40]);
  401.             HC164(0x00);
  402.             HC164(0x00);
  403.             HC164(0x00);
  404.             HC164(0x00);
  405.             HC164(0x00);
  406.                         delay_ms(NUM);
  407.                 }
  408.             else if(fen/8==6)
  409.                 {
  410.                         BLED_ON();
  411.             HC164(0x00);
  412.             HC164(LED_array[fen-48]);
  413.             HC164(0x00);
  414.             HC164(0x00);
  415.             HC164(0x00);
  416.             HC164(0x00);
  417.             HC164(0x00);
  418.             HC164(0x00);
  419.                         delay_ms(NUM);
  420.                 }
  421.             else if(fen/8==7)
  422.                 {
  423.                         BLED_ON();
  424.             HC164(LED_array[fen-56]);
  425.             HC164(0x00);
  426.             HC164(0x00);
  427.             HC164(0x00);
  428.             HC164(0x00);
  429.             HC164(0x00);
  430.             HC164(0x00);
  431.             HC164(0x00);
  432.                         delay_ms(NUM);
  433.                 }
  434. /////////////////////////////////////////////////////////////////////////////////////////////////////
  435.             if((shi*5)/8==0)
  436.                 {
  437.                         RLED_ON();
  438.             HC164(0x00);
  439.             HC164(0x00);
  440.             HC164(0x00);
  441.             HC164(0x00);
  442.             HC164(0x00);
  443.             HC164(0x00);
  444.             HC164(0x00);
  445.             HC164(LED_array[(shi*5)]);
  446.                         delay_ms(NUM);
  447.                 }
  448.             else if((shi*5)/8==1)
  449.                 {
  450.                         RLED_ON();
  451.             HC164(0x00);
  452.             HC164(0x00);
  453.             HC164(0x00);
  454.             HC164(0x00);
  455.             HC164(0x00);
  456.             HC164(0x00);
  457.             HC164(LED_array[(shi*5)-8]);
  458.             HC164(0x00);
  459.                         delay_ms(NUM);
  460.                 }
  461.             else if((shi*5)/8==2)
  462.                 {
  463.                         RLED_ON();
  464.             HC164(0x00);
  465.             HC164(0x00);
  466.             HC164(0x00);
  467.             HC164(0x00);
  468.             HC164(0x00);
  469.             HC164(LED_array[(shi*5)-16]);
  470.             HC164(0x00);
  471.             HC164(0x00);
  472.                         delay_ms(NUM);
  473.                 }
  474.             else if((shi*5)/8==3)
  475.                 {
  476.                         RLED_ON();
  477.             HC164(0x00);
  478.             HC164(0x00);
  479.             HC164(0x00);
  480.             HC164(0x00);
  481.             HC164(LED_array[(shi*5)-24]);
  482.             HC164(0x00);
  483.             HC164(0x00);
  484.             HC164(0x00);
  485.                         delay_ms(NUM);
  486.                 }
  487.             else if((shi*5)/8==4)
  488.                 {
  489.                         RLED_ON();
  490.             HC164(0x00);
  491.             HC164(0x00);
  492.             HC164(0x00);
  493.             HC164(LED_array[(shi*5)-32]);
  494.             HC164(0x00);
  495.             HC164(0x00);
  496.             HC164(0x00);
  497.             HC164(0x00);
  498.                         delay_ms(NUM);
  499.                 }
  500.             else if((shi*5)/8==5)
  501.                 {
  502.                         RLED_ON();
  503.             HC164(0x00);
  504.             HC164(0x00);
  505.             HC164(LED_array[(shi*5)-40]);
  506.             HC164(0x00);
  507.             HC164(0x00);
  508.             HC164(0x00);
  509.             HC164(0x00);
  510.             HC164(0x00);
  511.                         delay_ms(NUM);
  512.                 }
  513.             else if((shi*5)/8==6)
  514.                 {
  515.                         RLED_ON();
  516.             HC164(0x00);
  517.             HC164(LED_array[(shi*5)-48]);
  518.             HC164(0x00);
  519.             HC164(0x00);
  520.             HC164(0x00);
  521.             HC164(0x00);
  522.             HC164(0x00);
  523.             HC164(0x00);
  524.                         delay_ms(NUM);
  525.                 }
  526.             else if((shi*5)/8==7)
  527.                 {
  528.                         RLED_ON();
  529.             HC164(LED_array[(shi*5)-56]);
  530.             HC164(0x00);
  531.             HC164(0x00);
  532.             HC164(0x00);
  533.             HC164(0x00);
  534.             HC164(0x00);
  535.             HC164(0x00);
  536.             HC164(0x00);
  537.                         delay_ms(NUM);
  538.                 }
  539.         }
  540. }

  542. /*********************************************************************/
  543. /*                读出DS1302时分秒且显示函数                         */
  544. /*********************************************************************/
  545. void read_sfm(void)
  546. {
  547.         miao = read_1302(read_miao);
  548.         fen  = read_1302(read_fen);
  549.         shi  = read_1302(read_shi);
  550.         display(shi, fen, miao);
  551. }

  553. /*********************************************************************/
  554. /*                       按键扫描函数                                */
  555. /*********************************************************************/
  556. void keyscan(void)           //
  557. {            
  558.         if(KEY_set==0)           //选择按键按下
  559.         {
  560.                 delay_ms(10);
  561.                 if(KEY_set==0)
  562.                 FMQ(1, 100);
  563.                 {
  564.                         while(!KEY_set)
  565.                         display(shi, fen, miao); //加上这句，按键按下就不会闪
  566.                         knum ++;
  567.                         if(knum==1)        //分闪烁
  568.                         {
  569.                                 write_1302(0x8E,       0x00);  //保护取消
  570.                                 write_1302(write_miao, 0x80);
  571.                         }
  572.                         if(knum==3)         //时钟启动
  573.                         {
  574.                                 knum=0;
  575.                                 write_1302(write_miao, 0x00);
  576.                                 write_1302(0x8E,       0x80);  //保护启动
  577.                         }
  578.                 }
  579.         }
  580.         if(knum==1)        //分钟调节
  581.         {
  582.                 if(KEY_add==0)       //加
  583.                 {
  584.                         delay_ms(10);
  585.                         if(KEY_add==0)
  586.                         FMQ(1, 100);
  587.                         {
  588.                                 while(!KEY_add)
  589.                                 display(shi, fen, miao); //加上这句，按键按下就不会闪
  590.                                 fen ++;
  591.                                 if(fen==60)
  592.                                         fen = 0;
  593.                                 write_1302(write_fen,fen/10*16 + fen%10); //写入1302
  594.                                 read_sfm();     //读出时间，然后显示
  595.                         }
  596.                 }
  597.                 if(KEY_dec==0)
  598.                 {
  599.                         delay_ms(10);
  600.                         if(KEY_dec==0)
  601.                         FMQ(1, 100);
  602.                         {
  603.                                 while(!KEY_dec)
  604.                                 display(shi, fen, miao); //加上这句，按键按下就不会闪
  605.                                 fen --;
  606.                                 if(fen==-1)
  607.                                 fen = 59;
  608.                                 write_1302(write_fen,fen/10*16 + fen%10);
  609.                                 read_sfm();
  610.                         }
  611.                 }
  612.         }
  613.         if(knum==2)
  614.         {
  615.                 if(KEY_set==0)
  616.                 {
  617.                         delay_ms(10);
  618.                         if(KEY_set==0)
  619.                         FMQ(1, 100);
  620.                         {
  621.                                 while(!KEY_set)
  622.                                 display(shi, fen, miao); //加上这句，按键按下就不会闪
  623.                                 shi ++;
  624.                                 if(shi==12)
  625.                                 shi = 0;
  626.                                 write_1302(write_shi,shi/10*16 + shi%10);
  627.                                 read_sfm();
  628.                         }
  629.                 }
  630.                 if(KEY_dec==0)
  631.                 {
  632.                         delay_ms(10);
  633.                         if(KEY_dec==0)
  634.                         FMQ(1, 100);
  635.                         {
  636.                                 while(!KEY_dec)
  637.                                 display(shi, fen, miao); //加上这句，按键按下就不会闪
  638.                                 shi --;
  639.                                 if(shi==-1)
  640.                                 shi = 11;
  641.                                 write_1302(write_shi,shi/10*16+shi%10);
  642.                                 read_sfm();
  643.                         }
  644.                 }
  645.         }
  646. }

  648. /*********************************************************************/
  649. /*                 主程序                                            */
  650. /*********************************************************************/                        
  651. void main(void)
  652. {
  653. //        DS1302_init();
  654. //        TIMER0_init();
  655.         FMQ(1, 120);
  656.         while(1)
  657.         {
  658. /*                if(miao_num<10)                 //秒点闪烁
  659.                 led = 0;
  660.                 if(miao_num>=10)
  661.                 led = 1;         */
  662.                 read_sfm();
  663.                 keyscan();
  664.         }
  665. }

  667. /*********************************************************************/
  668. /*                   TIMER0(1秒)定时中断函数                         */
  669. /*********************************************************************/
  670. /*
  671. void TIMER0() interrupt 1
  672. {
  673.         TMOD = 0x01;
  674.         TH0  = (65536-50000)/256;        
  675.         TL0  = (65536-50000)%256;
  676.         miao_num ++;
  677.         if(miao_num>=20)
  678.         {
  679.                 miao_num = 0;
  680.                 miao_flag = 1;
  681.         }
  682. }
  683. */
复制代码


作者: cjjcjj1    时间: 2017-3-30 21:41
提示: 作者被禁止或删除 内容自动屏蔽
作者: tianxing    时间: 2017-3-31 13:28
谢admin送分。
作者: tianxing    时间: 2017-3-31 19:22
原理图无法上传？

作者: admin    时间: 2017-3-31 21:58
tianxing 发表于 2017-3-31 19:22
原理图无法上传？

楼主的原理图是图片还是pdf 如果是图片的话最好不要超过2兆 容易导致失败，最好用qq截图来弄，这样成功率是100%，pdf直接上传
作者: tianxing    时间: 2017-4-1 10:10
谢了。
作者: vincetan9    时间: 2017-4-1 14:18
说得好啊
作者: 越快乐越堕落    时间: 2017-4-10 13:59
牛 但是你这个怎么看呢 绿色是时还是分
作者: 越快乐越堕落    时间: 2017-4-10 14:14
共享一下原理图吧楼主
作者: tianxing    时间: 2017-4-12 11:01
红蓝绿分别对应时分秒，图只能发包了。

DS1302_164_60BRG.rar

17.92 KB, 下载次数: 25, 下载积分: 黑币 -5

作者: tianxing    时间: 2017-4-12 11:19
红蓝绿分别对应时分秒。

截图00.png (165.23 KB, 下载次数: 162)

原理图

原理图
作者: xsj1877578806    时间: 2018-8-1 14:08
好东西，收藏学习学习
作者: songxia8013    时间: 2018-8-1 21:56
这菜不错，很香！找空我也做下。
作者: bhjyqjs    时间: 2018-8-8 09:19
高！楼主牛人也！
作者: 999看    时间: 2018-8-8 17:42
        date = date/16*10 + date%16;//进制转换 16转10进制   这里应该错了
作者: sunke928    时间: 2018-8-12 12:31
学习贴收藏了，谢谢分享
作者: xiaoxiao1122    时间: 2018-8-14 12:14
学习支持
作者: xiaoxiao1122    时间: 2018-8-17 12:42
好东西，收藏



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1