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:

 

 

 

 

 

 

 

 

 

dsPIC30F2010 I2C and PCF8574 Interfacing using MikroC

Introduction

The dsPIC30F2010 is a 16-bit micro-controller. It means that its internal data bus is 16-bit wide. Additionally its I/O data is also 16-bit wide. However a small foot-print 16-bit MCU like the dsPIC30F2010 has only 28 pins including supply voltage pins, ADC voltage pins, clock pins ,etc. So we can get a full 16-bit input output from its pins.

 

Pin Diagrams

 

To get a full 8-bit or 16-bit external I/O, we need to add any I/O expansion chips. These chips implement the SPI or I2C interface. Here I use the PCF8574 I2C I/O expansion chip. This chip an 8-bit bidirectional micro-processor expansion chip. 

 

The PCF8574 Series 

The device features an 8-bit quasi-bidirectional I/O port (P0–P7), including latched outputs with high current drive capability for directly driving LEDs. Each quasi-bidirectional I/O can be used as an input or output without the use of a data-direction control signal. At power on, the I/Os are high. In this mode, only a current source to VCC is active.

This chip is suitable for,

• Telecom Shelters: Filter Units
• Servers
• Routers (Telecom Switching Equipment)
• Personal Computers
• Personal Electronics
• Industrial Automation
• Products with GPIO-Limited Processors 

PCF8574 Interfacing Diagram

PCF8574AP DIP-16

We can event use this chip for a 4x4 matrix keypad, or driving an HD44780-base character LCD.

 

Pin Configuration and Functions

This device has various package types. A PDIP-16 or a SOIC-16 are common for most of electronics hobbyists.

 

Simplified Block Diagram of Device

This device has an 8-bit customizable slave address with R/W bit.

PCF8574 Interface Definition

 

We can custom its optional slave address via A2...A0 bits. Its default write address when A2...A0 are wired to GND is 0x40.

 

Address Reference

 

The Master I2C device need to write device slave address followed by output port data twice.

PCF8574 Write Mode

To read from this I2C slave device, the microprocessor need to write device read address (eg. 0x41), followed by I2C in read mode.

PCF8574 Read Mode

 

We can use various I/O devices with this chip.

 

PCF8574 Typical Application

 Interrupt Output (INT) pin is optional.

 

dsPIC30F2010 I2C Programming using MikroC

MikroC for dsPIC offer a build-in dedicated and software I2C libraries. Both of them are stable and reliable for most of applications. It excepts that the software I2C operates at lower clock frequency.

Here I use its dedicated I2C module. Most of dsPIC30F MCUs have more than one I2C module. 

Important :

• I²C library routines require you to specify the module you want to use. To select the desired I²C module, simply change the letter x in the routine prototype for a number from 1 to 3.
• Number of I²C modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

These are its library routines:

Library Routines

• I2Cx_Init
• I2Cx_Start
• I2Cx_Restart
• I2Cx_Is_Idle
• I2Cx_Read
• I2Cx_Write
• I2Cx_Stop
• I2C_Set_Active

Generic Routines

• I2C_Start
• I2C_Restart
• I2C_Is_Idle
• I2C_Read
• I2C_Write
• I2C_Stop

 For more information about using the I2C module, please see this page.

PCF8574AP Output LEDs Example

For an introductory example, the dsPIC30F2010 send an 8-bit data to this chip. The 8-bit output of PCF8574AP connect individual LED.

 

Schematic:

Schematic

 MikroC Source Code:

 

1. 
   
2. const char PCF8574_W=0x40;
3. const char PCF8574_R=0x41;
4. const char PCF8574A_W=0x70;
5. const char PCF8574A_R=0x71;
6. 
   
7. void pcf8574_write(char device, char _data){
8. I2C1_Start(); // issue I2C start signal
9. I2C1_Write(device); // send byte via I2C (device address + W)
10. I2C1_Write(_data); // send byte (data address)
11. I2C1_Stop(); // issue I2C stop signal
12. }
13. 
    
14. void blink(unsigned int duration, unsigned int counts){
15. while(counts>0){
16. pcf8574_write(PCF8574A_W,0x00);
17. Vdelay_ms(duration);
18. pcf8574_write(PCF8574A_W,0xFF);
19. Vdelay_ms(duration);
20. counts--;
21. }
22. pcf8574_write(PCF8574A_W,0x00);
23. }
24. void main(){
25. char temp = 0, i = 0;
26. I2C1_Init(100000); // initialize I2C communication
27. Delay_ms(10);
28. pcf8574_write(PCF8574A_W,0x00);
29. blink(100,100);
30. while(1){
31. pcf8574_write(PCF8574A_W,temp);
32. temp+=(1<<i);
33. i++;
34. if(i > 8) i = temp = 0;
35. Delay_ms(200);
36. }
37. }

 

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 For a full I2C devices interfacing example using the ATMega644P chip see this post.

 

 

 

dsPIC30F2010 and Nokia 5110 LCD Software SPI in MikroC

Introduction

