Arduino Projekten

Wed 20-Mar-19
19:14:07




LCD - Aansluiting met 8-bits.

Datum: Sun 05 July 2015
Samenvatting: Het LCD (20x4 tekens en RGB-background-light) is nu met 8-bits aangesloten.


Hier wordt de 8-bits data overdracht gebruikt om de Lcd aan te sturen. Tevens zijn de backlight-kleuren (RGB) aangesloten op 3 PWM-uitgangen. Ook de zes-potmeters zijn aangesloten.

PinNaam Functie Kleur draad
1 Gnd Ground Zwart Gnd
2 Vcc +5V Lcd Rood +5V
3 Vlcd Lcd Display Bias Groen Potmeter Loper
5 Rs Register Select: L=Command H=DataBlauw Arduino D12
4 R/W Read/Write: L=Write H=Read Blauw Gnd
6 Enable Enable H->L=Accept Data Blauw Arduino D13
7 D0 Data I/O 0 Geel Arduino D1
8 D1 Data I/O 1 Geel Arduino D2
9 D2 Data I/O 2 Geel Arduino D3
10 D3 Data I/O 3 Geel Arduino D4
11 D4 Data I/O 4 Oranje Arduino D5
12 D5 Data I/O 5 Oranje Arduino D6
13 D6 Data I/O 6 Oranje Arduino D7
14 D7 Data I/O 7 Oranje Arduino D8
15 Anod. VccBacklight Common Anode Rood +5V
16 Kat. Rood Backlight Rood Wit Arduino D9
17 Kat. GroenBacklight Groen Wit Arduino D10
18 Kat. BlauwBacklight Blauw Wit Arduino D11

8-bits aansturing

Allereerst is hier 8-bits aansturing gebruikt. Geen gedoe met bytes opsplitsen, maar rechtstreeks de 8 bitjes sturen naar de poort-aansluitingen. Dit maakt het programma een beetje eenvoudiger.

Display Weergave

Het display geeft ongeveer aan wat hij bij de ArSid moet gaan aangeven. Naderhand moet nog blijken of alle gegevens nuttig zijn. En wellicht worden de gegevens ook op andere regels geplaatst.

  1. De oscilator "O:" met twee frequenties er achter. De Sid heeft er drie, hoe dit polyfoon moet worden, moet ik nog uitzoeken. Of de frequenties moeten een verloop (Pitch-waarde) aan gaan geven. - Nog bepalen -
  2. Het filter "F:", met wat voor type (LowPass, BandPass, HighPass), de resonantie frequentie en een CutOff factor.
  3. De golfvorm "W:", met wat voor vorm (Blokgolf, Driehoek, Zaagtand, Ruis) en een duty-cycle waarde van de blokgolf.
  4. De Omhullende, met de 4 ADSR-waardes.

Dit geeft voor mij alvast een idee wat ik op het display kan weergeven.

Potmeter Funkties

Mijn experimenteerhuis heeft maar 6 potmeters. Voldoende om er wat mee te experimenteren, qua display weergave. Ik heb ook waardes van potmeters gecombineerd om van alles op het scherm te laten veranderen.

  1. De Release-waarde - deze beïnvloedt ook de blauwe achtergrond verlichting.
  2. De Sustain-waarde - deze beïnvloedt ook de groene achtergrond verlichting.
  3. De Decay-waarde - deze beïnvloedt ook de rode achtergrond verlichting.
  4. De Attack-waarde - deze doet een Xor op de drie kleuren van de achtergrond verlichting.
  5. De Duty-cycle-waarde - deze beïnvloedt ook het grafiekje van het filter-type. Ook doet deze een Xor met de Frequentie voor een waarde voor de Filter-Frequentie.
  6. De Oscilator-frequentie-waarde - deze beïnvloedt ook het grafiekje van de golfvorm. Ook doet deze een Xor met de Duty-Cycle voor een waarde voor de Filter-Frequentie.
  7. Geen Potmeter - De Filter-Frequentie is een Xor waarde van de zes potmeters (dus inclusief de ADSR-potmeters)

