PIC18F4550 and HD44780 LCD Interfacing Example using MikroC

Overview

The HD44780 alphanumeric display has been using for many years now. In early years, it is commonly found in some electronic and control system, laser printers, etc. At that time, interfacing this LCD with an 8-bit micro-controller and programming in Assembly language was common. This display controller uses the Motorola 6800 data bus with three control signals, Register Select (RS), Read/Write (R/W), and Enable (E). However it support a 4-bit data transfer mode that split the 8-bit data into higher nibble and lower nibble, in which the higher nibble sent and latched first.

 

A Blue Back LED 16x2 Character LCD

A Blue Back LED 16x2 Character LCD

 

Currently, this display controller still in used. It is very popular among students, engineer, hobbyists, and small electronic control projects. There are a lot of replacement controllers available at very low cost and riches in dimensions. Using this LCD with and Arduino is very popular due to its ready-to-use module and libraries. This display can be converted into a serial communication interface such as I2C or SPI.

 

PIC18F4550 and a 16x2 LCD Example

MikroC has a lot of hardware libraries even in free mode. We can follow its example programs in its reference manual. To get started, I repeat an example code in its Lcd Libary. There are some library functions that we need to know especially the LCD pins declaration.

Library Routines

• Lcd_Init
• Lcd_Out
• Lcd_Out_Cp
• Lcd_Chr
• Lcd_Chr_Cp
• Lcd_Cmd

The LCD pins declaration such as R/S, E, and D7:4 must be putted first at the head of C source code before these functions can be called. For more information please see its Help file in the compiler IDE. 

Schematic

 

Schematic

 

 

MikroC Source Code

1. 
   
2. 
   
3. // LCD module connections
4. sbit LCD_RS at RD2_bit;
5. sbit LCD_EN at RD3_bit;
6. sbit LCD_D4 at RD4_bit;
7. sbit LCD_D5 at RD5_bit;
8. sbit LCD_D6 at RD6_bit;
9. sbit LCD_D7 at RD7_bit;
10. 
    
11. sbit LCD_RS_Direction at TRISD2_bit;
12. sbit LCD_EN_Direction at TRISD3_bit;
13. sbit LCD_D4_Direction at TRISD4_bit;
14. sbit LCD_D5_Direction at TRISD5_bit;
15. sbit LCD_D6_Direction at TRISD6_bit;
16. sbit LCD_D7_Direction at TRISD7_bit;
17. // End LCD module connections
18. 
    
19. char txt1[] = "mikroElektronika";
20. char txt2[] = "EasyPIC6";
21. char txt3[] = "Lcd4bit";
22. char txt4[] = "example";
23. 
    
24. char i; // Loop variable
25. 
    
26. void Move_Delay() { // Function used for text moving
27. Delay_ms(500); // You can change the moving speed here
28. }
29. 
    
30. void main(){
31. 
    
32. 
    
33. Lcd_Init(); // Initialize LCD
34. 
    
35. Lcd_Cmd(_LCD_CLEAR); // Clear display
36. Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off
37. Lcd_Out(1,6,txt3); // Write text in first row
38. 
    
39. Lcd_Out(2,6,txt4); // Write text in second row
40. Delay_ms(2000);
41. Lcd_Cmd(_LCD_CLEAR); // Clear display
42. 
    
43. Lcd_Out(1,1,txt1); // Write text in first row
44. Lcd_Out(2,5,txt2); // Write text in second row
45. 
    
46. Delay_ms(2000);
47. 
    
48. // Moving text
49. for(i=0; i<4; i++) { // Move text to the right 4 times
50. Lcd_Cmd(_LCD_SHIFT_RIGHT);
51. Move_Delay();
52. }
53. 
    
54. while(1) { // Endless loop
55. for(i=0; i<8; i++) { // Move text to the left 7 times
56. Lcd_Cmd(_LCD_SHIFT_LEFT);
57. Move_Delay();
58. }
59. 
    
60. for(i=0; i<8; i++) { // Move text to the right 7 times
61. Lcd_Cmd(_LCD_SHIFT_RIGHT);
62. Move_Delay();
63. }
64. }
65. }

 

