4.Versuch

LCD mit 3 Wires und einer Tastatur

Hallo Arduino-Fellows,

Nun was versteht man unter LCD 3 Wires. Unter einer LCD mit 3 Wires versteht man, dass diese mit einem Shiftregister mittels 3 Strobes vom Arduino angesteuert werden.

Die Verwendung eines Shiftregisters wie 74HC595 hat in dieser Anordnung erhebliche Vorteile. Auf die Funktion eines Shiftregisters verweise ich auf einschlägige Literatur oder entsprechende Arduino Tutorial Web Seiten. Mit der Ansteuerung einer LCD mit dem Shiftregister ist es nicht getan. Man kann die Ansteuerung der LCD über die IDE mit dem Seriellen Port durchführen. Interessanter aber meine ich, ist der Anschluss einer Tastatur mit 3x4 Matrix, die es für ungefähr 9 Euro zu kaufen gibt. Das Programm zeigt nur eine einfache Ansteuerung der LCD ( Hitachi HD44780U ). Mit dem Drücken auf eine Taste auf die Tastatur erscheint ein Zeichen, daß man gedrückt hat. Es gibt keine Taste die ein Reset oder ein Clear auf der LCD macht. Das Programm ist wegweisend für die Programmierung von Sensoren, einem Türschließer oder einem Kaffeeautomaten mit Menüausgabe.

Die Matrix, die in der Programmzeile 163-167 gezeigt wird, gilt nur für die im Bild gezeigte Tastaturmatrix. Ist eine andere Tastatur vorhanden, so muss man erst die Tastaturmatrix für das Scanning herausfinden oder das Datenblatt lesen.

Zeigt das LCD kein Zeichen an, so muß man die 3 Drähte zum Shiftregister hin überprüfen, ob diese richtig mit latchpin, datapin oder clockpin verdrahtet sind.Erscheinen irgendwelche Zeichen, so sind die 4 Parallel-Ausgaenge vom Shiftregister nicht richtig verdrahtet.

Abb.:Schaltplan Ansteuerung einer LCD mittes Tastatur

Abb.: Aufbau der Schaltung mit gedrückter Taste 4

Abb.: Meldung, dass alles in Ordnung ist

Lit: Lit: Michael Margolis Arduino Kochbuch O' Reilly Verlag

Texas Instruments SN74HC595 Shiftregister

Datenblatt von Hitachi HD44780

Arduino is a Trademark

5.Programm

