Return to rtc.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src

Annotation of hatari/src/rtc.c, revision 1.1

1.1     ! root        1: /*
        !             2:   Hatari - rtc.c
        !             3: 
        !             4:   This file is distributed under the GNU Public License, version 2 or at
        !             5:   your option any later version. Read the file gpl.txt for details.
        !             6: 
        !             7:   Mega-ST real time clock.
        !             8:   There is probably a more efficient way to do it, such as using directly a
        !             9:   timer in ram instead of calling localtime for each function. For now it will
        !            10:   show that it works, at least...
        !            11: 
        !            12:   In fact these mappings seems to force the gem to ask the IKBD for the real
        !            13:   time (seconds units). See ikbd.c for the time returned by the IKBD.
        !            14: */
        !            15: static char rcsid[] = "Hatari $Id: rtc.c,v 1.2 2003/06/08 17:12:21 thothy Exp $";
        !            16: 
        !            17: #include <time.h>
        !            18: 
        !            19: #include "main.h"
        !            20: #include "rtc.h"
        !            21: #include "decode.h"
        !            22: 
        !            23: 
        !            24: static BOOL rtc_bank;           /* RTC bank select (0=normal, 1=configuration(?)) */
        !            25: static Sint8 fake_am, fake_amz;
        !            26: 
        !            27: 
        !            28: /*-----------------------------------------------------------------------*/
        !            29: /*
        !            30:   Read seconds units.
        !            31: */
        !            32: void Rtc_SecondsUnits_ReadByte(void)
        !            33: {
        !            34:   struct tm *SystemTime;
        !            35:   time_t nTimeTicks;
        !            36: 
        !            37:   /* Get system time */
        !            38:   nTimeTicks = time(NULL);
        !            39:   SystemTime = localtime(&nTimeTicks);
        !            40:   STRam[0xfffc21] = SystemTime->tm_sec % 10;
        !            41: }
        !            42: 
        !            43: 
        !            44: /*-----------------------------------------------------------------------*/
        !            45: /*
        !            46:   Read seconds tens.
        !            47: */
        !            48: void Rtc_SecondsTens_ReadByte(void)
        !            49: {
        !            50:   struct tm *SystemTime;
        !            51:   time_t nTimeTicks;
        !            52: 
        !            53:   /* Get system time */
        !            54:   nTimeTicks = time(NULL);
        !            55:   SystemTime = localtime(&nTimeTicks);
        !            56:   STRam[0xfffc23] = SystemTime->tm_sec / 10;
        !            57: }
        !            58: 
        !            59: 
        !            60: /*-----------------------------------------------------------------------*/
        !            61: /*
        !            62:   Read minutes units.
        !            63: */
        !            64: void Rtc_MinutesUnits_ReadByte(void)
        !            65: {
        !            66:   if(rtc_bank)
        !            67:   {
        !            68:     STRam[0xfffc25] = fake_am;
        !            69:   }
        !            70:   else
        !            71:   {
        !            72:     struct tm *SystemTime;
        !            73:     time_t nTimeTicks;
        !            74: 
        !            75:     /* Get system time */
        !            76:     nTimeTicks = time(NULL);
        !            77:     SystemTime = localtime(&nTimeTicks);
        !            78:     STRam[0xfffc25] = SystemTime->tm_min % 10;
        !            79:   }
        !            80: }
        !            81: 
        !            82: 
        !            83: /*-----------------------------------------------------------------------*/
        !            84: /*
        !            85:   Write minutes units.
        !            86: */
        !            87: void Rtc_MinutesUnits_WriteByte(void)
        !            88: {
        !            89:   /* TOS 1.0x uses this... */
        !            90:   if(rtc_bank)
        !            91:     fake_am = ((STRam[0xfffc25] & 0x0f) | 0xf0);
        !            92:   /* else ignore */
        !            93: }
        !            94: 
        !            95: 
        !            96: /*-----------------------------------------------------------------------*/
        !            97: /*
        !            98:   Read minutes tens.
        !            99: */
        !           100: void Rtc_MinutesTens_ReadByte(void)
        !           101: {
        !           102:   if(rtc_bank)
        !           103:   {
        !           104:     STRam[0xfffc27] = fake_amz;
        !           105:   }
        !           106:   else
        !           107:   {
        !           108:     struct tm *SystemTime;
        !           109:     time_t nTimeTicks;
        !           110: 
        !           111:     /* Get system time */
        !           112:     nTimeTicks = time(NULL);
        !           113:     SystemTime = localtime(&nTimeTicks);
        !           114:     STRam[0xfffc27] = SystemTime->tm_min / 10;
        !           115:   }
        !           116: }
        !           117: 
        !           118: 
        !           119: /*-----------------------------------------------------------------------*/
        !           120: /*
        !           121:   Write minutes tens.
        !           122: */
        !           123: void Rtc_MinutesTens_WriteByte(void)
        !           124: {
        !           125:   /* TOS 1.0x uses this... */
        !           126:   if(rtc_bank)
        !           127:     fake_amz = ((STRam[0xfffc27] & 0x0f) | 0xf0);
        !           128:   /* else ignore */
        !           129: }
        !           130: 
        !           131: 
        !           132: /*-----------------------------------------------------------------------*/
        !           133: /*
        !           134:   Read hours units.
        !           135: */
        !           136: void Rtc_HoursUnits_ReadByte(void)
        !           137: {
        !           138:   struct tm *SystemTime;
        !           139:   time_t nTimeTicks;
        !           140: 
        !           141:   /* Get system time */
        !           142:   nTimeTicks = time(NULL);
        !           143:   SystemTime = localtime(&nTimeTicks);
        !           144:   STRam[0xfffc29] = SystemTime->tm_hour % 10;
        !           145: }
        !           146: 
        !           147: 
        !           148: /*-----------------------------------------------------------------------*/
        !           149: /*
        !           150:   Read hours tens.
        !           151: */
        !           152: void Rtc_HoursTens_ReadByte(void)
        !           153: {
        !           154:   struct tm *SystemTime;
        !           155:   time_t nTimeTicks;
        !           156: 
        !           157:   /* Get system time */
        !           158:   nTimeTicks = time(NULL);
        !           159:   SystemTime = localtime(&nTimeTicks);
        !           160:   STRam[0xfffc2b] = SystemTime->tm_hour / 10;
        !           161: }
        !           162: 
        !           163: 
        !           164: /*-----------------------------------------------------------------------*/
        !           165: /*
        !           166:   Read weekday.
        !           167: */
        !           168: void Rtc_Weekday_ReadByte(void)
        !           169: {
        !           170:   struct tm *SystemTime;
        !           171:   time_t nTimeTicks;
        !           172: 
        !           173:   /* Get system time */
        !           174:   nTimeTicks = time(NULL);
        !           175:   SystemTime = localtime(&nTimeTicks);
        !           176:   STRam[0xfffc2d] = SystemTime->tm_wday;
        !           177: }
        !           178: 
        !           179: 
        !           180: /*-----------------------------------------------------------------------*/
        !           181: /*
        !           182:   Read day units.
        !           183: */
        !           184: void Rtc_DayUnits_ReadByte(void)
        !           185: {
        !           186:   struct tm *SystemTime;
        !           187:   time_t nTimeTicks;
        !           188: 
        !           189:   /* Get system time */
        !           190:   nTimeTicks = time(NULL);
        !           191:   SystemTime = localtime(&nTimeTicks);
        !           192:   STRam[0xfffc2f] = SystemTime->tm_mday % 10;
        !           193: }
        !           194: 
        !           195: 
        !           196: /*-----------------------------------------------------------------------*/
        !           197: /*
        !           198:   Read day tens.
        !           199: */
        !           200: void Rtc_DayTens_ReadByte(void)
        !           201: {
        !           202:   struct tm *SystemTime;
        !           203:   time_t nTimeTicks;
        !           204: 
        !           205:   /* Get system time */
        !           206:   nTimeTicks = time(NULL);
        !           207:   SystemTime = localtime(&nTimeTicks);
        !           208:   STRam[0xfffc31] = SystemTime->tm_mday / 10;
        !           209: }
        !           210: 
        !           211: 
        !           212: /*-----------------------------------------------------------------------*/
        !           213: /*
        !           214:   Read month units.
        !           215: */
        !           216: void Rtc_MonthUnits_ReadByte(void)
        !           217: {
        !           218:   struct tm *SystemTime;
        !           219:   time_t nTimeTicks;
        !           220: 
        !           221:   /* Get system time */
        !           222:   nTimeTicks = time(NULL);
        !           223:   SystemTime = localtime(&nTimeTicks);
        !           224:   STRam[0xfffc33] = (SystemTime->tm_mon + 1) % 10;
        !           225: }
        !           226: 
        !           227: 
        !           228: /*-----------------------------------------------------------------------*/
        !           229: /*
        !           230:   Read month tens.
        !           231: */
        !           232: void Rtc_MonthTens_ReadByte(void)
        !           233: {
        !           234:   struct tm *SystemTime;
        !           235:   time_t nTimeTicks;
        !           236: 
        !           237:   /* Get system time */
        !           238:   nTimeTicks = time(NULL);
        !           239:   SystemTime = localtime(&nTimeTicks);
        !           240:   STRam[0xfffc35] = (SystemTime->tm_mon + 1) / 10;
        !           241: }
        !           242: 
        !           243: 
        !           244: /*-----------------------------------------------------------------------*/
        !           245: /*
        !           246:   Read year units.
        !           247: */
        !           248: void Rtc_YearUnits_ReadByte(void)
        !           249: {
        !           250:   struct tm *SystemTime;
        !           251:   time_t nTimeTicks;
        !           252: 
        !           253:   /* Get system time */
        !           254:   nTimeTicks = time(NULL);
        !           255:   SystemTime = localtime(&nTimeTicks);
        !           256:   STRam[0xfffc37] = SystemTime->tm_year % 10;
        !           257: }
        !           258: 
        !           259: 
        !           260: /*-----------------------------------------------------------------------*/
        !           261: /*
        !           262:   Read year tens.
        !           263: */
        !           264: void Rtc_YearTens_ReadByte(void)
        !           265: {
        !           266:   struct tm *SystemTime;
        !           267:   time_t nTimeTicks;
        !           268: 
        !           269:   /* Get system time */
        !           270:   nTimeTicks = time(NULL);
        !           271:   SystemTime = localtime(&nTimeTicks);
        !           272:   STRam[0xfffc39] = (SystemTime->tm_year - 80) / 10;
        !           273: }
        !           274: 
        !           275: 
        !           276: /*-----------------------------------------------------------------------*/
        !           277: /*
        !           278:   Read clock mod.
        !           279: */
        !           280: void Rtc_ClockMod_ReadByte(void)
        !           281: {
        !           282:   STRam[0xfffc3b] = ((STRam[0xfffc3b] & 0x0f) | 0xf0);
        !           283: }
        !           284: 
        !           285: 
        !           286: /*-----------------------------------------------------------------------*/
        !           287: /*
        !           288:   Write clock mod.
        !           289: */
        !           290: void Rtc_ClockMod_WriteByte(void)
        !           291: {
        !           292:   rtc_bank = STRam[0xfffc3b] & 1;
        !           293: }
        !           294: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.