My Intro for LCD

This will show an intro for my group with name. For LCD Blue Parralel & Arduino UNO.

Dec 25, 2019

•

746 views

•

0 respects

art

lcd

custom characters

Components and supplies

Standard LCD - 16x2 White on Blue

Arduino UNO

Resistor 1k ohm

Breadboard (generic)

Jumper wires (generic)

Apps and platforms

Discord

Discord Group

Project description

Code

LCD Blue Parallel 16x2 My Group Animated Intro.

It is supposed to be an animated intro for my group. If it doesn't work comment me so i can enter the fixed code instead of this one. Use it for an LCD Blue Parallel 16x2 with an Arduino UNO.

1#include <LiquidCrystal.h>
2
3LiquidCrystal lcd(12,11,5,4,3,2); //Put  in the order of rs,Enable,DB4,DB5,DB6,DB7 ports from the arduino UNO connected to  the LCD B.P. 16x2.
4
5byte customCharA[] = {
6  0x00,
7  0x00,
8  0x00,
9  0x00,
10  0x00,
11  0x10,
12  0x00,
13  0x00
14};
15
16byte customCharB[]  = {
17  0x00,
18  0x00,
19  0x00,
20  0x00,
21  0x10,
22  0x18,
23  0x10,
24  0x00
25};
26
27byte customCharC[] = {
28  0x00,
29  0x00,
30  0x00,
31  0x00,
32  0x18,
33  0x1C,
34  0x18,
35  0x00
36};
37
38byte customCharD[]  = {
39  0x00,
40  0x00,
41  0x00,
42  0x00,
43  0x1C,
44  0x1E,
45  0x1C,
46  0x10
47};
48
49byte customCharE[] = {
50  0x00,
51  0x00,
52  0x00,
53  0x00,
54  0x0E,
55  0x1F,
56  0x0E,
57  0x08
58};
59
60byte customCharF[]  = {
61  0x00,
62  0x00,
63  0x00,
64  0x04,
65  0x0E,
66  0x1F,
67  0x0E,
68  0x08
69};
70
71byte customCharG[] = {
72  0x00,
73  0x00,
74  0x04,
75  0x0E,
76  0x0E,
77  0x1F,
78  0x0E,
79  0x08
80};
81
82byte customCharH[]  = {
83  0x00,
84  0x04,
85  0x0E,
86  0x0A,
87  0x0E,
88  0x1F,
89  0x0E,
90  0x08
91};
92
93byte customCharI[] = {
94  0x04,
95  0x0E,
96  0x0A,
97  0x00,
98  0x0E,
99  0x1F,
100  0x0E,
101  0x08
102};
103
104byte customCharLOADA[]  = {
105  0x00,
106  0x00,
107  0x00,
108  0x03,
109  0x0F,
110  0x0C,
111  0x18,
112  0x18
113};
114
115byte customCharLOADB[] = {
116  0x00,
117  0x00,
118  0x00,
119  0x18,
120  0x1E,
121  0x06,
122  0x03,
123  0x03
124};
125
126byte customCharLOADC[]  = {
127  0x03,
128  0x03,
129  0x06,
130  0x1E,
131  0x18,
132  0x00,
133  0x00,
134  0x00
135};
136
137byte customCharLOADD[] = {
138  0x18,
139  0x18,
140  0x0C,
141  0x0F,
142  0x03,
143  0x00,
144  0x00,
145  0x00
146};
147
148void setup() {
149  // put your setup code here, to run once:
150
151  lcd.begin(16,2);
152
153
154  lcd.print("Arduno Nerds");
155  lcd.createChar(1, customCharA);
156  lcd.home();
157  lcd.write(1);
158  delay(1000);
159  lcd.clear();
160  lcd.print("Arduno Nerds");
161  lcd.createChar(2, customCharB);
162  lcd.home();
163  lcd.write(2);
164  delay(1000);
165  lcd.clear();
166  lcd.print("Arduno Nerds");
167  lcd.createChar(3, customCharC);
168  lcd.home();
169  lcd.write(3);
170  delay(1000);
171  lcd.clear();
172  lcd.print("Arduno  Nerds");
173  lcd.createChar(4, customCharD);
174  lcd.home();
175  lcd.write(4);
176  delay(1000);
177  lcd.clear();
178  lcd.print("Arduno Nerds");
179  lcd.createChar(5,  customCharE);
180  lcd.home();
181  lcd.write(5);
182  delay(1000);
183  lcd.clear();
184  lcd.print("Arduno Nerds");
185  lcd.createChar(6, customCharF);
186  lcd.home();
187  lcd.write(6);
188  delay(1000);
189  lcd.clear();
190  lcd.print("Arduno Nerds");
191  lcd.createChar(7, customCharG);
192  lcd.home();
193  lcd.write(7);
194  delay(1000);
195  lcd.clear();
196  lcd.print("Arduno Nerds");
197  lcd.createChar(8, customCharH);
198  lcd.home();
199  lcd.write(8);
200  delay(1000);
201  lcd.clear();
202  lcd.print("Arduno  Nerds");
203  lcd.createChar(9, customCharI);
204  lcd.home();
205  lcd.write(9);
206  delay(5000);
207  lcd.clear();
208  lcd.setCursor(1,1);
209  lcd.createChar(10,  customCharLOADA);
210  lcd.home();
211  lcd.write(10);
212  delay(1000);
213  lcd.clear();
214  lcd.setCursor(2,1);
215  lcd.createChar(11, customCharLOADB);
216  lcd.home();
217  lcd.write(11);
218  delay(1000);
219  lcd.clear();
220  lcd.setCursor(2,2);
221  lcd.createChar(12, customCharLOADC);
222  lcd.home();
223  lcd.write(12);
224  delay(1000);
225  lcd.clear();
226  lcd.setCursor(1,2);
227  lcd.createChar(13,  customCharLOADD);
228  lcd.home();
229  lcd.write(13);
230  delay(1000);
231  lcd.clear();
232  lcd.setCursor(1,1);
233  lcd.createChar(10, customCharLOADA);
234  lcd.home();
235  lcd.write(10);
236  delay(1000);
237  lcd.clear();
238  lcd.setCursor(2,1);
239  lcd.createChar(11, customCharLOADB);
240  lcd.home();
241  lcd.write(11);
242  delay(1000);
243  lcd.clear();
244  lcd.setCursor(2,2);
245  lcd.createChar(12,  customCharLOADC);
246  lcd.home();
247  lcd.write(12);
248  delay(1000);
249  lcd.clear();
250  lcd.setCursor(1,2);
251  lcd.createChar(13, customCharLOADD);
252  lcd.home();
253  lcd.write(13);
254  delay(1000);
255  lcd.clear();
256  lcd.setCursor(1,1);
257  lcd.createChar(10, customCharLOADA);
258  lcd.home();
259  lcd.write(10);
260  delay(1000);
261  lcd.clear();
262  lcd.setCursor(2,1);
263  lcd.createChar(11,  customCharLOADB);
264  lcd.home();
265  lcd.write(11);
266  delay(1000);
267  lcd.clear();
268  lcd.setCursor(2,2);
269  lcd.createChar(12, customCharLOADC);
270  lcd.home();
271  lcd.write(12);
272  delay(1000);
273  lcd.clear();
274  lcd.setCursor(1,2);
275  lcd.createChar(13, customCharLOADD);
276  lcd.home();
277  lcd.write(13);
278  delay(1000);
279  lcd.clear();
280  lcd.setCursor(1,1);
281  lcd.print("Intro  Done.");
282  delay(2000);
283  lcd.clear();
284
285}
286
287void loop() {
288  // put your main code here, to run repeatedly:
289
290  
291
292}

