PIC16F887 Timer1 and Ultra Sonic Range Measurement Application

Introduction

Additionally to Timer0, PIC16F887 has an 16-bit timer - Timer1. This timer is more advanced than Timer0. It has some additional features over Timer0

• Optional LP oscillator
• Synchronous or asynchronous operation
• Gate mode
• Interrupt on overflow
• Capture/compare function, etc.

x2

x1.5

x1

x0.5

00:00 / 00:00

• Pause
• Unmute
• Fullscreen
• Fluid Player 3.51.0

Block diagram of Timer1

 There are some registers to Timer1.

Registers relate to Timer1

 Timer1 Control Register (T1CON) set the overall operations of Timer1.

Timer1 Control Register (T1CON)

 Timer1 Application of Ultra-Sonic Range Measurement

An application of timer is pulse width measurement of external incoming event. For instance Ultrasonic Ranging Module HC-SR04, is a low cost popular range measurement for electronics hobbyist.

Popular HC-SR04 sample (Ali Express)

This module is a non-contact measuring type of sensor. It uses sounds wave traveling in space, along with its echo signal to get the distance. Measurement ranges from 4cm to 4 meters.

To make its measurement works properly the programmer must check its timing diagram.  

Timing Diagram

 It has a formula to measure range in term of receiving pulse width.

Range = (high level time)*(velocity)/2

Velocity of sound is 340m/s.

In short form we use only high time in us,

Range (in cm) = high level time (in us) / 58 

To get range in Inch,

Range (in inch) = high level time (in us) / 148

Programming in MikroC

System has HC-SR04 as its input. A character LCD output displays sampling range measurement. PIC16F887 controller uses its internal 8MHz oscillator.

Timer1 measure echo signal from HC-SR04 input to RD1. RD1 of PIC16F887 is trigger pin initiating range measurement of sensor. Prescaler is assigned to 1:2 to get a 1us timing.

Schematic Diagram

 MikroC source code:

	sbit LCD_RS at RB4_bit;
	sbit LCD_EN at RB5_bit;
	sbit LCD_D4 at RB0_bit;
	sbit LCD_D5 at RB1_bit;
	sbit LCD_D6 at RB2_bit;
	sbit LCD_D7 at RB3_bit;
	sbit LCD_RS_Direction at TRISB4_bit;
	sbit LCD_EN_Direction at TRISB5_bit;
	sbit LCD_D4_Direction at TRISB0_bit;
	sbit LCD_D5_Direction at TRISB1_bit;
	sbit LCD_D6_Direction at TRISB2_bit;
	sbit LCD_D7_Direction at TRISB3_bit;
	#define TRIG PORTD.RD0 // Trigger Pin is connected to RD0
	#define ECHO PORTD.RD1 // ECHO Pin is connected to RD1
	void main()
	{
	unsigned long Tm;
	char Tl, Th;
	unsigned distance;
	char Txt[7];
	PORTD=0x00;
	TRISD=0x02;
	ANSELH = 0;
	OSCCON|=0x70;
	Lcd_Init();
	Lcd_Cmd(_LCD_CURSOR_OFF);
	Lcd_Out(1,1,"Starting Up.");
	Delay_Ms(2000);
	T1CON=0x10; // select 1:2 Prescaler and Ignore others
	while(1)
	{
	TMR1H = 0;
	TMR1L = 0;
	// initialize the communication
	TRIG = 0;
	Delay_us(5);
	TRIG = 1;
	Delay_us(10);
	TRIG = 0;
	// wait for echo back
	while(ECHO == 0);
	T1CON.TMR1ON=1;
	while(ECHO == 1);
	T1CON.TMR1ON = 0; // sampling
	// end of transmission
	Tl = TMR1L;
	Th = TMR1H;
	Tm = Th*256 + Tl; // making 16-bit value
	Distance=Tm/58;
	IntToStr(Distance, Txt);
	Lcd_Cmd(_LCD_CLEAR);
	Lcd_Out(1,1, "Distance (cm)");
	Lcd_Out(2,1, Txt);
	Delay_Ms(1000);
	}
	}

view raw Program7-6ULTRASONIC.c hosted with ❤ by GitHub

Click here to download its zip file.

PIC16F887 Timer0 Interrupt Driven Display

Introduction

Since timer interrupt runs in background of microcontroller program. We can use this feature to create timing tick activating some tasks.

Multiplexing a display requires an activating time ranging around 5ms for each digit to display properly. More digits require more time in milliseconds. Other remaining tasks in microcontroller program need to wait until display driving finished. Embedded controller program designed using this method is not responsive.

Using timer0 interrupt, a timing tick can activate each digit of multiplexing display regularly. Display timing doesn't consume main program loop timing. Main program just operate other remaining tasks. Any program written using interrupt is flexible.

Simulation sample of this program

Timer0 Interrupt Programming

