This post provides the LCD^[1] interfacing code using PIC12F675 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.

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

PIC12F675 microcontroller has only 6 IO pins ( 5 of them can be made input or output, but pin4 (GP3) can only be made an input ). So it is not possible to directly attach LCD with PIC12F675 even in 4bit mode^[2]. To make this possible, a serial to parallel shift register IC (4094) is used in this circuit. In this way by only using 3 pins of PIC12F675 microcontroller, we can interface LCD with it in 4bit mode. This is shown below in the figure.

In the above figure, GP0 pin is being used as Enable pin for LCD. GP1 pin is used as Clock pin and GP2 pin is used as Data pin for 4094 IC.

Code

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

LCD interfacing code using PIC12F675 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.

For more detail: PIC12F675 LCD Interfacing Code and Proteus Simulation

Current Project / Post can also be found using:

• pic12f675 code
• rs232 lcd proteus
• lcd in proteus

The post PIC12F675 LCD Interfacing Code and Proteus Simulation appeared first on PIC Microcontroller.

Matrix keypads are very useful when designing certain systems which needs user input. These keypads are constructed by arranging push button switches in rows and columns as shown in Fig.1. Scanning keypad to detect pressed keys involves several steps and there are several methods to achieve this. The method presented here is capable of detecting more that one key press at time and encode that information in single 16bit (unsigned int) variable. For example this keypad scan routine can be used to detect key presses like CTRL+C in computer keypads.

The example program given in this page uses schematic diagram shown and uses Microchip C18 compiler. The example program will display number of key pressed in 7 segment LED display. If more than one key pressed at a time, it will display ‘H’ character. Schematic diagram shown also shows ICD2 connection which is optional and you can use any programmer/debugger to upload this program to PIC.

Example program has function “ unsigned int ScanKeypad(void) ” where you can use this in your codes provided that keypad is connected to PICs pins as given in schematic bellow.

Keypad Scan Algorithm.

Scanning any matrix keypad involves several steps. The operation algorithm of example ScanKeypad(void) routine given here is explained in following steps. This routine uses logic operations instead of assigning values to ports because we can change only necessary pins while not touching unused pin values. This is very useful when you have other IP or OP devices connected to remaining pins of same port used by keypad. i.e. PORTB4:7 and PORTD0:3 in this example. ScanKeypad(void) routine should be called only after setting ROW pins and OP and Column pins as IP from main program via setting and clearing appropriate TRIS bits (shown in example code).

1. ScanKeypad(void) routine supply logic 0 (0V or GND) to all 4 keypad row wires named R1, R2, R3 and R4 in schematic diagram.(Assume that no key is pressed and since all columns has 1k pull down resisters connected as in schematic diagram. This will cause PICs PORTB0:3 pins to read logic 0 if we read them)

2. Next ScanKeypad(void) will set RD4 (ROW1) pin to Logic High (5V). Now if one or more key from keypad ROW1 pressed, Logic High will be passed through respective switch to PICs respective PORTB0:3 inputs. Pressing keys from any other row will not have any effect on this because these rows have logic 0.

3. Now we read all 4 columns (PORTB0:3) at once and get that data in to unsigned int variable. Since we read only 4 bits, these bits will be recorded in bits 0 to 3 in keys variable. Other 12 bits of keys variable will be set to 0. If any switch belongs to row one pressed, that respective bit will be set.

4. Now we shift least significant 4 bits with row 1 keypad data in keys variable to most significant 4 bits of keys variable in ScanKeypad(void) routine. i.e. shift keys bits 0:3 to keys bits 12:15.

5. Next make ROW1 (RD4) logic 0 and ROW2 (RD5) logic1. Read PORTB0:3 and get result tin to unsigned int keys_tmp variable. Then shift result left by 8 and position row2 data acquired in to keys_tmp bits 8:11. Then combine (bit wise OR) keys and keys_tmp variables in to keys variable. Now we have row1 and row 2 switch status in keys variable bits 8:15.

6. Repeat 5 for column 3 with respective modifications, (refer example code) and take row 3 key status in to keys variable bits 4:7. Now we have rows 1,2 and 3 data in keys bits 4:15

7. Repeat 5 for column 4 with respective modifications, (refer example code).

8. Now we have status of all 16 keys in variable keys and return that variable from ScanKeypad() routine

9. If we have at least one key pressed, then return from ScanKeypad()  will be non zero.

10. If we get non zero value from ScanKeypad(), we should de-bounce keypad and identify really pressed keys and process them as required.

For more detail: Matrix Keypad interfacing with PIC microcontroller.

Current Project / Post can also be found using:

• multiplexing uses pic keypad

The post Matrix Keypad interfacing with PIC microcontroller. appeared first on PIC Microcontroller.

This post provides the code for interfacing 24LC64 EEPROM with PIC12F675 microcontroller. This 24LC64 EEPROM has i2c based interface and PIC12F675 doesn’t have any built in i2c modules, so software i2c module is created 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 interface LCD with PIC12F675 microcontroller. If you don’t then please read this page first, before proceeding with this article. It is also assumed that you know how to create software i2c module in PIC12F675, if you don’t then please read this page first. You should also read how to write/read a byte in/from 24LC64 EEPROM from it’s datasheet.

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

In the above circuit^[1], GP4 pin is being used as SDA pin and GP5 pin is the SCK pin. Both of these pins are pulled up using 10K resistors as required for i2c protocol. 24LC64 EEPROM is the slave device, while PIC12F675 is configured to be the master. LCD is also attached with PIC12F675, just to show the values received from the EEPROM, 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, string ‘Saeed’ is stored in the 24LC64 EEPROM and then retrieved back and displayed on the LCD. As shown in Figure 1, ‘Saeed‘ is correctly displayed on the LCD, this shows that it was stored and retrieved from 24LC64 EEPROM successfully.

Code

The code for the main function is shown below.

In the main function, firstly ADC and comparator are turned off to make pins digital IO pins instead of analog pins using InitCCT() function. Then LCD is initialized using InitLCD() function. Then i2c pins are initialized using InitI2C() function. Then Write_Byte_To_24LC64_EEPROM(0x0001, ‘d’); function writes 0x64 (i-e ‘d’) value on 0x0001 address in the EEPROM. After that, Read_Byte_From_24LC64_EEPROM(0x0001); function reads a single byte from 0x0001 address and saves this value in RxByte variable.