Al die Xor invloeden komen niet in de uiteindelijke ArSid, maar ze zijn hier wel geinig om te zien variëren. De Arsid zelf gaat 16 potmeters krijgen, dus meer dan voldoende om alle funkties een eigen potmeter te geven.

Programma is nu sneller

De grove "delay()"-aanroepen bij het eerste Lcd-programma zijn nu vervangen door "delayMicrosecondes()" aanroepen.

Hierbij moet de kanttekening worden geplaatst dat de Lcd-Commando's ClearScreen (%00000001) en HomeCursor (%0000001x) meer tijd nodig hebben om verwerkt te worden (elk 1.7ms tegen 40us voor de andere commando's - dit is ruim 50x zo lang). Hier moet uiteindelijk rekening worden gehouden in de ArSid, anders is het display geblokkeerd.

De mini grafiekjes voor filtertype en golfvorm zijn nu in een array met constanten gebracht. Nu hoeft eigenlijk alleen het patroon worden veranderd in het Character Ram om het grafiekje anders te laten worden. Het vreet wel tijd (800us tegen 160us), maar met maar 8 verschillende eigen tekens lijkt het een acceptabele oplossing.


Broncode: [1: LCD - Aansluiting met 8-bits.]

1: De broncode van LCD - Aansluiting met 8-bits.

(Sun 05 July 2015) Het LCD (20x4 tekens en RGB-background-light) is nu met 8-bits aangesloten.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
//
// Exploring Program for a LCD 20x4 (8-Bit Interface)
//
// First building with Display Master-Layout
//

byte lcd_d0  =  0; // Data 0
byte lcd_d1  =  1; // Data 1
byte lcd_d2  =  2; // Data 2
byte lcd_d3  =  3; // Data 3
byte lcd_d4  =  4; // Data 4
byte lcd_d5  =  5; // Data 5
byte lcd_d6  =  6; // Data 6
byte lcd_d7  =  7; // Data 7
byte lcd_rs  = 12; // Register Select
byte lcd_en  = 13; // Enable
byte lcd_br  =  9; // PowerBacklight Red
byte lcd_bg  = 10; // PowerBacklight Red
byte lcd_bb  = 11; // PowerBacklight Red

byte qqstart=0;
byte qq=32;

word oscfreq  = 0;
word filtfreq = 0;
word waveduty = 0;
byte adsr_a   = 0;
byte adsr_d   = 0;
byte adsr_s   = 0;
byte adsr_r   = 0;

void setup ()
{
lcd_init();
display_init();
}

void loop ()
{
do_pots();
}

//=======================================================================================
// Potmeters
//=======================================================================================

void do_pots ()
{
  oscfreq  =analogRead(A5)   ;
  waveduty =analogRead(A4)   ;
  adsr_a   =analogRead(A3)/64;
  adsr_d   =analogRead(A2)/64;
  adsr_s   =analogRead(A1)/64;
  adsr_r   =analogRead(A0)/64;

  filtfreq = (adsr_a ^ adsr_d ^ adsr_s ^ adsr_r) * 4096 ) ^
             (adsr_a ^ adsr_d ^ adsr_s ^ adsr_r) *  256 ) ^
             oscfreq ^
             waveduty ;

  lcd_gotoxy( 7,0);
  lcd_number(oscfreq ,5);
  lcd_gotoxy( 7,1);
  lcd_number(filtfreq,5);
  lcd_gotoxy( 7,2);
  lcd_number(waveduty,5);

  lcd_gotoxy( 2,3);
  lcd_number(adsr_a  ,2);
  lcd_gotoxy( 7,3);
  lcd_number(adsr_d  ,2);
  lcd_gotoxy(12,3);
  lcd_number(adsr_s  ,2);
  lcd_gotoxy(17,3);
  lcd_number(adsr_r  ,2);

  display_waveform  (oscfreq /128);
  display_filtertype(waveduty/128);

  analogWrite( lcd_br, 255 - ( adsr_a ^ adsr_d ) * 17 );
  analogWrite( lcd_bg, 255 - ( adsr_a ^ adsr_s ) * 17 );
  analogWrite( lcd_bb, 255 - ( adsr_a ^ adsr_r ) * 17 );
}