This example program multiplex a two-digit display using timer0 interrupt timing ticks. Each digit will be activated for 5ms. It's a free running timer that counts up from 0 to 59 seconds before it resets.

Timer0 clock prescaler is assigned to 1:256. Number of ticks per second is 30. Display type is common cathode. We just use an inverting buffer here due to simulation problem.

Schematic Diagram

This controller pulse from its 8MHz internal oscillator.

	#define Ticks_Per_Second 30
	#define RATE 5
	char LED[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
	char interrupt_count;
	char s1,s10;
	void interrupt() {
	if(INTCON.T0IF) interrupt_count++;
	if(interrupt_count==Ticks_Per_Second)
	{ s1++;
	interrupt_count=0;
	if(s1==10) {s10++; s1=0; }
	if(s10==6) s10=0;
	}
	INTCON.T0IF=0;
	}
	void PORT_SETUP() {
	PORTC=0x00; // Clear PORTC
	PORTD=0x00; // Clear PORTD
	TRISD=0x00; // PORTD AS OUTPUT
	TRISC=0x00; // PORTC AS OUTPUT
	}
	void timer_setup() {
	OPTION_REG.T0CS=0; // SELECT INTERNAL SOURCE
	OPTION_REG.PSA=0; // PRESCALER ASSIGNED TO TMR0
	OPTION_REG|=0x07; // SELECT 1:256 PRESCALER
	}
	void interrupt_setup() {
	INTCON.GIE=1; // Enable Global Interrut
	INTCON.T0IE=1; // ENABLE TIMER0 INTERRUPT
	INTCON.T0IF=0; // CLEAR FLAG
	}
	void SSD(){
	PORTC=LED[s10];
	PORTD=0x01;
	delay_ms(RATE);
	PORTD=0x00;
	PORTC=LED[s1];
	PORTD=0x02;
	delay_ms(RATE);
	PORTD=0x00;
	}
	void main() {
	s1=s10=0;
	interrupt_count=0;
	OSCCON|=0x70;
	PORT_SETUP();
	timer_SETUP();
	interrupt_setup();
	while(1) SSD();
	}

view raw Program7-5.c hosted with ❤ by GitHub

Click here to download its source file.

PIC16F887 Timer0 Creating Delay Function in MikroC

Introduction

In previous post of Timer0 interrupt programming, we use its interrupt advantage to create a timer tick in a range of milli second. We can decorate some more features over this capability.

A precise timing delay function can be created using timer0 interrupt programming. In this example we create a delay function from the existing 1ms-delay routine that it was written in previous example. 

Program simulation sample

 

Programming

Delay function created by adding more routine that rely on free running counter in the ISR coding of Timer0 interrupt.

void ms_delay(unsigned count) {
     while(ms_count<count);
      ms_count=0;

}

There is no change in source code but it excepts only one additional routine that handle timing delay. 

Schematic Diagram

Program in MikroC

	#define Ticks_Per_Ms 4
	#define OUTPUT PORTD.RD0
	char counter;
	unsigned ms_count;
	void interrupt() {
	if(INTCON.T0IF) {
	counter++;
	if(counter==Ticks_Per_Ms)
	{ counter=0; ms_count++;}
	}
	INTCON.T0IF=0; // CLEAR INTERRUPT FLAG
	}
	void ms_delay(unsigned count) {
	while(ms_count<count);
	ms_count=0;
	}
	void main() {
	PORTD=0x00; // CLEAR PORTD
	TRISD=0x00; // SET PORTD OUTPUT
	OSCCON|=0x70; // SELECT 8MHz INTRC
	OPTION_REG.T0CS=0; // SELECT INTERNAL SOURCE
	OPTION_REG.PSA=0; // PRESCALER ASSIGNED TO TIMER0
	OPTION_REG&=0xF8; // SELECT 1:2 PRESCALER
	INTCON.GIE=1; // ENABLE GLOBAL INTERRUPT
	INTCON.T0IE=1; // ENABLE TIMER0 OVERFLOW INTERRUPT
	INTCON.T0IF=0; // CLEAR INTERRUPT FLAG
	counter=0;
	ms_count=0;
	TMR0=0; // CLEAR TIMER0
	while(1) {
	OUTPUT=1;
	ms_delay(100);
	OUTPUT=0;
	ms_delay(50);
	}
	}

view raw gistfile1.txt hosted with ❤ by GitHub

Click here to download source file.

 

PIC16F887 Timer0 Interrupt Programming in MikroC

Introduction

Timer0 module is able to trigger interrupt even it's operate in timer or counter mode. It must be enabled and handled in ISR to get full advantage. 

Timer0 interrupt is a thread written in ISR that doesn't need to be polled in main program loop. It's automatically called whenever its interrupt flag is set, then it's executed and automatically return to previous program context.

Timer interrupt is useful for creating a timer tick that schedule tasks in microcontroller program. However we use this advantage to create a simple 1ms timing delay seeing its effect. It's other than an output square wave.

Simulation sample of this programming example

Program Configuration

Main Program

In main program setting up, RD0 of Port D is output pin. It must be configure to output direction in its corresponding TRISD register.

Oscillator is driven from PIC16F887 internal RC oscillator using its maximum 8MHz frequency. 

Timer0 module is selected to operate in timer mode with 1:2 prescaler.

Global interrupt, Timer0 interrupt must be enabled. It's interrupt flag and Timer0 register must be cleared first.

Main program loop stay idle as there's no additional code to handle.

Interrupt Service Routine 

To handle interrupt, targeting interrupt source must be written in interrupt service routine (ISR). Timer0 interrupt flag must be tested first and clear before remaining code.

void interrupt() {
     if(INTCON.T0IF) {
        counter++;
        if(counter==Ticks_Per_Ms)
           { counter=0; OUTPUT^=1; }
           }
     INTCON.T0IF=0;    
}

The void interrupt() is MikroC compiler's reserve keyword used for ISR. It's unique for all interrupt source in Mid-Range PIC16F887 microcontroller.

Creating Timer Tick 

PIC executing speed is,

Fins = (Fosc)/4 = (8MHz)/4 = 2MHz.

Its executing period is,

Tins = 1/(Fins) = 1/(2MHz) =  500ns.

Timer0 pulses at 1:2 rate. It's increment for every,

Ttimer0 = 2 * 500ns = 1us.

Timer0 overflows when,

256 * 1us = 256us.

If it overflows for four time it create a timing tick of about 1ms.

4 * 256us = 1024us. 

MikroC Program

C program lists about is written for this programming example.

	#define Ticks_Per_Ms 4
	#define OUTPUT PORTD.RD0
	char counter=0;
	void interrupt() {
	if(INTCON.T0IF) {
	counter++;
	if(counter==Ticks_Per_Ms)
	{ counter=0; OUTPUT^=1; }
	}
	INTCON.T0IF=0; // CLEAR INTERRUPT FLAG
	}
	void main() {
	PORTD=0x00; // CLEAR PORTD
	TRISD=0x00; // SET PORTD OUTPUT
	OSCCON|=0x70; // SELECT 8MHz Internal Oscillator
	OPTION_REG.T0CS=0; // SELECT INTERNAL SOURCE
	OPTION_REG.PSA=0; // PRESCALER ASSIGNED TO TIMER0
	OPTION_REG&=0xF8; // SELECT 1:2 PRESCALER
	INTCON.GIE=1; // ENABLE GLOBAL INTERRUPT
	INTCON.T0IE=1; // ENABLE TIMER0 OVERFLOW INTERRUPT
	INTCON.T0IF=0; // CLEAR INTERRUPT FLAG
	TMR0=0; // CLEAR TIMER0
	while(1); // WAIT HERE
	}

view raw Program7-3.c hosted with ❤ by GitHub

Click here to download this example.

Diagram lists below is its full schematic.

Schematic diagram

 

PIC16F887 Timer0 in timer mode MikroC

Introduction

As mentioned earlier, Timer0 works in either timer and counter mode. Timer0 Clock Select bit toggle between these two modes. Implementation of timer of a microcontroller has already described in previous post.

In this programming example of using Timer0 module, timer creates a time tick that's a square wave output on a microcontroller digital output pin.

Configuration

Timer0 module of PIC16F887 is configured to operate in timer mode. Prescaler is assigned to WDT to get 1:1 ratio.

Microcontroller clock is its 8MHz internal oscillator. Microcontroller executing speed is,

Finstruction = Fosc/4 = (8MHz)/4 = 2MHz.

Microcontroller instruction executing cycle is,

Tinstruction = 1/2MHz =  500ns.

Input clock pulse is directly drive to Timer0 module. Timer0 overflow time is,

Timer0overflow = 256 * 500ns = 128us.

Each time Timer0 overflow RD0 of Port D toggles, creating an output square wave. The period of square wave is,

Tinterrupt = 2 * 128us = 256us.

Its frequency is,

1 / (256us) = 3906Hz.

Programming for Timer0

This programming example is simulated using Proteus.

Schematic Diagram

 

MikroC program lists below,

#define OUTPUT PORTD.RD0
 
void main() {
     PORTD=0x00;                // CLEAR PORTD
     TRISD=0x00;                 // SET PORTD AS OUTPUT
     OSCCON|=0x70;                 // SELECT INTERNAL OSCILLATOR 8MHz
     OPTION_REG.T0CS=0;           // SELCT INTERNAL SOURCE
     OPTION_REG.PSA=1;       // Prescaler Assigned to WDT
     OPTION_REG&=0xF8 ;      // SELECT 1:1 Prescaler
     TMR0=0;                // CLEAR TIMER0
     while(1)
     if(INTCON.T0IF){
        INTCON.T0IF=0;
        PORTD^=1;
     }
}

Click here to download this programming example.