Write_Page_To_24LC64_EEPROM(0x0020, TxArray, 4); function writes 4 bytes present in the TxArray starting from address 0x0020. And Read_Bytes_From_24LC64_EEPROM(0x0020, RxArray, 4); function  reads 4 bytes from the starting address of 0x0020 and saves these bytes in RxArray. In the end all of these 5 received bytes are displayed on the LCD. You can verify from Figure 1, that all of these bytes were correctly received and displayed on the LCD. Using these simple read and write functions you can easily interface 24LC64 EEPROM with PIC12F675.

24LC64 EEPROM interfacing with PIC12F675 code 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.

For more detail: Interfacing of PIC12F675 with (i2c based) 24LC64 EEPROM (code and Proteus simulation)

Current Project / Post can also be found using:

• address of eeprom in proteus for i2c

The post Interfacing of PIC12F675 with (i2c based) 24LC64 EEPROM (code + Proteus simulation) appeared first on PIC Microcontroller.

Description

HD44780 based LCD displays are very popular among hobbyists because they are cheap and they can display characters. Besides they are very easy to interface with microcontrollers and most of the present day high-level compilers have in-built library routines for them. Today, we will see how to interface an HD44780 based character LCD to a PIC16F688 microcontroller. The interface requires 6 I/O lines of the PIC16F688 microcontroller: 4 data lines and 2 control lines. A blinking test message, “Welcome to Embedded-Lab.com”, will be displayed on the LCD screen.

Required Theory

All HD44780 based character LCD displays are connected through 14 pins: 8 data pins (D0-D7), 3 control pins (RS, E, R/W), and three power lines (Vdd, Vss, Vee). Some LCDs have LED backlight feature that helps to read the data on the display during low illumination conditions. So they have two additional connections (LED+ and LED-), making altogether 16 pin. A 16-pin LCD module with its pin diagraam is shown below.

Control pins
The control pin RS determines if the data transfer between the LCD module and an external microcontroller are actual character data or command/status. When the microcontroller needs to send commands to LCD or to read the LCD status, it must be pulled low. Similarly, this must be pulled high if character data is to be sent to and from the LCD module.

The direction of data transfer is controlled by the R/W pin. If it is pulled Low, the commands or character data is written to the LCD module. And, when it is pulled high, the character data or status information from the LCD registers is read. Here, we will use one way data transfer, i.e., from microcontroller to LCD module, so the R/W pin will be grounded permanently.

The enable pin (E) initiates the actual data transfer. When writing to the LCD display, the data is transferred only on the high to low transition of the E pin.

Power supply pins
Although most of the LCD module data sheets recommend +5V d.c. supply for operation, some LCDs may work well for a wider range (3.0 to 5.5 V). The Vdd pin should be connected to the positive power supply and Vss to ground. Pin 3 is Vee, which is used to adjust the contrast of the display. In most of the cases, this pin is connected to a voltage between 0 and 2V by using a preset potentiometer.

Data pins
Pins 7 to 14 are data lines (D0-D7). Data transfer to and from the display can be achieved either in 8-bit or 4-bit mode. The 8-bit mode uses all eight data lines to transfer a byte, whereas, in a 4-bit mode, a byte is transferred as two 4-bit nibbles. In the later case, only the upper 4 data lines (D4-D7) are used. This technique is beneficial as this saves 4 input/output pins of microcontroller. We will use the 4-bit mode.

For further details on LCDs, I recommend to read these two articles first from Everyday Practical Electronics magazine : How to use intelligent LCDs Part 1, and Part 2.

Circuit Diagram

Data transfer between the MCU and the LCD module will occur in the 4-bit mode. The R/W pin (5) of the LCD module is permanently grounded as there won’t be any data read from the LCD module. RC0-RC3 serves the 4-bit data lines (D4-D7, pins 11-14) of the LCD module. Control lines, RS and E, are connected to RC4 and RC5. Thus, altogether 6 I/O pins of the PIC16F688 microcontrollers are used by the LCD module. The contrast adjustment is done with a 5K potentiometer as shown below. If your LCD module has backlight LED, use a 68Ω resistance in series with the pin 15 or 16 to limit the current through the LED. The detail of the circuit diagram is shown below.

For more detail: Lab 4: Interfacing a character LCD using PIC16F688

The post Lab 4: Interfacing a character LCD using PIC16F688 appeared first on PIC Microcontroller.

Figure 1 shows the basic relay driver circuit. As you can see an NPN transistor BC547 is being used to control the relay. The transistor is driven into saturation (turned ON) when a LOGIC 1 is written on the PORT PIN thus turning ON the relay. The relay is turned OFF by writing LOGIC 0 on the port pin. A diode (1N4007/1N4148) is connected across the relay coil; this is done so as to protect the transistor from damage due to the BACK EMF generated in the relay’s inductive coil when the transistor is turned OFF. When the transistor is switched OFF the energy stored in the inductor is dissipated through the diode & the internal resistance of the relay coil. Normally 1N4148 can be used as it is fast switching diode with a maximum forward current of 300ma. This diode is also called as free-wheeling diode.

The LED is used to indicate that the RELAY has been turned ON. The resistor R1 defines the current flowing through the LED thereby defining the LED’s intensity.

Resistor R2 is used as a Series Base Resistor to set the base current. When working with 8051 controllers I have noted that it’s not compulsory to use this resistor as the controller has internal 10k resistor which acts as a base resistor.

Microcontrollers have internal pull up resistors hence when a port pin is HIGH the output current flows through this internal pull up resistor. 8051 microcontrollers have an internal pull up of 10KΩ. Hence the maximum output current will be  5v/10k = 0.5ma. This current is not sufficient to drive the transistor into saturation and turn ON the relay. Hence an external pull up resistor R3 is used. Let us now calculate the value of R3.

Normally a relay requires a pull in current of 70ma to be turned ON. So our BC547 transistor will require enough base current to make sure it remains saturated and provide the necessary collector current i.e. 70ma. The gain (h_fe) of BC547 is 100 so we need to provide at least   70ma/100 = 0.7ma  of base current. In practice you require roughly double the value of this current so we will calculate for 1.4ma of base current.