1 /* LCD display with 3 wires
2 * ------------------------
3 * Prg to HEF 4094 umgeschrieben HC595
4 * based on previous examples by Tomek.
5 * This program will use shiftout to send
6 * data to a shift register with strobe that
7 * will transfer the serial into parallel data
8 *
9 * the pin-out for LCD displays is standard and there is plenty
10 * of documentation to be found on the internet.
11 *
12 * (cleft) 2007 Dojodave for K3 and SADI
13 * http://www.arduino.cc
14 *
15 */
16 // pins to be used on Arduino
17 //int led = A5; //Pinout=A5 Meine Zusätze Controlled
18 byte ClearDisplay = B00000001;//auf 4bit s. Instruction Tabel 1,53ms Reset DDram
19 byte ReturnHome = B00000010;// 1.53ms
20 byte EntryModeSet = B00000100;//39micros I=0 S=0 (I=inc,d=dec)
21 byte EntryModeInc= B00000110; //mit Increment
22 byte EntryModeShift= B00000101; // entry mit shift
23 byte Displayclear= B00001000; //D=OFF,C=OFF,B=OFF
24 byte DisplayCursoron=B00001111; // D=on C=on B=on Cursoron
25 byte DisplayCursoroff=B00001110;
26 byte Cursorshift= B00010000; // S/C=0 R/L=0
27 byte Functionset= B00100000; // DL=4bit=0,N=2Lines=1, F=5x8dots=0 erst
28 byte SetCGRAM= B01000000; // ACG=0 39micros
29 byte SetDDRAM= B10000000; //ADD=0 39micros
30 byte Functionset2Line=B00101000; //mit 2 Linien
31 byte Functionset5x11Dots = B00100100;//mit 1 Linien 5x11Dots
32 byte Cursorshiftall= B00011100;
33 byte SetDDRAMADDR =0x80;
34 int count = 0;
35 int dataPin = 10;//datapin 14 sehr sehr wichtig das das stimmt.Sonst zeigt LCD nichts an.
36 int latchPin= 12;//latchpin rclk pin12
37 int clockPin = 11;//clockpin srclk pin11
38 int wait1=39; //in micros
39 int wait2=100;
40 int wait3=64;
41 void LCDInit() {
42 delay(1000); //to be sure
43 // initialize LCD after a short pause
44 // needed by the LCD's controller s.Instruction Table
45 /////////// 4 pin initialization
46 LCDCommandWrite(Functionset); // 4 pin initialization
47 delayMicroseconds(wait1*105);//4.1ms
48 LCDCommandWrite(Functionset); // 4 pin initialization
49 delayMicroseconds(wait1*105);
50 LCDCommandWrite(Functionset); // 4 pin initialization
51 delayMicroseconds(wait1*105);
52 LCDCommandWrite (ReturnHome);// finally 4bit interface Flag
53 delayMicroseconds(wait1);
54 LCDCommandWrite(Functionset2Line); // function set:als Flag
55 // 4-bit interface, 2 display lines, 5x8 font
56 /////////// end of 4 pin initialization
57 delayMicroseconds(wait1);
58 LCDCommandWrite(EntryModeSet); // entry mode set:
59 // increment automatically, no display shift
60 delayMicroseconds(wait1);
61 LCDCommandWrite(ClearDisplay);
62 delayMicroseconds(wait1*105);
63 //LCDCommandWrite(DisplayCursoron); //und Cursor blinkt dann o.K
64 // delayMicroseconds(wait1);
65 }
66 void Shift595(int value) {
67 digitalWrite(latchPin,LOW);
68 shiftOut(dataPin, clockPin, LSBFIRST, value);
69 digitalWrite(latchPin, HIGH);
70 }
71 void LCDCommandWrite(int value) {
72 //value ist o.K for init ohne control control=?? gegüber Original
73 int i = 0;
74 int value1 = 0;
75 digitalWrite(latchPin,LOW); // set the latchpin LOW
76 value1 = value;
77 value1 >>= 4; //send the first 4 databits (from 8) OR swap
78 value1 &= 239; // set Enable LOW
79 //Serial.print("1=");Serial.println(value1, BIN);
80 Shift595(value1);
81 value1 |= 16; // Set Enable HIGH
82 //Serial.print("2=");Serial.println(value1, BIN);
83 Shift595(value1);
84 value1 &= 239; // set Enable LOW
85 // Serial.print("3=");Serial.println(value1, BIN);
86 Shift595(value1);
87 delay(1);
88 value &= 15; // set HByte to zero
89 value &= 239; // set Enable LOW
90 // Serial.print("4=");Serial.println(value, BIN);
91 Shift595(value);
92 value |= 16; // Set Enable HIGH
93 // Serial.print("5=");Serial.println(value, BIN);
94 Shift595(value);
95 value &= 239; // set Enable LOW
96 // Serial.print("6=");Serial.println(value, BIN);
97 Shift595(value);
98 }
99 void LCDWrite(int value) {
100 int i = 0;
101 int value1 = 0;
102 digitalWrite(latchPin,LOW); // set the strobe LOW latchpin
103 value1=value;
104 value1 >>= 4;
105 //send the first 4 databits (from 8)
106 value1 |= 64; // set DI HIGH latchpin
107 value1 &= 223; // set RW LOW datapin
108 value1 &= 239; // set Enable LOW
109 Shift595(value1);
110 value1 |= 16; // Set Enable HIGH
111 Shift595(value1);
112 value1 &= 239; // set Enable LOW
113 Shift595(value1);
114 delay(1);
115 value &= B1111; // set HByte to zero myset LSB to MSB
116 value |= 64; // set DI HIGH
117 value &= 223; // set RW LOW datapin
118 value &= 239; // set Enable LOW
119 Shift595(value);
120 value |= 16; // Set Enable HIGH
121 Shift595(value);
122 value &= 239; // set Enable LOW
123 Shift595(value);
124 }
125 void Begin (int col,int lines,int dotsize)
126 { if (lines>1) {
127 LCDCommandWrite(Functionset2Line);
128 }
129 int numlines=lines;
130 int currline=0;
131 if ((dotsize!=0)&&(lines==1)) // wenn 0=>5x8
132 {
133 LCDCommandWrite(Functionset5x11Dots);
134 }
135 delayMicroseconds(10000);
136 LCDInit();
137 LCDCommandWrite(DisplayCursoron); // display control:
138 // turn display on, cursor on, no blinking
139 // clear display, set cursor position to zero
140 Clear();
142 LCDCommandWrite(EntryModeSet);
143 }
144 void Clear()
145 {
146 LCDCommandWrite(ClearDisplay);//löscht das Display
147 delayMicroseconds(100);
148 }
149 void Home()
150 {LCDCommandWrite(ReturnHome);// Setzt Cursor an die obere linke Ecke
151 delayMicroseconds(wait1);
152 }
153 /*===========================================================
154 // Routine für keypatch Quelle: Michael Margolis Arduino Kochbuch Kapitel 5.5 */
155 const int numRows = 4; // Zeilen der Tastatur
156 const int numCols = 3; // Spalten der Tastatur
157 int priWert;
158 const int rate=500;
159 const int debounceTime = 500; // 100 statt 20 Zeit in Millisekunden, bis sich die Taste stabilisiert
160 // keymap definiert die Zeichen, die zurueckgegeben werden, wenn die entsprechende Taste gedrueckt
161 // Anschluß magenta Pin7 auf Pin8 Arduino der Letzte braun Pin2 auf Arduino Pin 2
162 // 2-5 sind Zeilen 5-7 sind die Spalten
163 const char keymap[numRows][numCols] = {
164 { '1', '2', '3' } ,
165 { '4', '5', '6' } ,
166 { '7', '8', '9' } ,
167 { '*', '0', '#' }
168 };
169 const int rowPins[numRows] = { 5,4,3,2 }; // s.Blatt
170 const int colPins[numCols] = {8,7,6 }; // siehe Blatt
171 // gibt gedrueckte Taste zurueck bzw. 0, wenn keine Taste gedrueckt wurde
172//==============================================================
173 char getKey() //Subroutine Scan Tastatur
174 {
175 char key = 0; // 0 bedeutet, es wurde eine Taste gedrueckt und LED gruen blinkt
176 for(int column = 0; column < numCols; column++)
177 {
178 digitalWrite(colPins[column],LOW); // Aktuelle Spalte aktivieren.
179 for(int row = 0; row < numRows; row++) // Alle Zeilen auf
180 // Tastendruck untersuchen.
181 {
182 if(digitalRead(rowPins[row]) == LOW)
183 // Taste gedrueckt?
184 {
185 delay(debounceTime); // Entprellen while(digitalRead(rowPins[row]) == LOW);
// Auf Tastenfreigabe warten
186 key = keymap[row][column]; // Festhalten, welche Scan
187 Serial.print("col=");Serial.print(column);
188 Serial.print("row=");Serial.print(row);Serial.println();
// Taste gedrueckt wurde.
189 }
190 }
191 digitalWrite(colPins[column],HIGH); // Aktuelle Spalte deaktivieren.
192 }
193 return key; // gedru¨ckte Taste (oder 0) zuru¨ckgeben
194 }
195 //===========================================================
196 void setup (void)
197 {
198 Serial.begin(9600);
199 pinMode(clockPin,OUTPUT);
200 pinMode(latchPin,OUTPUT);
201 pinMode(dataPin,OUTPUT);
202 //setup für keypad
203 // Scan keypad
204 for (int row = 0; row < numRows; row++)
205 {
206 pinMode(rowPins[row],INPUT); // Pins fu¨r Zeilen als Einga¨nge schalten
207 digitalWrite(rowPins[row],HIGH); // Pullups aktivieren
208 }
209 for (int column = 0; column < numCols; column++)
210 {
211 pinMode(colPins[column],OUTPUT); // Pins fuer Spalten als Ausgaenge schalten
212 digitalWrite(colPins[column],HIGH); // Alle Spalten sind inaktiv
213 }
214 // pinMode(led,OUTPUT);
215 LCDInit();
216 delayMicroseconds(wait1*105);
217 int wrote[] = {
218 'L','C','D','-','D', 'i', 's', 'p', 'l', 'a', 'y', ' ','O','.','k' };
219 for ( count = 0; count<=14; count++) {
220 LCDWrite(wrote[count]);
221 }
222 delay(5000); //Zeige 5sec die Meldung
223 Home();
224 LCDCommandWrite(DisplayCursoron);
225 LCDCommandWrite(~EntryModeInc);
226 LCDCommandWrite(SetDDRAM);
227 LCDCommandWrite(0x00); //DDRAM Adresse setzen Home
228 }
229 void loop (void)
230 {
231 char key = getKey(); //Routine Tastatur
232 if( key != 0) {
233 priWert=int(key); // Wert von Keypad holen
234 LCDWrite(priWert);
235 }
236 delayMicroseconds(wait1*105); //4,1ms
237 } //END

