Saeed's Blog

Follow Me

2022-07-02T19:18:00.003+05:00

Follow me on Facebook,

Electronic Beans

Follow me on Instagram,

https://www.instagram.com/sylabofficial/

Follow me on Twitter,
Follow @MSaeedYasin

Some of my tweets,
Tweets by MSaeedYasin

PIC16F877A based controllable digital clock using LCD display (Code+Proteus simulation)

2016-01-30T20:50:00.000+05:00

This PIC16F877A microcontroller tutorial answers the question,
" How to implement a controllable digital clock using PIC16F877A ? "

Using PIC16 simulator (Proteus) you can verify this digital clock code and change it according to your needs. Using three push buttons (As shown in figure below) you can adjust time as you desire. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

In this article, it is assumed that you know,

How to make a simple digital clock using PIC16F877A. If you don't then please read this page.
How to interface LCD with PIC16F877A microcontroller. If you don't then please read this page.
How to configure timer0 of PIC16F877A microcontroller. If you don't then please read this page.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A based controllable clock circuit

The above figure was taken after setting time to 03:59:38, timer0 is used as the base for digital clock generation. Timer0 is used here to generate 1msec interrupts. After every 1msec a global variable named msCounter increments. When msCounter reaches a value of 1000 then another global variable named secCounter increments and this process repeats itself. Similarly, when secCounter reaches 60, then minCounter increments. And when minCounter reaches 60 then hrCounter increments. This process continues until hrCounter reaches 24 then all of these variables reset their values. LCD is updated with the new values of hrCounter, minCounter and secCounter after every second.

You can set time using three push buttons attached on RE0, RE1 and RE2 pins (As shown in the above figure). By pressing 'Set Time' button one time, code enters in configuration state. Hours value starts to blink and you can modify it using Up and Down buttons. Pressing Up button increments the value and pressing Down button decrements the value. When you are done setting Hours value, press 'Set Time' button again, then Minutes value will start to blink and you can adjust this value using Up and Down buttons. Similarly, after setting Minutes value, you can press 'Set Time' button again, then Seconds value will start to blink and you can adjust this value using Up and Down buttons. When you are done adjusting the time, then press 'Set Time' button for the last time and this clock will start to work normally.

A crystal of 4MHz value is used in this circuit, which makes this PIC16F877A run at a speed of 1MIPS (Million of instructions per second).

Code

The main function code is shown below.

Figure 2. Main function code for digital clock on PIC16F877A

In the main function, firstly PORTE pins are made input and ADC is turned off on these pins. Then LCD is initialized using InitLCD() function. Then Timer0 is initialized to generate 1msec interrupts.

After that, in the while(1) loop, there is a state machine running. A variable named State is used to keep track of the current state of the clock. When this code starts, then State has a value of NORMAL_STATE. In the normal state, clock value is incremented after every second and whenever msCounter reaches a value of zero^[1], then new values of hrCounter, minCounter and secCounter are updated on the LCD. UpdateTimeCounters() function is called every time and it corrects the values of every counter variable depending upon the value of msCounter, which is incremented in the ISR function of timer0.

In the normal state, code keeps checking RE0 pin value, if 'Set Time' button is pressed then RE0 pin value becomes zero. This is detected using if(!RE0) statement in the code. When 'Set Time' button is pressed then state is changed to 'CONFIG_HR_STATE' (i-e configure hours value state). In this state, Up and Down buttons are constantly monitored and hrCounter value can be adjusted. Similarly, by pressing 'Set Time' button again, state is changed to 'CONFIG_MIN_STATE' (i-e configure minutes value state). In this state minCounter value can be adjusted using Up and Down buttons and by pressing 'Set Time' button again, state is changed to 'CONFIG_SEC_STATE' (i-e configure seconds value state). In this state secCounter value can be adjusted using Up and Down buttons. By pressing 'Set Time' button again, state is changed to 'NORMAL_STATE' and clock starts to run normally.

You can leave your comments in the comment section below.

Notes and References

^[1]msCounter increments to a value of 1000, then resets to 0 and starts to increment again. So, msCounter becomes zero again after every 1 second exactly. So LCD updates with new time value after every second.

Downloads

Controllable digital clock display code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A internal EEPROM code + Proteus simulation

2016-01-26T10:00:00.000+05:00

This post provides the internal EEPROM reading and writing code for PIC16F877A microcontroller. As we know^[1], PIC16F877A microcontroller has 256 bytes of built in EEPROM data space with an address range of 0x00 to 0xFF. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The result of simulating the code in Proteus is shown below.

Figure 1. Internal EEPROM testing circuit for PIC16F877A

In the above circuit^[2], LED attached on RB0 indicates whether a byte was successfully written in the internal EEPROM or not. In the above figure, LED is ON which indicates that EEPROM was successfully programmed.

Code

The code for the main function is shown below.

Figure 2. Main code for eeprom testing with PIC16F877A

In the main function, firstly RB0 pin is made an output. After that, eeprom_write(address, value) function writes the desired data value on the given address in the internal EEPROM. For example, in the above code a value of 0xFF is being written on the 0x00 address of EEPROM. Also, eeprom_read(address) function reads the value of byte present at the given address. In the above code, the data value from the 0x00 address of internal EEPROM is being compared to 0xFF, if it is a match then LED is turned on, if it is not a match then LED is turned off.

These two functions eeprom_write(address, value) and eeprom_read(address) are built in functions provided by the HI-TECH C compiler. You don't need to write your own functions to access internal EEPROM. Just use these functions and you are done. It is that simple.

You can leave your comments and suggestions in the comment section below.

Notes and References

^[1]From the datasheet of PIC16F877A.
^[2]In this circuit, PIC16F877A is running at 5 MIPS speed using 20 MHz crystal. You can use any crystal from 0 to 20MHz with this code.

Downloads

EEPROM code for PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A based simple calculator (Code+Proteus simulation)

2016-01-25T10:00:00.000+05:00

This PIC microcontroller tutorial provides a simple calculator implementation for PIC16F877A microcontroller. This is a simple one digit^[1] calculator which implements only 4 functions addition(+), subtraction(-), multiplication(x) and division(/). The code for PIC16F877A is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

In this post, it is assumed that you know,

How to interface keypad with PIC16F877A microcontroller. If you don't then please read this page.
How to interface LCD with PIC16F877A microcontroller. If you don't then please read this page.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. Circuit diagram for implementing calculator on PIC16F877A

In the above figure, we can see that a result of "3+5=8" is shown on the screen. To achieve this result, first press '3' from the keypad. Then press '+' and then press '5'. After that, on pressing '=' from the keypad the result '8' is automatically displayed on the screen.

Features of this calculator

You can give any single digit input from 0 to 9.
You can press 'ON/C' button at any time to reset the calculator.
4 functions are implemented i-e addition, subtraction, multiplication and division.
Error messages are displayed if wrong input is detected. For example, if calculator is expecting a number, but a function key is pressed then 'Wrong Input' message is displayed. Similarly, 'Wrong Function' message is displayed if wrong key is pressed instead of a function key.

Main function code

The code for the main function is shown below.

Figure 2. Main function code for calculator implementation on PIC16F877A

In the main code, firstly keypad and LCD are initialized. Then the code waits for the first number^[1] from the keypad. After getting this number LCD screen is cleared. And this number is displayed on the LCD. After that, code waits for the function key^[2] from the user. After getting the function key, code waits for the second number^[1] and then the equal sign. After getting the equal sign, according to the desired function the result is calculated and displayed on the screen.

You can leave your comments in the comment section below.

Notes and References

^[1] You can give any single digit input from 0 to 9.
^[2] You can select any function i-e '+' or '-' or 'x' or '/'.

Downloads

The calculator code for PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

How to interface keypad with PIC16F877A ?

2016-01-23T21:35:00.000+05:00

This PIC microcontroller tutorial provides a simple method to interface any keypad (e-g 4x4 or 4x3 etc) with PIC16F877A microcontroller. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

In this post, it is assumed that you know, how to interface LCD with PIC16F877A microcontroller, If you don't then please read this page.

The circuit required to interface keypad with PIC16F877A^[1] is shown below.

Figure 1. Interfacing keypad with PIC16F877A circuit

The result of simulating the code in Proteus is shown above in the figure. This code is written in such a way that when you press any key from the keypad, then the value of that key is displayed on the LCD. For example, in the above figure LCD screen is displaying '3', because this picture was taken after pressing '3' from the keypad.

In the above circuit, RD0, RD1 and RD4:7 pins are used to interface LCD with PIC16F877A. LCD is used here just to show the pressed key value. 8 pins of PORTB are used to interface 4x4 keypad. 4 pins are used to attach columns and 4 pins are used to attach rows and scanning algorithm code is used to check for any pressed key.

Code

The main function code is shown below.

Figure 2. Main code for interfacing keypad with PIC16F877A

In the main function, keypad is initialized using InitKeypad() function. Then LCD is initialized using InitLCD() function. After that, in the while(1) loop, GetKey() function is used to read any pressed key value. GetKey() function is a blocking function, i-e code hangs in it until the user presses any key. After a key is pressed from the keypad, then LCD screen is cleared using ClearLCDScreen() function and the value of pressed key is displayed on the LCD screen using WriteDataToLCD() function and then again code starts to wait in the GetKey() function for the user to press another key.

The code used to initialize keypad is shown below.

Figure 3. InitKeypad function code

