home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 September / PCWK996.iso / demo / wgelectr / emul51 / examples / time.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-12  |  3.6 KB  |  163 lines
  1. /*****************************************/
  2. /* Time.c demo program for the EMUL51-PC */
  3. /* The program simulates a simple alarm  */
  4. /* clock. The time delay uses timer0     */
  5. /* interrupt and assumes 12Mhz oscillator*/
  6. /*****************************************/
  7.  
  8. /* create Franklin extended symbol file  */
  9. #pragma code symbols debug objectextend
  10.  
  11. /*****************************************/
  12. /* Include register definitions for the  */
  13. /* 8051 and C string functions           */
  14. /*****************************************/
  15.  
  16. #include <reg51.h> 
  17. #include <string.h>
  18. #include <stdio.h>
  19.  
  20. /*****************************************/
  21. /* Definition of global variables        */
  22. /*****************************************/
  23.  
  24. typedef struct {
  25.         unsigned char hour;
  26.         unsigned char min;
  27.         unsigned char sec;
  28.         unsigned char tenth;
  29.         unsigned char hunth;
  30.         } TIME;
  31.  
  32. bit alarmflg = 0, flipflop;
  33. xdata char status [10];
  34. char counter;
  35.  
  36. void maritime_clock ( ) ;
  37. void timer0_delay ( ) ;
  38. void check_alarm ( ) ;
  39.  
  40. /****************************************/
  41. /* Predefined timer values              */
  42. /****************************************/
  43.  
  44. TIME    timer = { 10, 15, 30, 00, 00 };        
  45. TIME    alarmtime = { 10, 17, 00, 00, 00 }; /* 1 1/2 min catnap */
  46.  
  47. /****************************************/
  48. /* Main function                        */
  49. /****************************************/    
  50.  
  51. main()
  52. {
  53.         
  54. /* lets use timer0 in the 8 bit autoreload mode to get our */
  55. /* hundreths of a second interrupt - this could be done    */
  56. /* by counting to 250 forty times or 10,000 cpu cycles     */
  57. /* (assuming 12Mhz clock)                                  */
  58.  
  59.     TH0 = 6; /* auto reload value goes in TH0 */ 
  60.     /* (256-250) as 8051 timers increment and interrupt on overflow */
  61.     counter = 0 ; /* used to count to forty */
  62.  
  63.     IE = 0x82; /* initialize interrupt register to enable timer0 */
  64.     TMOD = 2;  /* setup timer 0 in 8 bit autoreload mode */
  65.     TR0 = 1;   /* start the cycle clock */ 
  66.  
  67.        while(1) {
  68.  
  69.         maritime_clock();
  70.     }
  71. }                
  72.  
  73. /****************************************/    
  74. /* 1/100th sec delay function           */
  75. /****************************************/    
  76.  
  77. void timer0() interrupt 1
  78.  
  79. {
  80.     TF0 = 0 ; /* disable further interrupts */
  81.     
  82.     if (++counter > 39) {
  83.         counter = 0;
  84.         timer.hunth++;
  85.     }
  86.  
  87.     return;        
  88.  
  89. }
  90.  
  91. /****************************************/        
  92. /* Function for incrementing maritime   */
  93. /* (24 hour) clock                      */    
  94. /****************************************/    
  95.  
  96. void maritime_clock ( )
  97.  
  98. {
  99.     /* 100ths second */
  100.  
  101.     if (timer.hunth > 9) {
  102.         timer.hunth = 0;
  103.         timer.tenth++;
  104.         }
  105.     else return;
  106.  
  107.     /* 10ths second */
  108.     
  109.     if (timer.tenth > 9) {
  110.         timer.tenth = 0;
  111.         timer.sec++;
  112.         }
  113.     else return;
  114.  
  115.     /* seconds */
  116.     
  117.     flipflop = !flipflop; /* toggle bit */
  118.  
  119.     if (flipflop) strcpy (status, "TICK");
  120.     else strcpy (status, "TOCK");
  121.     
  122.     if (alarmflg) {
  123.         if (P1 == 255)    P1 = 0;
  124.         else P1 = 255;
  125.         }
  126.     else P1++; /* P1 as binary counter - works well on demo board  */        
  127.  
  128.     if ( timer.sec > 59 ){
  129.         timer.sec = 0;
  130.         timer.min ++;
  131.         }
  132.     else return;
  133.         
  134.     /* Minutes */
  135.     
  136.     if ( timer.min > 59 ){
  137.         timer.min = 0;
  138.         timer.hour ++;
  139.         }
  140.     else {
  141.         check_alarm();
  142.         return;    
  143.         }
  144.         
  145.     /* Hours */
  146.     
  147.     if ( timer.hour > 23 )    timer.hour = 0;
  148.     check_alarm();
  149.     
  150. }    
  151.  
  152. /*****************************************/
  153. /* Function for checking set time        */
  154. /*****************************************/
  155.  
  156. void check_alarm ( void )
  157. {
  158.     if ( ( timer.min == alarmtime.min)
  159.        & ( timer.hour == alarmtime.hour) ) {
  160.        alarmflg = 1;
  161.        strcpy (status,"RINGING");
  162.        }
  163. }