5.Versuch

Knightrider mit Töne

Hallo Arduino-Fellows,
Hier stelle ich einen Knightrider vor, der mit 9V Anschluss, sowie einen 5V Anschluss (ARDUINO UNO ) der für einen Lautsprecher, die Spannung hergibt.

Den Lautsprecher habe ich aus einem alten Kassettenrekorder ausgebaut. Den 9V - Anschluss habe ich aus einem vorhanden Steckerkabel mit angelöteten Pins verbessert. (s.Abb oben)

Durch den Einsatz von Transistoren – hier BC337 – kann man die Leistung des Arduino wesentlich erhöhen, indem man den Arduino nur noch als Controller verwendet. Hier geht der Kollektor des Transistors auf Masse. ARDUINO steuert die LED über die Kathode mit der Basis, die einen Widerstand von 1000 Ohm erhält. Die Anode der grünen LED arbeitet mit 330 Ohm.

Die Belastbarkeit der gängigen ARDUINO's sind aus dem Datenblatt zu ersehen. Auf dem ARDUINO UNO befindet sich ein Spannugsregler und der Hohlbuchse, die mit Vin 5V den ATMEL - Chip versorgen kann. Der Spannungsregler darf nur in den Grenzwerten von 9V bis 12 V arbeiten. Ich habe die Erfahrung gemacht, dass die USB-Buchse zu viel Leistung zieht, sodass der USB-Baum nicht mehr von WIN 7 aus richtig funktioniert.
Benötigt man mehr als 100mA, so ist ein externes Netzteil, wie in diesem Versuch anzuwenden.