In the InitKeypad() function, PORTB is initialized to interface with the keypad. RB0 to RB3 pins are made output and RB4 to RB7 pins are made inputs. Then internal weak pull up is enabled on all the input pins^[2].

GetKey() function code is shown below.

Figure 4. GetKey function code

In the GetKey() function shown above, code hangs in the while(key=='n') loop until a key is pressed. READ_SWITCHES() function scans the whole keypad to detect any pressed key, if a key is pressed then the value of that key is returned from READ_SWITCHES() function, otherwise 'n' is returned which means no key has been pressed. In the end of function value of pressed key is returned.

When key 1 is pressed then RowC wire is shorted with C1 wire inside the keypad. Similarly, when key 9 is pressed then RowA wire is shorted with C3 wire. This behavior is true for all the keys. Then the next question is, how to detect this behavior in the code ?

We can detect pressed key value in the microcontroller using the "Scanning Algorithm Code". This algorithm is written with the name of 'READ_SWITCHES()' function in the code. This function is shown below.

Figure 5. Keypad scanning algorithm code

In the scanning algorithm ( i-e READ_SWITCHES() function ), we test Row A keys first by making RowA wire equal to zero and making other rows one. Then each column is checked if it is equal to zero. Then RowB wire is made zero, while making all other rows one. Then again each column is checked to detect if any RowB key is pressed. This pattern is repeated for every row. If no key is pressed, then 'n' value is returned from the function.

For example, if key 7 was pressed when this code was being executed then C1 will be zero ( Because keypad shorts the corresponding row and column wire ). "if( C1 == 0 )" condition will become true and there is a small delay of some micro seconds after which "while( C1 == 0 );" statement is present. This statement basically makes the controller to wait until the key is no longer pressed, to remove the possibility of reading one pressed key many times. After that, value of the key ( i-e '7' in this case ) is returned from the function.

This code provides you Keypad.c and Keypad.h files, which you can use in any other project as you need. By simply calling InitKeypad() and GetKey() functions in your code, you can easily interface keypad with your PIC controller.

You can leave your comments in the comment section below.

Notes and References

^[1]In this circuit PIC16F877A is running on 20MHz crystal. You can change this crystal if you need. There is no particular reason for selecting 20MHz crystal. This code will work even for 4MHz crystal.
^[2]It is important to enable pull up on the input pins. Because these pins should be in high state when no key is pressed, so that scanning algorithm can work correctly. When a key is pressed, then the corresponding input pin becomes low and pressed key is detected.

Downloads

Keypad interfacing code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

How to implement free running counter in PIC16F877A using seven segment display?

2016-01-23T19:55:00.000+05:00

This post provides the implementation of free running counter ( using c language ) for PIC16F877A microcontroller. This code is written in such a way that, the counter starts from a value of '0' ( displayed on the seven segment ) and then increments this value after every second. So, the seven segment display starts from '0' and then displays '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'b', 'C', 'd', 'E', and in the end 'F'. After displaying 'F', counter starts from '0' again and this pattern repeats forever.

The code and Proteus simulation is given in the 'Downloads' section at the bottom of this page. It is assumed that you know how to make an LED blink with PIC16F877A microcontroller. If you don't, then please read this post first.

The following figure shows the circuit of free running counter in Proteus.

Figure 1. Free running counter implementation using PIC16F877A

A crystal of 20 MHz is used here. You can use any crystal value from 0 to 20MHz with PIC16F877A. As we know that PIC16F877A microcontroller has an architecture which executes an instruction in 4 CPU cycles^[1], hence this 20MHz crystal makes this PIC16F877A run at 5.0 MIPS (Million of instructions per second).

PORTB is used here to connect PIC16F877A with the seven segment display. RB0 pin is attached with the 'a' segment of the seven segment display. Similarly, RB1 pin is connected with 'b' segment, RB2 pin is connected with 'c' segment and so on.

Common cathode seven segment display is used in this example. You can easily modify this circuit and code for the common anode seven segment display as well.

Code

The following function is used in the code to display values on the seven segment display.

Figure 2. DisplayOn7Segment() function code

For example, to display '0' on the seven segment display, we can call this function in the main as DisplayOn7Segment('0');.

The code for the main function is shown below.

Figure 3. Main function for PIC16F877A free running counter

In the main function code, a variable 'ch' is displayed on the seven segment display. Then there is a delay of about 1 second. After that, a new value of ch is selected using the switch statement. Then the new value present in ch variable is displayed on the seven segment. This process continues forever.

You can leave your comments in the comment section below.

Notes and References

^[1] From PIC16F877A datasheet.

Downloads

Free running counter code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

How to display custom characters on LCD using PIC16F877A ?

2016-01-21T21:40:00.002+05:00

This post explains the idea of creating custom characters on any LCD ( e-g on 16x2 LCD ) which has HD44780U controller in it. Almost all 16x2 or 20x2 LCDs have HD44780U controller in them^[1]. This controller provides the functionality of CGRAM ( Character Generator RAM ). We can write character patterns on this RAM and then they can be easily displayed on the LCD. The code for custom character generation using PIC16F877A microcontroller and Proteus simulation can be downloaded from the 'Downloads' section at the bottom of this page.

If you don't know how to interface LCD with PIC16F877A in 8bit mode, then you should read this post first. The required circuit for displaying custom characters on LCD is shown below.

Figure 1. PIC16F877A interfacing with LCD in 8bit mode

PORTB is being used as data bus for the LCD. Also, RD1 pin is used as RS (Register Select for LCD) and RD0 pin is used as E (Enable pin for LCD).

A crystal of 20 MHz is used here. You can use any crystal value from 3 to 20MHz in this circuit. Close-up picture of the LCD is shown below.

Figure 2. Custom characters displayed on LCD

Figure 2 shows the custom characters displayed on the LCD by running the code.

How to generate custom character ?

I am going to explain custom character generation using an example. In the figure 2, first character displayed on the LCD is named 'Curvy Object' in the code. To generate this character, First make a box of 8 by 5 dots. Then fill the dots required to make the custom character you want to display. Following figure explains this concept.

Figure 3. Custom character code array generation

After filling the dots, find out the value of each line. For example, ( in the figure 3 for 'Curvy Object' creation ) first line has a value of 0x01, because only first dot ( at 2⁰ position ) needs to be displayed. Then second line has a value of 0x02, because only one dot at 2¹ position needs to be displayed. Similarly, third line has a value of 0x04, fourth line has a value of 0x08 and fifth line has a value of 0x10. Sixth line has the two dots to be displayed, hence 0x10 + 0x01 = 0x11 is it's value. Seventh line has all the dots to be displayed, which corresponds to a value of 0x10 + 0x08 + 0x04 + 0x02 + 0x01 = 0x1F. Eight line has no dots to be displayed, so it has a value of zero. After finding out these values make an array of these values as shown in the figure 3. This array named 'CurvyObject', which has 8 bytes of data will be transmitted to the CGRAM of LCD.

We can program 8 custom characters when we are using 5x8 font in the LCD settings. And we can program 4 custom characters when we are using 5x10 font in the LCD settings. I have used 5x8 font in the code, hence at most 8 custom characters can be programmed. Using the approach to make the custom character described above, 2 custom characters were defined in the code. These custom character arrays are shown below^[2].

Figure 4. Custom character arrays used in the code

Code

The code for the InitLCD() function is shown below^[3]. This function is used to initialize the LCD properly with the custom characters.

Figure 5. LCD Initialization code

'LCDBuildChar()' function is used to transfer the custom character array to the CGRAM of the LCD. This function is programming 2 custom characters in the CGRAM of the LCD. Note that 'Curvy Object' is being written at 0x00 position and 'Square Box' at 0x01 position of CGRAM in LCD.

'LCDBuildChar()' function is shown below.

Figure 6. Custom Character Build Function

For the details of this function, please refer to the "CGRAM Programming Section" of HD44780U datasheet.

After the programming of these custom characters, we can display them on the LCD using the WriteDataToLCD() function. For example, to display 'Curvy Object' on the LCD just write WriteDataToLCD(0x00); because this custom character was stored at 0x00 position in CGRAM. Similarly, to display 'Square Box' on the LCD, just write WriteDataToLCD(0x01); in the main function. The code for the main function is displayed below.

Figure 7. Main function code for calling custom characters

In the main function, after initializing the LCD, both custom characters are being displayed on the LCD. You can change the custom character array to change it's shape. And then WriteDataToLCD() function can be used to display that new custom character on the LCD. It is that easy.

You can leave your comments in the comment section below.

Notes and References

^[1] Most 16x2 LCDs have HD44780U controller inside them. So, the datasheet for HD44780U controller explains all the commands you can give to the LCD. You can get HD44780U controller datasheet from Google.
^[2] You can match these custom character array definitions with the characters displayed on the LCD in Figure 2.
^[3] LCD initialization procedure is also given in the HD44780U controller datasheet.

Downloads

Custom character display on LCD code for PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A based digital clock using LCD display (Code+Proteus simulation)

2015-06-26T15:25:00.000+05:00

This PIC16F877A microcontroller tutorial answers the question,
" How to implement a digital clock using PIC16F877A ? "

Using PIC16 simulator (Proteus) you can verify this digital clock code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

In this article, it is assumed that you know,

How to interface LCD with PIC16F877A microcontroller. If you don't then please read this page.
How to configure timer0 of PIC16F877A microcontroller. If you don't then please read this page.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A based digital clock