For more detail: Interfacing Relay to Microcontroller Schematic

Current Project / Post can also be found using:

• 5 pin 24vdc relay
• transistor 548

The post Interfacing Relay to Microcontroller appeared first on PIC Microcontroller.

To interface LCD (Displaytech 162A) with PIC16F877microcontroller and to display “IITK” in the Liquid Crystal Display (LCD).

1. MPLAB IDE (PIC microcontrollers simulator)
2. PIC BURNER 3 with software to load the code
3. LCD (Displaytech 162A)
4. Computer System with Windows operating system and RS 232 cable
5. PIC16F877 Microcontroller

1. +5V D.C Power Supply
2. Resistors – 10K Ω-1,50Ω-1
3. Capacitors – 27 µ F-2
4. Potentiometers – 10K Ω -1
5. 20MHz Crystal oscillator
6. SPST switches -1

1. Write the assembly code in MPLAB IDE simulator , compile it and check for errors
2. Once the code was error free, run it and check the output in the simulator.
3. After checking the code in the simulator, load the code (in .HEX format) into PIC16F877 microcontroller using PIC BURNER3.
4. Make connections as shown in the circuit diagram.
5. Switch on the power supply and observe “IITK” displayed in the LCD.

Liquid Crystal Display (LCD-Displaytech 162A )LCD Displaytech 162A consists of a LCD panel, a controller IC (KS0070B) and a back light LED. The LCD module consists of total 16 pins in which, 2 are for power supply, 2 pins for Backlight LED, one pin for contrast adjustment, 3 pins are for control signals and 8 pins are data pins. In order to display any data, we need to do certain initiations. The following are the main three steps in displaying any data in the LCD display.

1. Initializing LCD by sequence of instructions
2. Executing commands depending on our settings in the LCD
3. Writing data into the DRAM locations of LCD in the Standard Character Pattern of LCD

For doing above steps, refer the manual for LCD and follow the instructions and timing diagrams strictly.
MPLABIDEMPLABIDE is a free software which can be downloaded from the website www.microchip.com
Working with MPLABIDE :
MPLABIDE is a simulator for PIC microcontrollers to write and edit the code in assembly language, compile it and also to run the code. Output can be verified using simulator.

For more detail: Lecture 43  Interfacing PIC16F877 Microcontroller with an LCD

The post Lecture 43 : Interfacing PIC16F877 Microcontroller with an LCD appeared first on PIC Microcontroller.

Interfacing is one of the important concepts in microcontroller 8051 because the microcontroller is a CPU that can perform some operation on a data and gives the output. However to perform the operation we need an input device to enter the data and in turn output device displays the results of the operation. Here we are using keyboard and LCD display as input and output devices along with the microcontroller.

Interfacing is the process of connecting devices together so that they can exchange the information and that proves to be easier to write the programs. There are different type of input and output devices as for our requirement such as LEDs, LCDs, 7segment, keypad, motors and other devices.

Here is given some important modules interfaced with microcontroller 8051.

1. LED Interfacing to Microcontroller:

Description:

LEDs are most commonly used in many applications for indicating the output. They find huge range of applications as indicators during test to check the validity of results at different stages. They are very cheap and easily available in a variety of shape, color and size.

The principle of operation of LEDs is very easy. A simple LEDs also servers as a basic display devices, it On and OFF state express meaning full information about a device. The common available LEDs have a 1.7v voltage drop that means when we apply above 1.7V, the diode conducts. The diode needs 10mA current to glow with full intensity.

The following circuit describes “how to glow the LEDs”.

LEDs can be interfaced to the microcontroller in either common anode or common cathode configuration. Here the LEDs are connected in common anode configuration because the common cathode configuration consumes more power.

Source code:

#include<reg51.h>
void main()
{
unsigned int i;
while(1)
{
P0=0x00;
for(i=0;i<30000;i++);
P0=0xff;
for(i=0;i<30000;i++);}}

2. 7-Segment Display interfacing circuit

Description:
A Seven segment display is the most basic electronic display. It consists of eight LEDs which are associated in a sequence manner so as to display digits from 0 to 9 when proper combinations of LEDs are switched on. A 7-segment display uses seven LEDs to display digits from 0 to 9 and the 8th LED is used for dot.

The 7-segment displays are used in a number of systems to display the numeric information. They can display one digit at a time. Thus the number of segments used depends on the number of digits to display. Here the digits 0 to 9 are displayed continuously at a predefined time delay.

The 7-segment displays are available in two configurations which are common anode and common cathode. Here common anode configuration is used because output current of the microcontroller is not sufficient enough to drive the LEDs. The 7-segment display works on negative logic, we have to provide logic 0 to the corresponding pin to make on LED glow.

Source Code:

#include<reg51.h>
sbit a= P3^0;
void main()
{
unsigned char n[10]= {0x40,0xF9,0x24,0x30,0x19,0x12,0x02,0xF8,0xE00,0x10};
unsigned int i,j;
a=1;
while(1)
{
for(i=0;i<10;i++)
{
P2=n[i];
for(j=0;j<60000;j++);
}
}
}

3. LCD Interfacing to Microcontroller

LCD stands for liquid crystal display which can display the characters per line. Here 16 by 2 LCD display can display 16 characters per line and there are 2 lines. In this LCD each character is displayed in 5*7 pixel matrix.

LCD is very important device which is used for almost all automated devices such as washing machines, an autonomous robot, power control systems and other devices. This is achieved by displaying their status on small display modules like 7-seven segment displays, multi segment LEDs etc. The reasons being, LCDs are reasonably priced, easily programmable and they have a no limitations of displaying special characters.

It consists of two registers such as command/instruction register and data register.

The command/instruction register stores the command instructions given to the LCD. A command is an instruction which is given to the LCD that perform a set of predefined tasks like initializing, clearing the screen, setting the cursor posing, controlling display etc.

The data register stores the data to be displayed on LCD. The data is an ASCII value of the characters to be displayed on the LCD.

Operation of LCD is controlled by two commands. When RS=0, R/W=1 it reads the data and when RS=1, R/W=0, it writes (print) the data.

Source code:

#include<reg51.h>
#define kam P0

sbit rs= P2^0;
sbit rw= P2^1;
sbit en= P2^2;

