Um auch bei kleineren Projekten die Möglichkeiten zu bekommen, bequem ein Tastenfeld (Keypad) zum Beispiel an einen Attiny85 anzuschließen habe ich dieses mittels einer Widerstandskaskade an einen analogen Eingang angeschlossen. Das Bild mit der Folientastatur zeigt, welche Leiterbahn die Zeile oder die Spalte abbildet.
Ich habe diese Anordnung aufgebaut und den Punkt A0 an den analogen Eingang A0 am Arduino Nano verbunden. +Vref wurde auf die 5V am Arduino gelegt. Anschließend habe ich mir die Werte des jeweiligen Tastendrucks am seriellen Monitor ausgelesen.
Normalerweise sollte der Tastendruck am Keypad selber keinen Widerstand darstellen. Deswegen könnte man die Widerstandsverhältnisse 1 zu 1 auf die 10bit-Auflösung des Mikrocontrollers umrechnen. Das würde dann so aussehen:
Bei Druck der „1“ bildet sich ein Spannungsteiler zwischen der +Vref(5V) und Masse (-V).
Vom Messpunkt gesehen ist ein Widerstand von 1kOhm gegen Masse vorhanden und 12,5 kOhm gegen +Vref.
Somit fällt über den Schalter gegen +Vref 4,44 V ab und über den Messwiderstand R1 0,56 V.
Das ist der Wert, der am analogen Eingang des Arduinos gemessen wird und mit 10 Bit aufgelöst einen Wert von 115 auswirft.
Beim Tastendruck „#“ liegt die volle +Vref Spannung am Messpunkt an (da R7 =0 Ohm beträgt) und sollte so den Wert 1023 abbilden.
Beim Tastendruck „6“ entsteht ein Teiler von 6,8k zu 1,0k. Die Spannung am Messpunkt sollte 0,64 V betragen, über den 6,8k Widerstand fallen 4,36 V ab. Der Rückgabewert am Messpunkt A0 beträgt 131.
Über die so kaskadierten Widerstandswerte können die ausgelesenen 10bit-Werte am Arduino verarbeitet werden. Jeder Taste wird so ein bestimmter Wert zugeordnet.
Hier ein Beispielsketch für einen Arduino Nano, welcher die Ausgabe der Tastendrücke auf dem Seriellen Monitor ausgibt:
/*
Analog Keyboard attached at one analog PIN
Demonstrates analog Keyboard input by reading an analog value on analog pin 0.
The circuit:
A0
|
–1,5k—-1k—-1k———Ground 0V
| | |
K1——K2—-K3——10,0k–VCC
| | |
K4——K5—-K6——6,8k—VCC
| | |
K7——K8—-K9——3,0k—VCC
| | |
K*——K0—-K#——0R—–VCC
*/
int keyboardPin = A0; // select the analog input pin
int keyboardValue; // variable to store the 10 bit value coming from the Keypad
bool abfragebeendet=false;
byte key=99;
void setup() {
Serial.begin(9600);
}
void getKey() {
// read the value from the sensor:
keyboardValue = analogRead(keyboardPin);
while (keyboardValue>2){ //when the signal on A0 is min. 2 a Key is pressed
while (abfragebeendet==false){ //a while-loop to check that the Key-check run once
delay(10); //after 10ms
keyboardValue = analogRead(keyboardPin); //read the keyboardValue again to reduce bouncing and contact errors
if (keyboardValue>=40 && keyboardValue<=77)key=1; if (keyboardValue>=78 && keyboardValue<=85)key=2; if (keyboardValue>=86 && keyboardValue<=96)key=3; if (keyboardValue>=97 && keyboardValue<=110)key=4; if (keyboardValue>=111 && keyboardValue<=120)key=5; if (keyboardValue>=121 && keyboardValue<=138)key=6; if (keyboardValue>=139 && keyboardValue<=180)key=7; if (keyboardValue>=181 && keyboardValue<=205)key=8; if (keyboardValue>=206 && keyboardValue<=260)key=9; if (keyboardValue>=261 && keyboardValue<=300)key=66; if (keyboardValue>=301 && keyboardValue<=510)key=0; if (keyboardValue>=600 && keyboardValue<=1000)key=77;
//Serial.print(„Du hast Taste „);
//Serial.print(key);
//Serial.print(“ gedrückt „);
//Serial.println(keyboardValue);
abfragebeendet=true; //Key-check is finished, close the inner while-loop
}
keyboardValue = analogRead(keyboardPin); //check the Value on pin a0
delay(1);
} //the outter while-loop will closed, if no key pressed still
abfragebeendet=false;
}
void loop() {
getKey();
if (key<99){
Serial.print(„Das war Taste: „);
Serial.println(key);
}
key=99;
}
Die Rückgabewerte am Arduino waren jedoch nicht die gleichen, wie man sie rechnerisch erwartet hätte. Da scheinen Bauteilbedingt teils größere Unterschiede zu bestehen. Daher habe ich mir die Werte mit einem kleinen Sketch ausgelesen und notiert. Im Sketch habe ich dann die Toleranzbereiche für jede Taste händisch angepasst.
Wenn dann die Ausgabe am seriellen Monitor passt und jeder Tastendruck einwandfrei erkannt wird, kann man den Code auch z.B. auf den kleinen Attiny85 übertragen. Hierzu muss nur noch alles was die serielle Ausgabe angeht herausgelöscht werden und ggf. der Analogpin auf pin1 gelegt werden, da pin0 am Attiny keinen analoge Signale einliest.
Gabunz's Blog 