The above figure was taken after 2 minute and 01 seconds of code simulation in Proteus. In the code, timer0 is used as the base for digital clock generation. Timer0 is used here to generate 1msec interrupts. After every 1msec a global variable named msCounter increments. When msCounter reaches a value of 1000 then another global variable named secCounter increments and this process repeats itself. Similarly, when secCounter reaches 60, then minCounter increments. And when minCounter reaches 60 then hrCounter increments. This process continues until hrCounter reaches 24 then all of these variables reset their values. LCD is updated with the new values of hrCounter, minCounter and secCounter after every second.

A crystal of 4MHz value is used in this circuit, which makes this PIC16F877A run at a speed of 1MIPS (Million of instructions per second).

Code

The main function code is shown below.

Figure 2. Main function code for digital clock on PIC16F877A

In the main function, firstly LCD is initialized using InitLCD() function. Then Timer0 is initialized to generate 1msec interrupts. After that, in the while(1) loop, whenever msCounter reaches a value of zero^[1], then new values of hrCounter, minCounter and secCounter are updated on the LCD. UpdateTimeCounters() function is called every time and it corrects the values of every counter variable depending upon the value of msCounter, which is incremented in the ISR function of timer0 (shown below).

Figure 3. Timer0 ISR code for digital clock

In the above figure, interrupt code for timer0 is shown. Timer0 expires after every 1msec and an interrupt is generated which executes interrupt ISR() function shown above. In this function, timer0 register is initialized to a value of 0x08 which makes timer0 to expire after exactly 1msec. After that, timer0 interrupt flag is cleared and msCounter variable is incremented. So, this means that msCounter variable increments after every 1msec.

The code used to initialize Timer0 is shown below.

Figure 4. Init1msecTimerInterrupts function code

In the function Init1msecTimerInterrupts(), timer0 is initialized to generate an interrupt after every 1msec. Timer0 counts from 0 to 249 and a prescalar of 1:4 means that an interrupt will be generated after every 250x4 = 1msec time.

UpdateTimeCounters() function code is shown below.

Figure 5. UpdateTimeCounter function code

In this function it is clear that when msCounter reaches a value of 1000 then secCounter increments and msCounter becomes zero. Similarly, when secCounter reaches 60, then minCounter increments and secCounter becomes zero. And when minCounter reaches 60 then hrCounter increments and minCounter becomes zero. This process continues until hrCounter reaches 24 then all of these variables reset their values.

This code is intended to be a simple example of how PIC16F877A can be used to make a digital clock display. You can leave your comments in the comment section below.

Notes and References

Downloads

Digital clock display code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A timer1 code + Proteus simulation

2015-06-24T16:20:00.000+05:00

This PIC16F877A microcontroller tutorial answers the question,
" How to use timer1 of PIC16F877A and how to handle its interrupts? "

Using PIC16 simulator (Proteus) you can verify this PIC timer1 code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A timer1 simulation

In this circuit, PIC16F877A is running on external crystal of 20MHz value. RB0 pin is toggled every time timer1 expires and executes it's ISR^[1] code. In the above figure, it is clear that after approximately every 13msec, RB0 pin is toggled i-e timer1 expires. You can easily change this value in the code.

Code

The main function code is shown below.

Figure 2. Main function for timer1 of PIC16F877A

In the main function, firstly TRISB0 is made zero to make RB0 pin an output pin, also RB0 pin is made zero. After that, InitTimer1() function is called which initializes timer1. Rest of the work is done in timer1 interrupt service routine. Every time timer1 expires RB0 pin is toggled.

The code used to initialize timer1 is shown below.

Figure 3. InitTimer1 function code for PIC16F877A

In this function, T1CON is initialized to make timer1 prescalar to be 1:1. Timer1 is an 16bit timer, so it expires after reaching a value of 65535. When timer1 prescalar is made 1:1 then it means that timer1 value will increment after every clock cycle. Since PIC16F877A is running at 5MIPS^[2] speed, this means that timer1 will expire after every 65536/5 = 13.1 msec^[3]. TMR1IE bit enables timer1 interrupts and GIE bit enables global interrupts.

Timer1 interrupt service routine code is shown below.

Figure 4. Timer1 interrupt service routine

Whenever timer1 expires, then an interrupt is generated which executes the function shown above in the Figure 4. In this function, RB0 pin is toggled every time and timer1 interrupt flag is cleared. This means that in Figure 1 when ever RB0 pin toggles than timer1 interrupt has occurred.

This is just an example code for timer1 of PIC16F877A microcontroller. You can modify it to fulfill your circuit requirements. You can leave your comments in the comment section below.

Notes and References

^[1]Interrupt service routine i-e when ever timer1 expires, it generates an interrupt and the code which is executed due to that interrupt is called it's ISR.
^[2]I am using external crystal of 20MHz for this PIC16F877A microcontroller. Since PIC microcontrollers execute every instruction in 4CPU cycles, so effectively this PIC16F877A is running at 20MHz/4 = 5 MIPS (million of instructions per second) speed. You can use any crystal value from 4 to 20MHz with PIC16F877A in HS mode.
^[3]You can confirm this value from Figure 1.

Downloads

Timer1 code for PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A timer0 code + Proteus simulation

2015-06-23T15:43:00.003+05:00

This PIC16F877A microcontroller tutorial answers the question,
" How to use timer0 of PIC16F877A and how to handle its interrupts? "

Using PIC16 simulator (Proteus) you can verify this PIC timer0 code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A timer0 simulation

In this circuit, PIC16F877A is running on external crystal of 20MHz value. RB0 pin is toggled every time timer0 expires and executes it's ISR^[1] code. In the above figure, it is clear that after approximately every 100usec, RB0 pin is toggled i-e timer0 expires. You can easily change this value in the code.

Code

The main function code is shown below.

Figure 2. Main function for timer0 of PIC16F877A

In the main function, firstly TRISB0 is made zero to make RB0 pin an output pin, also RB0 pin is made zero. After that, InitTimer0() function is called which initializes timer0. Rest of the work is done in timer0 interrupt service routine. Every time timer0 expires RB0 pin is toggled.

The code used to initialize timer0 is shown below.

Figure 3. InitTimer0 function code for PIC16F877A

In this function, OPTION_REG is initialized to make timer0 prescalar to be 1:2. Timer0 is an 8bit timer, so it expires after reaching a value of 255. When timer0 prescalar is made 1:2 then it means that timer0 value will increment after every two clock cycles. Since PIC16F877 is running at 5MIPS^[2] speed, this means that timer0 will expire after every 256*2/5 = 102 usec^[3]. T0IE bit enables timer0 interrupts and GIE bit enables global interrupts.

Timer0 interrupt service routine code is shown below.

Figure 4. Timer0 interrupt service routine

Whenever timer0 expires, then an interrupt is generated which executes the function shown above in the Figure 4. In this function, RB0 pin is toggled every time and timer0 interrupt flag is cleared. This means that in Figure 1 when ever RB0 pin toggles than timer0 interrupt has occurred.

This is just an example code for timer0 of PIC16F877A microcontroller. You can modify it to fulfill your circuit requirements. You can leave your comments in the comment section below.

Notes and References

^[1]Interrupt service routine i-e when ever timer0 expires, it generates an interrupt and the code which is executed due to that interrupt is called it's ISR.
^[2]I am using external crystal of 20MHz for this PIC16F877A microcontroller. Since PIC microcontrollers execute every instruction in 4CPU cycles, so effectively this PIC16F877A is running at 20MHz/4 = 5 MIPS (million of instructions per second) speed. You can use any crystal value from 4 to 20MHz with PIC16F877A in HS mode.
^[3]You can confirm this value from Figure 1.

Downloads

Timer0 code for PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A LCD code + Proteus simulation

2014-12-10T13:34:00.001+05:00

This PIC16F877A microcontroller tutorial provides very detailed and comprehensive LCD^[1]code. Using PIC16 simulator (Proteus) you can verify this LCD code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A LCD interfacing circuit

In the above figure, RB0 pin is being used as RS pin for LCD. RB1 pin is used as RW pin, RB2 pin is used as Enable pin and RB4 to RB7 pins are used as Data bus for the LCD. When code starts running then 'saeedsolutions.blogspot.com' is displayed on the first line of LCD first. Also, on the second line in the end, two custom characters are also displayed (Downward arrow and Upward arrow). Then whole screen starts to scroll towards left. Following animation shows the result of simulating the code in Proteus.

Figure 2. LCD close up animation (Result of simulating code in Proteus)

Code

The code for the main function is shown below.

Figure 3. Main function for interfacing LCD with PIC16F877A

In the main function, firstly LCD is initialized using InitLCD() function. After that, 'saeedsolutions.blogspot.com' is written on the LCD screen^[2]. In this way using WriteStringToLCD() function, you can write any string on the LCD screen. GotoYXPositionOnLCD(LCD_LINE2, 38) statement makes the DDRAM(Data Display RAM) pointer to go to LCD line 2 second last character position, this means that next character written to LCD will be displayed at this position. Each line of the LCD can have 40 characters saved in its DDRAM at most and only 16 characters are displayed at a given time^[3].

There are 8 custom characters^[4] defined in the code as well. At position 0x06 Downward Arrow custom character is defined and at position 0x07 Upward Arrow custom character is defined. These two characters are displayed at last position of LCD line 2 using WriteDataToLCD(0x06) for Downward Arrow and WriteDataToLCD(0x07) for Upward Arrow. Then there is delay of 1 second using __delay_ms(1000); statement.