void lcd_initi();
void lcd_dat(unsigned char );
void lcd_cmd (unsigned char );
void delay(unsigned int );
void display(unsigned char *s, unsigned char r);
void main()
{lcd_initi();
lcd_cmd(0x80);
delay(100);
display(“EDGEFX TECHLNGS”, 15);

lcd_cmd(0xc0);display(“KITS & SOLTIONS”,15);
while(1);}void display(unsigned char *s, unsigned char r)
{unsigned int w;
for(w=0;w<r;w++)
{lcd_dat(s[w]);}}

void lcd_initi(){lcd_cmd(0x01);delay(100);lcd_cmd(0x38);
delay(100);lcd_cmd(0x06);delay(100);
lcd_cmd(0x0c);delay(100);}
void lcd_dat(unsigned char dat)
{kam = dat;
rs=1;
rw=0;

en=1;
delay(100);
en=0;}void lcd_cmd(unsigned char cmd)
{kam=cmd;rs=0;rw=0;en=1;
delay(100);en=0;}
void delay( unsigned int n)
{unsigned int a;
for(a=0;a<n;a++);}

For more detail: Major Electronic Peripherals Interfacing to Microcontroller 8051

The post Major Electronic Peripherals Interfacing to Microcontroller 8051 appeared first on PIC Microcontroller.

Embedded C Program for DS-1307 I2C Communication

#include <16F877.h>

#include <lcd_4bit.c>

#use delay(clock=4000000)

#define RTC_SDA  PIN_C4

#define RTC_SCL  PIN_C3

#use i2c(master, sda=RTC_SDA, scl=RTC_SCL)

void rtc_get_time() ;

int convert(int k);

int sec,min,hr,k[20],z,k1[20];

int day1,date,month,year;

void main()

{SETUP_ADC(ADC_OFF);

lcd_init();

while(1)

{rtc_get_time();

lcd_cmd(0x80);

sprintf(k,”%02d:%02d:%02d”,hr,min,sec);

lcd_array(k);

lcd_cmd(0xc0);

sprintf(k1,”%02d:%02d:%02d “,date,month,year,);

lcd_array(k1);

lcd_cmd(0xc9);

switch(day1)

{

case 1: lcd_str(“Sunday”);

break;

case 2: lcd_str(“Monday”);

break;

case 3: lcd_str(“Tuesday”);

break;

case 4: lcd_str(“Wednesday”);

break;

case 5: lcd_str(“Thursday”);

break;

case 6: lcd_str(“Friday”);

break;

case 7: lcd_str(“Saturday”);

break;

} }}

void rtc_get_time()

{

  i2c_start();

  i2c_write(0xD0);

  i2c_write(0x00);

  i2c_start();

  i2c_write(0xD1);

  sec = i2c_read();

  min = i2c_read();

  hr  = i2c_read();

 day1=i2c_read();

 date=i2c_read();

 month=i2c_read();

 year=i2c_read(0);

  i2c_stop();

 

 sec= convert(sec);

 min= convert(min);

 hr= convert(hr);

 day1= convert(day1);

 date= convert(date);

 month= convert(month);

 year= convert(year);

 z=’a’;

if(hr>12)

{

hr=hr-12;

z=’p’;

}

}

int convert(int k)

{

int a0,a1,a;

 a0=((k&0x0F));

 a1=k>>4;

  a=((a1*10)+a0);

  return a;

}

Above shows  a simple program to read the Time value from DS-1307 IC. RTC Ds-1307 consumes very low power(500nA), so it can be backup by a battery for power failure issues.   For DS1307, the device address is D0. The data, for example seconds value, located in the zeroth register is taken and converted from BCD to integer, before displaying it on the LCD. We can also write the Time value to Ds1307 registers one by one.

For more detail: Interfacing DS1307 to PIC Microcontroller with C code and Circuit Diagram

The post Interfacing DS1307 to PIC Microcontroller with C code and Circuit Diagram appeared first on PIC Microcontroller.

This post provides the solution for using the PIC controller UART interface (e-g to connect PIC controller with PC using serial adapter).

Complete code and simulation can be downloaded from the ‘Downloads‘ section at the bottom of this post. The following figure shows the result of simulation of PIC UART in Proteus7.6.

In the main function UART is intialized by calling the function InitUART (defined in the serial.c file included in the project). Then a Hello World! is sent on the UART terminal (e-g using serial adapter you can display this Hello World! on Hyper Terminal on PC). After that, interrupts are enabled because in the Interrupt Service Routine (ISR) UART interrupt is handled as shown below in the code.

The code was compiled in MPLAB v8.76 with HI-TECH C and simulation was made in Proteus v7.6.
To download code click here.
To download Proteus simulation click here.

For more detail: Interfacing with UART of PIC microcontroller

The post Interfacing with UART of PIC microcontroller appeared first on PIC Microcontroller.

In this session we will see how to interface 16×2 LCD to PIC18F4550 microcontroller which is of family PIC18F. You can get information of 16×2 LCD in the session How to Interface 16X2 LCD with 8051 Microcontroller

Features of PIC18F4550:

• PIC18F4550 belongs to the PIC18F family; PIC18F4550 is an 8bit microcontroller and uses RISC architecture. PIC18F4550 has 40 pins in PDIP (dual in line package) and 44 pin in TQFP (Quad flat package).
• 32KB flash memory, 2048 bytes of SRAM (synchronous Random Access memory), EEPROM (Electrically Erasable Program Read Only Memory) of 256 bytes are embedded in the PIC18F4550.
• It has 35 I/O pins for interfacing and communication with other peripherals, 13channel of 10bit analog to digital converters which are used for interfacing and communicating the analog peripherals (DC motor, LDR, etc.).

It has 2 CCP and 1 ECCP module that is enhanced capture and compare module which is mainly used for modulation and waveform generation functions. CCP module is of 16bit register works as 16 capture bit register, 16 compare bit register, and PWM and duty cycle register.

• PIC18F4550 has SPI (serial peripheral interface) and i2c (inter integrated circuit) for master and slave modes. It has SPP (Streaming Parallel Port) for USB streaming transfer.
• PIC18F4550 is embedded with 4 timer modules (timer0 to timer3), 2 comparator modules and 3 external interrupt. It has Dual Oscillator options allow microcontroller and USB module to run at different clock speeds. It can operate in 2.0V to 5.5V
  

