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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 如何根据成型的单片机时钟编写程序？
返回列表 发新帖
查看: 3099|回复: 4
收起左侧

如何根据成型的单片机时钟编写程序？

[复制链接]
ID:154366 发表于 2016-12-28 11:51 | 显示全部楼层 |阅读模式
286黑币
QQ图片20161228114049.jpg

如图，单片机的型号是stc15f204ea，之前在网上买了些零件，将之组装完成后才发现缺少相对应的程序。

请问，如果想要编写出相对应的时钟闹钟程序，需要怎么做？

可以的话，请务必留下详细的回复。

编写程序, 单片机, 如何

相关帖子
回复

使用道具 举报

ID:113208 发表于 2016-12-28 21:02 | 显示全部楼层
这个要有电路图呀！而且你跟他买，他应该会提供程序。
回复

使用道具 举报

ID:7485 发表于 2016-12-28 21:21 | 显示全部楼层
有电路图就可以。要知道按键、显示、蜂鸣器、ds1302各自对应的IO。
回复

使用道具 举报

ID:155507 发表于 2016-12-28 21:21 | 显示全部楼层
相对应的时钟闹钟程序
  1. //
  2. // STC15F204EA DIY LED Clock
  3. //

  5. #include "stc15.h"
  6. #include <stdint.h>
  7. #include <stdio.h>
  8. #include "adc.h"
  9. #include "ds1302.h"
  10. #include "led.h"
  11.    
  12. #define FOSC    11059200

  14. // clear wdt
  15. #define WDT_CLEAR()    (WDT_CONTR |= 1 << 4)

  17. // alias for relay and buzzer outputs, using relay to drive led for indication of main loop status
  18. #define RELAY   P1_4
  19. #define BUZZER  P1_5
  20.    
  21. // adc channels for sensors
  22. #define ADC_LIGHT 6
  23. #define ADC_TEMP  7

  25. // three steps of dimming. Photoresistor adc value is 0-255. Lower values = brighter.
  26. #define DIM_HI  100
  27. #define DIM_LO  190

  29. // button switch aliases
  30. #define SW2     P3_0
  31. #define S2      1
  32. #define SW1     P3_1
  33. #define S1      0

  35. // display mode states
  36. enum keyboard_mode {
  37.     K_NORMAL,
  38.     K_WAIT_S1,
  39.     K_WAIT_S2,
  40.     K_SET_HOUR,
  41.     K_SET_MINUTE,
  42.     K_SET_HOUR_12_24,
  43.     K_SEC_DISP,
  44.     K_TEMP_DISP,
  45.     K_DATE_DISP,
  46.     K_DATE_SWDISP,
  47.     K_SET_MONTH,
  48.     K_SET_DAY,
  49.     K_WEEKDAY_DISP,
  50.     K_DEBUG
  51. };

  53. // display mode states
  54. enum display_mode {
  55.     M_NORMAL,
  56.     M_SET_HOUR_12_24,
  57.     M_SEC_DISP,
  58.     M_TEMP_DISP,
  59.     M_DATE_DISP,
  60.     M_WEEKDAY_DISP,
  61.     M_DEBUG
  62. };

  64. /* ------------------------------------------------------------------------- */

  66. void _delay_ms(uint8_t ms)
  67. {       
  68.     // i,j selected for fosc 11.0592MHz, using oscilloscope
  69.     // the stc-isp tool gives inaccurate values (perhaps for C51 vs sdcc?)
  70.     // max 255 ms
  71.     uint8_t i, j;
  72.     do {
  73.             i = 4;
  74.             j = 240;
  75.             do
  76.             {
  77.                     while (--j);
  78.             } while (--i);
  79.     } while (--ms);
  80. }

  82. // GLOBALS
  83. uint8_t  count;     // was uint16 - 8 seems to be enough
  84. uint16_t temp;      // temperature sensor value
  85. uint8_t  lightval;  // light sensor value

  87. volatile uint8_t displaycounter;
  88. volatile uint8_t _100us_count;
  89. volatile uint8_t _10ms_count;

  91. uint8_t dmode = M_NORMAL;     // display mode state
  92. uint8_t kmode = K_NORMAL;
  93. uint8_t smode,lmode;

  95. volatile __bit  display_colon;         // flash colon
  96. __bit  flash_01;
  97. __bit  flash_23;
  98. __bit  beep = 1;

  100. volatile __bit  S1_LONG;
  101. volatile __bit  S1_PRESSED;
  102. volatile __bit  S2_LONG;
  103. volatile __bit  S2_PRESSED;

  105. volatile uint8_t debounce[2];      // switch debounce buffer
  106. volatile uint8_t switchcount[2];
  107. #define SW_CNTMAX 80

  109. void timer0_isr() __interrupt 1 __using 1
  110. {
  111.     // display refresh ISR
  112.     // cycle thru digits one at a time
  113.     uint8_t digit = displaycounter % 4;

  115.     // turn off all digits, set high   
  116.     P3 |= 0x3C;

  118.     // auto dimming, skip lighting for some cycles
  119.     if (displaycounter % lightval < 4 ) {
  120.         // fill digits
  121.         P2 = dbuf[digit];
  122.         // turn on selected digit, set low
  123.         P3 &= ~(0x4 << digit);  
  124.     }
  125.     displaycounter++;

  127.     //  divider: every 10ms
  128.     if (++_100us_count == 100) {
  129.         _100us_count = 0;
  130.         _10ms_count++;

  132.         // colon blink stuff, 500ms
  133.         if (_10ms_count == 50) {
  134.             display_colon = !display_colon;
  135.             _10ms_count = 0;
  136.         }
  137.             
  138.         // switch read, debounce:
  139.         // increment count if settled closed
  140.         if ((debounce[0]) == 0x00) {
  141.             // down for at least 8 ticks
  142.             S1_PRESSED = 1;
  143.             switchcount[0]++;
  144.         } else {
  145.             // released or bounced, reset state            
  146.             S1_PRESSED = 0;
  147.             switchcount[0] = 0;
  148.         }

  150.         if ((debounce[1]) == 0x00) {
  151.             // down for at least 8 ticks            
  152.             S2_PRESSED = 1;
  153.             switchcount[1]++;
  154.         } else {
  155.             // released or bounced, reset state
  156.             S2_PRESSED = 0;
  157.             switchcount[1] = 0;
  158.         }

  160.         // debouncing stuff
  161.         // keep resetting halfway if held long
  162.         if (switchcount[0] > SW_CNTMAX)
  163.             {switchcount[0] = SW_CNTMAX; S1_LONG=1;}
  164.         if (switchcount[1] > SW_CNTMAX)
  165.             {switchcount[1] = SW_CNTMAX; S2_LONG=1;}

  167.         // read switch positions into sliding 8-bit window
  168.         debounce[0] = (debounce[0] << 1) | SW1;
  169.         debounce[1] = (debounce[1] << 1) | SW2;
  170.     }
  171. }

  173. void Timer0Init(void)                //100us @ 11.0592MHz
  174. {
  175.         TL0 = 0xA4;                //Initial timer value
  176.         TH0 = 0xFF;                //Initial timer value
  177.     TF0 = 0;                //Clear TF0 flag
  178.     TR0 = 1;                //Timer0 start run
  179.     ET0 = 1;        // enable timer0 interrupt
  180.     EA = 1;         // global interrupt enable
  181. }

  183. #define getkeypress(a) a##_PRESSED

  185. int8_t gettemp(uint16_t raw) {
  186.     // formula for ntc adc value to approx C
  187.     return 76 - raw * 64 / 637;
  188. }

  190. /*********************************************/
  191. int main()
  192. {
  193.     // SETUP
  194.     // set photoresistor & ntc pins to open-drain output
  195.     P1M1 |= (1<<6) | (1<<7);
  196.     P1M0 |= (1<<6) | (1<<7);
  197.             
  198.     // init rtc
  199.     ds_init();
  200.     // init/read ram config
  201.     ds_ram_config_init();
  202.    
  203.     // uncomment in order to reset minutes and hours to zero.. Should not need this.
  204.     //ds_reset_clock();   
  205.    
  206.     Timer0Init(); // display refresh & switch read
  207.    
  208.     // LOOP
  209.     while(1)
  210.     {

  212.       RELAY = 0;
  213.       _delay_ms(100);
  214.       RELAY = 1;

  216.       // run every ~1 secs
  217.       if ((count & 3) == 0) {
  218.           lightval = getADCResult8(ADC_LIGHT) >> 3;
  219.           temp = gettemp(getADCResult(ADC_TEMP)) + (config_table[CONFIG_TEMP_BYTE]&CONFIG_TEMP_MASK) - 4;

  221.           // constrain dimming range
  222.           if (lightval < 4)
  223.               lightval = 4;

  225.       }      

  227.       ds_readburst(); // read rtc

  229.       // keyboard decision tree
  230.       switch (kmode) {
  231.          
  232.           case K_SET_HOUR:
  233.               flash_01 = !flash_01;
  234.               if (! flash_01) {
  235.                   if (getkeypress(S2)) ds_hours_incr();
  236.                   if (getkeypress(S1)) kmode = K_SET_MINUTE;
  237.               }
  238.               break;
  239.               
  240.           case K_SET_MINUTE:
  241.               flash_01 = 0;
  242.               flash_23 = !flash_23;
  243.               if (! flash_23) {
  244.                   if (getkeypress(S2)) ds_minutes_incr();
  245.                   if (getkeypress(S1)) kmode = K_SET_HOUR_12_24;
  246.               }
  247.               break;

  249.           case K_SET_HOUR_12_24:
  250.               dmode=M_SET_HOUR_12_24;
  251.               if (getkeypress(S2)) ds_hours_12_24_toggle();
  252.               if (getkeypress(S1)) kmode = K_NORMAL;
  253.               break;
  254.               
  255.           case K_TEMP_DISP:
  256.               dmode=M_TEMP_DISP;
  257.               if (getkeypress(S1))
  258.                   { uint8_t offset=config_table[CONFIG_TEMP_BYTE]&CONFIG_TEMP_MASK;
  259.                     offset++; offset&=CONFIG_TEMP_MASK;
  260.                     config_table[CONFIG_TEMP_BYTE]=(config_table[CONFIG_TEMP_BYTE]&~CONFIG_TEMP_MASK)|offset;
  261.                   }
  262.               if (getkeypress(S2)) kmode = K_DATE_DISP;
  263.               break;
  264.                         
  265.           case K_DATE_DISP:
  266.               dmode=M_DATE_DISP;
  267.               if (getkeypress(S1)) {kmode=K_WAIT_S1; lmode=CONF_SW_MMDD?K_SET_DAY:K_SET_MONTH; smode=K_DATE_SWDISP; }
  268.               if (getkeypress(S2)) kmode = K_WEEKDAY_DISP;                        
  269.               break;

  271.           case K_DATE_SWDISP:
  272.               CONF_SW_MMDD=!CONF_SW_MMDD;
  273.               kmode=K_DATE_DISP;
  274.               break;
  275.               
  276.           case K_SET_MONTH:
  277.               flash_01 = !flash_01;
  278.               if (! flash_01) {
  279.                   if (getkeypress(S2)) { ds_month_incr(); }
  280.                   if (getkeypress(S1)) { flash_01 = 0; kmode = CONF_SW_MMDD?K_DATE_DISP:K_SET_DAY; }
  281.               }
  282.               break;
  283.               
  284.           case K_SET_DAY:
  285.               flash_23 = !flash_23;
  286.               if (! flash_23) {
  287.                   if (getkeypress(S2)) { ds_day_incr(); }
  288.                   if (getkeypress(S1)) { flash_23 = 0; kmode = CONF_SW_MMDD?K_SET_MONTH:K_DATE_DISP;
  289.                   }
  290.               }
  291.               break;
  292.               
  293.           case K_WEEKDAY_DISP:
  294.               dmode=M_WEEKDAY_DISP;
  295.               if (getkeypress(S1)) ds_weekday_incr();
  296.               if (getkeypress(S2)) kmode = K_NORMAL;
  297.               break;
  298.          
  299.           case K_DEBUG:
  300.               dmode=M_DEBUG;
  301.               if (count>100) kmode = K_NORMAL;
  302.               if (S1_PRESSED||S2_PRESSED) count=0;
  303.               break;

  305.           case K_SEC_DISP:
  306.               dmode=M_SEC_DISP;
  307.               if (getkeypress(S1) || (count>100)) { kmode = K_NORMAL; }
  308.               if (getkeypress(S2)) { ds_sec_zero(); }
  309.               break;

  311.           case K_WAIT_S1:
  312.               count=0;
  313.               if (!S1_PRESSED) {
  314.                if (S1_LONG) {S1_LONG=0; kmode=lmode;}
  315.                       else  {kmode=smode;}
  316.                }
  317.               break;

  319.           case K_WAIT_S2:
  320.               count=0;
  321.               if (!S2_PRESSED) {
  322.                if (S2_LONG) {S2_LONG=0; kmode=lmode;}
  323.                       else  {kmode=smode;}
  324.                }
  325.               break;

  327.           case K_NORMAL:         
  328.           default:
  329.               flash_01 = 0;
  330.               flash_23 = 0;

  332.               dmode=M_NORMAL;

  334.               if (S1_PRESSED) { kmode = K_WAIT_S1; lmode=K_SET_HOUR; smode=K_SEC_DISP;  }
  335.               //if (S2_PRESSED) { kmode = K_WAIT_S2; lmode=K_DEBUG;    smode=K_TEMP_DISP; }
  336.               if (S2_PRESSED) { kmode = K_TEMP_DISP; }
  337.       
  338.       };

  340.       // display execution tree
  341.      
  342.       clearTmpDisplay();

  344.       switch (dmode) {
  345.           case M_NORMAL:
  346.               if (flash_01) {
  347.                   dotdisplay(1,display_colon);
  348.               } else {
  349.                   if (!H12_24) {
  350.                       filldisplay( 0, (rtc_table[DS_ADDR_HOUR]>>4)&(DS_MASK_HOUR24_TENS>>4), 0);        // tenhour
  351.                   } else {
  352.                       if (H12_TH) filldisplay( 0, 1, 0);        // tenhour in case AMPM mode is on, then '1' only is H12_TH is on
  353.                   }                  
  354.                   filldisplay( 1, rtc_table[DS_ADDR_HOUR]&DS_MASK_HOUR_UNITS, display_colon);      
  355.               }
  356.   
  357.               if (flash_23) {
  358.                   dotdisplay(2,display_colon);
  359.                   dotdisplay(3,H12_24&H12_PM);        // dot3 if AMPM mode and PM=1
  360.               } else {
  361.                   filldisplay( 2, (rtc_table[DS_ADDR_MINUTES]>>4)&(DS_MASK_MINUTES_TENS>>4), display_colon);        //tenmin
  362.                   filldisplay( 3, rtc_table[DS_ADDR_MINUTES]&DS_MASK_MINUTES_UNITS, H12_24 & H12_PM);                  //min
  363.               }
  364.               break;

  366.           case M_SET_HOUR_12_24:
  367.               if (!H12_24) {
  368.                   filldisplay( 1, 2, 0); filldisplay( 2, 4, 0);
  369.               } else {
  370.                   filldisplay( 1, 1, 0); filldisplay( 2, 2, 0);                  
  371.               }
  372.               filldisplay( 3, LED_h, 0);
  373.               break;

  375.           case M_SEC_DISP:
  376.               dotdisplay(0,display_colon);
  377.               dotdisplay(1,display_colon);
  378.               filldisplay(2,(rtc_table[DS_ADDR_SECONDS]>>4)&(DS_MASK_SECONDS_TENS>>4),0);
  379.               filldisplay(3,rtc_table[DS_ADDR_SECONDS]&DS_MASK_SECONDS_UNITS,0);
  380.               break;
  381.               
  382.           case M_DATE_DISP:
  383.               if (flash_01) {
  384.                   dotdisplay(1,1);
  385.               } else {
  386.                  if (!CONF_SW_MMDD) {
  387.                   filldisplay( 0, rtc_table[DS_ADDR_MONTH]>>4, 0);        // tenmonth ( &MASK_TENS useless, as MSB bits are read as '0')
  388.                   filldisplay( 1, rtc_table[DS_ADDR_MONTH]&DS_MASK_MONTH_UNITS, 1); }         
  389.                  else {
  390.                   filldisplay( 2, rtc_table[DS_ADDR_MONTH]>>4, 0);        // tenmonth ( &MASK_TENS useless, as MSB bits are read as '0')
  391.                   filldisplay( 3, rtc_table[DS_ADDR_MONTH]&DS_MASK_MONTH_UNITS, 0); }         
  392.               }
  393.               if (!flash_23) {
  394.                  if (!CONF_SW_MMDD) {
  395.                   filldisplay( 2, rtc_table[DS_ADDR_DAY]>>4, 0);                      // tenday   ( &MASK_TENS useless)
  396.                   filldisplay( 3, rtc_table[DS_ADDR_DAY]&DS_MASK_DAY_UNITS, 0); }     // day      
  397.                  else {
  398.                   filldisplay( 0, rtc_table[DS_ADDR_DAY]>>4, 0);                      // tenday   ( &MASK_TENS useless)
  399.                   filldisplay( 1, rtc_table[DS_ADDR_DAY]&DS_MASK_DAY_UNITS, 1); }     // day      
  400.               }     
  401.               break;
  402.                   
  403.           case M_WEEKDAY_DISP:
  404.               filldisplay( 1, LED_DASH, 0);
  405.               filldisplay( 2, rtc_table[DS_ADDR_WEEKDAY], 0);                //weekday ( &MASK_UNITS useless, all MSBs are '0')
  406.               filldisplay( 3, LED_DASH, 0);
  407.               break;
  408.               
  409.           case M_TEMP_DISP:
  410.               filldisplay( 0, ds_int2bcd_tens(temp), 0);
  411.               filldisplay( 1, ds_int2bcd_ones(temp), 0);
  412.               filldisplay( 2, CONF_C_F ? LED_f : LED_c, 1);
  413.               // if (temp<0) filldisplay( 3, LED_DASH, 0);  -- temp defined as uint16, cannot be <0
  414.               break;                  

  416.           case M_DEBUG:
  417.               filldisplay( 0, switchcount[0]>>4, S1_LONG);
  418.               filldisplay( 1, switchcount[0]&15, S1_PRESSED);
  419.               filldisplay( 2, switchcount[1]>>4, S2_LONG);
  420.               filldisplay( 3, switchcount[1]&15, S2_PRESSED);
  421.               break;
  422.       }

  424.       __critical { updateTmpDisplay(); }
  425.                   
  426.       // save ram config
  427.       ds_ram_config_write();
  428.       
  429.       if (S1_PRESSED || S2_PRESSED && ! (S1_LONG || S2_LONG)) {
  430.           // try to dampen button over-response
  431.           _delay_ms(100);
  432.       }

  434.       // reset long presses when button released
  435.       if (! S1_PRESSED && S1_LONG) {
  436.           S1_LONG = 0;
  437.       }
  438.       if (! S2_PRESSED && S2_LONG) {
  439.           S2_LONG = 0;
  440.       }
  441.         
  442.       count++;
  443.       WDT_CLEAR();
  444.     }
  445. }
  446. /* ------------------------------------------------------------------------- */
复制代码


https://github.com/zerog2k/stc_diyclock
回复

使用道具 举报

ID:158248 发表于 2016-12-28 23:09 | 显示全部楼层
这个得根据电路来写程序，你可以用已有的原件设计电路，再编写程序。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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