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.

  

 

dsPIC30F2010 and SN74HC595N 16x4 Character LCD

Introduction

The SN74HC595N outputs can control any devices such relays, LED, or even a HD44780-based character LCD. Using a single SN74HC595N shift registers a master MCU can control a character LCD using the LCD 4-bit data transfer mode.

 

Information Screen

I made my own serial character LCD using a SN74HC595N chip, a TC1604-01 16x4 HD44780 LCD, some passive components, and a DIY PCB.

 

 

 

DIY SN74HC595N 16x4 Serial LCD using TC1604-01 HD44780

However using its 4-bit data transfer mode, we need to care about the LCD RS and Enable Pin since the nibbles have to transfer twice. 

dsPIC30F2010 LCD Programming in MikroC

I need to write my own LCD driver routine for this example. However the source code is difficult than using the direct 4-bit LCD interface.

We can wire your own SPI LCD using the schematic below.

Schematic: 

 

Schematic Diagram

 

However the 16x2 and the 16x4 LCD pin outs are the same. We can use one of these.

In this example, the dsPIC30F2010 show some texts on this serial LCD module. 

MikroC Source Code:

 

1. /*TWI LCD Driver*/
2. #define RS 1
3. #define RW 2
4. #define EN 3
5. #define BL 0
6. 
   
7. // Chip Select Pin
8. sbit Chip_Select at LATE3_bit;
9. sbit Chip_Select_Direction at TRISE3_bit;
10. 
    
11. char backLight=0;
12. 
    
13. void lcd_delay(unsigned int counts){
14. unsigned int i=0;
15. for (i=0;i<counts;i++);
16. }
17. 
    
18. void spi_lcd_command(char command){
19. char _data;
20. _data=command&0xF0;
21. SPI1_Write(_data|(backLight<<BL)|(1<<EN));
22. Chip_Select = 0; // Select SPI chip
23. Chip_Select = 1; // Deselect SPI chip
24. 
    
25. SPI1_Write(_data|(backLight<<BL));
26. Chip_Select = 0; // Select SPI chip
27. Chip_Select = 1; // Deselect SPI chip
28. 
    
29. _data=command<<4;
30. SPI1_Write(_data|(backLight<<BL)|(1<<EN));
31. 
    
32. Chip_Select = 0; // Select SPI chip
33. lcd_delay(10);
34. 
    
35. Chip_Select = 1; // Deselect SPI chip
36. SPI1_Write(_data|(backLight<<BL));
37. Chip_Select = 0; // Select SPI chip
38. Chip_Select = 1; // Deselect SPI chip
39. }
40. 
    
41. void spi_lcd___data(char command){
42. char __data;
43. __data=command&0xF0;
44. SPI1_Write(__data|(backLight<<BL)|(1<<EN)|(1<<RS));
45. Chip_Select = 0; // Select SPI chip
46. Chip_Select = 1; // Deselect SPI chip
47. SPI1_Write(__data|(backLight<<BL)|(1<<RS));
48. Chip_Select = 0; // Select SPI chip
49. Chip_Select = 1; // Deselect SPI chip
50. lcd_delay(50);
51. 
    
52. __data=command<<4;
53. SPI1_Write(__data|(backLight<<BL)|(1<<EN)|(1<<RS));
54. Chip_Select = 0; // Select SPI chip
55. Chip_Select = 1; // Deselect SPI chip
56. SPI1_Write(__data|(backLight<<BL)|(1<<RS));
57. Chip_Select = 0; // Select SPI chip
58. Chip_Select = 1; // Deselect SPI chip
59. }
60. 
    
61. void spi_lcd_xy(char x, char y){
62. //16x2
63. //char addr[]={0x80,0xC0};
64. //16x4
65. char addr[]={0x80,0xC0,0x90,0xD0};
66. spi_lcd_command(addr[y-1]+x-1);
67. }
68. 
    
69. void spi_lcd_line_1(void){
70. spi_lcd_command(0x80);
71. }
72. 
    
73. void spi_lcd_line_2(void){
74. spi_lcd_command(0xC0);
75. }
76. 
    
77. void spi_lcd_line_3(void){
78. spi_lcd_command(0x90);
79. }
80. 
    
81. void spi_lcd_line_4(void){
82. spi_lcd_command(0xD0);
83. }
84. 
    
85. void spi_lcd_cursor_off(void){
86. spi_lcd_command(0x0C);
87. }
88. 
    
89. void spi_lcd_text(char *txt){
90. while(*txt) spi_lcd___data(*txt++);
91. }
92. 
    
93. void i2c_lcdClear(void){
94. spi_lcd_command(0x01);
95. Delay_ms(10);
96. }
97. 
    
