Creating a second-counter in C for Gameboy - c

Question

So I am new to C and have been assigned the task of making a game. I'll be using a Gameboy emulator and have been discouraged from importing any libraries beyond the basics.
I would like to come up with a way to run a second-counter (that will display on screen,) but unable to use the time.h library, I feel a bit stuck.
Is there anyway I could go about doing this?
I was told that Gameboy runs rather slow, and if I could get it caught in a 'busy loop' I could 'approximate a second' and count that way.
I've considered the sleep function to do this, but that's in unistd.h library.
I've also considered perhaps setting up a loop and counting up to 10 thousand (or whatever number may take a second to calculate,) but all of this will be happening simultaneously to the game at hand, and I am afraid things like that will delay the gameplay and other things happening.
Any recommendations?
Edit: I think anything beyond stdlib.h and stdio.h is disallowed.

Answer 1

The gameboy has a hardware timer.
Sometimes it's useful to have a timer that interrupts
at regular intervals for routines that require
periodic or percise updates. The timer in the GameBoy
has a selectable frequency of 4096, 16384, 65536, or
262144 Hertz. This frequency increments the Timer
Counter (TIMA). When it overflows, it generates an
interrupt. It is then loaded with the contents of
Timer Modulo (TMA). The following are examples:
;This interval timer interrupts 4096 times per second
ld a,-1
ld ($FF06),a ;Set TMA to divide clock by 1
ld a,4
ld ($FF07),a ;Set clock to 4096 Hertz
So write your interrupt handler to keep track of the number of interrupts and update the displayed clock every 4096 (=0x1000) interrupts.

Answer 2

Implementations of some (not all) delay functions are blocking, (nothing else in code runs until delay function returns. Also are susceptible to run-time options such as whether in debug or release mode of execution, etc. (i.e. will run at inconsistent times depending on these modes)
an implementation that is not blocking, i.e. that during the delay, system events are given time-slices to continue would likely require use of multi-threading. But since C is not intrinsically a multithreaded language, you would have to use additional non-standard C libs that you are not allowed to use.
Given you understand this, and would be OK with a simple technique (i.e. blocking, with susceptibility to execution mode), then just use a simple time loop. Follow these steps:
1) create a development (test) function that is simply a for loop with a hard-coded index value:
void sec_delay(void)
{
//loop incrementer value
int i = 334000000;//change value here during testing to adjust duration of calling
//test program. eg: for 60 calls, should elapse 60 seconds.
//this value run on PC shown below provided 1 second duration.
while(i-- > 0);
}
2) characterize sec_delay
Run a program that calls sec delay 60 times and time its execution against a clock or stopwatch.
void sec_delay(void);
int main(void)
{
int i;
for(i=0;i<60;i++)//target 60 seconds, change to 600 for 10 min. or 10 for 10 sec.
{
sec_delay();
}
printf("Done");//uses stdio.h
getchar(); //uses stdio.h
return 0;
}
3) Use the execution time for this executable to adjust the loop incrementer value so you can be as close to 1 minute as possible. For higher accuracy, loop the main program 600 times and map the incrementer in sec_loop so that time elapsed is 10 minutes.
Once you have characterized the sec_delay() function as described, you essentially have something you can use for a 1 second timer.
4) Now that you have a a value for 1 second elaplse time, create a new prototype:
void delay(float);
And create a #define:
#define SEC 334000000.0 //enter your value here in float
Finally, define delay() function:
void delay(float secs)//note, fractions of seconds can be called
{
if(secs < 0) break;//leave for negative values;
int i = (int)secs*SEC ;
while(i-- > 0);
}