void display_filtertype (byte filtertype)
{ const byte filterchar[128] ={ // [0] -none- -none- -none-
                                B00000000, B00011111, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                                B00000000, B00011111, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                                // [1] -none- -none- -Low-
                                B00000000, B00011100, B00000010, B00000010, B00000001, B00000001, B00000000, B00000000,
                                B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00010000, B00010000,
                                // [2] -none- -Band- -none-
                                B00000000, B00000001, B00000010, B00000010, B00000100, B00000100, B00001000, B00001000,
                                B00000000, B00010000, B00001000, B00001000, B00000100, B00000100, B00000010, B00000010,
                                // [3] -none- -Band- -Low-
                                B00000000, B00011101, B00000010, B00000010, B00000101, B00000101, B00001000, B00001000,
                                B00000000, B00010000, B00001000, B00001000, B00000100, B00000100, B00010010, B00010010,
                                // [4] -High- -none- -none-
                                B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000001, B00000001,
                                B00000000, B00000111, B00001000, B00001000, B00010000, B00010000, B00000000, B00000000,
                                // [5] -High- -none- -Low-
                                B00000000, B00011100, B00000010, B00000010, B00000001, B00000001, B00000001, B00000001,
                                B00000000, B00000111, B00001000, B00001000, B00010000, B00010000, B00010000, B00010000,
                                // [6] -Hign- -Band- -none-
                                B00000000, B00000001, B00000010, B00000010, B00000100, B00000100, B00001001, B00001001,
                                B00000000, B00010111, B00001000, B00001000, B00010100, B00010100, B00000010, B00000010,
                                // [7] -High- -Band- -Low-
                                B00000000, B00011101, B00000010, B00000010, B00000101, B00000101, B00001001, B00001001,
                                B00000000, B00010111, B00001000, B00001000, B00010100, B00010100, B00010010, B00010010
                              };

  filtertype=(filtertype & 0x07) * 16;
  lcd_write(0,64 + 2*8); // Set to Char Ram
  for (byte qq=0; qq<=15; qq=qq+1)
      { lcd_write(1, filterchar[ filtertype + qq ]);
      }
  lcd_write(0, B10000000); // Set to Display
//lcd_gotoxy(2,1);
//lcd_write(1,2);
//lcd_write(1,3);
}

void display_waveform (byte wavetype)
{ const byte wavechar[128] ={ // [1] Square
                              B00000000, B00000001, B00000001, B00000001, B00000001, B00000001, B00011111, B00000000,
                              B00000000, B00011111, B00000001, B00000001, B00000001, B00000001, B00000001, B00000000,
                              // [2] Triangle
                              B00000000, B00000000, B00000001, B00000010, B00000100, B00001000, B00010000, B00000000,
                              B00000000, B00010000, B00001000, B00000100, B00000010, B00000001, B00000000, B00000000,
                              // [4] Sawtooth
                              B00000000, B00000000, B00000000, B00000000, B00000011, B00001100, B00010000, B00000000,
                              B00000000, B00000011, B00001101, B00110001, B00000001, B00000001, B00000001, B00000000,
                              // [8] Noise
                              B00000000, B00000001, B00000001, B00001001, B00001001, B00001101, B00010010, B00000000,
                              B00000000, B00000010, B00000011, B00010101, B00010101, B00001101, B00001000, B00000000
                            };
  wavetype=(wavetype & 0x03) * 16;
  lcd_write(0,64 + 4*8); // Set to Char Ram
  for (byte qq=0; qq<=15; qq=qq+1)
      { lcd_write(1, wavechar[ wavetype + qq ]);
      }
  lcd_write(0, B10000000); // Set to Display
//lcd_gotoxy(2,2);
//lcd_write(1,4);
//lcd_write(1,5);
}