DIY PIC18F4550 Prototype Board

I tested this example on my DIY PIC18F4550 Prototype Board.

 

PIC18F4550 Prototype Board

PIC18F4550 Prototype Board

 

 

On-board Switches and LCD Example

In this example, when one of two on-board push buttons is pressed it will shows its state - Press or Released. The schematic is shown in the example above.

MikroC Source Code

 

#define SW4 RB4_bit
#define SW5 RB5_bit

// LCD module connections
sbit LCD_RS at RD2_bit;
sbit LCD_EN at RD3_bit;
sbit LCD_D4 at RD4_bit;
sbit LCD_D5 at RD5_bit;
sbit LCD_D6 at RD6_bit;
sbit LCD_D7 at RD7_bit;

sbit LCD_RS_Direction at TRISD2_bit;
sbit LCD_EN_Direction at TRISD3_bit;
sbit LCD_D4_Direction at TRISD4_bit;
sbit LCD_D5_Direction at TRISD5_bit;
sbit LCD_D6_Direction at TRISD6_bit;
sbit LCD_D7_Direction at TRISD7_bit;
// End LCD module connections


void main(){

  /// PORTB AS INPUT
  PORTB = 0;
  LATB = 0;
  TRISB = (1<<5)|(1<<4);
  
  // ENABLE PORTB PULL-UP
  INTCON2 &=~(1<<7);
  // DISABLE ANALOG INPUTS
  ADCON1 = 0x0F;
  
  Lcd_Init();                        // Initialize LCD

  Lcd_Cmd(_LCD_CLEAR);               // Clear display
  Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off

  Lcd_Out(1,1,"PIC18F4550 LCD");
  Lcd_out(2,1,"Buttons Example");

  Delay_ms(7000);
  Lcd_Cmd(_LCD_CLEAR);               // Clear display
  Lcd_Out(1,1, "Press on SW4.");
  Lcd_Out(2,1, "Press on SW5.");
  while(1){
    if(SW4==0){
      Lcd_Out(1,1, "SW4 is Pressed.");
      while(SW4 == 0);
      Lcd_Out(1,1, "SW4 is Released.");
    }
    if(SW5==0){
      Lcd_Out(2,1, "SW5 is Pressed.");
      while(SW5 == 0);
      Lcd_Out(2,1, "SW5 is Released.");
    }
  }
}

 

Example Pictures

I tested this example on my DIY PIC18F4550 Prototype Board.

 

My DIY PIC18F4550 Prototype Board

My DIY PIC18F4550 Prototype Board

My DIY PIC18F4550 Prototype Board

 

 

 

  

PIC18F4550 LED and Switch Interfacing using MikroC

Introduction

PIC18F4550 is a high performance 8-bit PIC micro-controller produced by Microchip Technology nearly two decades now. It's a USB micro-controller since it has a USB interface that supports up to USB 2.0. It operates up to 48MHz by enable its Phase Lock Loop (PLL) with pre-scaler and post-scaler settings.

 

A DIY PIC18F4550 Prototype Board

 

It has up to 5 I/O ports ranging from PORTA to PORTE. They are digital programmable input output ports. Some ports have an alternative functions such as ADC inputs, PWM output, SPI, I2C, interrupt capture, etc.

PIC18F4550-I/P I stock and its pin diagram

 

This 8-bit chip is very easy to program since there are a lot of compilers including Assembly and C. Using Assembly is free since the manufacture offer this feature with it MPLABX IDE compiler.  

Today, using a high level programming language is common since modern micro-controllers have a large RAM and Flash memory space. The XC8 C compiler is free of charge with some limited C language features. Some commercial C compiler for this chip are CCS PICC, Mikroelektronika MikroC, IAR Embedded Workbench for PIC18, etc. 

