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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › 单片机高精度计时器电路原理图 PCB与源代码
返回列表 发新帖
查看: 3725|回复: 1
打印 上一主题 下一主题
收起左侧

单片机高精度计时器电路原理图 PCB与源代码

[复制链接]
跳转到指定楼层
楼主
ID:112317 发表于 2016-4-7 02:01 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
（原创）51单片机高精度计时器电路原理图。采用AT89S52加DP8573，实现两个功能：带掉电保持功能的日历时钟、由外部开关信号触发的高精度计时，pcb文件与原理图配套，完全对应，可直接加工制作.
以上所有文件打包下载： 源码pcb等资料.rar (206.35 KB, 下载次数: 12)

  1. //********************************************************************
  2. // Author        : Bing Wang
  3. // Date          : Mar. 2017
  4. // File          : msTIMER.c
  5. // Hardware      : 89S51/89S52
  6. //********************************************************************

  8. #include <AT89X52.h>                // SFR definition file.
  9. #include <stdio.h>
  10. #include <absacc.h>                        //
  11. #include <ctype.h>                        //
  12. #include <stdlib.h>                        //
  13. #include <math.h>

  15. // Interface address definition
  16. // DP8573AN RTC
  17. xdata char DP8573SEC         _at_ 0x0600;
  18. xdata char DP8573MIN         _at_ 0x0700;
  19. xdata char DP8573HOUR         _at_ 0x0800;
  20. xdata char DP8573WEEK         _at_ 0x0E00;
  21. xdata char DP8573DAY         _at_ 0x0900;
  22. xdata char DP8573MONTH        _at_ 0x0A00;
  23. xdata char DP8573YEAR         _at_ 0x0B00;

  25. xdata char DP8573SECs        _at_ 0x1900;        // Second Save
  26. xdata char DP8573MINs         _at_ 0x1A00;        // Minute Save
  27. xdata char DP8573HOURs        _at_ 0x1B00;        // Hour Save
  28. xdata char DP8573DAYs        _at_ 0x1C00;        // Day Save
  29. xdata char DP8573MONs        _at_ 0x1D00;        // Month Save

  31. xdata char DP8573MSR         _at_ 0x0000;        // Main Status Register
  32. xdata char DP8573PFR         _at_ 0x0400;        // Periodic Flag Register
  33. xdata char DP8573TSCR         _at_ 0x0400;        // Time Save Control Register
  34. xdata char DP8573RTMR         _at_ 0x0100;        // Real Time Mode Register
  35. xdata char DP8573OMR         _at_ 0x0200;        // Output Mode Register
  36. xdata char DP8573ICR0         _at_ 0x0300;        // Interrupt Control Register 0
  37. xdata char DP8573ICR1         _at_ 0x0400;        // Interrupt Control Register 1

  39. unsigned char msCNT, Tsecond;
  40. unsigned char SecRTC, MinRTC, HourRTC, WeekRTC, DayRTC, MonthRTC, YearRTC;
  41. unsigned char CmdOld, KeyCmd;
  42. unsigned char second, secondOld, minute, minuteOld, hour, hourOld;
  43. unsigned char day, dayOld, month, monthOld, year, yearOld, timeH, timeL;

  45. void UART_Init(void)
  46. {
  47.         SCON = 0x50;        // Setup serial port ctrl reg
  48.                                         // Mode 1: 8-bit uart var. baud rate
  49.                                         // REN: enable receiver
  50.         PCON &= 0x7F;        // Clear SMOD bit in power ctrl reg
  51.                                         // This bit doubles the baud rate
  52.         TMOD &= 0xCF;        // Clear M1 and M0 for timer 1
  53.         TMOD |= 0x20;        // Set M1 for 8-bit autoreload timer
  54.                                         // TMOD: Timer 1 Mode 2: 8-bit auto-reload timer
  55.         TH1 = 213;                // 1200 baud with 20MHz xtal
  56.         TR1 = 1;                // Start timer 1
  57.         TI = 1;                        // Set TI to indicate ready to xmit
  58. }

  60. void DP8573A_Init(void)
  61. {
  62.         DP8573MSR = 0x40;        // RS=1
  63.         DP8573ICR0 = 0x04;        // Interrupt every 1sec
  64.         DP8573RTMR = 0x00;         // 24 hour mode + stop timer
  65.         DP8573MSR = 0x00;        // RS=0
  66.         DP8573PFR = 0x00;        // Clear INT flags + battery backup
  67.         DP8573TSCR = 0x80;        // Time save enable
  68.         DP8573SECs = 0x00;        // Clear saved second
  69.         DP8573MINs = 0x00;        // Clear saved minute
  70.         DP8573HOURs = 0x00;        // Clear saved hour
  71.         DP8573DAYs = 0x00;        // Clear saved day
  72.         DP8573MONs = 0x00;        // Clear saved month
  73.         DP8573MSR = 0x44;        // RS=1, clear INT flag
  74.         DP8573RTMR = 0x08;        // Clock start
  75. }

  77. void delay1s(void)
  78. {
  79.         unsigned int k;
  80.         for (k=0;k<40000;k++);
  81. }

  83. void delay100ms(void)
  84. {
  85.         unsigned int k;
  86.         for (k=0;k<2000;k++);
  87. }

  89. unsigned char KeyScan(void)
  90. {
  91.         unsigned char keypad;

  93.         keypad = P1;
  94.         keypad &= 0x1D;

  96.         switch (keypad)
  97.         {
  98.                 case 0x1C:
  99.                         keypad = 1;
  100.                         break;
  101.                 case 0x19:
  102.                         keypad = 2;
  103.                         break;
  104.                 case 0x15:
  105.                         keypad = 3;
  106.                         break;
  107.                 case 0x0D:
  108.                         keypad = 4;
  109.                         break;
  110.                 default:
  111.                         keypad = 0;
  112.                         break;
  113.         }
  114.         return keypad;
  115. }

  117. void AdjustRTC(void)
  118. {
  119.         unsigned char EndCMD, Para, ParaOld, ParaValue;

  121.         SecRTC = DP8573SEC;
  122.         SecRTC = (SecRTC>>4)*10 + (SecRTC%16);
  123.         MinRTC = DP8573MIN;
  124.         MinRTC = (MinRTC>>4)*10 + (MinRTC%16);
  125.         HourRTC = DP8573HOUR;
  126.         HourRTC = (HourRTC>>4)*10 + (HourRTC%16);
  127.         DayRTC = DP8573DAY;
  128.         DayRTC = (DayRTC>>4)*10 + (DayRTC%16);
  129.         MonthRTC = DP8573MONTH;
  130.         MonthRTC = (MonthRTC>>4)*10 + (MonthRTC%16);
  131.         YearRTC = DP8573YEAR;
  132.         YearRTC = (YearRTC>>4)*10 + (YearRTC%16);
  133.         EndCMD = 0;
  134.         Para = ParaOld = 0;
  135.         CmdOld = 0;

  137.         while (!EndCMD) {
  138.                 if (KeyCmd != CmdOld) {
  139.                         switch (KeyCmd) {
  140.                                 case 1:                                        // Setting
  141.                                         Para += 1;
  142.                                         if (Para >= 7) { Para = 0; EndCMD = 1; }
  143.                                         break;
  144.                                 case 2:                                        // +
  145.                                         switch(Para) {
  146.                                                 case 1:                        // Year
  147.                                                         if (YearRTC >= 99) YearRTC = 0;
  148.                                                         else YearRTC++;
  149.                                                         putchar(16);        // Set cursor to the last 2 chars
  150.                                                         putchar(14);
  151.                                                         putchar((YearRTC/10)+48);
  152.                                                         putchar((YearRTC%10)+48);
  153.                                                         break;
  154.                                                 case 2:                        // Month
  155.                                                         if (MonthRTC >= 12) MonthRTC = 1;
  156.                                                         else MonthRTC++;
  157.                                                         putchar(16);        // Set cursor to the last 2 chars
  158.                                                         putchar(14);
  159.                                                         putchar((MonthRTC/10)+48);
  160.                                                         putchar((MonthRTC%10)+48);
  161.                                                         break;
  162.                                                 case 3:                        // Day
  163.                                                         if (DayRTC >= 31) DayRTC = 1;
  164.                                                         else DayRTC++;
  165.                                                         putchar(16);        // Set cursor to the last 2 chars
  166.                                                         putchar(14);
  167.                                                         putchar((DayRTC/10)+48);
  168.                                                         putchar((DayRTC%10)+48);
  169.                                                         break;
  170.                                                 case 4:                        // Hour
  171.                                                         if (HourRTC >= 24) HourRTC = 0;
  172.                                                         else HourRTC++;
  173.                                                         putchar(16);        // Set cursor to the last 2 chars
  174.                                                         putchar(14);
  175.                                                         putchar((HourRTC/10)+48);
  176.                                                         putchar((HourRTC%10)+48);
  177.                                                         break;
  178.                                                 case 5:                        // Minute
  179.                                                         if (MinRTC >= 59) MinRTC = 0;
  180.                                                         else MinRTC++;
  181.                                                         putchar(16);        // Set cursor to the last 2 chars
  182.                                                         putchar(14);
  183.                                                         putchar((MinRTC/10)+48);
  184.                                                         putchar((MinRTC%10)+48);
  185.                                                         break;
  186.                                                 case 6:                        // Second
  187.                                                         if (SecRTC >= 59) SecRTC = 0;
  188.                                                         else SecRTC++;
  189.                                                         putchar(16);        // Set cursor to the last 2 chars
  190.                                                         putchar(14);
  191.                                                         putchar((SecRTC/10)+48);
  192.                                                         putchar((SecRTC%10)+48);
  193.                                                         break;
  194.                                                 default:
  195.                                                         break;
  196.                                         }
  197.                                         break;
  198.                                 case 3:                                        // -
  199.                                         switch(Para) {
  200.                                                 case 1:                        // Year
  201.                                                         if (YearRTC == 0) YearRTC = 99;
  202.                                                         else YearRTC--;
  203.                                                         putchar(16);        // Set cursor to the last 2 chars
  204.                                                         putchar(14);
  205.                                                         putchar((YearRTC/10)+48);
  206.                                                         putchar((YearRTC%10)+48);
  207.                                                         break;
  208.                                                 case 2:                        // Month
  209.                                                         if (MonthRTC == 1) MonthRTC = 12;
  210.                                                         else MonthRTC--;
  211.                                                         putchar(16);        // Set cursor to the last 2 chars
  212.                                                         putchar(14);
  213.                                                         putchar((MonthRTC/10)+48);
  214.                                                         putchar((MonthRTC%10)+48);
  215.                                                         break;
  216.                                                 case 3:                        // Day
  217.                                                         if (DayRTC == 1) DayRTC = 31;
  218.                                                         else DayRTC--;
  219.                                                         putchar(16);        // Set cursor to the last 2 chars
  220.                                                         putchar(14);
  221.                                                         putchar((DayRTC/10)+48);
  222.                                                         putchar((DayRTC%10)+48);
  223.                                                         break;
  224.                                                 case 4:                        // Hour
  225.                                                         if (HourRTC == 0) HourRTC = 24;
  226.                                                         else HourRTC--;
  227.                                                         putchar(16);        // Set cursor to the last 2 chars
  228.                                                         putchar(14);
  229.                                                         putchar((HourRTC/10)+48);
  230.                                                         putchar((HourRTC%10)+48);
  231.                                                         break;
  232.                                                 case 5:                        // Minute
  233.                                                         if (MinRTC == 0) MinRTC = 59;
  234.                                                         else MinRTC--;
  235.                                                         putchar(16);        // Set cursor to the last 2 chars
  236.                                                         putchar(14);
  237.                                                         putchar((MinRTC/10)+48);
  238.                                                         putchar((MinRTC%10)+48);
  239.                                                         break;
  240.                                                 case 6:                        // Second
  241.                                                         if (SecRTC == 0) SecRTC = 59;
  242.                                                         else SecRTC--;
  243.                                                         putchar(16);        // Set cursor to the last 2 chars
  244.                                                         putchar(14);
  245.                                                         putchar((SecRTC/10)+48);
  246.                                                         putchar((SecRTC%10)+48);
  247.                                                         break;
  248.                                                 default:
  249.                                                         break;
  250.                                         }
  251.                                         break;
  252.                                 case 4:                                        // Enter
  253.                                         ParaValue = ((SecRTC/10)*16) + (SecRTC%10);
  254.                                         SecRTC = ParaValue;
  255.                                         ParaValue = ((MinRTC/10)*16) + (MinRTC%10);
  256.                                         MinRTC = ParaValue;
  257.                                         ParaValue = ((HourRTC/10)*16) + (HourRTC%10);
  258.                                         HourRTC = ParaValue;
  259.                                         ParaValue = ((DayRTC/10)*16) + (DayRTC%10);
  260.                                         DayRTC = ParaValue;
  261.                                         ParaValue = ((MonthRTC/10)*16) + (MonthRTC%10);
  262.                                         MonthRTC = ParaValue;
  263.                                         ParaValue = ((YearRTC/10)*16) + (YearRTC%10);
  264.                                         YearRTC = ParaValue;
  265.        
  266.                                         DP8573MSR = 0x40;        // RS=1
  267.                                         DP8573RTMR = 0x00;         // 24 hour mode + stop timer
  268.                                         DP8573SEC = SecRTC;
  269.                                         DP8573MIN = MinRTC;
  270.                                         DP8573HOUR = HourRTC;
  271.                                         DP8573DAY = DayRTC;
  272.                                         DP8573MONTH = MonthRTC;
  273.                                         DP8573YEAR = YearRTC;
  274.                                         DP8573MSR = 0x40;        // RS=1
  275.                                         DP8573RTMR = 0x08;         // 24 hour mode + run timer
  276.                                         EndCMD = 1;
  277.                                         Para = 0;
  278.                                         break;
  279.                                 default:
  280.                                         break;
  281.                         }
  282.                         // Display setting
  283.                         if (ParaOld != Para) {
  284.                                 putchar(13);
  285.                                 ParaOld = Para;
  286.                                 switch(Para) {
  287.                                         case 1:                        // Year
  288.                                                 printf("Year:");
  289.                                                 putchar(16);        // Set cursor to the last 2 chars
  290.                                                 putchar(14);
  291.                                                 putchar((YearRTC/10)+48);
  292.                                                 putchar((YearRTC%10)+48);
  293.                                                 break;
  294.                                         case 2:                        // Month
  295.                                                 printf("Month:");
  296.                                                 putchar(16);        // Set cursor to the last 2 chars
  297.                                                 putchar(14);
  298.                                                 putchar((MonthRTC/10)+48);
  299.                                                 putchar((MonthRTC%10)+48);
  300.                                                 break;
  301.                                         case 3:                        // Day
  302.                                                 printf("Day:");
  303.                                                 putchar(16);        // Set cursor to the last 2 chars
  304.                                                 putchar(14);
  305.                                                 putchar((DayRTC/10)+48);
  306.                                                 putchar((DayRTC%10)+48);
  307.                                                 break;
  308.                                         case 4:                        // Hour
  309.                                                 printf("Hour:");
  310.                                                 putchar(16);        // Set cursor to the last 2 chars
  311.                                                 putchar(14);
  312.                                                 putchar((HourRTC/10)+48);
  313.                                                 putchar((HourRTC%10)+48);
  314.                                                 break;
  315.                                         case 5:                        // Minute
  316.                                                 printf("Minute:");
  317.                                                 putchar(16);        // Set cursor to the last 2 chars
  318.                                                 putchar(14);
  319.                                                 putchar((MinRTC/10)+48);
  320.                                                 putchar((MinRTC%10)+48);
  321.                                                 break;
  322.                                         case 6:                        // Second
  323.                                                 printf("Second:");
  324.                                                 putchar(16);        // Set cursor to the last 2 chars
  325.                                                 putchar(14);
  326.                                                 putchar((SecRTC/10)+48);
  327.                                                 putchar((SecRTC%10)+48);
  328.                                                 break;
  329.                                         default:
  330.                                                 break;
  331.                                 }        // End SWITCH
  332.                         }                // End if(ParaOld != Para)
  333.                 }                        // End if(KeyCmd != CmdOld)
  334.                 CmdOld = KeyCmd;
  335.                 KeyCmd = KeyScan();
  336.         }                                 // End while(!EndCMD)
  337. //        CmdOld = KeyCmd;
  338. //        putchar(7);                        // Cursor back 1 char
  339. //        putchar(23);                // Cursor blinking
  340. }

  342. void DisplayRTC(void)
  343. {
  344.         putchar(13);
  345.         hour = DP8573HOUR;                // Hour
  346.         timeH = hour >> 4;
  347.         putchar(timeH+48);
  348.         timeL = hour % 16;
  349.         putchar(timeL+48);
  350.         putchar(':');
  351.        
  352.         minute = DP8573MIN;                // Minute
  353.         timeH = minute >> 4;
  354.         putchar(timeH+48);
  355.         timeL = minute % 16;
  356.         putchar(timeL+48);
  357.         putchar(':');

  359.         second = DP8573SEC;                // Second
  360.         timeH = second >> 4;
  361.         putchar(timeH+48);
  362.         timeL = second % 16;
  363.         putchar(timeL+48);

  365.         putchar(' ');
  366.         putchar(' ');
  367.         year = DP8573YEAR;                // Year
  368.         timeH = year >> 4;
  369.         putchar(timeH+48);
  370.         putchar(25);                        // .
  371.         putchar(3);
  372.         timeL = year % 16;
  373.         putchar(timeL+48);

  375.         month = DP8573MONTH;        // Month
  376.         timeH = month >> 4;
  377.         putchar(timeH+48);
  378.         putchar(25);                        // .
  379.         putchar(3);
  380.         timeL = month % 16;
  381.         putchar(timeL+48);

  383.         day = DP8573DAY;                // Day
  384.         timeH = day >> 4;
  385.         putchar(timeH+48);
  386.         timeL = day % 16;
  387.         putchar(timeL+48);

  389.         secondOld = second;
  390.         minuteOld = minute;
  391.         hourOld =  hour;
  392.         yearOld = year;
  393.         monthOld = month;
  394.         dayOld = day;
  395. }

  397. void msTimer(void) interrupt 0 using 0  {
  398.   if (++msCNT == 1)  {        /* 1s */
  399.     Tsecond++;                        /* second counter    */
  400.     msCNT = 0;                        /* clear int counter */
  401.   }
  402. }

  404. main()
  405. {
  406.         UART_Init();
  407.         delay1s();
  408.         delay100ms();
  409.         putchar(15);        // Set VFD brightness
  410.         delay100ms();
  411.         putchar(0x20);        // Lowest brightness to reduce power consumption

  413.         // user-defined char #1: \05 \01; show with \01
  414.         putchar(5); putchar(1);
  415.         // SHI: 02 39 17 EE 45 A2 B1 C8 04 06 00
  416.         putchar(0x02);
  417.         putchar(0x39);
  418.         putchar(0x17);
  419.         putchar(0xEE);
  420.         putchar(0x45);
  421.         putchar(0xA2);
  422.         putchar(0xB1);
  423.         putchar(0xC8);
  424.         putchar(0x04);
  425.         putchar(0x06);
  426.         putchar(0x00);
  427.         // user-defined char #2: \05 \02; show with \02
  428.         putchar(5); putchar(2);
  429.         // JIAN: 40 17 90 4B A5 52 E9 54 BA 43 00
  430.         putchar(0x40);
  431.         putchar(0x17);
  432.         putchar(0x90);
  433.         putchar(0x4B);
  434.         putchar(0xA5);
  435.         putchar(0x52);
  436.         putchar(0xE9);
  437.         putchar(0x54);
  438.         putchar(0xBA);
  439.         putchar(0x43);
  440.         putchar(0x00);
  441.         // user-defined char #3: \05 \03; show with \03
  442.         putchar(5); putchar(3);
  443.         // RI: 00 1F 08 84 43 E1 10 88 7C 00 00
  444.         putchar(0x00);
  445.         putchar(0x1F);
  446.         putchar(0x08);
  447.         putchar(0x84);
  448.         putchar(0x43);
  449.         putchar(0xE1);
  450.         putchar(0x10);
  451.         putchar(0x88);
  452.         putchar(0x7C);
  453.         putchar(0x00);
  454.         putchar(0x00);
  455.         // user-defined char #4: \05 \04; show with \04
  456.         putchar(5); putchar(4);
  457.         // QI: 50 7F 95 4E E7 52 BB F4 AA 55 01 =or= 50 7D D4 AE 77 2A 9F EA A5 95 80
  458.         putchar(0x50);
  459.         putchar(0x7F);
  460.         putchar(0x95);
  461.         putchar(0x4E);
  462.         putchar(0xE7);
  463.         putchar(0x52);
  464.         putchar(0xBB);
  465.         putchar(0xF4);
  466.         putchar(0xAA);
  467.         putchar(0x55);
  468.         putchar(0x01);

  470.         putchar(22);        // Hide cursor
  471.         putchar(13);        // Reset display
  472.         putchar(1);
  473.         putchar(2);
  474.         putchar(':');
  475.         putchar(16);        // Set cursor position
  476.         putchar(11);
  477.         putchar(3);
  478.         putchar(4);
  479.         putchar('-');

  481.         delay1s();
  482.         DP8573A_Init();
  483.         P1 = 0x7F;                // P1: 1DO + 7DI
  484.         delay1s();

  486.         // Used to set RTC
  487. /*        DP8573MSR = 0x40;
  488.         DP8573RTMR = 0x00;
  489.         DP8573MIN = 54;
  490.         DP8573HOUR = 24;
  491.         DP8573DAY = 24;
  492.         DP8573MONTH = 3;
  493.         DP8573YEAR = 7;
  494.         DP8573MSR = 0x40;
  495.         DP8573RTMR = 0x08;
  496. */
  497.         DisplayRTC();
  498.         delay1s();
  499.         delay1s();
  500.         CmdOld = KeyScan();

  502.         while(1)
  503.         {
  504.                 hour = DP8573HOUR;                // Hour
  505.                 if (hour != hourOld) {
  506.                         putchar(16);                // Set cursor position
  507.                         putchar(0);
  508.                         timeH = hour >> 4;
  509.                         putchar(timeH+48);
  510.                         timeL = hour % 16;
  511.                         putchar(timeL+48);
  512.                         putchar(':');
  513.                         hourOld = hour;
  514.                 }
  515.                 minute = DP8573MIN;                // Minute
  516.                 if (minute != minuteOld) {
  517.                         putchar(16);                // Set cursor position
  518.                         putchar(3);
  519.                         timeH = minute >> 4;
  520.                         putchar(timeH+48);
  521.                         timeL = minute % 16;
  522.                         putchar(timeL+48);
  523.                         putchar(':');
  524.                         minuteOld = minute;
  525.                 }
  526.                 second = DP8573SEC;                // Second
  527.                 if (second != secondOld) {
  528.                         putchar(16);                // Set cursor position
  529.                         putchar(6);
  530.                         timeH = second >> 4;
  531.                         putchar(timeH+48);
  532.                         timeL = second % 16;
  533.                         putchar(timeL+48);
  534.                         secondOld = second;
  535.                 }
  536.                 year = DP8573YEAR;
  537.                 if (year != yearOld) {
  538.                         putchar(16);                // Set cursor position
  539.                         putchar(10);
  540.                         timeH = year >> 4;
  541.                         putchar(timeH+48);
  542.                         timeL = year % 16;
  543.                         putchar(timeL+48);
  544.                         yearOld = year;
  545.                 }
  546.                 month = DP8573MONTH;
  547.                 if (month != monthOld) {
  548.                         putchar(16);                // Set cursor position
  549.                         putchar(12);
  550.                         timeH = month >> 4;
  551.                         putchar(timeH+48);
  552.                         timeL = month % 16;
  553.                         putchar(timeL+48);
  554.                         yearOld = year;
  555.                 }
  556.                 day = DP8573DAY;
  557.                 if (day != dayOld) {
  558.                         putchar(16);                // Set cursor position
  559.                         putchar(14);
  560.                         timeH = day >> 4;
  561.                         putchar(timeH+48);
  562.                         timeL = day % 16;
  563.                         putchar(timeL+48);
  564.                         dayOld = day;
  565.                 }

  567.                 KeyCmd = KeyScan();
  568.                 if (KeyCmd == 1) {                // RTC adjustment
  569.                         AdjustRTC();
  570.                         DisplayRTC();
  571.                 }
  572.         }
  573. }
复制代码




计时器, 开关, 日历
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:163578 发表于 2017-2-5 23:12 | 只看该作者
谢谢楼主，最近正好想做这个计时器用于CNC计算稼动率。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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