16X2 LCD Interfacing PIC Microcontroller – Circuit Explanation:

The resistor R1 is used for giving the contrast to the LCD. The crystal oscillator of 12 MHz is connected to the OSC1 and OSC2 pins of Pic microcontroller PIC18F4550 for system clock. The capacitor C2 and C3 will act filters to the crystal oscillator. You can use different ports or pins for interfacing the LCD before going to different ports please check the data sheet whether the pins for general purpose or they are special function pins.

Programming PIC for Interfacing 16X2 LCD:

Interfacing LCD to PIC is not different from interfacing to 8051. The basic concept and gist of the programming is almost same. Visit the following link for more information http://www.electronicshub.org/interfacing-16×2-lcd-8051/.

Only the pins, registers and architecture using for interfacing will be different. When we look at the program, functions like initialization, sending data to the LCD will be almost same.

In the pic programming also for initializing the LCD the R/W pin should be low for writing the data, Enable pins should be high and register select pin (RS) should be high for writing the data. For sending a command the RS should be low, R/W pin should be low and enable pin should be high.

Initializing the LCD function:

lcdcmd(0x38);//Configure the LCD in 8-bit mode,2 line and 5×7 font
lcdcmd(0x0C);// Display On and Cursor Off
lcdcmd(0x01);// Clear display screen
lcdcmd(0x06);// Increment cursor
lcdcmd(0x80);// Set cursor position to 1st line,1st column

Sending command to the LC:

• rs=0;    Register select pin is low.                                                      
• rw=0;  Read/write Pin is also for writing the command to the LCD.
• en=1;enable pin is high.

Sending data to the LCD:

• rs=1; Register select pin is high.
• rw=0; Read/write Pin is also for writing the command to the LCD.
• en=1; enable pin is high.

Steps for Programming:

• Install MPLAB in your system and create a new project, in selecting device and family select PIC18F family and add PIC18F4550 controller to your project.
• Select the compiler which you have installed and add the file to your project. After adding the file paste the code which is given below and run it. As it is a precompiled and tested program you will not find any errors.
• After compiling the program with no errors dump the program into your development board using PICKIT2 or PICKIT3 programmer/ debugger.
• If you are not using PICKIT then just compile the code and make the HEX file use this HEX file for programming the PIC microcontroller.

For more detail: Interfacing16X2 LCD with PIC Microcontroller

The post Interfacing16X2 LCD with PIC Microcontroller appeared first on PIC Microcontroller.

ESP8266 wifi module interfacing with pic microcontroller: Hi everyone I hope you are fine and doing well. In this tutorial, I will guide you how to interface ESP8266 wifi module with pic microcontroller. We will be using pic18f46k22 microcontroller in this tutorial. I have seen many tutorials on internet on various websites related to interfacing of ESP8266 wifi module with Arduino But I have not found a single tutorial on how to interface ESP8266 wifi module with pic microcontroller. This module can be used to make internet of things based pic microcontroller projects. I have made a project on wifi based home automation system in which I also used esp8266 module. This module can be used in many applications. For example you can use it to send data to server and you can also use to control servo motor from website. It is very easy to interface this module with arduinobecause there are many resources available online related to Arduino. But in case of pic microcontroller you have to develop your library yourself.

The post ESP8266 wifi module interfacing with pic microcontroller appeared first on PIC Microcontroller.

servo motor interfacing WITH 8051 MICROCONTROLLER: This article is about interfacing of servo motor with 8051 microcontroller. You will learn how to interface and control this motor using 8051 microcontroller. Servo motors are used in robotics, embedded systems and industries because they are very precise and reliable. They are used to operate remote control toy cars, airplanes or robots. Their motion can be controlled by rotating them in particular angle. Servo motor can be controlled by PWM signal. In this article we will interface servo motor with 8051 microcontroller and control its speed.  I will recommend you to read a article on how to used keil compiler and how to use I/O ports of 8051 microcontroller before learning about interfacing servo motor with 8051.

The post servo motor interfacing with 8051 using keil compiler appeared first on PIC Microcontroller.

STEPPER MOTOR INTERFACING WITH 8051 MICROCONTROLLER: Stepper motors are type of DC motors. Stepper motor has multiple electromagnetic coils that are arranged in group called phases. Motor rotates when particular phase is energized. One step rotation occurs at a time by energizing a particular coil. We can also control the speed of motor. It can be interfaced with 8051 microcontroller but the same case is here about DC motors that we can’t connect them directly with controller. Here in this article we will learn how to interface stepper motor with 8051 microcontroller. Before starting this article you should know how to use keil for 8051 programmingand how to use input output ports of 8051 microcontroller.

The post STEPPER MOTOR INTERFACING WITH 8051 MICROCONTROLLER appeared first on PIC Microcontroller.

DC MOTOR INTERFACING WITH 8051 MICROCONTROLLER: In many projects of embedded systems, we may need to control a DC motor using controller.  It is not good to connect DC motor directly to the microcontroller. Since the maximum current that can be sink from 8051 microcontroller is 15 mA at 5v. But a DC Motor needs much more currents. It also needs more voltages as 6v, 12v, 24v etc., (depending upon the type of motor used). One more thing to notice is that the back emf produced by the motor may affect the proper functioning of the microcontroller and reversing the direction can damage the controller. Due to these reasons we can’t connect a DC Motor directly to a microcontroller. This article will demonstrate how to control the DC motor using AT89C51 Microcontroller.

The post DC MOTOR INTERFACING WITH 8051 MICROCONTROLLER appeared first on PIC Microcontroller.

INTERFACING LCD WITH 8051 MIROCONTROLLER: In this article you will learn how to interface lcd with 8051 microcontroller. It is not very hard for interfacing lcd with 8051 microcontroller when you already know how to use kiel for programming of 8051 and how to used input output ports of 8051 microcontroller. LCD is used for displaying alphabets, numbers or some messages etc.  We already learnt about the use of LCD using PIC microcontroller in previous article. Now in this tutorial we will study how to interface LCD with 8051 microcontroller. 8051 is basic level of using controllers, so it’s a bit difficult as compared to PIC microcontroller and LCD interfacing code is also changed here. you can also scroll text on lcd as we did in pic microcontroller tutorial.