However Mikroelektronika offers a free version of its compiler for evaluation without limiting any features. But the compiling code is not larger than 2KB. It's suitable for any small control project, students and hobbyists.

 

PIC18F4550 LED Blinking using MikroC

I test the oscillator and on-board LED of my DIY PIC18F4550 prototype board by blinking an LED connects to RD0.

The on-board crystal clock frequency is 20MHz. So need to do additional configurations to get a 48MHz clock frequency. It's useful to drive the USB hardware clock of this micro-controller. 

After creating a new project, go to Project menu and click on Edit Project as show in the picture below.

 

Edit Project to set a 48MHz clock frequency.

Schematic

 

Schematic

 

 

MikroC Source Code

1. 
   #define LED LATD0_bit
2. 
   
3. void main() {
4. PORTD = 0;
5. LATD = 0;
6. TRISD = 0;
7. while(1){
8. LED = 0;
9. Delay_ms(1000);
10. LED = 1;
11. Delay_ms(1000);
12. }
13. }

 

 Hardware Test

 

LED Blinking at RD0

 We can do the LED blinking using MPLABX XC8 or CCS PICC Compiler with the same chip.

 

PIC18F4550 LED and Button Test using MikroC

There two on-board user buttons for testing the input of RB4 and RB5 pin. RB4 has an alternative analog input function. So we need to disable analog input at this pin, or even all analog input pins. By clearing the PCFG3:PCFG0 nibble of the ADCON1, all analog input function will disabled.

Unlike the mid-range 8-bit PIC microcontroller, the high end 8-bit PIC micro-controllers have an additional output data latch port registers (LATx). We use this register for data output. 

Most of PORTB of any 8-bit PIC micro-controllers have an optional PortB Pull-Up (nRBPU). In PIC18F4550, we just clear the nRBPU bit of the INTCON1 register to enable this feature. 

In this example, I tested the input from RB5:RB4 of PORTB that will toggle the output LATD7:LATD6 LED. 

 

Schematic

 

Schematic

 

 

MikroC Source Code

1. 
   #define SW4 RB4_bit
2. #define SW5 RB5_bit
3. #define LED4 LATD6_bit
4. #define LED5 LATD7_bit
5. 
   
6. const millis = 500;
7. 
   
8. void main() {
9. /// PORTB AS INPUT
10. PORTB = 0;
11. LATB = 0;
12. TRISB = (1<<5)|(1<<4);
13. // PORTD AS OUTPUT
14. PORTD = 0;
15. LATD = 0;
16. TRISD = 0;
17. // ENABLE PORTB PULL-UP
18. INTCON2 &=~(1<<7);
19. // DISABLE ANALOG INPUTS
20. ADCON1 = 0x0F;
21. // TEST LED
22. LED4=1;
23. LED5=1;
24. Delay_ms(5000);
25. LED4 = 0;
26. LED5 = 0;
27. while(1){
28. if(SW4==0){
29. Delay_ms(millis);
30. LED4^=1;
31. }
32. if(SW5==0){
33. Delay_ms(millis);
34. LED5^=1;
35. }
36. }
37. }

  

PIC18F4550 DIY Prototype Board 

 

DIY PIC18F4550 Prototype Board

DIY PIC18F4550 Prototype Board

DIY PIC18F4550 Prototype Board

 

 I tested this example on my DIY PIC18F4550 Prototype Board.

 

dsPIC30F2010 Software I2C LCD and RTC

Introduction

A dedicated I2C module of a micro-controller including the dsPIC30F2010 is fixed. For instance the I2C1 port pins of the dsPIC30F2010 are RF2(SDA) and RF3(SCL). These pins share with other communication module such as ICSP and UART1. So we need to disconnect them first before setting up a proper communication port connection. However, some modern micro-controllers have a port remapping for communication interface pins.  

 

PCF8574T Software I2C Character LCD

 

