Hello,

I have got the following problem. I am using a ST7FLIT19B microcontroller. I would like to use the lite timer of the controller for a system clock. To do this I defined a time structure similar to the timeval structure:

typedef struct stTimeSpec
{
  UINT32    tv_sec;      // seconds since last reboot
  UINT16    tv_msec;   // milliseconds since last reboot
} stTimeSpec_t;

I then defined a global variable volatile stTimeSpec_t systemTimeGlob; which I increment in the timer interrupt routine of the lite timer once every millisecond.

To guarantee the consistency of the time structure for any given access, I would like to restrict access by any function other than the timer interrupt through a time_get function. This time_get function copies the value of the global structure to an address supplied and protects this memcopy by disabling the timer interrupt before starting the copy and enabling it again after the copy is done.

void get_time(stTimeSpec_t *currentSystemTimePtr)
{
  TB1IE = 0; // Disable Timebase interrupt
  memcpy(currentSystemTimePtr, &systemTimeGlob, sizeof(systemTimeGlob));
  TB1IE = 1; // Enable Timebase interrupt
}

In order to do this, I would like to selectively disable the timer interrupt for the Lite Timer by clearing the TB1IE bit in the LTCSR1 register of the controller and then enable it again by setting the bit after the memcopy is done. When I try this approach however, I am losing a millisecond from time to time.

My first approach was to clear and set the bit by accessing the byte-address of the register and just using a bitmask for the TB1IE bit. This made me lose lots of timer interrupts, often several in a row. After reading the documentation a second time, I guess this was due to the fact, that accessing the LTCSR1 register this way cleared the TB1F flag and therefore a timer counter overflow occurring during the memcopy would get lost.

The second approach now is to directly address the bit in the register, using the directive at 0x5B hbit TB1IE ; and then just setting TB1IE to 0 or 1 (as seen in the code example for get_time above). What I would expect to happen with this is, that the TB1F flag would be preserved when enabling the interrupt after the memcopy and then immediately getting a timer interrupt if a timer counter overflow occurred during the memcopy, therefore not losing any timer interrupts at all. Unfortunately for some reason I am still losing a millisecond now and then.

The only way I was able to lock the interrupts for the memcopy and not lose any timer interrupts at all was to use the _rim_(); and _sim_(); instructions, therefore locking all interrupts for the time of the copy operation (which is not a good idea and which I would like to avoid).

Can you explain to me, why this is happening and if there is any way to prevent this while still being able to deactivate the timer interrupt during the memcopy? Do you have any suggestions how I could accomplish what I have in mind, or is it just not possible with the controller I am using?

Thanks for your help,
Stephan