The post INTERFACING LCD WITH 8051 MIROCONTROLLER with code appeared first on PIC Microcontroller.

INTERFACING ADC USING 8051 MICROCONTROLLER: In this article you will learn how to interface, analog to digital converter with 8051 microcontroller. Unlike, pic microcontroller, Arduino and avr microcontroller, 8051 microcontroller do not have built in ADC.  if we want to interface any sensor with 8051 microcontroller, we have to use external ADC. For example, you want to measure temperature with 8051 microcontroller and you are using LM35 temperature sensor to measure temperature. LM35 temperature sensor gives output in the form of analog voltage. So we need to use analog to digital converter. We use Analogue to digital convertor (ADC) to convert the analogue signal into digital form. Analogue signal can be the output of some sensor. And then the data in digital format can then be used for further processing by the digital processors. Now in this tutorial we will learn about ADC 0804 and its interfacing using 8051 microcontroller.

The post INTERFACING ADC 0804 with 8051 MICROCONTROLLER appeared first on PIC Microcontroller.

Bluetooth module HC 05 interfacing with pic microcontroller: Hi Everyone, In this article I will explain you how to interface Bluetooth module HC 05 with pic16f877a microcontroller or any other microcontroller like 8051, AVR and Arduino. It is very easy to communicate with android mobile through Hc 05 Bluetooth module. It has many applications and this Bluetooth module Hc 05 is very popular in engineering students. Many students use this module in their microcontroller based projects. Examples of most popular Bluetooth based project are robot control through android mobile and home automation system. You can also use it to measure solar energy on your sell phone through android application.

Page Contents

• 1 Introduction to Bluetooth module HC 05
• 2 Bluetooth module HC 05 pin out
• 3 Bluetooth module HC 05 interfacing with pic microcontroller
• 4 LED control with Bluetooth module Hc 05 sing pic microcontroller
• 5 Solar energy measurement on android app using pic microcontroller
• 6 Code of Bluetooth module interfacing with pic microcontroller

Introduction to Bluetooth module HC 05

So lets start with basic introduction of Bluetooth module Hc 05. It has single chip on board integrated circuit based on CMOS technology.It has upto +4dBm transmission power.It has wide operating voltages between 3.6 to 6 volt. Default baud rate of this device is 9600. But you can change it according to your requirement by using AT commands. I will explain later how to use AT commands of this bluetooth module. HC 05 work on serial communication. It communicates with microcontroller through UART communication. So you should know how to use serial communication of pic microcontroller. If you know serial communication programming of pic16f877a controller you can easily interface this module and write a program in C.

The post Bluetooth module HC 05 interfacing with pic microcontroller appeared first on PIC Microcontroller.

Finger Print Sensor, which we used to see in Sci-Fi movies a few years back, is now become very common to verify the identity of a person for various purposes. In present time we can see fingerprint-based systems everywhere in our daily life like for attendance in offices, employee verification in banks, for cash withdrawal or deposits in ATMs, for identity verification in government offices etc. We have already interfaced it with Arduino and with Raspberry Pi, today we are going to interface Finger Print Sensor with PIC microcontroller. Using this PIC microcontroller PIC16f877A Finger Print System, we can enroll new fingerprints in the system and can delete the already fed fingerprints. Complete working of the system has been shown in the Video given at the end of article.

Required Components

1. PIC16f877A Microcontroller
2. Fingerprint Module
3. Push buttons or keypad
4. 16×2 LCD
5. 10k pot
6. 18.432000 MHz Crystal Oscillator
7. Bread Board or PCB (ordered from JLCPCB)
8. Jumper wires
9. LED (optional)
10. Resistor 150 ohm -1 k ohm (optional)
11. 5v Power supply

Circuit Diagram and Explanation

In this PIC Microcontroller Finger Print sensor interfacing project, we have used 4 push buttons: these buttons are used for multifunctioning. Key 1 is used for matching the finger print and increment fingerprint ID while storing or deleting the fingerprint in the system. Key 2 is used for enrolling the new fingerprint and for decrement fingerprint ID while storing or deleting fingerprint in the system. Key 3 is used for delete stored finger from the system and key 4 is used for OK. A LED is used for an indication that fingerprint is detected or matched. Here we have used a fingerprint module which works on UART. So here we have interfaced this fingerprint module with PIC microcontroller at its default baud rate which is 57600.

So, first of all, we need to make the all the required connection as shown in Circuit Diagram below. Connections are simple, we have just connected fingerprint module to PIC microcontroller’s UART. A 16×2 LCD is used for displaying all messages. A 10k pot is also used with LCD for controlling the contrast of the same. 16×2 LCD data pins are connected PORTA pins. LCD’s d4, d5, d6, and d7 pins are connected with Pin RA0, RA1, RA2, and RA3 of PIC microcontroller respectively. Four push buttons (or keypad) is connected to PORTD’s Pin RD0, RD1, RD2, and RD. LED is also connected at port PORTC’s pin RC3. Here we have used an 18.432000 MHz external crystal oscillator to clock the microcontroller.

Operation of Fingerprint Sensor with PIC Microcontroller

Operation of this project is simple, just upload hex file, generated from source code, into the PIC microcontroller with the help of PIC programmer or burner (PIckit2 or Pickit3 or others)and then you will see some intro messages over LCD and then the user will be asked to enter a choice for operations. To match fingerprint user need to press key 1 then LCD will ask for Place Finger on Finger Print Sensor. Now by putting a finger over fingerprint module, we can check whether our fingerprints are already stored or not. If your fingerprint is stored then LCD will show the message with the storing ID of fingerprint-like ‘ID:2’ otherwise it will show ‘Not Found’.

Now to enroll a finger Print, the user needs to press enroll button or key 2 and follow the instructions messages on the LCD screen.

If the user wants to delete any of fingerprints then the user needs to press the delete button or key 3. After which, LCD will ask for the ID of the fingerprint which is to be deleted. Now by using increment push button or key 1(match push button or key 1) and decrement push button or key 2 (enroll push button or key 2) for increment and decrement, the user can select the ID of saved Finger Print and press OK button to delete that fingerprint. For more understanding have a look at the video given at the end of the project.

FingerPrint interfacing Note: Program of this project is a little bit complex for a beginner. But its simple interfacing code made by using reading r305 fingerprint module datasheet. All the instruction of functioning of this fingerprint module is given in the datasheet.