Abb.: Schaltplan Knightrider mit Töne

Abb.: Steckbrettaufbau der Schaltung

Lit: Datenblatt von Transistor BC337
Schaltplan mit TinyCAD gezeichnet
Michael Magolis Arduino Kochbuch Verlag:O'Reilly
Arduino is a Trademark

6.Programm

/*******************************************************************************************
* Gibt Tone uber einen Lautsprecher an Digitalpin 5 aus.
* Der Analogport liefert die Frequenz für den Lautsprecher.
*/
const int speakerPin = 5; // Lautsprecher an Pin 5
const int pitchPin = 0;
int Wartzeit = 250; // 250ms Wartezeit
/* KnightRider
*/
const int AnzahlLED = 8;
const int ledPins[] = {13,12,11,10,9,8,7,6};
const int wait = 30;
void setup(){
for (int led = 0; led < AnzahlLED; led++)
{
pinMode(ledPins[led], OUTPUT);
}
}
void loop() {
for (int led = 0; led < AnzahlLED-1; led++)
{
digitalWrite(ledPins[led], HIGH);
delay(wait);
digitalWrite(ledPins[led + 1], HIGH);
delay(wait);
digitalWrite(ledPins[led], LOW);
delay(wait*2);
}
for (int led = AnzahlLED-1; led > 0; led--) {
digitalWrite(ledPins[led], HIGH);
delay(wait);
digitalWrite(ledPins[led - 1], HIGH);
delay(wait);
digitalWrite(ledPins[led], LOW);
delay(wait*2);
}
/* Hier wird ein Ton ausgegeben
*/
{
int sensor0Reading = analogRead(pitchPin); // Hier werden kein Poti-Wert fur Frequenz einlesen
// Analogwert auf geeigneten Wertebereich abbilden
int frequency = map(sensor0Reading, 0, 1023, 500,5000); // 500Hz bis 5kHz
tone(speakerPin, frequency, Wartzeit); // Ton ausgeben
delay(Wartzeit); // gewünschte Dauer ausgeben
}
} //END

6.Versuch

Zwei Taster steuern ein grüne LED an

Hallo Arduino-Fellows,


