Timer based Real Time Clock (RTC)

[jov_damo86]

int32 Ticker;
int8 Seconds=0;

//optional:
// int8 Year=0,Month=0,Days=0,Hours=0,Minutes=0;

////////////////////////////////////////////////////////////////////////////////
// Test whether a given year is a leap year.
// This optimized version only works for the period 2001 - 2099
////////////////////////////////////////////////////////////////////////////////
#define IS_LEAP(year) (year%4 == 0)


////////////////////////////////////////////////////////////////////////////////
// Initialize RTC
////////////////////////////////////////////////////////////////////////////////
void Initialize_RTC(void)
{
Ticker = TIMER1_FREQUENCY; // initialize clock counter to number of clocks per second
setup_timer_1( T1_INTERNAL | T1_DIV_BY_1 ); // initialize 16-bit Timer1 to interrupt
// exactly every 65536 clock cycles
// (about 76 times per second)
enable_interrupts( INT_TIMER1 ); // Start RTC
}

////////////////////////////////////////////////////////////////////////////////
// -=Process Zero Drift Real Time Clock Information=-
//
// Most algorithms configure the timer to generate an interrupt every 100ms, and
// then count the number of interrupts. The problem in that approach is that most
// clock frequencies can't be divided by 256 and you don't get an exact 100ms.
// The small errors will add up to an error of several seconds a day.
//
// The algorithm presented here is exact in the long run because it doesn't
// count the number of interrupts but counts the number of clock cycles.
////////////////////////////////////////////////////////////////////////////////
#int_TIMER1
void TIMER1_isr()
{
Ticker -= 65536; // Decrement ticker by clocks per interrupt
if ( Ticker < 65536 ) // If second has expired
{ Ticker += TIMER1_FREQUENCY; // Increment ticker by clocks per second
seconds++; // Increment number of seconds
}

/* --- Optional part start ---
if(Seconds == 60) {Minutes++; Seconds=0;
if(Minutes == 60) {Hours++; Minutes=0;
if(Hours == 24) {Days++; Hours=0;
if ( (Days == 29 && Month==2 && !IS_LEAP(Year))
|| (Days == 30 && Month==2)
|| (Days == 31 && (Month==4 || Month==6 || Month==9 || Month==11 ))
|| (Days == 32)
) {Month++;Days=0;}
if(Month == 13) {Year++; Month=0;}
}}}
--- Optional part end --- */
}


Wow great! it was very accurate...i tried it! thanks for the code...

But,any code to modified:
int8 Year=0,Month=0,Days=0,Hours=0,Minutes=0;
or seconds using a push button
Thanks in advance!

[nachomanz]

Hi,

Can I use this code to measure milliseconds or microseconds? How can I do it?

Thanks!!

[jov_damo86]

I guess you can modify the program by multiplying the seconds to make into smaller units:

int8 millisecond, microsecond
void TIMER1_isr()
{
Ticker -= 65536; // Decrement ticker by clocks per interrupt
if ( Ticker < 65536 ) // If second has expired
{ Ticker += TIMER1_FREQUENCY; // Increment ticker by clocks per second
seconds++; // Increment number of seconds
millisecond=seconds*1000; //in millisecond
microsecond=seconds*1000000 //in microsecond
}


for the conversion:
1000 millisec=1second
1^6 microsec = 1 second

[LourenceGuo]

I tried this code with 8MHz crystal with PIC16LF873A, it works.
But the when I let the clock work over 12 hours, it is 6seconds faster than my computer, I am not sure if my computer clock is so precise, but is always work well.
I add some function to test the time: a 2*16 LCD display, and a temperature sensor to measure the temperature, three keys to set the time.

And I modified a little in the:
--- Optional part start ---
The begining value for Days and Month can not be 0, so I changed it to 1.

[Neutone]

[LourenceGuo]

Thank you for the reply!

The crystal I used is 8MHz, HC-49S, but the load capacitor and ppm is
not sure. The capacitor I used is pf, there is no resistor in parallel or serial connection with the crystal.
Please kindly help to figure out how to connect the resistor to stablize the crystal, and what is the value ? Because the design we made before is not so critical for the crystal circuit.
And I also will try to use a clear load capacitor and ppm crystal to try the time precision.

The computer I use, I think have battery to hold the time on the mainboard, so the time for computer will never stopped.
Thank you!
_________________
All things are difficult before they are easy.

[hayee]

Hi Everyone,
U guys r really doing well. I have seen ur RTC code and tried it But i have a problem in this. I have add lcd also for display but it is not working properly. When i add this line to the code

[hayee]

Hi Everyone,
I have solved the problem.It was an initializing problem.
Thanx

[sjharris]

I would like to use this code with a 16F877, have made the code and simulated it in Labcenter electronics and it seems to drift -3 minutes in 15 minutes of operation.
So I programmed into a PIC and tried it in circuit but I can't get it to work. Does the 16f877 need an external oscillator on it to make the internal clock work??

TIA
SJHarris

[ckielstra]

A late response but I don't like open questions.

[asmboy]

I did a project over a year ago that required fail safe time keeping no matter what happened to the pic ( watchdog , batt change, powerdown etc) and am much more in favor of using parts like the ST micro M41T94MQ6E, which is a fine 2nd generation+ , free standing RTC clock, with its own 32khz crystal.

It includes extra non volatile ram - so can be used with a family parts to add NV storage and is communicated with using SPI .

my project had to remember the time no matter what happened in restart etc land and also had to be a deterministic design, so no interrupts were used.

I see a lot of crazy bending AND FOLDING of pic code in this post , when a bit of extra HARDWARE - controlled by the PIC can do a MUCH better and more robust job of it . and with a small diode coupled ultracap, can KEEP telling accurate RealTime for many MINUTES - while batteries are changed

if you want REAL time keeping use a REAL time keeping chip ;-))
just my 2 cents

[FvM]

Yes, a hardware RTC is a better solution for a lot of applications. I guess, the other forum members participating in this thread did already know about.

[volcane]

[mutthunaveen]

Thanks for your code..... thank you very much.

Now I am calculating for the drift.

[nukeman]

I'll admit I'm new to PIC programming, but I'm pretty experienced with math in general and I've figured out a way to save a little memory when using this algorithm. I'm sure this isn't generally as much of a concern when using a PIC that has 8k words or more memory, but if you're trying to do a lot of stuff at once with one of the smaller chips, saving every byte you can is very handy.

The basic principle involves first noting that the TIMER1_FREQUENCY value and 65536 can generally be divided by some meaningfully large power of 2. In my particular implementation, TIMER1_FREQUENCY is 1000000, so both values can be divided evenly by 64. This means we're now decrementing Ticker by 1024 each time instead of 65536 and TIMER1_FREQUENCY becomes TIMER1_FREQUENCY_BY_64, or 15625. If we do this, it means we can now declare Ticker as an int16 instead of an int32.

I believe in total this saves at least 2 bytes of RAM and 6 to 8 words of ROM. Of course, it isn't quite as pretty to look at. For anyone who chooses to make this change, I recommend commenting it well enough so you can figure out later what you did. At the very least, comment out anything you change so if you're looking at it later you can figure out what it used to look like.