void interrupt Timer0_ISR(void)
{
if (T0IE && T0IF)    //are TMR0 interrupts enabled and
//is the TMR0 interrupt flag set?
{
T0IF=0;                      //TMR0 interrupt flag must be cleared in software
//to allow subsequent interrupts
++counter;                 //increment the counter variable by 1
}

void interrupt Timer0_ISR(void)
{
if (T0IE && T0IF)    //are TMR0 interrupts enabled and
//is the TMR0 interrupt flag set?
{
T0IF=0;                      //TMR0 interrupt flag must be cleared in software
//to allow subsequent interrupts
++counter;                 //increment the counter variable by 1
}
}
مثال لبرنامج بسيط :
unsigned char counter;         //counter variable to count
//the number of TMR0 overflows
/*----------------------------------------------------------
Subroutine: Timer0_ISR
Parameters: none
Returns: nothing
This is the Interrupt Service Routine for
Timer0 overflow interrupts. On TMR0 overflow
the counter variable is incremented by 1
----------------------------------------------------------*/
void interrupt Timer0_ISR(void)
{
if (T0IE && T0IF)                //are TMR0 interrupts enabled and
//is the TMR0 interrupt flag set?
{
T0IF=0;                      //TMR0 interrupt flag must be
//cleared in software
//to allow subsequent interrupts
++counter;                 //increment the counter variable
//by 1
}
}

/*PIC16F877A
1sec timer using TIMER0
Oscillator * 4MHz
*/
// Define LED connection
sbit LED at RB0_bit;
unsigned short Num;// overflow counter 0 .. 18

// Interrupt service routine
void interrupt(){
Num ++;                   // Interrupt causes Num to be incremented by 1
if(Num == 18){         // after 1 sec period
LED = ~LED;         // Toggle LED every sec
Num = 0;                 //clear again
}
TMR0 = 39;             // TMR0 returns to its initial value
INTCON.T0IF = 0; // Bit T0IF is cleared so that the interrupt could reoccur
}

void main() {
TRISB = 0b00000000; // PORTB All Outputs
LED = 0;
Num = 0; // begin 
OPTION_REG = 0x07;       // Prescaler (1:256) is assigned to the timer TMR0
TMR0 = 39;                          // Timer T0 counts from 39 to 255
INTCON = 0xA0;                // Enable interrupt TMR0 and Global Interrupts
do {
 // You main programs goes here
} while(1);                              // infinite loop
}

/*
Timer0 as a counter
Oscillator * 4MHz */

 
// LCD module connections
sbit LCD_RS at RB2_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connections
 
// Define Messages
char message1[] = "Frequency=   Hz";
char *freq = "00";
 
 
void Display_Freq(unsigned int freq2write) {
freq[0] = (freq2write/10)%10 + 48;   // Extract tens digit-add 48 >> change to ASCII 
freq[1] =  freq2write%10     + 48;     // Extract ones digit add 48 >> change to ASCII 
// Display Frequency on LCD
Lcd_Out(1, 11, freq);
}
 
void main() {
 
TRISB = 0; // PORTB All Outputs
TRISA = 0XFF; // INPUTS 
 
OPTION_REG = 0b00101000; // Prescaler (1:1), TOCS =1 for counter mode
 
Lcd_Init();                 // Initialize LCD
Lcd_Cmd(_LCD_CLEAR);     // CLEAR display
Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off
Lcd_Out(1,1,message1);      // Write message1 in 1st row
do {
 
TMR0=0;
Delay_ms(1000);  // Delay 1 Sec TIMER0 COUNT=Hz
 
Display_Freq(TMR0);
 
} while(1);  // Infinite loop
}

//STEP 1 Comments
/*Name : LED & SOUNDER
PICMICRO : PIC16F877A
 */
// STEP 2: definitions
#define TEMP_LED 250                 // Constant value , 250 ,defined as "TEMP_LED .   
#define LED PORTD.B0 //LED at pin RD0=PORTD.B0 defined as "LED" '
#define BUZZER PORTD.B1         //SOUNDER at pin RD1 = PORTD.B1 defined as "BUZZER" .
#define T0IF INTCON.T0IF           //Timer0 Interrupt Flag Bit INTCON.F0IF defined as "T0IF"

// STEP 3 : Variable decleraion
unsigned char TimerLed = 0;
/*Variable : Char data type is an 8-bit so it can get to hold values up to 255
     we need a maximum of 250,TEMP_LED , so it's fine */

//STEP 4 : Setting Function , Others
void settings ( void )                           // Setting Function
{
//PORTS Setting
TRISD = 0 ;                         // PORTD as outputs
// Setting the OPTION register
OPTION_reg = 0b11000100;
// bit 0 -> Prescaler Rate Select bit 0  >0
// bit 1 -> Prescaler Rate Select bit 0  >0
// bit 2 -> Prescaler Rate Select bit 0  >1  (3 bits 100= 1:32)
// bit 3 -> Prescaler assigned to Timer0 >0
// bit 4 -> It does not matter  >0
// bit 5 -> Timer0 Clock derived from internal clock cycle >0
// bit 6 -> It does not matter >1
// bit 7 -> pull-up resistors on port B disabled >1

// Set interrupt
INTCON = 0b10100000;
// bit 0 -> RBIF - Flag of interrupt ports B   >0
// bit 1 -> INTF - Interrupt Flag of RB0/INT  >0
// bit 2 -> T0IF - on Timer0 interrupt flag  >0
// bit 3 -> RBIE, Interrupt on Port B disabled  >0
// bit 4 -> INTE, Interrupt port RB0/INT disabled >0
// bit 5 -> TMR0IE, Interrupt on Timer0 enabled    >1
// bit 6 -> PEIE, interrupt device disabled  >0
// bit 7 -> GIE, Management Interrupt active       >1

TMR0 = 100 ;  // Set Timer0 to 100 , as initial value
}

//step 5 : main function
void main ( )
{
settings ( ) ;                        // Run Setting Function for ports and registers
while ( 1 )                           // run a loop
{

/*The only thing that I do during this endless cycle,
is the reversal of the state of BUZZER each 200 micro-sec
in order to generate a square wave of 2.5 KHz,
which applied at the buzzer, 
in fact, causing it to emit a note at that frequency*/

Delay_us ( 200);
BUZZER = 1;
Delay_us ( 200);
BUZZER = 0;
}//end loop
}  // end main

// STEP 6 : Interrupt Routine Service IRS
/* This routine, having the attribute "interrupt" 
which called automatically whenever an interrupt occurs. 
in this routine , Timer0 will generate an interrupt every millisecond */ 

void interrupt (  )
{
if( T0IF )                                            // Interrupt was caused by an overflow of Timer0?
{
TMR0 =  100 ;                               // Timer0 reloaded
TimerLed ++;                                // Increment the timer for the blinking LED
if( TimerLed >= TEMP_LED )  // If the time has passed TEMP_LED=250
{
LED = LED^1 ;                         // Invert LED status to flash .
TimerLed = 0 ;                           // Reloading the LED timer to start again
}
T0IF = 0 ;                                       // Reset the interrupt flag of timer 0
}  // end that occurred on Timer0 interrupt
}                                                                // end of interrupt service routine