In the while(1) loop, LCD screen is scrolled to the left by one character after every 0.2 seconds. This scrolling is achieved using the function ScrollLCD(ScrollScreen, ToLeft, 1), in which you can change ScrollScreen to ScrollCursor if you want to scroll cursor only. You can change ToLeft parameter to ToRight if you want to scroll towards right. You can change value 1 to any x number, if you want to scroll LCD by x characters instead of 1 character at a time.

In the code, custom characters^[4] defined are shown below (From LCD.h file).

Figure 4. Custom characters defined in the code

There are 8 custom characters defined. You can learn how to create these arrays from this link. Then you can replace these arrays with your own custom character arrays and those custom characters can be called from the main function if required.

In the code you can easily select the configuration for the LCD to be used. Following figure shows the pin selection code.

Figure 5. LCD configuration selection code

Here for example, you can change RB0 to RB3 if you want to attach RS pin of the LCD on pin36 of PIC16F877A. You will also need to change LCD_RS_Dir to TRISB3 for RB3. Similarly, you can change other pin definitions as well.

In the Selectables, there are many macros defined. You should uncomment or comment these macros as per requirement. For example, the above code shows that LCD is being configured in DataBus4bit mode, Entry mode is set to increment with each character, 16x2 LCD is selected, character font is 5x8 and custom characters are being defined.

There are many functions available in LCD.c file which you can use in your code. This tutorial only covers few of these functions. You can leave your comments in the comment section below.

Notes and References

^[1]Here LCD means most widely used common 16x2 LCD, which has HD44780U controller in it.
^[2]As shown in Figure 1, "saeedsolutions.blogspot.com" is displayed in the Proteus simulation.
^[3]This statement is valid only for 16x2 LCD. For 20x2 LCD 20 characters are displayed on LCD screen at a given time, but only 40 characters can be saved for each LCD line in DDRAM.
^[4]Custom character are special characters, which you can store in the CGRAM(Character generator RAM) of LCD. These characters can be designed to display custom made character. For details on how to make these custom characters, you can check this link.

Downloads

LCD interfacing code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A LCD interfacing code (In 4bit mode) + Proteus simulation

2014-10-24T16:02:00.001+05:00

This PIC16F877A microcontroller tutorial answers the question,
"How to interface LCD^[1] in 4bit mode with PIC16F877A" ?

Also, using PIC16 simulator (Proteus) you can verify this LCD code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A LCD interfacing circuit

In the above figure, RB0 pin is being used as Enable pin for LCD. RB1 pin is used as RS pin and PORTB (RB4 to RB7) pins are used as Data bus for the LCD. When code starts running then 'Hello World!' is displayed on the LCD.

Code

The code for the main function is shown below.

Figure 2. Main function for interfacing LCD with PIC16F877A

In the main function, firstly LCD is initialized in 4 bit mode using InitLCD() function. After that, LCD screen is cleared using ClearLCDScreen() function. Then 'Hello World!' is written on the LCD screen^[2]. In this way using WriteStringToLCD() function, you can write any string on the LCD screen.

In the code you can easily select pins to be used for interfacing with the LCD. Following figure shows the pin selection code.

Figure 3. LCD pins selection code

Here for example, you can change RB0 to RD3 if you want to attach Enable pin of the LCD on pin22 of PIC16F877A. You will also need to change LCD_E_Dir to TRISD3 for RD3.

We can write data or command to the LCD. Following code shows the functions required for this.

Figure 4. Functions to write data and command to LCD

WriteCommandToLCD() function writes a command to LCD in 4bit mode. WriteDataToLCD() function writes any given character on the LCD. For example, to write 'a' on LCD, simply call WriteDataToLCD('a'); in your main function.

LCD initialization function is shown below.

Figure 5. InitLCD function for PIC16F877A

InitLCD() function (shown above) is initialising LCD in 4bit mode with cursor off, blink off and entry mode set to increment. This initialisation process is written according to the datasheet of HD44780U controller, which is built in the LCD^[1].

You can leave your comments in the comment section below.

Notes and References

^[1]Here LCD means most widely used common 16x2 LCD, which has HD44780U controller in it.
^[2]As shown in Figure 1, Hello World! is displayed in the Proteus simulation.

Downloads

LCD interfacing code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A LCD interfacing code (In 8bit mode) + Proteus simulation

2014-08-27T13:43:00.001+05:00

This PIC16F877A microcontroller tutorial answers the question,
"How to interface LCD^[1] in 8bit mode with PIC16F877A" ?

Also, using PIC16 simulator (Proteus) you can verify this LCD code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A LCD interfacing circuit

In the above figure, RD0 pin is being used as Enable pin for LCD. RD1 pin is used as RS pin and PORTB is used as Data bus for the LCD. When code starts running then 'Hello World!' is displayed on the LCD.

Code

The code for the main function is shown below.

Figure 2. Main function for interfacing LCD with PIC16F877A

In the main function, firstly LCD is initialised using InitLCD() function. After that, LCD screen is cleared using ClearLCDScreen() function. Then 'Hello World!' is written on the LCD screen^[2]. In this way using WriteStringToLCD() function, you can write any string on the LCD screen.

In the code you can easily select pins to be used for interfacing with the LCD. Following figure shows the pin selection code.

Figure 3. LCD pins selection code

Here for example, you can change RD0 to RD3 if you want to attach Enable pin of the LCD on pin22 of PIC16F877A. You will also need to change LCD_E_Dir to TRISD3 for RD3.

We can write data or command to the LCD. Following code shows the functions required for this.

Figure 4. Functions to write data and command to LCD

WriteCommandToLCD() function writes a command to LCD in 8bit mode. WriteDataToLCD() function writes any given character on the LCD. For example, to write 'a' on LCD, simply call WriteDataToLCD('a'); in your main function.

LCD initialisation function is shown below.

Figure 5. InitLCD function for PIC16F877A

InitLCD() function (shown above) is initialising LCD in 8bit mode with cursor off, blink off and entry mode set to increment. This initialisation process is written according to the datasheet of HD44780U controller, which is built in the LCD^[1].

You can leave your comments in the comment section below.

Notes and References

^[1]Here LCD means most widely used common 16x2 LCD, which has HD44780U controller in it.
^[2]As shown in Figure 1, Hello World! is displayed in the Proteus simulation.

Downloads

LCD interfacing code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A UART code + Proteus simulation

2014-08-26T14:53:00.003+05:00

This post answers the question, "How to use interrupt based UART in PIC16F877A" ?
Also, using PIC16 simulator (Proteus) you can verify this UART code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

This PIC16F877A microcontroller tutorial provides the interrupt based UART functions which you can easily understand and use. After reading this page you can easily use PIC16F877A serial UART interface.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F877A UART circuit

In the above figure, UART baudrate is currently set to 9600 bps, but you can change it to your desired value. RC6 pin is the TX pin and RC7 pin is the RX pin the UART. Whenever a new character is received on the UART, then PIC16F877A goes into interrupt service routine and received character is echoed back.

When code starts to execute then PIC16F877A sends 'Hello World' to virtual terminal. After that PIC16F877A echoes back whatever character is sent to it. 'Hi' was typed in the virtual terminal after the start up of the simulation in Proteus and PIC16F877A echoed it back.

Code

The code used to set different properties of UART is shown below. (From UART.h file)

Figure 2. UART settings in the code

In the above figure, _XTAL_FREQ is defined to be 20000000, which is the external crystal frequency used with this PIC16F877A. If you change the crystal (e-g by attaching an external crystal of different frequency) then you will need to change _XTAL_FREQ value as well. For example, if 12MHz external crystal is used, then _XTAL_FREQ should be defined as 12000000 in the above code.

Similarly, you can define Baudrate for the UART, in the above figure it is defined to be 9600 bps. You can change this value if you need. All other settings are at default, which means this UART will use one starting bit, 8 data bits and then one stop bit. There is no parity bit and no flow control mechanism.

The code for main function is shown below.

Figure 3. Main code for UART of PIC16F877A

In the main function, firstly UART is initialised using InitUART() function. After that, using SendStringSerially() function 'Hello World!' is sent on UART. After that, global and peripheral interrupts are enabled, so that when a character is received on UART then an interrupt should be generated. In the end, in the while(1) loop, code executes NULL statements.

The code for InitUART() function is shown below.

Figure 4. InitUART function code

From the above figure, it is clear that InitUART() function initialises UART TX and RX pin direction first. Also, baud rate is set in SPBRG register according to the value of external crystal and BAUDRATE. After that, various other register settings of UART are being programmed with correct values to start UART module.

The code for the UART byte transmit and receive functions is shown below.

Figure 5. UART byte transfer and receive function code

By using SendByteSerially() function, you can send a single byte on UART. For example, SendByteSerially('H'); statement will send character 'H' on UART. Similarly, ReceiveByteSerially() function will receive a byte from UART and return its value. You can call these function in your main to transmit or receive bytes on UART.

Interrupt service routine function for UART reception is shown below.

Figure 6. ISR code for UART reception

In the ISR code shown above, the character received from UART RX pin is stored in the RCREG register and this character is echoed back using SendByteSerially() function. Whenever a character is sent to PIC16F877A, then this interrupt ISR() function is executed automatically and in this function received character is echoed back.

You can leave your comments and suggestions in the comment section below.