98. void spi_lcd_init(void){
99. 
    
100. SPI1_Write(0);
101. lcd_delay(500);
102. spi_lcd_command(0x33);
103. lcd_delay(10);
104. spi_lcd_command(0x32);
105. lcd_delay(10);
106. spi_lcd_command(0x28);
107. lcd_delay(10);
108. spi_lcd_command(0x0F);
109. lcd_delay(10);
110. spi_lcd_command(0x01);
111. Delay_ms(20);
112. spi_lcd_command(0x06);
113. lcd_delay(50);
114. }
115. 
     
116. void main() {
117. Chip_Select = 1;
118. Chip_Select_Direction = 0; // Set CS# pin as Output
119. SPI1_Init(); // Initialize SPI module
120. spi_lcd_init();
121. Chip_Select = 1;
122. spi_lcd_line_1();
123. spi_lcd_text("dsPIC30F2010 SPI");
124. spi_lcd_line_2();
125. spi_lcd_text("SN74HC595N LCD");
126. spi_lcd_line_3();
127. spi_lcd_text("Programming with");
128. spi_lcd_line_4();
129. spi_lcd_text("MikroC for dsPIC");
131. while(1){
133. }
134. }

 

I tested this program on my DIY dsPIC30F1010 Prototype Board. It works fine. 

 

DIY dsPIC30F1010 Prototype Board

 

 

dsPIC30F2010 Simple DVM Serial LCD

There are one on-board POT. So we can make a simple 5VDC serial display digital voltmeter.  The variable DC input voltage is connect to RB4(AN4) pin via  a POT. Its maximum measurement is 5VDC since the supply and ADC reference voltage is 5VDC.

dsPIC30F2010 and SN74HC595N 16x4 Character LCD

MikroC Source Code:

 

1. /*TWI LCD Driver*/
2. #define RS 1
3. #define RW 2
4. #define EN 3
5. #define BL 0
6. 
   
7. // Chip Select Pin
8. sbit Chip_Select at LATE3_bit;
9. sbit Chip_Select_Direction at TRISE3_bit;
10. 
    
11. char backLight=0;
12. 
    
13. void lcd_delay(unsigned int counts){
14. unsigned int i=0;
15. for (i=0;i<counts;i++);
16. }
17. 
    
18. void spi_lcd_command(char command){
19. char _data;
20. _data=command&0xF0;
21. SPI1_Write(_data|(backLight<<BL)|(1<<EN));
22. Chip_Select = 0; // Select SPI chip
23. Chip_Select = 1; // Deselect SPI chip
24. 
    
25. SPI1_Write(_data|(backLight<<BL));
26. Chip_Select = 0; // Select SPI chip
27. Chip_Select = 1; // Deselect SPI chip
28. 
    
29. _data=command<<4;
30. SPI1_Write(_data|(backLight<<BL)|(1<<EN));
31. 
    
32. Chip_Select = 0; // Select SPI chip
33. lcd_delay(10);
34. 
    
35. Chip_Select = 1; // Deselect SPI chip
36. SPI1_Write(_data|(backLight<<BL));
37. Chip_Select = 0; // Select SPI chip
38. Chip_Select = 1; // Deselect SPI chip
39. }
40. 
    
41. void spi_lcd___data(char command){
42. char __data;
43. __data=command&0xF0;
44. SPI1_Write(__data|(backLight<<BL)|(1<<EN)|(1<<RS));
45. Chip_Select = 0; // Select SPI chip
46. Chip_Select = 1; // Deselect SPI chip
47. SPI1_Write(__data|(backLight<<BL)|(1<<RS));
48. Chip_Select = 0; // Select SPI chip
49. Chip_Select = 1; // Deselect SPI chip
50. lcd_delay(50);
51. 
    
52. __data=command<<4;
53. SPI1_Write(__data|(backLight<<BL)|(1<<EN)|(1<<RS));
54. Chip_Select = 0; // Select SPI chip
55. Chip_Select = 1; // Deselect SPI chip
56. SPI1_Write(__data|(backLight<<BL)|(1<<RS));
57. Chip_Select = 0; // Select SPI chip
58. Chip_Select = 1; // Deselect SPI chip
59. }
60. 
    
61. void spi_lcd_xy(char x, char y){
62. //16x2
63. //char addr[]={0x80,0xC0};
64. //16x4
65. char addr[]={0x80,0xC0,0x90,0xD0};
66. spi_lcd_command(addr[y-1]+x-1);
67. }
68. 
    
69. void spi_lcd_line_1(void){
70. spi_lcd_command(0x80);
71. }
72. 
    
73. void spi_lcd_line_2(void){
74. spi_lcd_command(0xC0);
75. }
76. 
    
77. void spi_lcd_line_3(void){
78. spi_lcd_command(0x90);
79. }
80. 
    
81. void spi_lcd_line_4(void){
82. spi_lcd_command(0xD0);
83. }
84. 
    
85. void spi_lcd_cursor_off(void){
86. spi_lcd_command(0x0C);
87. }
88. 
    
89. void spi_lcd_text(char *txt){
90. while(*txt) spi_lcd___data(*txt++);
91. }
92. 
    