Nokia 5510 LCD Module is 84x48 monochrome graphical LCD that use a Philip PCD8544 pixel matrix LCD controller/driver. It is very easy to use since it uses only three wires SPI interface with some additional control pin. It configuration setting is simple that is very similar to the KS0108 LCD controller except the three wires SPI interface. Using this interface is easy to connect and maintenance with a master MCU. 

 

Program Testing

 

 This graphical LCD is widely available at very low cost. Most electronic hobbyists use this LCD with an Arduino. However different micro-controllers can control this display via a dedicated or software SPI.

 

dsPIC30F2010 and Nokia 5110 LCD Programming using MikroC

MikroC doesn't have a build-in library for this LCD module. But it has both hardware and software SPI to communicate with any devices. Hardware or dedicated SPI is very fast even at the speed of Fosc/4 of a micro-controller clock.

 

Program Testing

 

I can not properly configure the hardware SPI module of the dsPIC30F2010 at this time. So I use its software SPI library instead due to its select-able pins and lower transmission speed. Commonly the Nokia 5110 LCD is unable to operates at high clock frequency. It should be below 500kbps.

Schematic:

Schematic Diagram

 

In this example, I use this LCD to shows some texts on screen. I can not put any additional graphic due to its limited ROM. The dsPIC30F2010 has only 12kBytes of ROM space. 

MikroC Source Code:

1. 
   #include "font.c"
2. 
   
3. sbit Chip_Select at LATE0_bit;
4. sbit SoftSpi_CLK at LATE1_bit;
5. sbit SoftSpi_SDI at RE2_bit;
6. sbit SoftSpi_SDO at LATE3_bit;
7. 
   
8. sbit RST at LATE4_bit;
9. //sbit CS at LATE5_bit;
10. sbit D_C at LATE5_bit;
11. 
    
12. sbit Chip_Select_Direction at TRISE0_bit;
13. sbit SoftSpi_CLK_Direction at TRISE1_bit;
14. sbit SoftSpi_SDI_Direction at TRISE2_bit;
15. sbit SoftSpi_SDO_Direction at TRISE3_bit;
16. 
    
17. sbit RST_Direction at TRISE4_bit;
18. //sbit CS_Direction at TRISE5_bit;
19. sbit D_C_Direction at TRISE5_bit;
20. 
    
21. #define LCD_C 0
22. #define LCD_D 1
23. 
    
24. #define LCD_X 84
25. #define LCD_Y 48
26. 
    
27. void LcdCharacter( char charactor);
28. void LcdClear(void);
29. void LcdInitialize(void);
30. void LcdString( char *charactor);
31. void LcdWrite( char dc,unsigned char _data);
32. void setXy(char x,char y);
33. 
    
34. void main() {
35. LcdInitialize();
36. LcdClear();
37. setXy(0,0);
38. LcdString("MikroC dsPIC");
39. setXy(0,1);
40. LcdString("Nokia 5510");
41. setXy(0,2);
42. LcdString("Monochrome");
43. setXy(0,3);
44. LcdString("LCD Example");
45. setXy(0,4);
46. LcdString("dsPIC30F2010");
47. setXy(0,5);
48. LcdString("16-bit MCU");
49. 
    
50. while(1){
51. 
    
52. }
53. }
54. 
    
55. void LcdCharacter( char character){
56. int i;
57. LcdWrite(LCD_D,0x00);
58. for(i=0;i<5;i++) LcdWrite(LCD_D,ASCII[character-0x20][i]);
59. LcdWrite(LCD_D,0x00);
60. }
61. 
    
62. void LcdClear(void){
63. int i;
64. for(i=0;i<LCD_X*LCD_Y/8;i++) LcdWrite(LCD_D,0x00);
65. }
66. 
    
67. void LcdInitialize(void){
68. Chip_Select_Direction = 0; // Set CS# pin as Output
69. RST_Direction = 0;
70. D_C_Direction = 0;
71. Soft_SPI_Init(); // Initialize Soft_SPI
72. 
    
73. RST=0;
74. RST=1;
75. Chip_Select=1;
76. 
    
77. LcdWrite(LCD_C,0x21); // LCD Extended Commands
78. LcdWrite(LCD_C,0xB0); // SET LCD CONTRAST
79. LcdWrite(LCD_C,0x04); // set temp coefficient 0x04
80. LcdWrite(LCD_C,0x14); // LCD bias 1:48 0x13
81. LcdWrite(LCD_C,0x20);
82. LcdWrite(LCD_C,0x0C); // LCD normal Mode
83. }
84. 
    
85. void LcdString( char *character){
86. while(*character) LcdCharacter(*character++);
87. }
88. 
    
89. void LcdWrite( char _dc, char _data){
90. D_C =_dc;
91. Chip_Select=0;
92. Soft_SPI_Write(_data);
93. Chip_Select=1;
94. }
95. 
    
96. /*Set the cursor*/
97. void setXy(char x,char y){
98. /*x ranges from 0 to 83*/
99. LcdWrite(LCD_C, 0x80+(6*x));
100. /*y ranges from 0 to 5*/
101. LcdWrite(LCD_C, 0x40+y);
102. }

 

I tested this example, on my DIY dsPIC30F2010 Prototype Board. The LCD dots is not clear due to its poor quality.