Downloads

UART code for PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A external interrupt code + Proteus simulation

2014-08-21T18:24:00.001+05:00

This post answers the question, "How to capture a pulse to generate an interrupt in PIC16F877A" ?
Also, using PIC16 simulator (Proteus) you can verify this external interrupt code and change it according to your needs. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

This PIC16F877A microcontroller tutorial provides the external interrupt code (e-g when you need to control servo motor which has position encoder, with your PIC microcontroller you can use this code). As we know, PIC16F877A microcontroller has one RB0/INT pin, this pin is used to service external interrupts in the circuit shown below.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram^[1].

Figure 1. PIC16F877A external interrupt capture circuit

In the above circuit^[2], normally a low value is present on the RB0/INT pin because of the pull down resistor. But when push button is pressed then a low to high pulse on the RB0/INT pin generates the interrupt. And code is written in such a way that whenever interrupt is generated then RD0 pin is toggled.

Code

The code for the main function is shown below.

Figure 2. Main function code for INT pin interrupt code for PIC16F877A

In the main function, firstly InitExternal_INT() function initialises interrupts on RB0/INT pin. Then RD0 pin direction is set to be an output. After that, NULL statements are executed in the while(1) loop forever. Rest of the work is done in the interrupt service routine code of RB0/INT pin.

The code for InitExternal_INT() function is shown below.

Figure 3. InitExternal_INT function code

In the InitExternal_INT() function, RB0 pin is made input to capture the push button signal. Then global and INT pin interrupts are enabled, also INT pin is made posedge triggered.

Whenever a posedge pulse is received on the RB0/INT pin, then following code is executed (shown below).

Figure 4. ISR code for external interrupts

In the RB0 INT pin interrupt service routine code (shown above), RD0 pin is toggled. This means that whenever you press the push button then LED attached with RD0 pin will toggle its state.

Using the code given in this post you will be able to easily handle interrupts in the PIC microcontroller. As an example, when you need to control servo motor (which has position encoder), then you can attach the output of position encoder on your PIC RB0/INT pin and capture interrupts on it. Whenever servo motor moves one position, then you will receive one interrupt. By incrementing a variable on each interrupt you can always keep track of servo motor position in real time.

You can leave your comments and suggestions in the comment section below.

Notes and References

^[1]This is just a sample circuit and code to test external interrupts on PIC16F877A. You can modify this code to meet your requirements.
^[2]In this circuit, PIC16F877A is running at 5 MIPS speed using 20 MHz external crystal.

Downloads

External interrupt code for PIC16F877A as compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A PWM (2 channel) code + Proteus simulation

2014-08-20T13:03:00.004+05:00

This PIC16F877A microcontroller tutorial provides the 2 channel PWM code (using C language) and Proteus simulation ( written using MPLAB and HI-TECH C compiler ). There are many uses for PWM signal, e-g you can control dc motor speed using PWM. CCP is the name for the built in PWM module in PIC16F877A. There are 2 built in PWM modules available, namely CCP1 and CCP2. This code is using both CCP1 and CCP2 modules to generate 2 separate PWM signals.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the PWM generator circuit diagram.

Figure 1. PIC16F877A PWM generation circuit

A crystal of 20MHz is used here with PIC16F877A. As we know that any PIC micro controller has an architecture which executes an instruction in 4 CPU cycles, hence this 20Mhz crystal makes this PIC16F877A run at 5MIPS (Million of instructions per second). In the above figure, it is clear that a PWM of 4.9kHz frequency with 50% duty cycle is being generated at RC2/CCP1 pin and a PWM of 4.9kHz frequency with 75% duty cycle is being generated at RC1/CCP2 pin.

Code

The code for main function is shown below.

Figure 2. Main code for PIC16F877A PWM

In the main function, PWM is initialised using the 'InitPWM()' function. Then PWM duty cycle is set to 50% on CCP1 module and 75% on CCP2 module ( You can verify this value from Figure 1 ). After that microcontroller is free and built in CCP1, CCP2 modules automatically generates desired PWM frequencies. When you need to change PWM duty cycle, then just call SetPWMDutyCycle() function and change the duty cycle as per requirement. You can pass a value of 0(0% duty cycle) to 255(100% duty cycle) in the argument of SetPWMDutyCycle() function.

The code for InitPWM() function is shown below.

Figure 3. InitPWM function code for PIC16F877A

InitPWM() function initialises the PWM module CCP1 and CCP2 to generate PWM signal at 4.88KHz using 'Timer 2'. RC2 ( Pin 17 ) gives the output of the CCP1 module and RC1 ( Pin 16 ) gives the output of the CCP2 module.

The code for 'SetPWMDutyCycle()' function is shown below.

Figure 4. SetPWMDutyCycle function code for PIC16F877A

SetPWMDutyCycle() is the function which is used to set the duty cycle value for the PWM. This function has 2 input arguments. First is the parameter to select CCP module, i-e if you want to change PWM of CCP1 module or CCP2 module. Write 1 here for CCP1 and 2 for CCP2 module. Then second parameter is the value of PWM duty cycle. Write 0 here for 0% duty cycle and write 255 here for 100% duty cycle. For example, to generate a PWM with 50% duty cycle on CCP1 write 'SetPWMDutyCycle(1, 127)' in your code.

You can calculate PWM frequency using the formula _XTAL_FREQ/(4*(PR2+1)*Prescalar). Where _XTAL_FREQ is the value of crystal frequency, in the above code it is defined to be 20000000. PR2 is Timer2 register, it's value is defined to be 0xFF ( In the InitPWM() function ). You can set PR2 value in between 0 to 0xFF only. Prescalar value is currently set to be 4 in InitPWM() function. Putting all these values, we get a PWM frequency of 20000000/(4*256*4) = 4.88kHz (This value can be verified from Figure1). You can modify these parameters to change PWM frequency.

An application of PIC16F877A could be that you can use this PWM code to control dc motor with PIC16F877A controller. You will need some sort of dc motor driver circuitry in between PIC16F877A controller and the dc motor. Other than that, using this simple PWM controlling code, you can control dc motor speed with PIC16F877A controller easily. You can leave your comments in the comment section below.

Downloads

2 channel PWM code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A PWM code + Proteus simulation

2014-08-19T20:02:00.002+05:00

This post provides the PWM code (using C language) and Proteus simulation for PIC16F877A microcontroller ( written using MPLAB and HI-TECH C compiler ). There are many uses for PWM signal, e-g you can control dc motor speed using PWM. CCP is the name for the built in PWM module in PIC16F877A. There are 2 built in PWM modules available, namely CCP1 and CCP2. This code is using CCP1 module to generate PWM. You can download the complete project code and Proteus simulation from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

The following diagram (made in Proteus) shows the circuit diagram.

Figure 1. PIC16F877A PWM circuit

Code

The code for main function is shown below.

Figure 2. Main code for PC16F877A PWM

In the main function, PWM is initialised using the 'InitPWM()' function. Then PWM duty cycle is set to 50% ( You can verify this value from Figure 1 ). After that microcontroller is free and built in CCP1 module automatically generates desired PWM frequency. When you need to change PWM duty cycle, then just call SetPWMDutyCycle() function and change the duty cycle as per requirement. You can pass a value of 0(0% duty cycle) to 1023(100% duty cycle) in the arguement of SetPWMDutyCycle() function.

The code for PWM functions is shown below.

Figure 3. PWM function code for PIC16F877A

InitPWM() function initialises the PWM module CCP1 to generate PWM signal at 4.88KHz using 'Timer 2'. RC2 ( Pin 17 ) gives the output of the CCP1 module. CCP1 module has 10bit PWM resolution. 'SetPWMDutyCycle()' is the function which is used to set the duty cycle value for the PWM of CCP1. This function has 1 input argument which is the required value of the duty cycle of PWM. Write 0 here for 0% duty cycle and write 1023 here for 100% duty cycle. For example, to generate a PWM with 50% duty cycle write 'SetPWMDutyCycle( 512)' in your code.

You can calculate PWM frequency using the formula _XTAL_FREQ/(4*(PR2+1)*Prescalar). Where _XTAL_FREQ is the value of crystal frequency, in the above code it is defined to be 20000000. PR2 is Timer2 register, it's value is defined to be 0xFF ( In the InitPWM() function ). You can set PR2 value in between 0 to 0xFF only. Prescalar value is currently set to be 4 in InitPWM() function. Putting all these values, we get a PWM frequency of 20000000/(4*256*4) = 4.88kHz (This value can be verified from Figure1). You can modify these parameters to change PWM frequency.

As an example, You can use this PWM code to control dc motor with PIC16F877A controller. You will need some sort of dc motor driver circuitry in between PIC16F877A controller and the dc motor. Other than that, using this simple PWM controlling code, you can control dc motor speed with PIC16F877A controller easily. You can leave your comments in the comment section below.

Downloads

PWM code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

How to use PIC16F877A pin as input? (Code+Proteus simulation)

2014-08-09T00:26:00.001+05:00

This post provides an example code to use PIC16F877A pins as inputs. After going through this example, you will understand how to make PIC16F877A pins as inputs and how to read their value in the code. This code is written in C language using MPLAB with HI-TECH C compiler.You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F877A microcontroller. If you don't then please read this page first, before proceeding with this article.

Following figure shows the circuit used to demonstrate how to get input in PIC16F877A microcontroller.

