Electronic – I need help designing a very simple timer

I'd not like to ruin your learning fun BUT if you get a more or complete idea on this project you can move on to more difficult ones.

The circuit below is almost exactly what immediately came to mind for me (I have had lots to do with 4017's in recent years :-) ) and lo and behold somebody has done a very nice job of writing it up.
The 4017 is a decoded "Johnson Counter" (look it up) which provides a sequencing one-of-ten output.
You can cause it to
count up to position N and stop,
or to position N and then reset
or you can chain chain several together
or more ....

A very useful IC.
Datasheet for the basic CMOS version here
and for the buffered 74HC4017 version here.

Note that the "basic" CD4017 has a very special feature which tends to be lacking on all "improved" versions - it has a Schmitt triggered clock input - which means that you can use it with a user pushbutton input or other slow and noisy input. ometimes an immensely valuable feature.

The circuit itself is enough:

Does this do whta you want?. Well, almost.
Look at the enable and reset lines.
Look at the datasheet.
What happens if you plug the enable line into output N?

https://homepages.westminster.org.uk/electronics/images/4017_08.gif

BUT they have done a really superb job of presenting a plug in bread-board version here

Leading to this. You could use one small breadboard and less LEDs and a different oscillator
(eg 555 / 4040 et al etc) but this is an extremely nicely done example

THEN you can consider a zillion alternatives [fromhere] - all images hotlink to a page. Look at he top of the page to see the obvious and extremely useful way that I got this eggtimer circuit collection and this overlapping but not identical egg timer circuit collection (plus some other stuff in each case).

74HC4017 "under the hood":

Clock accuracy:

Try it and see. Use a good quality clock cap- NOT a ceramic.

What if you clocked it twice as fasts and used eg diodes to OR a single LED per 2 outputs?
Or 3 times as fast?

If you want to use a faster clock look at CD4040, CD4020, CD4060. Note that one of these can both divide and self oscillate. You can still have 2 ICs total but a clock and a divider as well. Enjoy.

As you've discovered, handling counter overflow with an interrupt handler is tricky and race-prone. Even with your priority boost, you'll get the wrong answer if interrupts are disabled while you read the counter. There's a much simpler technique which works if you're not reading the clock from interrupt context (note that I'm using the DWT cycle counter here, which is built into the processor thus fast and simple):

uint64_t last_cycle_count_64 = 0;

// Call at least every 2^32 cycles (every 59.6 seconds @ 72 MHz).
// Do not call from interrupt context!
uint64_t GetCycleCount64() {
  last_cycle_count_64 += DWT->CYCCNT - (uint32_t)(last_cycle_count_64);
  return last_cycle_count_64;
}

If you need to call it from interrupt context (or with a preemptive OS):

volatile uint64_t last_cycle_count_64 = 0;

// Call at least every 2^32 cycles (every 59.6 seconds @ 72 MHz).
uint64_t GetCycleCount64() {
  uint32_t primask;
  asm volatile ("mrs %0, PRIMASK" : "=r"(primask));
  asm volatile ("cpsid i");  // Disable interrupts.
  int64_t r = last_cycle_count_64;
  r += DWT->CYCCNT - (uint32_t)(r);
  last_cycle_count_64 = r;
  asm volatile ("msr PRIMASK, %0" : : "r"(primask));  // Restore interrupts.
  return r;
}

You may need to enable the cycle counter first:

DWT->CYCCNT |= DWT_CTRL_CYCCNTENA_Msk;  // Set bit 0.