Here we have used a frame format to talk with fingerprint module. Whenever we send a command or data request frame to fingerprint module it responds us with the same frame format containing data or information related to applied command. All of the data and command frame format has been given in the user manual or in the datasheet of R305 fingerprint module.

Programming Explanation

In programming, we have used the below frame format.

uchar buf[20];
uchar buf1[20];
volatile uint index=0;
volatile int flag=0;
uint msCount=0;
uint g_timerflag=1;
volatile uint count=0;
uchar data[10];
uint id=1;

enum
{
 CMD,
 DATA,
 SBIT_CREN=4,
 SBIT_TXEN,
 SBIT_SPEN,
};

const char passPack[]={0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x7, 0x13, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1B};
const char f_detect[]={0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x3, 0x1, 0x0, 0x5};
const char f_imz2ch1[]={0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x4, 0x2, 0x1, 0x0, 0x8};
const char f_imz2ch2[]={0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x4, 0x2, 0x2, 0x0, 0x9};
const char f_createModel[]={0xEF,0x1,0xFF,0xFF,0xFF,0xFF,0x1,0x0,0x3,0x5,0x0,0x9};
char f_storeModel[]={0xEF,0x1,0xFF,0xFF,0xFF,0xFF,0x1,0x0,0x6,0x6,0x1,0x0,0x1,0x0,0xE};
const char f_search[]={0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x8, 0x1B, 0x1, 0x0, 0x0, 0x0, 0xA3, 0x0, 0xC8};
char f_delete[]={0xEF,0x1,0xFF,0xFF,0xFF,0xFF,0x1,0x0,0x7,0xC,0x0,0x0,0x0,0x1,0x0,0x15};

void lcdwrite(uchar ch,uchar rw)
{
     LCDPORT= ch>>4 & 0x0F;
     RS=rw;
     EN=1;
     __delay_ms(5);
     EN=0;
     LCDPORT= ch & 0x0F;
     EN=1;
     __delay_ms(5);
     EN=0;   
}

​lcdprint(char *str)
{

    while(*str)
    {
        lcdwrite(*str++,DATA);
        //__delay_ms(20);
    }
}

lcdbegin()
{
    uchar lcdcmd[5]={0x02,0x28,0x0E,0x06,0x01};
    uint i=0;
    for(i=0;i<5;i++)
    lcdwrite(lcdcmd[i], CMD);
}

void serialbegin(uint baudrate)
{
  SPBRG = (18432000UL/(long)(64UL*baudrate))-1;      // baud rate @18.432000Mhz Clock
    TXSTAbits.SYNC = 0;                              //Setting Asynchronous Mode, ie UART
    RCSTAbits.SPEN = 1;                              //Enables Serial Port
    TRISC7 = 1;                                   //As Prescribed in Datasheet
    TRISC6 = 0;                                   //As Prescribed in Datasheet
    RCSTAbits.CREN = 1;                                     //Enables Continuous Reception
    TXSTAbits.TXEN = 1;                                     //Enables Transmission

    GIE  = 1; // ENABLE interrupts
    INTCONbits.PEIE = 1; // ENable peripheral interrupts.
    PIE1bits.RCIE   = 1; // ENABLE USART receive interrupt
    PIE1bits.TXIE   = 0; // disable USART TX interrupt

    PIR1bits.RCIF = 0;
}

void serialwrite(char ch)
{
    while(TXIF==0);  // Wait till the transmitter register becomes empty
    TXIF=0;          // Clear transmitter flag
    TXREG=ch;        // load the char to be transmitted into transmit reg
}

serialprint(char *str)
{
    while(*str)
    {
        serialwrite(*str++);
    }
}

void interrupt SerialRxPinInterrupt(void)
{
    if((PIR1bits.RCIF == 1) && (PIE1bits.RCIE == 1))
    {
       
        uchar ch=RCREG;
        buf[index++]=ch;
        if(index>0)
            flag=1;
        RCIF = 0; // clear rx flag
    } 
}

void serialFlush()
{
    for(int i=0;i<sizeof(buf);i++)
    {
        buf[i]=0;
    }
}

