home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / utilities / time / savetime.lha / SaveTime.c next >
Encoding:
C/C++ Source or Header  |  1991-03-04  |  5.5 KB  |  149 lines
  1. /*********************************************
  2. *                                            *
  3. * Programm:  savetime                        *
  4. * Version:   V0.1                            *
  5. * Datum:     30. Mai 1991                    *
  6. *                                            *
  7. * Zweck:     Systemzeit regelmäßig in        *
  8. *            Hardwareuhr speichern           *
  9. *                                            *
  10. * Argumente: Zeit in Minuten (1-9)           *
  11. *            Falls kein Argument: 10 Minuten *
  12. *                                            *
  13. * Autor:     Helmut Kindler                  *
  14. *                                            *
  15. * Compiler:  DICE 2.06.24                    *
  16. * Aufruf:    DCC savetime.c -osavetime -1.3  *
  17. *                                            *
  18. *********************************************/
  19.  
  20.  
  21. #include <time.h>
  22. #include <stdio.h>
  23.  
  24. #define ClockBase   0xDC0000             /* Adresse der Hardwareuhr */
  25. #define ClockCtrl_D 0xDC001a             /* ctrl_D - Register       */
  26.  
  27. static short *clock  = ClockBase;         /* In clock speichern      */
  28. /*     short *ctrl_D = ClockCtrl_D; */    /* Adresse von ctrl_D      */
  29.  
  30. extern struct IntuitionBase *IntuitionBase;   /* Libs */
  31. extern struct DosBase       *DosBase;
  32.  
  33.  
  34. /**********************************
  35. * Hauptprogramm (was denn sonst?) *
  36. **********************************/
  37.  
  38. int main(argc,argv)
  39. int argc;
  40. char *argv[];
  41. {   extern short *clock;
  42.     void   FreezeClock (void);
  43.     void   WarmClock (void);
  44.     void   chkabort (void);
  45.     void   Delay (long ticks);
  46.     void   DisplayBeep (long *screen);
  47.  
  48.     time_t syszeit;
  49.     struct tm *syszeitstr;
  50.  
  51.     short sekunden_e, sekunden_z;        /* Einer (_e) und Zehner (_z), */
  52.     short minuten_e,  minuten_z;         /* wie sie in der Uhr stehen   */
  53.     short stunden_e,  stunden_z;
  54.     short datum_e,    datum_z;
  55.     short monat_e,    monat_z;
  56.     short jahr_e,     jahr_z;
  57.     short wochentag;                     /* sieht so aus als würde der  */
  58.                                          /* vom System nicht abgefargt  */
  59.     long ticks;                          /* Warte soviel 1/50-Sekunden  */
  60.     long mins = 10;                      /* Warte soviel Minuten        */
  61.  
  62.     if( argc > 1 )                                  /* Sogar Argumente! */
  63.         if( *argv[1] >= '1' & *argv[1] <= '9' )     /* Wenn auch nicht  */
  64.             mins = *argv[1] - '0';                  /* ausgefeilt       */
  65.  
  66.     ticks = mins * 60 * CLK_TCK;                   /* berechne die Zeit */
  67.  
  68.     while (1)                                      /* Auf immer und ewig? */
  69.     {
  70.         DisplayBeep (NULL);
  71.         FreezeClock ();                            /* Register einfrieren */
  72.  
  73.         syszeit    = time( NULL );                 /* aktuelle Zeit in    */
  74.         syszeitstr = localtime( &syszeit );        /* Uhrzeit und Datum   */
  75.                                                    /* auflösen            */
  76.         sekunden_e = syszeitstr->tm_sec % 10;      /* Und nun aufbereiten */
  77.         sekunden_z = syszeitstr->tm_sec / 10;
  78.         minuten_e  = syszeitstr->tm_min % 10;
  79.         minuten_z  = syszeitstr->tm_min / 10;
  80.         stunden_e  = syszeitstr->tm_hour % 10;
  81.         stunden_z  = syszeitstr->tm_hour / 10;
  82.         datum_e    = syszeitstr->tm_mday % 10;
  83.         datum_z    = syszeitstr->tm_mday / 10;
  84.         monat_e    = (syszeitstr->tm_mon + 1) % 10; /* Monate gehen in    */
  85.         monat_z    = (syszeitstr->tm_mon + 1) / 10; /* struct tm von 0-11 */
  86.         jahr_e     = syszeitstr->tm_year % 10;
  87.         jahr_z     = syszeitstr->tm_year / 10;
  88.         wochentag  = syszeitstr->tm_wday;
  89.  
  90.         *( clock        ) = sekunden_e ;         /* und jetzt abspeichern */
  91.         *( clock +  0x2 ) = sekunden_z ;
  92.         *( clock +  0x4 ) = minuten_e  ;
  93.         *( clock +  0x6 ) = minuten_z  ;
  94.         *( clock +  0x8 ) = stunden_e  ;
  95.         *( clock +  0xa ) = stunden_z  ;
  96.         *( clock +  0xc ) = datum_e    ;
  97.         *( clock +  0xe ) = datum_z    ;
  98.         *( clock + 0x10 ) = monat_e    ;
  99.         *( clock + 0x12 ) = monat_z    ;
  100.         *( clock + 0x14 ) = jahr_e     ;
  101.         *( clock + 0x16 ) = jahr_z     ;
  102.         *( clock + 0x18 ) = wochentag  ;
  103.  
  104.         WarmClock ();                             /* Register auftauen    */
  105.  
  106.         chkabort ();                              /* Abbruch ?            */
  107.         Delay (ticks);                            /* Nein? Dann warten!   */
  108.     }                                             /* Und von vorn         */
  109. }
  110.  
  111.  
  112.  
  113. /***************************************************
  114. * Anhalten der Register der Hardware-Uhr zum Lesen *
  115. ***************************************************/
  116.  
  117. void FreezeClock( void )
  118. {
  119.     extern short *clock;
  120.     short        *ctrl_D;            /* Control-D-Register       */
  121.  
  122.     /* ctrl_D = 0x00001a + clock; */
  123.     /* ctrl_D = clock + 0x1a; */
  124.     /* ctrl_D = (short *) (clock + 0x1a); */
  125.     ctrl_D = (short *) (0xdc0000 + 0x1a);
  126.     printf ("clock:\t%0x\tctrl_D:\t%0x\t*%0x", clock, ctrl_D, *ctrl_D);
  127.     *ctrl_D = *ctrl_D | 0x5;        /* Hold-, IRQ-Bit setzen    */
  128.     printf ("\t**%0x\n", *ctrl_D);
  129.  
  130.     while ( ( *ctrl_D & 0x2 ) )     /* Warten solange noch Busy */
  131.         puts ("Warte");
  132. }                                   /* und zurück               */
  133.  
  134.  
  135.  
  136. /********************************
  137. * Register weiter laufen lassen *
  138. ********************************/
  139.  
  140. void WarmClock( void )
  141. {
  142.     extern short *clock;
  143.     short        *ctrl_D;            /* Control-D-Register       */
  144.  
  145.     ctrl_D = clock + 0x1a;
  146.     *ctrl_D = *ctrl_D & 0xfffe;  /* Hold-Bit löschen    */
  147. }                                /* und zurück          */
  148.  
  149.