The friendly computer guide that comes in the box with your VIC 20 mentions several interesting features that the casual reader can easily miss. In my most recent rereading, I discovered the time-keeping feature of the VIC. The computer can keep real clock time, count elapsed time, or time controlled pauses during program execution.
The clock is available as the reserved variables TI and TI$. TI actually counts time passing. TI$ is a string variable, which depicts this time count in HHMMSS format (hours, minutes, and seconds, without any punctuation) on a twenty-four hour clock.
How does the VIC do this timekeeping? When the computer is first turned on, the timekeeper initializes at 000000 (midnight). You can then set it to act as a clock by assigning to TI$ a string representing the correct time. For instance, if I initialize the timekeeper as a clock at 1:29:30 in the afternoon, I would enter the statement:
TI$ = "132930"
The VIC would convert this to 48570 seconds after midnight, multiply by sixty, and assign:
TI = 2914200
and continue counting from there. TI is counted in one-sixtieth second intervals; that is, when TI has increased by sixty, one second has passed. The time count is kept in memory locations 160, 161, and 162.
Once you have set the correct time, you can check it whenever you wish by entering:
and the VIC will display the time, again in HHMMSS format. I like to set TI$ to keep clock time, and check it occasionally, so my wife doesn't have to complain about getting less attention than the computer. The timekeeper can be used in programming to control operations at scheduled times during the day, such as periodic data-collection from an experiment, or to control your lights in a household security program.
To use the VIC to count elapsed time, you cannot start and stop the time counter. To get around this problem, you must run a second variable to count time in parallel with TI, then stop counting with that second variable when the timed period is over. The following program uses the "hit any key" concept to start and stop timing:
100 GET A$ : IF A$ = "" THEN 100 110 TS = TI 120 PRINT "TIMING" 130 TC = TI : GET A$ : IF A$ = ""THEN 130 140 TE = (INT((TC-TS)/6 + 0.5))/10 150 GOSUB 400 : PRINT T$ 160 END 400 REM CONVERTS SECONDS TO HH : MM : SS.S FORMAT 410 H1 = INT (((TE/60/60/24)-(INT(TE/60/60/24)))*24) 420 B1 = STR$(H1) 430 H$ = MID$(B$, 2, 2) : IF H1<10 THEN H$ = "0" + MID$(B$, 2, 1) 440 T3 = TE-(H1 * 60 * 24) 450 M1 = INT(((T3/60/60) - (INT(T3/60/60)))*60) 460 B$ = STR$(M1) 470 M$ = MID$(B$, 2, 2) : IF M1<10 THEN M$ = "0" + MID$(B$, 2, 1) 480 T2 = T3 - (M1*60) 490 S1 = INT(((T2/60)-(INT(TE/60)))*60) 500 B$ = STR$(S1) 510 S$ = MID$(BS, 2, 4) : IF S1<10 THEN S$ = "0" + MID$(B$, 2, 3) 520 T$ = H$ + ":" + M$ + ":" : RETURN
Line 130 converts TE to the elapsed time in seconds and rounds off to the nearest tenth. The subroutine starting at line 400 will convert this to "clock" display, complete with colons in HH:MM:SS.S format, down to tenths of seconds. A simpler approach would use TI$ by assigning to it the elapsed time value and immediately printing it:
140 TE = TC-TS 150 TI = TE : PRINT TI$ : END
You won't want to use this method if you are using TI as a real clock, or if you're relying on the time-keeper to track more than one period at once.
You can use the timekeeper for the scoreboard in a game, either by displaying stopwatch time or TI$, to show time passing, or by calculating time remaining and displaying a countdown timer. The followinng program is a version of the countdown timer.
100 PL = 5 : REM PERIOD LENGTH 5 MINUTES 110 PS = TI : REM PERIOD STARTS NOW 120 PF = PS + PL * 60 : REM PERIOD FINISH TIME 130 TR = PF-TI : REM TIME REMAINING 140 GOSUB 400 150 PRINT "[clr]" T$ 160 IF TI <PF THEN 130 170 END 400 REM CONVERTS SECONDS TO MM : SS FORMAT 440 T3 = INT (TR / 60 + 0.5) 450 M1 = INT(((T3 / 60 / 60) - (INT(T3 / 60 / 60))) * 60) 460 B$ = STR$(M1) 470 M$ = MID$(B$, 2, 2) : IF M1<10 THEN M$ = "0" + MID$(B$, 2, 1) 480 T2 = T3-(M1 * 60)490 S1 = INT(((T2/60) - (INT(TE/60))) * 60) 500 B$ = STR$(S1) 510 S$ = MID$(B$,2,2): IF S1<10 THEN S$ = "0" + MID$(B$,2,1) 520 T$ = MS + ":" + S$: RETURN
The most valuable feature of the timekeeper is the ability to control the length of pauses made during execution, independent of the program lines being executed. The friendly computer guide shows how to make delays by using a FOR ... NEXT loop with the statements:
FOR I = 1 TO 100 : NEXT I
The major problem with this method is that it ties up the whole program while you pause. You can insert program lines for execution during the loop, but then some guesswork and experimenting will be necessary every time you program to obtain the desired pause. Frequently you will have to compromise between the statements you want to execute and the time you can allot to the pause. Finally, if the lines executed during the pause contain the decisions with varying amounts of program to be executed based on the decision, the length of the pause becomes unpredictable.
Getting Control Over Pause
The timekeeper counts independently, on a steady basis, and allows you to assume control of the length of a pause, while permitting other parts of the program to continue. To do this you simply note the time the pause begins and add the desired pause length, giving the time the pause will end. An IF decision watches for the clock to exceed that end time, and you can run other parts of the program while the pause is in progress. The decision watching for the end of the pause must be made with a reasonable frequency, so the number of statements you can execute between repetitions of the end-time decision will depend on how long the pause is and how exact you want the measurement of the pause to be.
As a very conservative rule-of-thumb, allow twenty eighty-character (multiple statement) program lines to reach the end-time decision at an interval of about ten percent of the total pause length. For example, if I pause for about ten seconds, I can allow up to one second, or about twenty program lines. Similarly, a two-second pause will allow up to four program lines between repetitions of the end-time decision. You can use a greater number of lines if they do not contain several statements each.
These time estimates are very rough: do some experimenting yourself to find how many statements you can squeeze in and still get accurate control of the pause length. Once you have established some rules for yourself, they should be useful in all your programming.
As an example of the pause, let's say that I'm writing a game program in which we explore a dungeon. If someone casts a magic spell of darkness, then I want to give no visual clues for the length of the spell–say twenty seconds–while the action of the program continues. The following segment of a program will provide that effect:
100 DEF FN PS(T2) = TI + (T2 * 60) 350 REM THE SPELL IS CAST 360 GOSUB 900 : P1 = FN PS(20) 370 REM P1 = TIME TO END BLACKOUT 380 REM THE 390 REM PROGRAM 400 REM CONTINUES 410 REM RUNNING 420 REM WITH A 430 REM BLACK 440 REM SCREEN 490 REM (UP TO FORTY PROGRAM LINES) 775 IF TI>P1 THEN GOSUB 902 : GOTO 800 780 GOTO 380 800 END 900 POKE 36879,8 : FOR I = 38400 TO 38906 : POKE I,0 : NEXT I 905 RETURN : REM BLACKOUT MAKER 920 POKE 36879,78 : RETURN : REM BLACKOUT LIFTER
This application uses the function PS to relate the desired pause length (T2) to a future time value (P1) which defines the end of the blackout.
Another application of the pause timer can limit how often I may perform an action. I'm writing a game in which the player fires a laser cannon that takes five seconds to recharge before it can be fired again. The line which times the firing interval looks like this:
350 IF PEEK(197) = 35 AND TI>P1 THEN GOSUB 800 : P1 = TI + (5*60) 800 RETURN: REM VISUAL AND SOUND EFFECT FOR LASER FIRING
Here there is no need to worry about running the end-time decision within a set interval – the next time I want to fire the cannon, the logical AND in the decision checks to see if it has recharged. This pause method can also be used in an education program, to limit how soon the student may answer after a question appears, or may try a second time after an incorrect first answer has been entered.
If you're interested in converting existing programs to timekeeper pauses, the statement:
FOR I = 1 TO 100 : NEXT I
is worth about eight counts on the timekeepeer, or 0.13 seconds. There will be some difference between this statement and a longer loop. For instance, modifying the statement to:
FOR I = 1 TO 1000 : NEXT I
This is worth 72 counts, or 1.2 seconds, not the eighty counts one might expect. This is because of the "overhead" time needed to establish the loop during execution. There may even be differences between machines. You can check your own timing with this simple program:
10 BT = TI 20 FOR J = 1 TO 1000 : NEXT J 30 FT = TI 40 ET = FT - BT 50 PRINT ET, ET/60
This displays the time passed in both counts and seconds. Try varying the length of the loop in line 20 to get a general idea of what the "overhead" time is on your computer.
You need to do nothing to the timer to use it as a basis for pauses. However, if you have the VIC on for long periods, or if you set TI$ to keep clock time and run the program near midnight, be careful: if the pause starts before midnight and ends after, you may never reach the end of the pause, since the clock resets to 000000 at midnight. You can put in additional statements to watch for this problem and compensate for it; you can have the program reset the clock to 000000 before timing any pauses; or you can ignore the possibility and hope for the best. The third option, technically unsound as it is, requires the least effort and presents no great threat.
These pause techniques have two important features: controllable pause lengths and the ability to run other, unrelated parts of the program while the pause is in effect. When you develop a program, you can select a length of pause that will not change as you add, change, remove, or relocate program statements. The pause can also be lengthened or shortened to suit your needs, without major changes in the program itself. You have made your pause independent of the program that contains it. At the same time, you can execute lines of an unrelated portion of the program while the pause is in progress, making the program independent of the pause it executes. The timekeeper in the VIC gives the programmer much better control of realism in his game and simulation programs.