int sendcmd2fp(char *pack, int len)
{
  uint res=ERROR;
  serialFlush();
  index=0;
  __delay_ms(100);
  for(int i=0;i<len;i++)
  {
    serialwrite(*(pack+i));
  }
  __delay_ms(1000);
  if(flag == 1)
  {
    if(buf[0] == 0xEF && buf[1] == 0x01)
    {
        if(buf[6] == 0x07)   // ack
        {
        if(buf[9] == 0)
        {
            uint data_len= buf[7];
            data_len<<=8;
            data_len|=buf[8];
            for(int i=0;i<data_len;i++)
                data[i]=0;
            for(int i=0;i<data_len-2;i++)
            {
                data[i]=buf[10+i];
            }
            res=PASS;
        }

        else
        {
         res=ERROR;
        }
        }
    }

int main()
{           
  void (*FP)(); 
  ADCON1=0b00000110;
  LEDdir= 0;
  SWPORTdir=0xF0;
  SWPORT=0x0F;
  serialbegin(57600);
  LCDPORTDIR=0x00;
  TRISE=0;
  lcdbegin();
  lcdprint("Fingerprint");
  lcdwrite(192,CMD);
  lcdprint("Interfacing");
  __delay_ms(2000);
  lcdwrite(1,CMD);
  lcdprint("Using PIC16F877A");
  lcdwrite(192,CMD);
  lcdprint("Circuit Digest");
  __delay_ms(2000);
  index=0;   
  while(sendcmd2fp(&passPack[0],sizeof(passPack)))
  {
     lcdwrite(1,CMD);
     lcdprint("FP Not Found");
     __delay_ms(2000);
     index=0;
  }
  lcdwrite(1,CMD);
  lcdprint("FP Found");
  __delay_ms(1000);
  lcdinst();
  while(1)
  {
    FP=match<enrol?matchFinger:enrol<delet?enrolFinger:delet<enrol?deleteFinger:lcdinst;
    FP();
  }
  return 0;
}

The post Interfacing Fingerprint Sensor with PIC Microcontroller appeared first on PIC Microcontroller.

Thermal printer is often referred as receipt printer. It is widely used in restaurants, ATM, shops and many other places where receipts or bill is required. It is a cost-effective solution and very handy to use from the user’s side as well as from the developer’s side. A thermal printer uses a special printing process which uses thermochromic paper or thermal paper for printing. The printer head is heated at a certain temperature that when the thermal paper passes from the print head, the paper coating turns black in the areas where the printer head is heated.

In this tutorial, we will interface a thermal printer CSN A1 with widely used PIC microcontroller PIC16F877A. Here in this project, a thermal printer is connected across PIC16F877A and a tactile switch is used to start the printing. A notification LED is also used to notify the printing status. It will glow only when the printing activity is going on.

// PIC16F877A Configuration Bit Settings
// 'C' source line config statements

// CONFIG
#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = ON       // Brown-out Reset Enable bit (BOR enabled)
#pragma config LVP = OFF         // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3/PGM pin has PGM function; low-voltage programming enabled)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

#include <xc.h>
#include "supporting_cfile\eusart1.h"
/*
 * System hardware related macros
 */
#define _XTAL_FREQ 200000000 //Crystal Frequency, used in delay routine
#define printer_sw PORTBbits.RB0 //this macro is for defining the printing switch
#define notification_led PORTBbits.RB2
void system_init(void);

void main(void) {    
    system_init();        
    while(1){
        if(printer_sw == 1){ //switch is pressed
            __delay_ms(50); // debounce delay
            if (printer_sw == 1){ // switch is still pressed
                notification_led = 1;                
                put_string("Hello! \n\r");//Print to Thermal printer
                __delay_ms(50);
                put_string("Thermal Printer Tutorial.\n\r");
                __delay_ms(50);
                put_string("Circuit Digest. \n\r");
                __delay_ms(50);
                put_string ("\n\r");
                put_string ("\n\r");
                put_string ("\n\r");
                put_string ("---------------------------- \n \r");
                put_string ("Thank You");
                put_string ("\n\r");
                put_string ("\n\r");
                put_string ("\n\r");
                notification_led = 0;
                } 
            }  
        }
    }

The post Thermal Printer interfacing with PIC16F877A appeared first on PIC Microcontroller.

RFID stands for Radio Frequency Identification. RFID module can read or write small amount of data into a Passive RFID tag, which can be used in identification process in various systems like Attendance system, security system, voting system etc. RFID is very convenient and easy technology.

To read the Passive RFID cards and tag, we need a microcontroller with UART hardware. If we select a microcontroller without UART, we need to implement software UART. Here we are using PIC Microcontroller PIC16F877A for interfacing RFID. We will simply read the unique identification no. of RFID tags and display it on 16×2 LCD.

RFID module and its Working

In this project, we chose EM-18 RFID module, which is small-sized, low cost, and power efficient module. EM-18 RFID module use 125 KHz RF frequency to read passive 125 KHz RFID tags. EM-18 module use Oscillator, demodulator and data decoder to read data from a passive card.

RFID Tag

There are three types of RFID tags available, Passive, Active or Battery-assisted passive. Different kind of RFID tags with a different kind of shapes and sizes are available in the market. Few of them use different frequency for communication purpose. We will use 125Khz Passive RFID cards which holds the unique ID data. Here are the RFID card and tags we are using for this project.

Working of RFID

The module uses UART communication protocol in 9600 Baud rate. When a Valid frequency tag is brought into the magnetic field of the EM-18 reader, the BC557 transistor gets on and the buzzer will start beeping, it also glows the LED. We are using a module which is easily available in the market and has complete circuitry with a buzzer, led, and an additional RS232 port.
Here is the RFID board module we are using with pin names. This module also has additional power option.

One thing needs to be kept in mind that the output of EM-18 reader uses 5V logic level. We could use another microcontroller which uses a lower logic level, but in such cases, the additional logic level converter is required. In few cases, the UART pin of the 3.3V microcontroller is often 5V tolerant.

The UART output provides 12-bit ASCII data. First 10 bits are RFID tag number, which is the unique ID and last two digits are used for error testing. Those last two digits are the XOR of the tag number. EM-18 module will read the data from 125 KHz Passive RFID tags or cards.

Those tags or IDs have a factory programmed memory array which stores the unique ID number. As those are passive, so no battery is present in the card or tags, they get energized by the magnetic field of the RF Transceiver module. These RFID tags are made using the EM4102 CMOS IC which is clocked by the magnetic field too.

Material Required

To make this project we need following items-

1. PIC16F877A
2. 20Mhz Crystal
3. 2pcs 33pF ceramic disc capacitor
4. 16×2 Character LCD
5. A breadboard
6. 10k preset pot
7. 4.7k resistor
8. Single strand wires to connect
9. A 5V adapter
10. RF Module EM-18
11. 5V Buzzer
12. 100uF & .1uF 12V capacitor
13. BC557 Transistor
14. LED
15. 2.2k and 470R resistor.

We are using the EM-18 module board with buzzer and led preconfigured. So, the components listed from 11 to 15 are not needed.

Circuit Diagram

The schematic is simple; we connected LCD across port RB and connected the EM-18 module across the UART Rx pin.

We have made the connection on breadboard according to schematic.

// PIC16F877A Configuration Bit Settings
// 'C' source line config statements
// CONFIG

#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = ON       // Brown-out Reset Enable bit (BOR enabled)
#pragma config LVP = OFF         // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3/PGM pin has PGM function; low-voltage programming enabled)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

#include "supporing_cfile\lcd.h"
#include "supporing_cfile\eusart1.h"

/*
 This Function is for system initializations.
 */

void system_init(void){
    TRISB = 0x00; //PORT B set as output pin
    lcd_init(); // This will initialize the lcd
    EUSART1_Initialize(); // This will initialize the Eusart
}

void main(void) {
    unsigned char count;
    unsigned char RF_ID[13];    
    system_init();
    lcd_com(0x80);
    lcd_puts("Circuit Digest");    
    while (1){        
        for (count=0; count<12; count++){
            RF_ID[count] = 0;
            RF_ID[count]=EUSART1_Read();
        }        
        lcd_com(0xC0); // Set the cursor for second line beginning
        lcd_puts("ID: ");
        lcd_puts(RF_ID);        
    }
}

The post RFID Interfacing with PIC Microcontroller appeared first on PIC Microcontroller.