//=======================================================================================
// LCD-Screen
//=======================================================================================

void display_init ()
{
// Line 1
lcd_print("O:   f:00000 f:00000");
// Line 3
lcd_print("W:   d:00512        ");
// Line 2
lcd_print("F:   f:00440    C:00");
// Line 4
lcd_print("A:00 D:00 S:00 R:00 ");

lcd_gotoxy(2,1);
lcd_write(1,2);
lcd_write(1,3);
lcd_gotoxy(2,2);
lcd_write(1,4);
lcd_write(1,5);
}

//=======================================================================================
// LCD
//=======================================================================================

void lcd_init ()
{
pinMode(lcd_d0, OUTPUT);  digitalWrite(lcd_d0,  LOW);
pinMode(lcd_d1, OUTPUT);  digitalWrite(lcd_d1,  LOW);
pinMode(lcd_d2, OUTPUT);  digitalWrite(lcd_d2,  LOW);
pinMode(lcd_d3, OUTPUT);  digitalWrite(lcd_d3,  LOW);
pinMode(lcd_d4, OUTPUT);  digitalWrite(lcd_d4,  LOW);
pinMode(lcd_d5, OUTPUT);  digitalWrite(lcd_d5,  LOW);
pinMode(lcd_d6, OUTPUT);  digitalWrite(lcd_d6,  LOW);
pinMode(lcd_d7, OUTPUT);  digitalWrite(lcd_d7,  LOW);

pinMode(lcd_rs, OUTPUT);  digitalWrite(lcd_rs,  LOW);
pinMode(lcd_en, OUTPUT);  digitalWrite(lcd_en,  LOW);

pinMode(lcd_br, OUTPUT);  digitalWrite(lcd_br,  LOW);
pinMode(lcd_bg, OUTPUT);  digitalWrite(lcd_bg,  LOW);
pinMode(lcd_bb, OUTPUT);  digitalWrite(lcd_bb,  LOW);
//--------------------------------------------------------------------------------------------------------
delay(20);                          // Wait while the LCD-unit itself is initialized
lcd_write(0, B00110000);    // 1st LCD write (set 8bits interface)
delay(6);                           // Wait some
lcd_write(0, B00110000);    // 2nd LCD write (set 8bits interface)
delay(1);                           //  Wait some more
lcd_write(0, B00110000);    // 3rd LCD write (set 8bits interface)
//--------------------------------------------------------------------------------------------------------
lcd_write(0, B00111000);    // Function-Set 8-bits, 2-lines, 5x8-font, <none>, <none>
lcd_write(0, B00001000);    // Set Display On/Off Control: Cursor, Blinking
lcd_write(0, B00000001);    // Clear Display
lcd_write(0, B00001100);    // Set Display On/Off Control: Cursor, Blinking
lcd_write(0, B00010100);    // Set Cursor/ Display Shift: Shift/Cursor, Right/Left, <none>, <none>
lcd_write(0, B00000110);    // Entry Mode Set: Inc/Dec, DisplShift
//--------------------------------------------------------------------------------------------------------
// Clear the Character Ram
lcd_write(0,64); // Set to Char Ram
for (byte qq=0; qq<=63; qq=qq+1)
  { lcd_write(1, B00000000);
  }
lcd_write(0, B00000010); // Set to Display
lcd_write(0, 128 +   0);    // Home the Crsr
}