On the other hand, the I2C communication protocol is very easy to emulate via software bit-banging method using Assembly, C, or even other high level programming languages. Mikro C offers both hardware and software I2C library routines. We can check its user's manual for details. Here I cut only some key-points:

External dependencies of Software I²C Library

The following variables must be defined in all projects using Software I²C Library:	Description :	Example :
extern sbit Soft_I2C_Scl;	Soft I²C Clock line.	sbit Soft_I2C_Scl at RB11_bit;
extern sbit Soft_I2C_Sda;	Soft I²C Data line.	sbit Soft_I2C_Sda at RB12_bit;
extern sbit Soft_I2C_Scl_Direction;	Direction of the Soft I²C Clock pin.	sbit Soft_I2C_Scl_Direction at TRISB11_bit;
extern sbit Soft_I2C_Sda_Direction;	Direction of the Soft I²C Data pin.	sbit Soft_I2C_Sda_Direction at TRISB12_bit;

Library Routines

• Soft_I2C_Init
• Soft_I2C_Start
• Soft_I2C_Read
• Soft_I2C_Write
• Soft_I2C_Stop
• Soft_I2C_Break

 

The Soft_I2C_Scl and Soft_I2C_Sda must be declared first before we can use the Soft_I2C_Init function. The Software I2C operates at lower clock speed and need more program space (ROM) since it's a purely software communication protocol.

 

dsPIC30F2010 Interfacing and Programming using MikroC

 

We can select any pins of the dsPIC30F2010 to operates a software I2C communication protocol. Here I use RD0 for SCL and RD1 for SDA. I'm not sure about its SCL clock frequency since I don't have an oscilloscope.

Schematic:

 

Schematic

 

In this example a PCF8574T character LCD and a DS3231 Real Time Clock (RTC) chip use a single I2C bus to communication with the master MCU.  The MCU continuous read the RTC data from DS3231 and shows it on the I2C character LCD. The DS3231 timing is very precise since it uses its internal calibrated RC oscillator.

PCF8574T Arduino TWI HD44780 LCD Module

 

Arduino DS3231 High Precision Real Time Clock Module

Arduino DS3231 High Precision Real Time Clock Module

 

The PCF8574T and DS3231 Arduino module are widely used among students and hobbyists due to its low cost and less complexity. 

MikroC Source Code:

1. 
   
2. // Software I2C connections
3. sbit Soft_I2C_Scl at RD0_bit;
4. sbit Soft_I2C_Sda at RD1_bit;
5. sbit Soft_I2C_Scl_Direction at TRISD0_bit;
6. sbit Soft_I2C_Sda_Direction at TRISD1_bit;
7. // End Software I2C connections
8. 
   
9. const char PCF8574_W=0x40;
10. const char PCF8574_R=0x41;
11. const char PCF8574T_LCD_W=0x4E;
12. const char PCF8574T_LCD_R=0x4F;
13. const char PCF8574A_W=0x70;
14. const char PCF8574A_R=0x71;
15. 
    
16. void pcf8574_write(char _data){
17. Soft_I2C_Start(); // issue I2C start signal
18. Soft_I2C_Write(PCF8574T_LCD_W); // send byte via I2C (device address + W)
19. Soft_I2C_Write(_data); // send byte (data address)
20. Soft_I2C_Stop(); // issue I2C stop signal
21. }
22. 
    
23. /*TWI LCD Driver*/
24. #define RS 0
25. #define RW 1
26. #define EN 2
27. #define BL 3
28. 
    
29. #define i2c_lcd_cursor_off() i2c_lcd_command(0x0C)
30. #define i2c_lcd_line_1() i2c_lcd_command(0x80)
31. #define i2c_lcd_line_2() i2c_lcd_command(0xC0)
32. 
    
33. char backLight=1;
34. 
    
35. void i2c_lcd_command(char command){
36. char _data;
37. _data=command&0xF0;
38. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
39. //_delay_us(10);
40. pcf8574_write(_data|(backLight<<BL));
41. //_delay_us(50);
42. 
    
43. _data=command<<4;
44. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
45. //_delay_us(10);
46. pcf8574_write(_data|(backLight<<BL));
47. //_delay_us(50);
48. }
49. 
    