#include <LiquidCrystal.h>

LiquidCrystal lcd(12,11,5,4,3,2); //Put  in the order of rs,Enable,DB4,DB5,DB6,DB7 ports from the arduino UNO connected to  the LCD B.P. 16x2.

byte customCharA[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x00,
  0x10,
  0x00,
  0x00
};

byte customCharB[]  = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x10,
  0x18,
  0x10,
  0x00
};

byte customCharC[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x18,
  0x1C,
  0x18,
  0x00
};

byte customCharD[]  = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x1C,
  0x1E,
  0x1C,
  0x10
};

byte customCharE[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharF[]  = {
  0x00,
  0x00,
  0x00,
  0x04,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharG[] = {
  0x00,
  0x00,
  0x04,
  0x0E,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharH[]  = {
  0x00,
  0x04,
  0x0E,
  0x0A,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharI[] = {
  0x04,
  0x0E,
  0x0A,
  0x00,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharLOADA[]  = {
  0x00,
  0x00,
  0x00,
  0x03,
  0x0F,
  0x0C,
  0x18,
  0x18
};

byte customCharLOADB[] = {
  0x00,
  0x00,
  0x00,
  0x18,
  0x1E,
  0x06,
  0x03,
  0x03
};

byte customCharLOADC[]  = {
  0x03,
  0x03,
  0x06,
  0x1E,
  0x18,
  0x00,
  0x00,
  0x00
};

byte customCharLOADD[] = {
  0x18,
  0x18,
  0x0C,
  0x0F,
  0x03,
  0x00,
  0x00,
  0x00
};

void setup() {
  // put your setup code here, to run once:

  lcd.begin(16,2);


  lcd.print("Arduno Nerds");
  lcd.createChar(1, customCharA);
  lcd.home();
  lcd.write(1);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(2, customCharB);
  lcd.home();
  lcd.write(2);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(3, customCharC);
  lcd.home();
  lcd.write(3);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno  Nerds");
  lcd.createChar(4, customCharD);
  lcd.home();
  lcd.write(4);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(5,  customCharE);
  lcd.home();
  lcd.write(5);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(6, customCharF);
  lcd.home();
  lcd.write(6);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(7, customCharG);
  lcd.home();
  lcd.write(7);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(8, customCharH);
  lcd.home();
  lcd.write(8);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno  Nerds");
  lcd.createChar(9, customCharI);
  lcd.home();
  lcd.write(9);
  delay(5000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10,  customCharLOADA);
  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);
  lcd.createChar(11, customCharLOADB);
  lcd.home();
  lcd.write(11);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);
  lcd.createChar(12, customCharLOADC);
  lcd.home();
  lcd.write(12);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);
  lcd.createChar(13,  customCharLOADD);
  lcd.home();
  lcd.write(13);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10, customCharLOADA);
  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);
  lcd.createChar(11, customCharLOADB);
  lcd.home();
  lcd.write(11);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);
  lcd.createChar(12,  customCharLOADC);
  lcd.home();
  lcd.write(12);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);
  lcd.createChar(13, customCharLOADD);
  lcd.home();
  lcd.write(13);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10, customCharLOADA);
  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);
  lcd.createChar(11,  customCharLOADB);
  lcd.home();
  lcd.write(11);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);
  lcd.createChar(12, customCharLOADC);
  lcd.home();
  lcd.write(12);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);
  lcd.createChar(13, customCharLOADD);
  lcd.home();
  lcd.write(13);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.print("Intro  Done.");
  delay(2000);
  lcd.clear();

}