93. void i2c_lcdClear(void){
94. spi_lcd_command(0x01);
95. Delay_ms(10);
96. }
97. 
    
98. void spi_lcd_init(void){
99. 
    
100. SPI1_Write(0);
101. lcd_delay(500);
102. spi_lcd_command(0x33);
103. lcd_delay(10);
104. spi_lcd_command(0x32);
105. lcd_delay(10);
106. spi_lcd_command(0x28);
107. lcd_delay(10);
108. spi_lcd_command(0x0C);
109. lcd_delay(10);
110. spi_lcd_command(0x01);
111. Delay_ms(20);
112. //spi_lcd_command(0x06);
113. lcd_delay(50);
114. }
115. 
     
116. void main() {
117. unsigned int temp_res;
118. float voltage=0;
119. char text[16];
120. TRISB = 0xFFFF; // PORTB is input
121. ADC1_Init(); // Enable ADC module
122. Delay_ms(10);
123. Chip_Select = 1;
124. Chip_Select_Direction = 0; // Set CS# pin as Output
125. SPI1_Init(); // Initialize SPI module
126. spi_lcd_init();
127. Chip_Select = 1;
128. spi_lcd_line_1();
129. spi_lcd_text("dsPIC30F2010 ADC");
130. spi_lcd_line_2();
131. spi_lcd_text("SN74HC595N SPI");
132. spi_lcd_line_3();
133. spi_lcd_text("LCD Voltmeter");
134. spi_lcd_line_4();
135. spi_lcd_text("MikroC for dsPIC");
136. Delay_ms(5000);
137. spi_lcd_command(0x01);
138. Delay_ms(20);
139. while(1){
140. // Get 10-bit results of AD conversion
141. temp_res = ADC1_Read(4);
142. voltage = (5.0 * temp_res)/1023;
143. spi_lcd_line_1();
144. spi_lcd_text(" AN4 ADC:");
145. spi_lcd_line_2();
146. sprintf(text," %4d Decimal",temp_res);
147. spi_lcd_text(text);
148. spi_lcd_line_3();
149. spi_lcd_text(" Voltage:");
150. spi_lcd_line_4();
151. sprintf(text," %0.4f Volts",voltage);
152. spi_lcd_text(text);
153. Delay_ms(500);
154. }
155. }

DIY dsPIC30F2010 Prototype Board:

 

ADC Voltage Reading

ADC Voltage Reading

ADC Voltage Reading

Information Screen

 

 

 

 

 

 

dsPIC30F2010 SPI Display 5VDC DVM using MikroC

In previous example, I use the SPI module of the dsPIC30F2010 to control a serial LED display and seven-segment display. Now let put them together making a serial display digital volt-meter.

 

ADC Reading 

 

There is one on-board POT so I use it to adjust input voltage that varies between 0 and +5VDC. It will show the reading voltage on a serial seven-segment display.

Schematic: 

Schematic Diagram

This is just schematic using device symbols. I can not be simulated like other build-in models. I download the dsPIC30F2010 symbol from SnapEDA for free. 

 

MikroC Source Code: 

1. 
   
2. // Chip Select Pin
3. sbit Chip_Select at LATE3_bit;
4. sbit Chip_Select_Direction at TRISE3_bit;
5. 
   
6. void SN74595_Send(char _data){
7. SPI_Write(_data); // Send high byte via SPI
8. Chip_Select = 0; // Select SPI chip
9. Chip_Select = 1; // Deselect SPI chip
10. }
11. 
    
12. // Common Cathod Segment Data
13. const char cc[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,
14. 0x7F,0x6F,0x77,0x7C,0x58,0x5E,0x79,0x71};
15. 
    
16. void show_number(char number){
17. SN74595_Send(~cc[number]);
18. }
19. 
    
20. 
    
21. 
    
22. void main() {
23. unsigned int temp_res;
24. float voltage=0;
25. char digit=0;
26. Chip_Select = 1; // Deselect DAC
27. Chip_Select_Direction = 0; // Set CS# pin as Output
28. SPI1_Init(); // Initialize SPI module
29. TRISB = 0xFFFF; // PORTB is input
30. TRISD = 0; // PORTD is output
31. TRISF = 0; // PORTF is output
32. ADC1_Init(); // Enable ADC module
34. while(1){
35. temp_res = ADC1_Read(4); // Get 10-bit results of AD conversion
36. voltage = (5.0 * temp_res)/1023;
37. digit = (char)voltage;
38. show_number(digit);
39. Delay_ms(500);
40. }
41. 
    
42. }

 
Using a 0.5 second delay time making the display run very smooth without glitching. It could saves the power consumption since the ADC reading is not so frequently. For more information about using the ADC please read this post.

 

Zero Volt ADC Reading

3 Volt ADC Reading

5 Volt ADC Reading

 I test example using my DIY dsPIC30F1010 Prototype Board. For more information about this PCB see this post.