ATMega644P SPI SN74HC595N TC1604A LCD

The SN74HC595N is an output expansion chip that could drive any devices, LED, relay or even writing data to LCD. A character LCD is easily controlled by this chip in write mode. A single chip SN74HC595N can control the HD44780 using its 4-bit data transfer mode.

 

 

 

In this example the ATMega644P master SPI send HD44780 LCD data and command to the LCD via an SN74HC595N shift registers chip.

A finished Assembling. SN74HC595N is soldered on-board. A 16x4 LCD stays at the top.

 

Soldering side

 

Schematic Diagram

 The original post uses Arduino Uno to control this LCD module.

Source Code "main.c":

1. /*
2. * 12-spi_74hc595_1604.c
3. *
4. * Created: 2/17/2026 3:27:49 PM
5. * Author : Admin
6. */
7. 
   
8. #include <stdio.h>
9. #include <avr/io.h>
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. #define DDR_SPI DDRB
14. #define PRT_SPI PORTB
15. #define DD_MOSI 5
16. #define DD_MISO 6
17. #define DD_SCK 7
18. #define DD_SS 4
19. 
    
20. void SPI_MasterInit(void)
21. {
22. /* Set MOSI and SCK output, all others input */
23. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
24. /* Enable SPI, Master, set clock rate fck/16
25. data is sample at the falling edge of SCK*/
26. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
27. }
28. 
    
29. void SPI_MasterTransmit(char cData)
30. {
31. /* Start transmission */
32. SPDR = cData;
33. /* Wait for transmission complete */
34. while(!(SPSR & (1<<SPIF)))
35. ;
36. }
37. 
    
38. void SPI_SlaveInit(void)
39. {
40. /* Set MISO output, all others input */
41. DDR_SPI = (1<<DD_MISO);
42. /* Enable SPI */
43. SPCR = (1<<SPE);
44. }
45. 
    
46. char SPI_SlaveReceive(void)
47. {
48. /* Wait for reception complete */
49. while(!(SPSR & (1<<SPIF)))
50. ;
51. /* Return Data Register */
52. return SPDR;
53. }
54. 
    
55. /*TWI LCD Driver*/
56. #define RS 1
57. #define RW 2
58. #define EN 3
59. #define BL 0
60. 
    
61. 
    
62. char backLight=0;
63. 
    
64. void lcd_delay(unsigned int counts){
65. for (unsigned int i=0;i<counts;i++);
66. }
67. 
    
68. void spi_lcd_command(char command){
69. char data;
70. data=command&0xF0;
71. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN));
72. PRT_SPI&=~(1<<DD_SS);
73. PRT_SPI|=(1<<DD_SS);
75. SPI_MasterTransmit(data|(backLight<<BL));
76. PRT_SPI&=~(1<<DD_SS);
77. PRT_SPI|=(1<<DD_SS);
79. data=command<<4;
80. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN));
81. PRT_SPI&=~(1<<DD_SS);
82. lcd_delay(10);
83. PRT_SPI|=(1<<DD_SS);
84. SPI_MasterTransmit(data|(backLight<<BL));
85. PRT_SPI&=~(1<<DD_SS);
86. PRT_SPI|=(1<<DD_SS);
87. }
88. 
    
89. void spi_lcd_data(char command){
90. char data;
91. data=command&0xF0;
92. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN)|(1<<RS));
93. PRT_SPI&=~(1<<DD_SS);
94. PRT_SPI|=(1<<DD_SS);
95. SPI_MasterTransmit(data|(backLight<<BL)|(1<<RS));
96. PRT_SPI&=~(1<<DD_SS);
97. PRT_SPI|=(1<<DD_SS);
98. lcd_delay(50);
100. data=command<<4;
101. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN)|(1<<RS));
102. PRT_SPI&=~(1<<DD_SS);
103. PRT_SPI|=(1<<DD_SS);
104. SPI_MasterTransmit(data|(backLight<<BL)|(1<<RS));
105. PRT_SPI&=~(1<<DD_SS);
106. PRT_SPI|=(1<<DD_SS);
107. }
108. 
     
109. void spi_lcd_xy(int8_t x, int8_t y){
110. //16x2
111. //char addr[]={0x80,0xC0};
112. //16x4
113. char addr[]={0x80,0xC0,0x90,0xD0};
114. spi_lcd_command(addr[y-1]+x-1);
115. }
116. 
     
117. void spi_lcd_line_1(void){
118. spi_lcd_command(0x80);
119. }
120. 
     
121. void spi_lcd_line_2(void){
122. spi_lcd_command(0xC0);
123. }
124. 
     
125. void spi_lcd_line_3(void){
126. spi_lcd_command(0x90);
127. }
128. 
     
129. void spi_lcd_line_4(void){
130. spi_lcd_command(0xD0);
131. }
132. 
     
133. void spi_lcd_cursor_off(void){
134. spi_lcd_command(0x0C);
135. }
136. 
     
137. void spi_lcd_text(char *txt){
138. while(*txt) spi_lcd_data(*txt++);
139. }
140. 
     
141. void i2c_lcdClear(void){
142. spi_lcd_command(0x01);
143. _delay_ms(10);
144. }
145. 
     
146. void spi_lcd_init(void){
148. SPI_MasterTransmit(0);
149. lcd_delay(500);
150. spi_lcd_command(0x33);
151. lcd_delay(10);
152. spi_lcd_command(0x32);
153. lcd_delay(10);
154. spi_lcd_command(0x28);
155. lcd_delay(10);
156. spi_lcd_command(0x0F);
157. lcd_delay(10);
158. spi_lcd_command(0x01);
159. _delay_ms(10);
160. spi_lcd_command(0x06);
161. lcd_delay(10);
162. }
163. 
     
164. int main(void)
165. {
166. /* Replace with your application code */
167. _delay_ms(1000);
168. SPI_MasterInit();
169. PRT_SPI|=(1<<DD_SS); //Set CS Pin High
170. spi_lcd_init();
171. spi_lcd_line_1();
172. spi_lcd_text("ATMega644P SPI");
173. spi_lcd_line_2();
174. spi_lcd_text("SN74HC595N LCD");
175. spi_lcd_line_3();
176. spi_lcd_text("TC1604A-01(R)");
177. spi_lcd_line_4();
178. spi_lcd_text("Example Using C");
179. unsigned char data[7],msg[16];
180. while (1)
181. {
183. }
184. }
185. 
     
186. 
     
187. 
     
188. 
     

AVR Hardware Experiment:

Tested ATMega644P

For a full tutorial list of ATMega644P using C in Microchip Studio IDE please see this page.