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.

 

 

 

 

 

 

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. 

 

 

 

dsPIC30F2010 I2C PCF8574T HD44780 LCD

Introduction

In previous post, I use the PCF8574AP DIP-16 chip to expand the output of dsPIC30F2010. Since this chip is an 8-bit bi-directional I/O device, it can be used to connect to any I/O peripheral devices. even an HD44780 character LCD. 

 

Test Program

A character LCD module comes with a PCF8574T is very popular and low cost. It is commonly an Arduino LCD module widely used among the students and electronic hobbyists. There are a lot of Arduino programming examples for this stuffs. 

 

dsPIC30F2010 Simple I2C LCD using PCF8574T 

Controlling an HD44780 character LCD via a PCF8574T is very easy with some additional code to process the 4-bit data transfer mode of the LCD chip controller. In this example, the I2C master micro-controller send some character to a 16x2 character LCD via a PCF8574T chip. 

Schematic:

Schematic

 This post show a full I2C devices interfacing examples using an ATMega644P AVR chip.

MikroC Source Code:

1. 
   
2. const char PCF8574_W=0x40;
3. const char PCF8574_R=0x41;
4. const char PCF8574T_LCD_W=0x4E;
5. const char PCF8574T_LCD_R=0x4F;
6. const char PCF8574A_W=0x70;
7. const char PCF8574A_R=0x71;
8. 
   
9. void pcf8574_write(char _data){
10. I2C1_Start(); // issue I2C start signal
11. I2C1_Write(PCF8574T_LCD_W); // send byte via I2C (device address + W)
12. I2C1_Write(_data); // send byte (data address)
13. I2C1_Stop(); // issue I2C stop signal
14. }
15. 
    
16. /*TWI LCD Driver*/
17. #define RS 0
18. #define RW 1
19. #define EN 2
20. #define BL 3
21. 
    
22. #define i2c_lcd_cursor_off() i2c_lcd_command(0x0C)
23. #define i2c_lcd_line_1() i2c_lcd_command(0x80)
24. #define i2c_lcd_line_2() i2c_lcd_command(0xC0)
25. 
    
26. char backLight=1;
27. 
    
28. void i2c_lcd_command(char command){
29. char _data;
30. _data=command&0xF0;
31. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
32. //_delay_us(10);
33. pcf8574_write(_data|(backLight<<BL));
34. //_delay_us(50);
35. 
    
36. _data=command<<4;
37. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
38. //_delay_us(10);
39. pcf8574_write(_data|(backLight<<BL));
40. //_delay_us(50);
41. }
42. 
    
43. void i2c_lcd__data(char command){
44. char _data;
45. _data=command&0xF0;
46. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
47. //_delay_us(10);
48. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
49. Delay_us(50);
50. 
    
51. _data=command<<4;
52. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
53. //Delay_us(10);
54. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
55. //Delay_us(50);
56. }
57. 
    
58. void i2c_lcd_xy(char x, char y){
59. char addr[]={0x80,0xC0};
60. i2c_lcd_command(addr[y-1]+x-1);
61. }
62. 
    
63. void i2c_lcd_text(char *txt){
64. while(*txt) i2c_lcd__data(*txt++);
65. }
66. 
    
67. void i2c_lcd_clear(void){
68. i2c_lcd_command(0x01);
69. Delay_ms(5);
70. }
71. 
    
72. void i2c_lcd_init(void){
73. pcf8574_write(0);
74. Delay_ms(10);
75. i2c_lcd_command(0x33);
76. Delay_us(10);
77. i2c_lcd_command(0x32);
78. Delay_us(10);
79. i2c_lcd_command(0x28);
80. Delay_us(10);
81. i2c_lcd_command(0x0F);
82. Delay_us(10);
83. i2c_lcd_command(0x01);
84. Delay_ms(10);
85. i2c_lcd_command(0x06);
86. Delay_us(10);
87. }
88. 
    
89. void main(){
90. char temp = 0, i = 0;
91. I2C1_Init(10000); // initialize I2C communication
92. Delay_ms(10);
93. i2c_lcd_init();
94. Delay_ms(10);
95. i2c_lcd_text("dsPIC30F2010 I2C");
96. i2c_lcd_line_2();
97. i2c_lcd_text("PCF8574T LCD");
98. i2c_lcd_cursor_off();
99. 
    
100. while(1){
101. 
     
102. }
103. }

I test this example on my DIY dsPIC30F2010 Prototype Board. It works fine.

 

My DIY dsPIC30F2010 Prototype Board

dsPIC30F2010 5V DVM I2C LCD using PCF8574T 