Figure 1. PIC16F877A pin as input demonstrating circuit

In this figure, PIC16F877A is running on external crystal of 20MHz^[1]. RB0 pin is being used as the input pin. When the push button is in the pushed state then, RB0 pin is high, otherwise RB0 pin is low. Whenever RB0 pin is high, then RD0 pin (Attached with the LED) is also made high just to indicate correct reading of RB0 pin status in the microcontroller.

Code

The code for reading the status of RB0 pin is shown below.

Figure 2. GPIO pins as input for PIC16F877A main code

In the main function, firstly RB0 pin is made an input and RD0 is made an output. Using TRISx register^[2], we can set the direction of any pin i-e if it is an input or output. So, TRISB0 = 1; makes RB0 pin an input pin. And TRISD0 = 0; makes RD0 pin an output pin. Also, using the statement RD0 = 0; RD0 pin is made low.

In the while(1) loop, status of RB0 pin is constantly being checked, if it becomes high then RD0 is also made high. If RB0 is low, then RD0 is also made low as well.

You can leave your comments in the comment section below.

Notes and References

^[1]Because every PIC microcontroller has an architecture which executes an instruction in 4 CPU cycles, when CPU frequency is defined to be 20MHz, then actual speed of this PIC microcontroller will be 5 MIPS (Million of instructions per second). You can attach any crystal from 0 to 20MHz with PIC16F877A.
^[2]For details please refer to PIC16F877A datasheet.

Downloads

Input pin code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F877A LED blinking code + Proteus simulation

2014-08-06T17:15:00.003+05:00

This post provides the code to make an LED blink using PIC16F877A microcontroller. This code is written in C language using MPLAB with HI-TECH C compiler. This code is intended to be the first step in learning how to use PIC16F877A microcontroller in your projects. You can download this code from the 'Downloads' section at the bottom of this page.

Following figure shows the minimum circuit required to make an LED blink with PIC16F877A.

Figure 1. Circuit diagram for LED blinking using PIC16F877A

In this figure, first thing to note is that there is a crystal of 20MHz used with PIC16F877A^[1]. You can use any crystal from 3 to 20MHz with PIC16F877A. MCLR master reset pin is pulled high to keep PIC16F877A out of reset. RB0 pin is being toggled in the code.

Code

The code for making LED blink using PIC16F877A is shown below.

Figure 2. Code for making LED blink using PIC16F877A

Whenever you are writing code for PIC microcontrollers, then you have to include "htc.h" file in the code. After including "htc.h" file, configuration bits are being set in the code shown above. To understand the details of how these configuration bits are being programmed, you can read this post.

After the configuration bits, LED pin is being defined as the RB0 pin. You can replace RB0 with any other pin name if you want (e-g RB1 etc). After LED pin definition, CPU frequency is being defined. You have to define _XTAL_FREQ macro, if you want to use built in delay functions like __delay_us() and __delay_ms(). Here CPU frequency is defined to be 20MHz, which is the crystal oscillator frequency attached with PIC16F877A in the circuit.

In the main function, firstly RB0 pin direction is set to be an output pin using TRISB0 = 0; statement. Using TRISx register^[2], we can set the direction of any pin i-e if it is an input or output. Then LED pin is made low using LED = 0; statement.

LED pin is being toggled in the while loop after every half second. In this way you can easily make LED blink using PIC16F877A microcontroller.

You can leave your comments in the comment section below.

Notes and References

^[1]Because every PIC microcontroller has an architecture which executes an instruction in 4 CPU cycles, when CPU frequency is defined to be 20MHz, then actual speed of this PIC microcontroller will be 5 MIPS (Million of instructions per second).
^[2]For details please refer to PIC16F877A datasheet.

Downloads

LED blinking code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

How to set PIC16F877A configuration bits in code ?

2014-08-05T15:20:00.003+05:00

This post provides the method to set configuration bits in the code for PIC16F877A microcontroller. You have to set configuration bits in order to make PIC microcontroller work correctly. Here I am going to explain the procedure of selecting configuration bits for PIC16F877A. A typical example code for setting configuration bits in the code (using MPLAB + HI-TECH C compiler) is also provided. Following steps are required to setup configuration bits for PIC16F877A.

Step 1:
The first step to start writing the configuration bits is to check "Special Features of the CPU" section in the datasheet of PIC16F877A. In this section, first chapter is about "Configuration bits". You should read this section and identify what values you want to put in the configuration register.

Step 2:
Open the file "pic16f877a.h" from the directory "C:\Program Files\HI-TECH Software\PICC\9.83\include". In the start of this file configuration bit macros are defined. Snapshot of these macros is shown below.

Figure 1. Configuration bits for PIC16F877A

Step 3:
Here we have to choose appropriate macros to be used in the code to set configuration bits correctly. For each configuration bit we have a choice between some macros. For example, for watchdog timer enable bit, we have a choice between WDTE_ON or WDTE_OFF. If we want to enable the watchdog timer, then WDTE_ON macro should be used in the code. But if we want to disable watchdog, then WDTE_OFF macro should be used in the code to set the configuration bit accordingly. Similarly, you can select appropriate macros for other configuration bits.

Code

We can program configuration bits in the code using __CONFIG macro^[1]. The code to make an LED blink with PIC16F877A^[2] is shown below in the figure. You can see how __CONFIG macro is used here, to set the desired configuration bits in the code.

Figure 2. PIC16F877A basic LED blinking code

You have to place the __CONFIG macro outside the main function, preferably in the start of the file. All the selected macros are separated with the & (AND operator) in code. In this code selected configuration bits for PIC16F877A are^[3],

External HS crystal is selected as CPU clock source.
Watchdog is disabled.
Power up timer is enabled.
Program memory code protection is disabled.
Brown out is enabled.
Low voltage programming is disabled.
Internal EEPROM data memory protection is disabled.
Flash program memory write is enabled.
In circuit debugger is disabled, RB6 and RB7 are general purpose pins.

Using this procedure you can easily write configuration bit settings in the code. You can leave your comments in the comment section below.

Notes and References

^[1]For details check manual of HI-TECH C Chapter 3.2.2.
^[2]You can download LED blinking code for PIC16F877A, from the 'Downloads' section at the bottom of this page.
^[3]For details of these settings, check the PIC16F877A datasheet section "Special features of the CPU".

Downloads

LED blinking code using PIC16F877A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F628A Comparator Code + Proteus Simulation

2014-08-04T18:57:00.001+05:00

This post provides the comparator code for PIC16F628A microcontroller. As we know, PIC16F628A microcontroller has one built in op-amp, which can be used as comparator. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to blink an LED with PIC16F628A microcontroller. If you don't then please read this page first, before proceeding with this article.

The result of simulating the code in Proteus is shown below^[1].

Figure 1. PIC16F628A comparator circuit

In the above circuit^[2], a variable voltage signal of 0 to 5 volts can be applied on Pin17 and Pin18 of PIC16F628A controller. There are two comparators in PIC16F628A as shown in the picture below.

Figure 2. PIC16F628A comparators

CIS register value was selected to be zero in the code, so Pin17 and Pin18 are the input pins for the comparators and Pin10, Pin11 are selected to be output pins. In the above circuit shown, Pin17 and Pin18 are attached with the -ve pin of the comparator and on the +ve pin a reference voltage of 2.5v is applied internally. LEDs attached on the RB4, RB5 pins show the result of the comparators.

So, in the Figure1, RB4 pin is high because voltage on Pin17 of PIC16F628A is 2.45v, which is less than 2.5v. If a voltage higher than 2.5v is applied on Pin17, then RB4 pin will become low. Similarly, RB5 pin is low because voltage on Pin18 of PIC16F628A is 2.90v, which is higher than 2.5v. If a voltage less than 2.5v is applied on Pin18, then RB5 pin will become High.

Code

The code for the main function is shown below.

Figure 3. Main function for comparator code for PIC16F628A

In the main function, firstly RB4 and RB5 pins are made outputs. Then comparator is initialised using the InitComparator() function. After that, in the while(1) loop, C1OUT and C2OUT bits of the CMCON register are continuously checked and state of RB4, RB5 pins is changed accordingly. C1OUT or C2OUT bit indicates the result of the comparator output. If voltage on Pin17 of PIC16F628A is higher than 2.5v then C1OUT is 0, but if it is less than 2.5v then C1OUT is 1. Similarly, If voltage on Pin18 of PIC16F628A is higher than 2.5v then C2OUT is 0, but if it is less than 2.5v then C2OUT is 1.

The code for the InitComparator() function is shown below.

Figure 4. InitComparator function code for PIC16F628A

In the InitComparator() function, first 2 lines only make RA0 and RA1 pins inputs. Then VRCON register is used to set a reference voltage of 2.5v on the +ve pin of the comparator internally within the microcontroller. After that, CMCON register is used to configure RA0 and RA1 pins as the comparator pins.

This is a simple example of how you can use comparators of PIC16F628A microcontroller. You can modify this code to meet your requirements.

You can leave your comments and suggestions in the comment section below.

Downloads

Comparator code using PIC16F628A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

Water Level Indicator using PIC microcontroller

2014-06-02T00:19:00.001+05:00

I have designed a new and better water level indicator using PIC microcontroller. It displays water level in the tank as well as in the reservoir. Also, it controls the motor which pumps the water in the tank from the reservoir. In the auto mode, motor is automatically turned on when water level reaches 20% in the tank and it is turned off when water level reaches 100%. You can also change the water level threshold on which motor will turn on by going in to the menu.

The following picture shows the final circuit in working condition.

Figure 1. Final working circuit for water level indicator

In the above image, seven segment display shows the current water level in the tank. While bar LED display shows the current water level in the reservoir. Also LCD shows different messages as well at different times. The yellow LED near bar LED display shows that if motor is turned on or not. When yellow LED is on, then motor is on, otherwise motor is off. The green LED in the top right corner shows if the circuit is powered on or not. The multiple wire connector in the top left corner is attaching sensors placed in the water reservoir to the circuit. While the multiple wire connector in the bottom left corner is attaching sensors placed in the water tank to the circuit. The push button on the left side is the 'Select' button, which is used to enter the menu. While push button in the middle is for going 'Up' in the menu and push button on the right is for going 'Down' in the menu. You can press 'Select' button again to select that item in the menu.

Here are some videos.

You can enter the menu by pressing the 'Select' button. There are many options in the menu. First option is to start/stop motor. If you press 'Select' button on it then circuit will try to start the motor if motor was in off state. But it will succeed only if there is water present in the reservoir. Otherwise it will flash an error that there is no water and motor will turn off. If motor turns on, then when you enter the menu again, then first option will change to stop motor instead of start motor. You can press 'Select' again to stop the motor immediately. All of this should be tested in the manual mode of operation. You can find out if circuit is in Manual Mode or Auto mode by looking on the right bottom of LCD screen during normal operation. If there is M displayed then circuit is in manual mode, if there is A displayed then circuit is in auto mode.

The next option is to enable or disable Auto mode. If auto mode is enabled, then circuit will start and stop the motor automatically. If circuit is in manual mode then it will never start motor by itself, it will only turn the motor off when tank level reaches 100%. You will have to manually start the motor in manual mode.

In the auto mode, you can adjust the thresholds on which it will start or stop the motor. There are 2 thresholds. First is named as TANK Threshold, second is named as RESV Threshold in the menu. You can save any value from 0% or 20% up to 100% in these thresholds. TANK threshold determines when the motor will start. For example, if TANK Threshold is 20%, then when water level in TANK reaches 20%, then motor will start automatically in the auto mode. RESV Threshold determines the low limit at which circuit will assume that there is no water remaining in the reservoir and it will stop the motor. RESV Threshold is the minimum water level you want to keep in the reservoir.

After that, there is an option to disable/enable sound. If sound is enabled then its symbol will be displayed on the LCD in the top right corner during normal operation. If sound is enabled then circuit will generate sound beeps whenever it does something or when tank is completely filled and motor is stopped. If you don't want to be disturbed with the sounds, then you can disable sound from the menu.

Lastly, there is an option of 'Exit' in the menu. When you press 'Select' button on it then you will return to the normal operation screen of the circuit.

All of these settings are saved in the internal EEPROM of PIC controller. So, the next time you power up this circuit it will remember its Threshold settings or sound settings or all other settings. You don't have to put those settings again in it.

There are 2 more symbols displayed on the LCD on the left side of sound symbol and Auto/Manual mode symbol. The one on the left side of sound symbol shows the tank. When water is falling in the tank, then it will show little dots falling inside that tank. This will happen only if you have connected water fall input sensor correctly in the tank. You can understand how to connect this circuit with water level sensors in the 'How to use this circuit' section below. Also, there is a bar displayed on the left side of Auto/Manual mode symbol. This shows motor status. If motor is off then this bar will stay there without moving. But if motor is ON, then this bar will start to rotate showing that motor is running.

Here is another picture of the circuit when it is not powered ON.

Figure 2. Water level indicator using PIC controller

The bottom of the circuit is the main part on which all the SMD components are attached. Here is a picture of the bottom side.

Figure 3. Bottom side of the circuit

Circuit Diagram

Here is the circuit diagram.

Figure 4. Circuit diagram of water level indicator using PIC controller

In the above circuit diagram, J9 connector is used to connect with water sensors in the reservoir and J10 connector is used to connect with water sensors in the tank. You can program your PIC controller through PICkit2 header J8.

How to use this circuit

To use this circuit you have to install the water level sensors in the water tank. Connector J10 is used to connect the circuit with the water level sensors as shown below.

Figure 5. Connections to water tank

Also you have to install the water level sensors in the water reservoir. Connector J9 is used to connect the circuit with the water level sensors as shown below.

Figure 6. Connections to the water reservoir

Components

12v Adopter Polarity

Input Voltage: 12volt power supply is required. Adopter polarity is shown in the picture.

Capacitors: The capacitors used in this circuit need to have a rating of at least 16v.
Q1, Q2, Q3 transistor: Any npn transistor will work here.

Water Sensors: Simple wires can be placed in the water tank. As the current required to pass through the wire is in nano amps. But if you want then you can place carbon rods at the end of wires which can be extracted from the 1.5v AA cell. These carbon rods should be thoroughly washed and then you should attach the wire to the carbon rod and then use some epoxy to hide the wire part.

LM7805: This is the 5v regulator used to power up the whole circuit.

Seven Segments: These are used to display water level. Common cathode seven segments are used.

LCD:   Common 16x2 LCD can be used in this circuit.
LED Bar: J7 is the 10 LEDs bar.
Crystal: 10Mhz crystal needs to be attached with the PIC18F452.
PIC18F452:   This microcontroller is used to generate all the required logic for this circuit.
D2, D4 Diodes:   Any diode 1N4007 or 1N4148 or any other general purpose diode will work here.
LS1 Relay:   This is a 12v relay. You should attach that relay which can handle power required by your motor. Preferably, you should use this small relay to drive a bigger relay which should be attached near the motor.
LS2 Buzzer:   Any 5v buzzer will work here.

PCB Design

The circuit diagram was made in the Orcad Schematic software and it is shown in the Figure 4 above. The PCB was designed in the Orcad Layout. The final PCB design is shown below.

Figure 7. PCB design for the water level indicator

Here is a picture of the PCB top side.

Figure 8. Water level indicator PCB top side

Here is a picture of the bottom side of the PCB.

Figure 9. Water level indicator PCB bottom side

Simulation

You can download the simulation made in Proteus software from 'Downloads' section below as well. Here is a screen shot of the simulation.

Figure 10. Water level indicator simulation

You can simulate the circuit by moving the DIP switches labeled as TANK and RESV in the above diagram. For example, in the above picture, it shows a water level of 40%, because the DIP switch named TANK has 2 inputs grounded. Similarly, RESV DIP switch has one input grounded that is why it shows a water level of 20%. Also, you can use Select, Up, Down buttons as well to enter the menu etc. You can completely test the behaviour of the circuit in this simulation.

You can leave your comments in the comment section below.

Buy it Now

If you want this circuit, but don't want to go through all the trouble to make it. Then you can purchase it by going on this link click here

Downloads

Water level indicator code with PIC18F452 was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F628A up down counter code + Proteus simulation

2014-05-12T16:17:00.000+05:00

This PIC16F628A microcontroller tutorial answers the question,
" How to implement a up down counter using PIC16F628A ? "

Using PIC16 simulator (Proteus) you can verify this counter code and change it according to your needs. Using one push button (Labeled as Count, as shown in figure below) you can increment (When SW1 switch is towards up position) or decrement (When SW1 switch is towards down position) count value (displayed on LCD) as you desire. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

In this article, it is assumed that you know, how to interface LCD with PIC16F628A microcontroller. If you don't then please read this page.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F628A based up down counter circuit

The above figure was taken after pressing Count button 4 times. SW1 switch position is set towards 'Up' position, hence count value was incremented with each press of Count button. LCD is updated with the new value of count after every 200 milli second.

You can set SW1 switch to 'Down' position and then after pressing Count button, count value will decrement. When count value reaches 100 then it resets to 0 value again.

A crystal of 20MHz value is used in this circuit, which makes this PIC16F628A run at a speed of 5MIPS (Million of instructions per second). You can use any other value of crystal ( From 0 to 20 MHz value only) as well.

Code

The main function code is shown below.

Figure 2. Main function code for up down counter on PIC16F628A

In the main function, firstly LCD is initialized using InitLCD() function. Then Count button pin and Up/Down button pin is made input. Then LCD screen is cleared and "Starting..." is displayed on the LCD for half a second.

After that, in the while(1) loop, depending up the value of Up_Or_Down button input value, Count variable is either incremented or decremented. In the end, Count value is displayed on the LCD after clearing the LCD screen.

You can leave your comments in the comment section below.

Downloads

Up down counter code with PIC16F628A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

PIC16F628A stop watch code + Proteus simulation

2014-04-01T20:18:00.003+05:00

This PIC16F628A microcontroller tutorial answers the question,
" How to implement a stop watch using PIC16F628A ? "

Using PIC16 simulator (Proteus) you can verify this stop watch code and change it according to your needs. Using three push buttons (As shown in figure below) you can adjust time as you desire. Then after setting the time, value displayed on the LCD starts to decrease with each second and when this value reaches zero, then LED D1 is turned on. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

In this article, it is assumed that you know,

How to make a simple digital clock using PIC16F628A. If you don't then please read this page.
How to interface LCD with PIC16F628A microcontroller. If you don't then please read this page.
How to configure timer0 of PIC16F628A microcontroller. If you don't then please read this page.

The following diagram (made in Proteus) shows the PIC microcontroller circuit diagram.

Figure 1. PIC16F628A based stop watch circuit

The above figure was taken when time was 00:00:03, i-e only 3 seconds were remaining until LED D1 is turned on. Timer0 is used as the base for digital clock generation. Timer0 is used here to generate 1msec interrupts. After every 1msec a global variable named msCounter increments. When msCounter reaches a value of 1000 then another global variable named secCounter decrements and this process repeats itself. Similarly, when secCounter reaches 0, then minCounter decrements. And when minCounter reaches 0 then hrCounter decrements. This process continues until hrCounter reaches 0. LCD is updated with the new values of hrCounter, minCounter and secCounter after every second.

You can set time using three push buttons attached on RA0, RA1 and RA2 pins (As shown in the above figure). By pressing 'Start/Stop' button one time, code enters in configuration state. Hours value starts to blink and you can modify it using Up and Down buttons. Pressing Up button increments the value and pressing Down button decrements the value. When you are done setting Hours value, press 'Start/Stop' button again, then Minutes value will start to blink and you can adjust this value using Up and Down buttons. Similarly, after setting Minutes value, you can press 'Start/Stop' button again, then Seconds value will start to blink and you can adjust this value using Up and Down buttons. When you are done adjusting the time, then press 'Start/Stop' button for the last time and this stop watch will start to work normally.

A crystal of 4MHz value is used in this circuit, which makes this PIC16F628A run at a speed of 1MIPS (Million of instructions per second).

Code

The main function code is shown below.

Figure 2. Main function code for stop watch on PIC16F628A

In the main function, firstly RB0 pin (This is the LED pin) is made output and then PORTA pins are made input and Comparator is turned off on these pins. Then LCD is initialized using InitLCD() function. Then Timer0 is initialized to generate 1msec interrupts.

After that, in the while(1) loop, there is a state machine running. A variable named State is used to keep track of the current state of the stop watch. When this code starts, then State has a value of NORMAL_STATE. In the normal state, clock value is decremented after every second and whenever msCounter reaches a value of zero^[1], then new values of hrCounter, minCounter and secCounter are updated on the LCD. UpdateTimeCounters() function is called every time and it corrects the values of every counter variable depending upon the value of msCounter, which is incremented in the ISR function of timer0.

In the normal state, code keeps checking RA0 pin value, if 'Start/Stop' button is pressed then RA0 pin value becomes zero. This is detected using if(!RA0) statement in the code. When 'Start/Stop' button is pressed then state is changed to 'CONFIG_HR_STATE' (i-e configure hours value state). In this state, Up and Down buttons are constantly monitored and hrCounter value can be adjusted. Similarly, by pressing 'Start/Stop' button again, state is changed to 'CONFIG_MIN_STATE' (i-e configure minutes value state). In this state minCounter value can be adjusted using Up and Down buttons and by pressing 'Start/Stop' button again, state is changed to 'CONFIG_SEC_STATE' (i-e configure seconds value state). In this state secCounter value can be adjusted using Up and Down buttons. By pressing 'Start/Stop' button again, state is changed to 'NORMAL_STATE' and stop watch starts to run normally.

You can leave your comments in the comment section below.

Notes and References

Downloads

Stop watch code with PIC16F628A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

Interfacing of PIC16F628A with DS1307 (RTC) code + Proteus simulation

2014-03-31T15:33:00.002+05:00

This post provides the code for interfacing DS1307 RTC with PIC16F628A microcontroller. This DS1307 RTC has i2c based interface. This code is written in C language using MPLAB with HI-TECH C compiler. You can download this code from the 'Downloads' section at the bottom of this page.

It is assumed that you know how to interface LCD with PIC16F628A microcontroller in 4bit mode. If you don't then please read this page first, before proceeding with this article. It is also assumed that you know how to use i2c module in PIC16F628A, if you don't then please read this page first.

The result of simulating the code in Proteus is shown below.

Figure 1. Interfacing DS1307 RTC with PIC16F628A circuit diagram

In the above circuit^[1], RA4 pin is being used as SDA pin and RB0 pin is the SCK pin. Both of these pins are pulled up using 100K resistors as required for i2c protocol. DS1307 RTC is the slave device, while PIC16F628A is configured to be the master. LCD is also attached with PIC16F628A, just to show the values received from the RTC, otherwise it is not required in this circuit. Proteus provides an 'I2C Debugger Tool' which is attached on the SDA and SCK pins in the above circuit, this debugger shows all the activity on i2c bus^[2]. It is attached in the circuit just for debugging purposes.

In the code, in the start a command is sent to DS1307 to set time to 12:40:59 AM and date to 31/03/14. After this, DS1307 starts to increment it's time after every second. Then new time is read from DS1307 RTC after every second and displayed on the LCD. Figure 1 was taken when time was 12:41:08 AM, which is correctly displayed on the LCD.

Code

The code for the main function is shown below.

Figure 2. Main code for interfacing DS1307 with PIC16F628A

In the main function, firstly LCD is initialized using InitLCD() function. Then i2c pins are initialized using InitI2C() function. Then using Set_DS1307_RTC_Time(AM_Time, 12, 40, 59) function, a command is sent to DS1307 to set it's time to 12:40:59 AM. After that, Set_DS1307_RTC_Date(31, 03, 14, Monday) command sets DS1307 date registers to 31/03/14 @ Monday date.

In the while(1) loop, Get_DS1307_RTC_Time() function reads current time from DS1307 and returns a pointer to an array which contains this current time, DisplayTimeToLCD() function takes this pointer as input and displays current time on the LCD in HH:MM:SS AM/PM format.

Also, Get_DS1307_RTC_Date() function reads current date from DS1307 and returns a pointer to an array which contains this current date, DisplayDateToLCD() function takes this pointer as input and displays current date on second line of the LCD in DD/MM/YY format.

Then there is a delay of one second using __delay_ms(1000); statement. This means that LCD is updated with new time and date after every second.

Using these simple 4 functions, Set_DS1307_RTC_Time(), Set_DS1307_RTC_Date(), Get_DS1307_RTC_Time(), Get_DS1307_RTC_Date() you can easily interface DS1307 RTC with PIC16F628A microcontroller.

You can leave your comments and suggestions in the comment section below.

Notes and References

^[1]In this circuit, PIC16F628A is running at 5 MIPS speed using 20 MHz crystal.
^[2] 'I2C Debugger Tool' receives all the i2c messages and displays them on the 'I2C Debug' window. This 'I2C Debug' window is shown below in the figure.

Figure 3. I2C Debug window

In the above figure, 'I2C Debugger Tool' is telling us that there were 4 sequences on the i2c bus, when this screen shot was taken. First sequence "S D0 A 00 A 59 A 40 A 52 A P" is explained below.

S is the starting bit sent from PIC16F628A(master) to DS1307(slave).
Then 0xD0 is sent to slave, this is the address of DS1307 RTC (As mentioned in it's datasheet). Also, LSB bit of 0xD0 is zero, which means it is a writing command for the slave. Slave sends an ACK after receiving this byte.
Then 0x00 is sent to slave, this is the starting address in DS1307 RTC on which we want to write first byte. Slave sends an ACK after receiving this address byte.
Then 0x59 (it is the value of seconds) is sent to slave, this is the value we want to save in DS1307 RTC on 0x00 address. Slave sends an ACK after receiving this byte.
Then 0x40 (it is the value of minutes) is sent to slave, this is the value we want to save in DS1307 RTC on 0x01 address. Slave sends an ACK after receiving this byte.
Then 0x52 (12 is the value of hours, while 7th bit in it means it is 12 hour time format with AM time) is sent to slave, this is the value we want to save in DS1307 RTC on 0x02 address. Slave sends an ACK after receiving this byte.
Then a stop bit (P) is sent to slave.
After receiving this command, slave DS1307 sets it's time to 12:40:59 AM time.

Only the first sequence is explained above, but you can easily understand remaining sequences using the same approach as described above.

Downloads

DS1307 RTC interfacing with PIC16F628A was compiled in MPLAB v8.85 with HI-TECH C v9.83 compiler and simulation was made in Proteus v7.10. To download code and Proteus simulation click here.

Saeed's Blog

Follow Me

PIC16F877A based controllable digital clock using LCD display (Code+Proteus simulation)

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A internal EEPROM code + Proteus simulation

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A based simple calculator (Code+Proteus simulation)

Features of this calculator

Main function code

Notes and References

Downloads

Further Reading Suggestions

How to interface keypad with PIC16F877A ?

Code

Notes and References

Downloads

Further Reading Suggestions

How to implement free running counter in PIC16F877A using seven segment display?

Notes and References

Downloads

Further Reading Suggestions

How to display custom characters on LCD using PIC16F877A ?

How to generate custom character ?

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A based digital clock using LCD display (Code+Proteus simulation)

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A timer1 code + Proteus simulation

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A timer0 code + Proteus simulation

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A LCD code + Proteus simulation

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A LCD interfacing code (In 4bit mode) + Proteus simulation

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A LCD interfacing code (In 8bit mode) + Proteus simulation

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A UART code + Proteus simulation

Code

Downloads

Further Reading Suggestions

PIC16F877A external interrupt code + Proteus simulation

Code

Notes and References

Downloads

Further Reading Suggestions

PIC16F877A PWM (2 channel) code + Proteus simulation

Code

Downloads

Further Reading Suggestions

PIC16F877A PWM code + Proteus simulation

Code

Downloads

Further Reading Suggestions