50. void i2c_lcd__data(char command){
51. char _data;
52. _data=command&0xF0;
53. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
54. Delay_us(10);
55. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
56. Delay_us(50);
57. 
    
58. _data=command<<4;
59. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
60. Delay_us(10);
61. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
62. Delay_us(50);
63. }
64. 
    
65. void i2c_lcd_xy(char x, char y){
66. char addr[]={0x80,0xC0};
67. i2c_lcd_command(addr[y-1]+x-1);
68. }
69. 
    
70. void i2c_lcd_text(char *txt){
71. while(*txt) i2c_lcd__data(*txt++);
72. }
73. 
    
74. void i2c_lcd_clear(void){
75. i2c_lcd_command(0x01);
76. Delay_ms(5);
77. }
78. 
    
79. void i2c_lcd_init(void){
80. pcf8574_write(0);
81. Delay_ms(10);
82. i2c_lcd_command(0x33);
83. Delay_us(10);
84. i2c_lcd_command(0x32);
85. Delay_us(10);
86. i2c_lcd_command(0x28);
87. Delay_us(10);
88. i2c_lcd_command(0x0F);
89. Delay_us(10);
90. i2c_lcd_command(0x01);
91. Delay_ms(10);
92. i2c_lcd_command(0x06);
93. Delay_us(10);
94. }
95. 
    
96. void rtc_set(void){
97. char rtc[7]={0x35,0x12,0x17,0x05,0x15,0x10,0x26};
98. char i=0;
99. Soft_I2C_Start(); // issue I2C start signal
100. Soft_I2C_Write(0xD0); // send byte via I2C (device address + W)
101. Soft_I2C_Write(0); // send byte (data address)
102. while(i<7){
103. Soft_I2C_Write(rtc[i]);
104. i++;
105. }
106. Soft_I2C_Stop();
107. }
108. void main(){
109. char temp[7], i = 0, text[16];
110. Soft_I2C_Init(); // Initialize Soft I2C communication
111. 
     
112. Delay_ms(10);
113. //rtc_set();
114. i2c_lcd_init();
115. Delay_ms(10);
116. i2c_lcd_clear();
117. 
     
118. i2c_lcd_text("Software I2C");
119. i2c_lcd_line_2();
120. i2c_lcd_text("PCF8574T DS3231");
121. i2c_lcd_cursor_off();
122. Delay_ms(5000);
123. i2c_lcd_clear();
124. while(1){
125. for(i = 0; i < 7; i++){
126. Soft_I2C_Start(); // issue I2C start signal
127. Soft_I2C_Write(0xD0); // send byte via I2C (device address + W)
128. Soft_I2C_Write(i); // send byte (data address)
129. Soft_I2C_Stop();
131. Soft_I2C_Start();
132. Soft_I2C_Write(0xD1); // send byte (device address + R)
133. temp[i] = Soft_I2C_Read(0u); // Read the data (NO acknowledge)
134. Soft_I2C_Stop(); // issue I2C stop signal
135. }
136. sprintf(text,"Date: %2X/%2X/20%2X",temp[4],temp[5],temp[6]);
137. i2c_lcd_line_1();
138. i2c_lcd_text(text);
139. sprintf(text,"Time: %2X/%2X/%2X",temp[2],temp[1],temp[0]);
140. i2c_lcd_line_2();
141. i2c_lcd_text(text);
142. Delay_ms(800);
143. }
144. }

The sprintf function uses a lot of memory space. We can process the ASCII data one-by-one to save memory space of the MCU.

 

DS3231 and PCF8574T Software I2C Programming

DS3231 and PCF8574T Software I2C Programming

 

I tested this program on my DIY dsPIC30F2010 Prototype Board. 

 

 

For a full software TWI programming examples please see this post.