Mit zwei Schaltern rot und blau steuert das Programm eine LED, die
mit 9V - Spannung gespeist wird an.
Das Experiment läßt sich lötfrei auf Steckbretter realisieren. Die Stecker
für die Stromversorgung habe ich selber aus vorhandenen Teilen zusammengebaut.
Die Transistoren BC 547 setze ich als Schalter ein. Arduino liefert keine 9V Spannung.
Aus diesem Grund muss die grüne LED mit Transistoren geschaltet werden.
Weiterhin ist es gut wenn ARDUINO mit GND zu dem Schaltkreis 'Response' verbunden wird.
Die Schalter werden mit einem 10k Ohm Widerstand entprellt. Die Transistoren werden an der Basis mit 1000 Ohm abgesichert.
LED grün Daten ergeben 330 Ohm an der Anode mit 114mW Verlustleistung.
Mit 9V Betriebsspannung und einem Betriebsstrom von 20mA.
Mit der Anordnung kann man auch einen Transistor oder eine LED grün testen.
Beachte die Belastbarkeit des ARDUINOs, das im 5. Versuch beschrieben wird.

Abb.: Schaltplan vom 10er Up-Zaehler

Abb.: Schaltungsaufbau auf dem Steckbrett.Nur Taster blau gedrückt.

Abb.: Schaltungsaufbau auf dem Steckbrett. Taster rot und balu gedrückt

Abb.: Schaltung

Lit:: Datenblatt von Transistor BC547
Datenblätter von der grünen und gelben LED
Schaltplan mit TinyCAD gezeichnet
Michael Magolis Arduino Kochbuch Verlag:O'Reilly
Arduino is a Trademark

7.Programm

/****************************************************************************

Pushbutton von Banzi Kapitel 5-1 um Schalter zu testen.
Die Schalter blau an Pin 2 steuert die LED an Pin 4 bzw rot Pin 5 an
*/
const int ledPingelb = 4; // LED-Pin gelb
const int ledPinrot = 5;
const int inputPinblau = 2; // Eingangspin fuer Taster blau
const int inputPinrot = 3; // Eingangspin fuer Taster rot
/*
2 Transistoren, die eine LED aufleuchten lassen, indem 2 Schalter rot und blau
gleichzeitig gedrückt werden. Dabei wird die LED grün mit 9V gespeist
*/
const int TransPin1 = 13; // Pins fur die jeweiligen LEDs wahlen
const int TransPin2 = 12;
const int duration = 500;// 500 ms
void setup() {
pinMode(ledPingelb, OUTPUT); // LED gelb als Ausgang deklarieren
pinMode(ledPinrot, OUTPUT); // LED rot als Ausgang deklarieren
pinMode(inputPinblau, INPUT); // Taster blau als Eingang deklarieen
pinMode(inputPinrot, INPUT); // Taster rot als Eingang deklarieren
pinMode(TransPin1, OUTPUT); // LED-Pin als Ausgang deklarieren
pinMode(TransPin2, OUTPUT); // LED-Pin als Ausgang deklarieren
}
void loop(){
int val1 = digitalRead(inputPinblau); // Eingangswert einlesen
if (val1 == HIGH) // Eingang HIGH?
{
digitalWrite(ledPingelb, LOW); // LED aus, da Kathode angesprochen wird
}
else
{
digitalWrite(ledPingelb, HIGH); // LED einschalten, wenn Taster gedrückt
}
int val2 = digitalRead(inputPinrot); // Eingangswert einlesen
if (val2 == HIGH) // Eingang HIGH?
{
digitalWrite(ledPinrot, LOW); // LED aus, da Kathode angesprochen wird
}
else
{
digitalWrite(ledPinrot, HIGH); // LED einschalten
}
int val3= digitalRead (inputPinrot);
int val4= digitalRead (inputPinblau);
if ( val3 && val4 )
{
digitalWrite(TransPin1,HIGH); // Diese Sequenz läßt die grüne LED blinken, wenn die
digitalWrite(TransPin2,HIGH); // die zwei Tasten blau und rot gedrückt bleiben

delay(duration/2); // 250ms

digitalWrite(TransPin1,LOW);

digitalWrite(TransPin2,LOW);

delay(duration/2);

}

else

{ digitalWrite(TransPin1,LOW);// grüne LED ist aus

digitalWrite(TransPin2,HIGH);

}

} // END