void loop() {
  // put your main code here, to run repeatedly:

  

}

Intro Code

arduino

This is in theory the code to run my intro design on you're lcd. If it doesn't work comment or send a message in my discord server so i will get working on fixing it. Have fun!

1#include <LiquidCrystal.h>
2
3LiquidCrystal lcd(12,11,5,4,3,2);
4
5byte  customCharA[] = {
6  0x00,
7  0x00,
8  0x00,
9  0x00,
10  0x00,
11  0x10,
12  0x00,
13  0x00
14};
15
16byte customCharB[] = {
17  0x00,
18  0x00,
19  0x00,
20  0x00,
21  0x10,
22  0x18,
23  0x10,
24  0x00
25};
26
27byte  customCharC[] = {
28  0x00,
29  0x00,
30  0x00,
31  0x00,
32  0x18,
33  0x1C,
34  0x18,
35  0x00
36};
37
38byte customCharD[] = {
39  0x00,
40  0x00,
41  0x00,
42  0x00,
43  0x1C,
44  0x1E,
45  0x1C,
46  0x10
47};
48
49byte  customCharE[] = {
50  0x00,
51  0x00,
52  0x00,
53  0x00,
54  0x0E,
55  0x1F,
56  0x0E,
57  0x08
58};
59
60byte customCharF[] = {
61  0x00,
62  0x00,
63  0x00,
64  0x04,
65  0x0E,
66  0x1F,
67  0x0E,
68  0x08
69};
70
71byte  customCharG[] = {
72  0x00,
73  0x00,
74  0x04,
75  0x0E,
76  0x0E,
77  0x1F,
78  0x0E,
79  0x08
80};
81
82byte customCharH[] = {
83  0x00,
84  0x04,
85  0x0E,
86  0x0A,
87  0x0E,
88  0x1F,
89  0x0E,
90  0x08
91};
92
93byte  customCharI[] = {
94  0x04,
95  0x0E,
96  0x0A,
97  0x00,
98  0x0E,
99  0x1F,
100  0x0E,
101  0x08
102};
103
104byte customCharLOADA[] = {
105  0x00,
106  0x00,
107  0x00,
108  0x03,
109  0x0F,
110  0x0C,
111  0x18,
112  0x18
113};
114
115byte  customCharLOADB[] = {
116  0x00,
117  0x00,
118  0x00,
119  0x18,
120  0x1E,
121  0x06,
122  0x03,
123  0x03
124};
125
126byte customCharLOADC[] = {
127  0x03,
128  0x03,
129  0x06,
130  0x1E,
131  0x18,
132  0x00,
133  0x00,
134  0x00
135};
136
137byte  customCharLOADD[] = {
138  0x18,
139  0x18,
140  0x0C,
141  0x0F,
142  0x03,
143  0x00,
144  0x00,
145  0x00
146};
147
148void setup() {
149  // put your setup  code here, to run once:
150
151  lcd.begin(16,2);
152
153
154  lcd.print("Arduno  Nerds");
155  lcd.createChar(1, customCharA);
156  lcd.home();
157  lcd.write(1);
158  delay(1000);
159  lcd.clear();
160  lcd.print("Arduno Nerds");
161  lcd.createChar(2,  customCharB);
162  lcd.home();
163  lcd.write(2);
164  delay(1000);
165  lcd.clear();
166  lcd.print("Arduno Nerds");
167  lcd.createChar(3, customCharC);
168  lcd.home();
169  lcd.write(3);
170  delay(1000);
171  lcd.clear();
172  lcd.print("Arduno Nerds");
173  lcd.createChar(4, customCharD);
174  lcd.home();
175  lcd.write(4);
176  delay(1000);
177  lcd.clear();
178  lcd.print("Arduno Nerds");
179  lcd.createChar(5, customCharE);
180  lcd.home();
181  lcd.write(5);
182  delay(1000);
183  lcd.clear();
184  lcd.print("Arduno  Nerds");
185  lcd.createChar(6, customCharF);
186  lcd.home();
187  lcd.write(6);
188  delay(1000);
189  lcd.clear();
190  lcd.print("Arduno Nerds");
191  lcd.createChar(7,  customCharG);
192  lcd.home();
193  lcd.write(7);
194  delay(1000);
195  lcd.clear();
196  lcd.print("Arduno Nerds");
197  lcd.createChar(8, customCharH);
198  lcd.home();
199  lcd.write(8);
200  delay(1000);
201  lcd.clear();
202  lcd.print("Arduno Nerds");
203  lcd.createChar(9, customCharI);
204  lcd.home();
205  lcd.write(9);
206  delay(5000);
207  lcd.clear();
208  lcd.setCursor(1,1);
209  lcd.createChar(10, customCharLOADA);
210  lcd.home();
211  lcd.write(10);
212  delay(1000);
213  lcd.clear();
214  lcd.setCursor(2,1);
215  lcd.createChar(11, customCharLOADB);
216  lcd.home();
217  lcd.write(11);
218  delay(1000);
219  lcd.clear();
220  lcd.setCursor(2,2);
221  lcd.createChar(12,  customCharLOADC);
222  lcd.home();
223  lcd.write(12);
224  delay(1000);
225  lcd.clear();
226  lcd.setCursor(1,2);
227  lcd.createChar(13, customCharLOADD);
228  lcd.home();
229  lcd.write(13);
230  delay(1000);
231  lcd.clear();
232  lcd.setCursor(1,1);
233  lcd.createChar(10, customCharLOADA);
234  lcd.home();
235  lcd.write(10);
236  delay(1000);
237  lcd.clear();
238  lcd.setCursor(2,1);
239  lcd.createChar(11,  customCharLOADB);
240  lcd.home();
241  lcd.write(11);
242  delay(1000);
243  lcd.clear();
244  lcd.setCursor(2,2);
245  lcd.createChar(12, customCharLOADC);
246  lcd.home();
247  lcd.write(12);
248  delay(1000);
249  lcd.clear();
250  lcd.setCursor(1,2);
251  lcd.createChar(13, customCharLOADD);
252  lcd.home();
253  lcd.write(13);
254  delay(1000);
255  lcd.clear();
256  lcd.setCursor(1,1);
257  lcd.createChar(10,  customCharLOADA);
258  lcd.home();
259  lcd.write(10);
260  delay(1000);
261  lcd.clear();
262  lcd.setCursor(2,1);
263  lcd.createChar(11, customCharLOADB);
264  lcd.home();
265  lcd.write(11);
266  delay(1000);
267  lcd.clear();
268  lcd.setCursor(2,2);
269  lcd.createChar(12, customCharLOADC);
270  lcd.home();
271  lcd.write(12);
272  delay(1000);
273  lcd.clear();
274  lcd.setCursor(1,2);
275  lcd.createChar(13,  customCharLOADD);
276  lcd.home();
277  lcd.write(13);
278  delay(1000);
279  lcd.clear();
280  lcd.setCursor(1,1);
281  lcd.print("Intro Done.");
282  delay(2000);
283  lcd.clear();
284
285}
286
287void  loop() {
288  // put your main code here, to run repeatedly:
289
290  
291
292}
293

#include <LiquidCrystal.h>

LiquidCrystal lcd(12,11,5,4,3,2);

byte  customCharA[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x00,
  0x10,
  0x00,
  0x00
};

byte customCharB[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x10,
  0x18,
  0x10,
  0x00
};

byte  customCharC[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x18,
  0x1C,
  0x18,
  0x00
};

byte customCharD[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x1C,
  0x1E,
  0x1C,
  0x10
};

byte  customCharE[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharF[] = {
  0x00,
  0x00,
  0x00,
  0x04,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte  customCharG[] = {
  0x00,
  0x00,
  0x04,
  0x0E,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharH[] = {
  0x00,
  0x04,
  0x0E,
  0x0A,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte  customCharI[] = {
  0x04,
  0x0E,
  0x0A,
  0x00,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte customCharLOADA[] = {
  0x00,
  0x00,
  0x00,
  0x03,
  0x0F,
  0x0C,
  0x18,
  0x18
};

byte  customCharLOADB[] = {
  0x00,
  0x00,
  0x00,
  0x18,
  0x1E,
  0x06,
  0x03,
  0x03
};

byte customCharLOADC[] = {
  0x03,
  0x03,
  0x06,
  0x1E,
  0x18,
  0x00,
  0x00,
  0x00
};

byte  customCharLOADD[] = {
  0x18,
  0x18,
  0x0C,
  0x0F,
  0x03,
  0x00,
  0x00,
  0x00
};

void setup() {
  // put your setup  code here, to run once:

  lcd.begin(16,2);


  lcd.print("Arduno  Nerds");
  lcd.createChar(1, customCharA);
  lcd.home();
  lcd.write(1);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(2,  customCharB);
  lcd.home();
  lcd.write(2);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(3, customCharC);
  lcd.home();
  lcd.write(3);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(4, customCharD);
  lcd.home();
  lcd.write(4);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(5, customCharE);
  lcd.home();
  lcd.write(5);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno  Nerds");
  lcd.createChar(6, customCharF);
  lcd.home();
  lcd.write(6);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(7,  customCharG);
  lcd.home();
  lcd.write(7);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(8, customCharH);
  lcd.home();
  lcd.write(8);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(9, customCharI);
  lcd.home();
  lcd.write(9);
  delay(5000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10, customCharLOADA);
  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);
  lcd.createChar(11, customCharLOADB);
  lcd.home();
  lcd.write(11);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);
  lcd.createChar(12,  customCharLOADC);
  lcd.home();
  lcd.write(12);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);
  lcd.createChar(13, customCharLOADD);
  lcd.home();
  lcd.write(13);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10, customCharLOADA);
  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);
  lcd.createChar(11,  customCharLOADB);
  lcd.home();
  lcd.write(11);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);
  lcd.createChar(12, customCharLOADC);
  lcd.home();
  lcd.write(12);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);
  lcd.createChar(13, customCharLOADD);
  lcd.home();
  lcd.write(13);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10,  customCharLOADA);
  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);
  lcd.createChar(11, customCharLOADB);
  lcd.home();
  lcd.write(11);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);
  lcd.createChar(12, customCharLOADC);
  lcd.home();
  lcd.write(12);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);
  lcd.createChar(13,  customCharLOADD);
  lcd.home();
  lcd.write(13);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.print("Intro Done.");
  delay(2000);
  lcd.clear();

}

void  loop() {
  // put your main code here, to run repeatedly:

  

}

Intro Code

arduino

This is in theory the code to run my intro design on you're lcd. If it doesn't work comment or send a message in my discord server so i will get working on fixing it. Have fun!

1#include <LiquidCrystal.h>
2
3LiquidCrystal lcd(12,11,5,4,3,2);
4
5byte
6  customCharA[] = {
7  0x00,
8  0x00,
9  0x00,
10  0x00,
11  0x00,
12  0x10,
13
14  0x00,
15  0x00
16};
17
18byte customCharB[] = {
19  0x00,
20  0x00,
21
22  0x00,
23  0x00,
24  0x10,
25  0x18,
26  0x10,
27  0x00
28};
29
30byte
31  customCharC[] = {
32  0x00,
33  0x00,
34  0x00,
35  0x00,
36  0x18,
37  0x1C,
38
39  0x18,
40  0x00
41};
42
43byte customCharD[] = {
44  0x00,
45  0x00,
46
47  0x00,
48  0x00,
49  0x1C,
50  0x1E,
51  0x1C,
52  0x10
53};
54
55byte
56  customCharE[] = {
57  0x00,
58  0x00,
59  0x00,
60  0x00,
61  0x0E,
62  0x1F,
63
64  0x0E,
65  0x08
66};
67
68byte customCharF[] = {
69  0x00,
70  0x00,
71
72  0x00,
73  0x04,
74  0x0E,
75  0x1F,
76  0x0E,
77  0x08
78};
79
80byte
81  customCharG[] = {
82  0x00,
83  0x00,
84  0x04,
85  0x0E,
86  0x0E,
87  0x1F,
88
89  0x0E,
90  0x08
91};
92
93byte customCharH[] = {
94  0x00,
95  0x04,
96
97  0x0E,
98  0x0A,
99  0x0E,
100  0x1F,
101  0x0E,
102  0x08
103};
104
105byte
106  customCharI[] = {
107  0x04,
108  0x0E,
109  0x0A,
110  0x00,
111  0x0E,
112  0x1F,
113
114  0x0E,
115  0x08
116};
117
118byte customCharLOADA[] = {
119  0x00,
120  0x00,
121
122  0x00,
123  0x03,
124  0x0F,
125  0x0C,
126  0x18,
127  0x18
128};
129
130byte
131  customCharLOADB[] = {
132  0x00,
133  0x00,
134  0x00,
135  0x18,
136  0x1E,
137
138  0x06,
139  0x03,
140  0x03
141};
142
143byte customCharLOADC[] = {
144  0x03,
145
146  0x03,
147  0x06,
148  0x1E,
149  0x18,
150  0x00,
151  0x00,
152  0x00
153};
154
155byte
156  customCharLOADD[] = {
157  0x18,
158  0x18,
159  0x0C,
160  0x0F,
161  0x03,
162
163  0x00,
164  0x00,
165  0x00
166};
167
168void setup() {
169  // put your setup
170  code here, to run once:
171
172  lcd.begin(16,2);
173
174
175  lcd.print("Arduno
176  Nerds");
177  lcd.createChar(1, customCharA);
178  lcd.home();
179  lcd.write(1);
180
181  delay(1000);
182  lcd.clear();
183  lcd.print("Arduno Nerds");
184  lcd.createChar(2,
185  customCharB);
186  lcd.home();
187  lcd.write(2);
188  delay(1000);
189  lcd.clear();
190
191  lcd.print("Arduno Nerds");
192  lcd.createChar(3, customCharC);
193  lcd.home();
194
195  lcd.write(3);
196  delay(1000);
197  lcd.clear();
198  lcd.print("Arduno Nerds");
199
200  lcd.createChar(4, customCharD);
201  lcd.home();
202  lcd.write(4);
203  delay(1000);
204
205  lcd.clear();
206  lcd.print("Arduno Nerds");
207  lcd.createChar(5, customCharE);
208
209  lcd.home();
210  lcd.write(5);
211  delay(1000);
212  lcd.clear();
213  lcd.print("Arduno
214  Nerds");
215  lcd.createChar(6, customCharF);
216  lcd.home();
217  lcd.write(6);
218
219  delay(1000);
220  lcd.clear();
221  lcd.print("Arduno Nerds");
222  lcd.createChar(7,
223  customCharG);
224  lcd.home();
225  lcd.write(7);
226  delay(1000);
227  lcd.clear();
228
229  lcd.print("Arduno Nerds");
230  lcd.createChar(8, customCharH);
231  lcd.home();
232
233  lcd.write(8);
234  delay(1000);
235  lcd.clear();
236  lcd.print("Arduno Nerds");
237
238  lcd.createChar(9, customCharI);
239  lcd.home();
240  lcd.write(9);
241  delay(5000);
242
243  lcd.clear();
244  lcd.setCursor(1,1);
245  lcd.createChar(10, customCharLOADA);
246
247  lcd.home();
248  lcd.write(10);
249  delay(1000);
250  lcd.clear();
251  lcd.setCursor(2,1);
252
253  lcd.createChar(11, customCharLOADB);
254  lcd.home();
255  lcd.write(11);
256
257  delay(1000);
258  lcd.clear();
259  lcd.setCursor(2,2);
260  lcd.createChar(12,
261  customCharLOADC);
262  lcd.home();
263  lcd.write(12);
264  delay(1000);
265  lcd.clear();
266
267  lcd.setCursor(1,2);
268  lcd.createChar(13, customCharLOADD);
269  lcd.home();
270
271  lcd.write(13);
272  delay(1000);
273  lcd.clear();
274  lcd.setCursor(1,1);
275
276  lcd.createChar(10, customCharLOADA);
277  lcd.home();
278  lcd.write(10);
279
280  delay(1000);
281  lcd.clear();
282  lcd.setCursor(2,1);
283  lcd.createChar(11,
284  customCharLOADB);
285  lcd.home();
286  lcd.write(11);
287  delay(1000);
288  lcd.clear();
289
290  lcd.setCursor(2,2);
291  lcd.createChar(12, customCharLOADC);
292  lcd.home();
293
294  lcd.write(12);
295  delay(1000);
296  lcd.clear();
297  lcd.setCursor(1,2);
298
299  lcd.createChar(13, customCharLOADD);
300  lcd.home();
301  lcd.write(13);
302
303  delay(1000);
304  lcd.clear();
305  lcd.setCursor(1,1);
306  lcd.createChar(10,
307  customCharLOADA);
308  lcd.home();
309  lcd.write(10);
310  delay(1000);
311  lcd.clear();
312
313  lcd.setCursor(2,1);
314  lcd.createChar(11, customCharLOADB);
315  lcd.home();
316
317  lcd.write(11);
318  delay(1000);
319  lcd.clear();
320  lcd.setCursor(2,2);
321
322  lcd.createChar(12, customCharLOADC);
323  lcd.home();
324  lcd.write(12);
325
326  delay(1000);
327  lcd.clear();
328  lcd.setCursor(1,2);
329  lcd.createChar(13,
330  customCharLOADD);
331  lcd.home();
332  lcd.write(13);
333  delay(1000);
334  lcd.clear();
335
336  lcd.setCursor(1,1);
337  lcd.print("Intro Done.");
338  delay(2000);
339  lcd.clear();
340
341}
342
343void
344  loop() {
345  // put your main code here, to run repeatedly:
346
347  
348
349}
350

#include <LiquidCrystal.h>

LiquidCrystal lcd(12,11,5,4,3,2);

byte
  customCharA[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x00,
  0x10,

  0x00,
  0x00
};

byte customCharB[] = {
  0x00,
  0x00,

  0x00,
  0x00,
  0x10,
  0x18,
  0x10,
  0x00
};

byte
  customCharC[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x18,
  0x1C,

  0x18,
  0x00
};

byte customCharD[] = {
  0x00,
  0x00,

  0x00,
  0x00,
  0x1C,
  0x1E,
  0x1C,
  0x10
};

byte
  customCharE[] = {
  0x00,
  0x00,
  0x00,
  0x00,
  0x0E,
  0x1F,

  0x0E,
  0x08
};

byte customCharF[] = {
  0x00,
  0x00,

  0x00,
  0x04,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte
  customCharG[] = {
  0x00,
  0x00,
  0x04,
  0x0E,
  0x0E,
  0x1F,

  0x0E,
  0x08
};

byte customCharH[] = {
  0x00,
  0x04,

  0x0E,
  0x0A,
  0x0E,
  0x1F,
  0x0E,
  0x08
};

byte
  customCharI[] = {
  0x04,
  0x0E,
  0x0A,
  0x00,
  0x0E,
  0x1F,

  0x0E,
  0x08
};

byte customCharLOADA[] = {
  0x00,
  0x00,

  0x00,
  0x03,
  0x0F,
  0x0C,
  0x18,
  0x18
};

byte
  customCharLOADB[] = {
  0x00,
  0x00,
  0x00,
  0x18,
  0x1E,

  0x06,
  0x03,
  0x03
};

byte customCharLOADC[] = {
  0x03,

  0x03,
  0x06,
  0x1E,
  0x18,
  0x00,
  0x00,
  0x00
};

byte
  customCharLOADD[] = {
  0x18,
  0x18,
  0x0C,
  0x0F,
  0x03,

  0x00,
  0x00,
  0x00
};

void setup() {
  // put your setup
  code here, to run once:

  lcd.begin(16,2);


  lcd.print("Arduno
  Nerds");
  lcd.createChar(1, customCharA);
  lcd.home();
  lcd.write(1);

  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(2,
  customCharB);
  lcd.home();
  lcd.write(2);
  delay(1000);
  lcd.clear();

  lcd.print("Arduno Nerds");
  lcd.createChar(3, customCharC);
  lcd.home();

  lcd.write(3);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");

  lcd.createChar(4, customCharD);
  lcd.home();
  lcd.write(4);
  delay(1000);

  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(5, customCharE);

  lcd.home();
  lcd.write(5);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno
  Nerds");
  lcd.createChar(6, customCharF);
  lcd.home();
  lcd.write(6);

  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");
  lcd.createChar(7,
  customCharG);
  lcd.home();
  lcd.write(7);
  delay(1000);
  lcd.clear();

  lcd.print("Arduno Nerds");
  lcd.createChar(8, customCharH);
  lcd.home();

  lcd.write(8);
  delay(1000);
  lcd.clear();
  lcd.print("Arduno Nerds");

  lcd.createChar(9, customCharI);
  lcd.home();
  lcd.write(9);
  delay(5000);

  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10, customCharLOADA);

  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);

  lcd.createChar(11, customCharLOADB);
  lcd.home();
  lcd.write(11);

  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);
  lcd.createChar(12,
  customCharLOADC);
  lcd.home();
  lcd.write(12);
  delay(1000);
  lcd.clear();

  lcd.setCursor(1,2);
  lcd.createChar(13, customCharLOADD);
  lcd.home();

  lcd.write(13);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);

  lcd.createChar(10, customCharLOADA);
  lcd.home();
  lcd.write(10);

  delay(1000);
  lcd.clear();
  lcd.setCursor(2,1);
  lcd.createChar(11,
  customCharLOADB);
  lcd.home();
  lcd.write(11);
  delay(1000);
  lcd.clear();

  lcd.setCursor(2,2);
  lcd.createChar(12, customCharLOADC);
  lcd.home();

  lcd.write(12);
  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);

  lcd.createChar(13, customCharLOADD);
  lcd.home();
  lcd.write(13);

  delay(1000);
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.createChar(10,
  customCharLOADA);
  lcd.home();
  lcd.write(10);
  delay(1000);
  lcd.clear();

  lcd.setCursor(2,1);
  lcd.createChar(11, customCharLOADB);
  lcd.home();

  lcd.write(11);
  delay(1000);
  lcd.clear();
  lcd.setCursor(2,2);

  lcd.createChar(12, customCharLOADC);
  lcd.home();
  lcd.write(12);

  delay(1000);
  lcd.clear();
  lcd.setCursor(1,2);
  lcd.createChar(13,
  customCharLOADD);
  lcd.home();
  lcd.write(13);
  delay(1000);
  lcd.clear();

  lcd.setCursor(1,1);
  lcd.print("Intro Done.");
  delay(2000);
  lcd.clear();

}

void
  loop() {
  // put your main code here, to run repeatedly:

  

}

Downloadable files

LCD Setup Schematic

This teaches you how to setup a LCD matching the current code.

LCD Setup Schematic

This teaches you how to setup a LCD matching the current code.

LCD Setup Schematic

Comments

Only logged in users can leave comments

Coder_SinaYT

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content