void lcd_write (byte rr, byte dd)
{
digitalWrite(lcd_en,  LOW);
delayMicroseconds(1);
// Write Commando (0) or Data (1)?
if ((rr & 0x01) == 0) { digitalWrite(lcd_rs, LOW)} else {digitalWrite(lcd_rs, HIGH)};

// Sent bit  7..0
if ((dd & 0x01) == 0) { digitalWrite(lcd_d0, LOW)} else { digitalWrite(lcd_d0, HIGH)}
if ((dd & 0x02) == 0) { digitalWrite(lcd_d1, LOW)} else { digitalWrite(lcd_d1, HIGH)}
if ((dd & 0x04) == 0) { digitalWrite(lcd_d2, LOW)} else { digitalWrite(lcd_d2, HIGH)}
if ((dd & 0x08) == 0) { digitalWrite(lcd_d3, LOW)} else { digitalWrite(lcd_d3, HIGH)}
if ((dd & 0x10) == 0) { digitalWrite(lcd_d4, LOW)} else { digitalWrite(lcd_d4, HIGH)}
if ((dd & 0x20) == 0) { digitalWrite(lcd_d5, LOW)} else { digitalWrite(lcd_d5, HIGH)}
if ((dd & 0x40) == 0) { digitalWrite(lcd_d6, LOW)} else { digitalWrite(lcd_d6, HIGH)}
if ((dd & 0x80) == 0) { digitalWrite(lcd_d7, LOW)} else { digitalWrite(lcd_d7, HIGH)}
// Set Enable and Reset it again.
digitalWrite(lcd_en,  HIGH);
delayMicroseconds(1);
digitalWrite(lcd_en,  LOW);
delayMicroseconds(45);
// Give a longer delay at ClearScreen and HomeScreen
if ((rr & 0x01) == 0) && ( dd == 0x01 ) )
   { // If Clear Display => Wait some longer.
     delay(2);
   }
if ((rr & 0x01) == 0) && (dd & 0xF7) == 0x02 ) )
   { // If Home Display => Wait some longer.
     delay(2);
   }
}

void lcd_print (char* ss)
{ // Print a character
  byte qq = 0;
  while ( ss[qq] != '\0' )
    { // chech every char if it is in the table.
      char cc=ss[qq];
      lcd_write(1,cc);
      qq=qq+1;
    }
}

void lcd_gotoxy(byte x, byte y)
{ byte bb=0;
  if (x > 19)     { x=19; }
  if (y >  3)     { y= 3; }
  switch (y)
    { case 0: { bb = 0x80 +  0 + x;
                break;
              }
      case 2: { bb = 0x80 + 20 + x;
                break;
              }
      case 1: { bb = 0x80 + 64 + x;
                break;
              }
      case 3: { bb = 0x80 + 84 + x;
                break;
              }
    }
  lcd_write(0,bb);
}

void lcd_number (word vv, byte num)
{ const word power10 [6] = {1, 1, 10, 100, 1000, 10000};
  byte ss=0;
  for (byte qq = num; qq > 0; qq = qq - 1)
    { ss = ( vv / power10 [qq] ) % 10;
      lcd_write (1,ss + 48);
    }
}

//=======================================================================================



Broncode: [1: LCD - Aansluiting met 8-bits.]

Afbeeldingen

lcd2_1.jpg
1/5: lcd2_1.jpg.
lcd2_2.jpg
2/5: lcd2_2.jpg.
lcd2_3.jpg
3/5: lcd2_3.jpg.
lcd2_4.jpg
4/5: lcd2_4.jpg.
lcd2_5.jpg
5/5: lcd2_5.jpg.

De aansluitingen van LCD - Aansluiting met 8-bits.

De eerste aansluitingen van een LCD (20x4 tekens en RGB-background-light) op de Arduino Uno

Arduino Uno

Pwr USB ?
 
?
aref
gnd Lcd Read/Write
? d13 Lcd Enable
ioreff d12 Lcd Register Select
reset d11 Lcd Backlight Blauw
+3.3v d10 Lcd Backlight Groen
+5v d9 Lcd Backlight Rood
Lcd Read/Write gnd d8
Lcd Read/Write gnd
Vin d7 Lcd D7
d6 Lcd D6
Release BG_Rood  Potm 1 a0 d5 Lcd D5
Sustain BG_Groen Potm 2 a1 d4 Lcd D4
Decay   BG_Blauw Potm 3 a2 d3 Lcd D3
Attack  BG_Xor   Potm 4 a3 d2 Lcd D2
Wave Duty cycle  Potm 5 a4 d1 Lcd D1
Osc. Frequentie  Potm 6 a5 d0 Lcd D0