There is one on-board POT. So I made a simple 5VDC Digital Volt Meter with this I2C LCD. The schematic remains the same a above.

 

Test Program

 

MikroC Source Code:

1. 
   
2. const char PCF8574_W=0x40;
3. const char PCF8574_R=0x41;
4. const char PCF8574T_LCD_W=0x4E;
5. const char PCF8574T_LCD_R=0x4F;
6. const char PCF8574A_W=0x70;
7. const char PCF8574A_R=0x71;
8. 
   
9. void pcf8574_write(char _data){
10. I2C1_Start(); // issue I2C start signal
11. I2C1_Write(PCF8574T_LCD_W); // send byte via I2C (device address + W)
12. I2C1_Write(_data); // send byte (data address)
13. I2C1_Stop(); // issue I2C stop signal
14. }
15. 
    
16. /*TWI LCD Driver*/
17. #define RS 0
18. #define RW 1
19. #define EN 2
20. #define BL 3
21. 
    
22. #define i2c_lcd_cursor_off() i2c_lcd_command(0x0C)
23. #define i2c_lcd_line_1() i2c_lcd_command(0x80)
24. #define i2c_lcd_line_2() i2c_lcd_command(0xC0)
25. 
    
26. char backLight=1;
27. 
    
28. void i2c_lcd_command(char command){
29. char _data;
30. _data=command&0xF0;
31. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
32. //_delay_us(10);
33. pcf8574_write(_data|(backLight<<BL));
34. //_delay_us(50);
35. 
    
36. _data=command<<4;
37. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
38. //_delay_us(10);
39. pcf8574_write(_data|(backLight<<BL));
40. //_delay_us(50);
41. }
42. 
    
43. void i2c_lcd__data(char command){
44. char _data;
45. _data=command&0xF0;
46. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
47. //_delay_us(10);
48. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
49. Delay_us(50);
50. 
    
51. _data=command<<4;
52. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
53. //Delay_us(10);
54. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
55. //Delay_us(50);
56. }
57. 
    
58. void i2c_lcd_xy(char x, char y){
59. char addr[]={0x80,0xC0};
60. i2c_lcd_command(addr[y-1]+x-1);
61. }
62. 
    
63. void i2c_lcd_text(char *txt){
64. while(*txt) i2c_lcd__data(*txt++);
65. }
66. 
    
67. void i2c_lcd_clear(void){
68. i2c_lcd_command(0x01);
69. Delay_ms(10);
70. }
71. 
    
72. void i2c_lcd_init(void){
73. pcf8574_write(0);
74. Delay_ms(10);
75. i2c_lcd_command(0x33);
76. Delay_us(10);
77. i2c_lcd_command(0x32);
78. Delay_us(10);
79. i2c_lcd_command(0x28);
80. Delay_us(10);
81. i2c_lcd_command(0x0F);
82. Delay_us(10);
83. i2c_lcd_command(0x01);
84. Delay_ms(10);
85. i2c_lcd_command(0x06);
86. Delay_us(10);
87. }
88. 
    
89. void main(){
90. unsigned int adc_rd;
91. char text[16];
92. long tlong;
93. float voltage;
94. ADPCFG = 0xFFFF; // Configure AN pins as digital
95. I2C1_Init(10000); // initialize I2C communication
96. Delay_ms(10);
97. i2c_lcd_init();
98. Delay_ms(10);
99. i2c_lcd_text("dsPIC30F2010 I2C");
100. i2c_lcd_line_2();
101. i2c_lcd_text("ADC PCF8574T LCD");
102. i2c_lcd_cursor_off();
103. Delay_ms(10000);
104. i2c_lcd_clear();
105. while(1){
106. adc_rd = ADC1_read(4); // get ADC value from 2nd channel
107. voltage = 5.0*adc_rd/1023;
108. i2c_lcd_line_1();
109. sprintf(text,"AN4 ADC: %4d 10", adc_rd);
110. i2c_lcd_text(text);
111. i2c_lcd_line_2();
112. sprintf(text,"Voltage: %.2f V", voltage);
113. i2c_lcd_text(text);
114. Delay_ms(500);
115. }
116. }

 

Using program C sprintf function is very easy to convert any data type into an array of ASCII characters. But it requires a lot of memory space. For limited ROM and RAM space, we can process the text, character, integer and floating point numbers one-by-one before sending it to UART or LCD stream. This post shows a simple number to ASCII character converting.

Archive: 

ADC Read Voltage 0.00 V

ADC Read Voltage 2.74 V

ADC Read Voltage 5.00 V

 See this short video on Youtube: