C64 Tastatur an den Arduino

[ArduinoBastler]

Hallo alle zusammen.

Bin hier auf das Forum gestoßen, da ich bei meinem aktuellen Projekt ein wenig Hilfe benötige und trotz Büchern usw. einfach nicht weiter komme.
Da ich leidenschaftlicher Commodore-Fan bin und eine Vielzahl an orig. Hardware besitze habe ich begonnen ein ITX-Mainboard in ein altes C64-Gehäuse zu verbauen, um darauf auch die guten alten Demos dieser Zeit genießen zu können.
Hardware ist alles drin, doch die originale Tastatur zu verwenden wäre natürlich das I-Tüpfelchen.
Habe nun zwei Sketches geschrieben. Beim ersten Frage ich die Tasten einzeln von der Matrix ab und schreibe sie in ein Array, um deren Status zu speichern und auswerten zu können. Dies Funktioniert und es werden auch die richtigen Tasten ausgegeben. Mein Problem liegt dabei eher im Entprellen der einzelnen Tasten. Manchmal schwankt dies doch jedoch sehr und ich erhalte unfreiwillig zwei Tastendrücke.

Belegungen der Ein- und Ausgänge auf Arduino:
Zeile A ->Pin2
Zeile B ->Pin3
Zeile C ->Pin4
Zeile D ->Pin5
Zeile E ->Pin6
Zeile F ->Pin7
Zeile G ->Pin8
Zeile H ->Pin9

Spalte 1 ->Pin 10
Spalte 2 ->Pin 11
Spalte 3 ->Pin A5
Spalte 4 ->Pin A4
Spalte 5 ->Pin A3
Spalte 6 ->Pin A2
Spalte 7 ->Pin A1
Spalte 8 ->PinA0

Die Sketch sie so aus:

//Variablen deklarieren
int stat;
int zeile[8] = {2,3,4,5,6,7,8,9};
int spalte[8]= {10,11,A5,A4,A3,A2,A1,A0};
int matrix[8][8];
void setup() {
//Starte die serielle Verbindung
Serial.begin(9600);

//Pinout für Indikator-LED definierten
pinMode(12, INPUT); //Jumper-Eingang
pinMode(13, OUTPUT); //Status-LED

//Pinout für die Tastatur-Matrix definieren
pinMode(10, INPUT); //Tastatur-Spalte 1
pinMode(11, INPUT); //Tastatur-Spalte 2
pinMode(A5, INPUT); //Tastatur-Spalte 3
pinMode(A4, INPUT); //Tastatur-Spalte 4
pinMode(A3, INPUT); //Tastatur-Spalte 5
pinMode(A2, INPUT); //Tastatur-Spalte 6
pinMode(A1, INPUT); //Tastatur-Spalte 7
pinMode(A0, INPUT); //Tastatur-Spalte 8

pinMode(2, OUTPUT); //Tastatur-Zeile A
pinMode(3, OUTPUT); //Tastatur-Zeile B
pinMode(4, OUTPUT); //Tastatur-Zeile C
pinMode(5, OUTPUT); //Tastatur-Zeile D
pinMode(6, OUTPUT); //Tastatur-Zeile E
pinMode(7, OUTPUT); //Tastatur-Zeile F
pinMode(8, OUTPUT); //Tastatur-Zeile G
pinMode(9, OUTPUT); //Tastatur-Zeile H

}

void loop() {
// put your main code here, to run repeatedly:
for(int x=0;x<8;x++){
digitalWrite(zeile[x],HIGH);
for(int y=0;y<8;y++){
matrix[x][y]=digitalRead(spalte[y]);
}
digitalWrite(zeile[x],LOW);
}
delay(120);
if(matrix[0][0] == 1){
Serial.print("1");
}
if(matrix[0][1] == 1){
Serial.println("Backspace");
}
if(matrix[0][2] == 1){
Serial.println("Control");
}
if(matrix[0][3] == 1){
Serial.println("RunStop");
}
if(matrix[0][4] == 1){
Serial.print(" ");
}
if(matrix[0][5] == 1){
//Serial.println("CMD");
}
if(matrix[0][6] == 1){
Serial.print("Q");
}
if(matrix[0][7] == 1){
Serial.print("2");
}
if(matrix[1][0] == 1){
Serial.print("3");
}
if(matrix[1][1] == 1){
Serial.print("W");
}
if(matrix[1][2] == 1){
Serial.print("A");
}
if(matrix[1][3] == 1){
//Serial.println("L-Shift");
}
if(matrix[1][4] == 1){
Serial.print("Z");
}
if(matrix[1][5] == 1){
Serial.print("S");
}
if(matrix[1][6] == 1){
Serial.print("E");
}
if(matrix[1][7] == 1){
Serial.print("4");
}
if(matrix[2][0] == 1){
Serial.print("5");
}
if(matrix[2][1] == 1){
Serial.print("R");
}
if(matrix[2][2] == 1){
Serial.print("D");
}
if(matrix[2][3] == 1){
Serial.print("X");
}
if(matrix[2][4] == 1){
Serial.print("C");
}
if(matrix[2][5] == 1){
Serial.print("F");
}
if(matrix[2][6] == 1){
Serial.print("T");
}
if(matrix[2][7] == 1){
Serial.print("6");
}
if(matrix[3][0] == 1){
Serial.print("7");
}
if(matrix[3][1] == 1){
Serial.print("Y");
}
if(matrix[3][2] == 1){
Serial.print("G");
}
if(matrix[3][3] == 1){
Serial.print("V");
}
if(matrix[3][4] == 1){
Serial.print("B");
}
if(matrix[3][5] == 1){
Serial.print("H");
}
if(matrix[3][6] == 1){
Serial.print("U");
}
if(matrix[3][7] == 1){
Serial.print("8");
}
if(matrix[4][0] == 1){
Serial.print("9");
}
if(matrix[4][1] == 1){
Serial.print("I");
}
if(matrix[4][2] == 1){
Serial.print("J");
}
if(matrix[4][3] == 1){
Serial.print("N");
}
if(matrix[4][4] == 1){
Serial.print("M");
}
if(matrix[4][5] == 1){
Serial.print("K");
}
if(matrix[4][6] == 1){
Serial.print("O");
}
if(matrix[4][7] == 1){
Serial.print("0");
}
if(matrix[5][0] == 1){
Serial.print("+");
}
if(matrix[5][1] == 1){
Serial.print("P");
}
if(matrix[5][2] == 1){
Serial.print("L");
}
if(matrix[5][3] == 1){
Serial.print(",");
}
if(matrix[5][4] == 1){
Serial.print(".");
}
if(matrix[5][5] == 1){
Serial.print(":");
}
if(matrix[5][6] == 1){
Serial.print("@");
}
if(matrix[5][7] == 1){
Serial.print("-");
}
if(matrix[6][0] == 1){
Serial.print("€");
}
if(matrix[6][1] == 1){
Serial.print("*");
}
if(matrix[6][2] == 1){
Serial.print(";");
}
if(matrix[6][3] == 1){
Serial.print("/");
}
if(matrix[6][4] == 1){
Serial.println("R-SHIFT");
}
if(matrix[6][5] == 1){
Serial.print("=");
}
if(matrix[6][6] == 1){
Serial.println("UP");
}
if(matrix[6][7] == 1){
Serial.println("HOME");
}
if(matrix[7][0] == 1){
Serial.println("DEL");
}
if(matrix[7][1] == 1){
Serial.println("");
}
if(matrix[7][2] == 1){
if(matrix[0][5] == 1){
Serial.println("CRSR-Right");
}
else{
Serial.println("CRSR-Left");
}
}
if(matrix[7][3] == 1){
if(matrix[0][5] == 1){
Serial.println("CRSR-Down");
}
else{
Serial.println("CRSR-Up");
}
}
if(matrix[7][4] == 1){
if(matrix[1][3] == 1){
Serial.println("F2");
}
else{
Serial.println("F1");
}
}
if(matrix[7][5] == 1){
if(matrix[1][3] == 1){
Serial.println("F4");
}
else{
Serial.println("F3");
}
}
if(matrix[7][6] == 1){
if(matrix[1][3] == 1){
Serial.println("F6");
}
else{
Serial.println("F5");
}
}
if(matrix[7][7] == 1){
if(matrix[1][3] == 1){
Serial.println("F8");
}
else{
Serial.println("F7");
}
}
}


Meine zweite Sketch basiert auf dem Keypad-Beispiel und wurde von mir angepasst. Tasten werden erkannt, doch werden die Tasten nicht richtig ausgegeben. Es wird je Taste irgendwie zumeist nur eine 1 oder eine wechselnde Ziffern oder Buchstabenreihe ausgegeben.

Die Sketch sieht wie folgt aus:

#include <Keypad.h>

#include "Keypad.h"
const byte ROWS = 8; //four rows
const byte COLS = 8; //four columns
char keys[ROWS][COLS] =
{
{'1','DEL','BACKSPACE','CTRL','STOP','COMMODORE','Q','2'},
{'3','w','a','L-SHIFT','z','s','e','4'},
{'5','r','d','x','c','f','t','6'},
{'7','y','g','v','b','h','u','8'},
{'9','i','j','n','m','k','o','0'},
{'+','p','l',',','.',':','@','-'},
{'€','*',';','/','R-SHIFT','=','UP','HOME'},
{'DEL','RETURN','LEFT-RIGHT','UP-DOWN','F1','F3','F5','F7'}};
byte rowPins[ROWS] = {
2, 3, 4, 5, 6, 7, 8, 9}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {
10, 11, A5, A4, A3, A2, A1, A0}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup()
{
Serial.begin(9600);
delay(1000);
}

void loop()
{
char key = keypad.getKey();
if (key != NO_KEY)
{
Serial.print(key);
}
}

Nun halt mein Problem.

Wie kann ich das Entprellen in die erste Sketch integrieren? Verstehe leider die Benutzung von Debounce nicht. Die Erläuterung im dazu bringt mich einfach nicht weiter.

Und zweitens. Sieht jemand den Fehler im zweiten Sketch? PIN-Belegung ist wie im ersten Sketch. Die Eingänge sind auch mit 10k-Widerständen auf Masse gezogen.

Hoffe ihr könnt mir ein wenig auf die Sprünge helfen.
Und schonmal vielen Dank für eure Mühe.

[Thorsten Pferdekämper]

Hi,
die Sache mit dem Entprellen ist mir jetzt zu viel zu schreiben.
Bei der Keypad-Library liegt's wahrscheinlich an Deinen Pulldown-Widerständen. Die Keypad Library arbeitet mit INPUT_PULLUP und die Tastendrücke sind Low-aktiv. Da sind Deine Pulldown-Widerstände Kontraproduktiv. Das ist dann fast so als ob immer jede Taste gedrückt ist, je nachdem wie das dann genau mit den internen Pullup-Widerständen wechselwirkt.
Gruß,
Thorsten

[ArduinoBastler]

So habe das ganze jetzt mal einfach so gelöst, dass ich die Pulldown Widerstände ganz einfach von der Masse gelöst habe. Jetzt gibt mit der Arduino schon einmal die einzelnen Letter aus. Das ist schon einmal ein Anfang.
Jetzt muss ich halt nur noch in den zweiten Schritt gehen und versuchen mehrere Tasten gleichzeitig abfragen.

[Thorsten Pferdekämper]

Hi,
anscheinend kann das die keypad-Lib sogar, ist nur nicht dokumentiert. Schau mal in die Keypad.h rein. Soweit ich es verstehe:
Rufe getKeys() auf. Wenn das Ergebnis true ist, dann ist mindestens eine Taste gedrückt. Die gedrückten Tasten stehen im Array key[]. Das Array hat eine Länge von 10 (#define LIST_MAX 10 in Keypad.h), d.h. es kann maximal 10 gleichzeitig gedrückte Tasten verarbeiten.
Gruß,
Thorsten

[ArduinoBastler]

Ja habe mir mal den Beispielcode angeguckt. Die Library kann bis zu zehn Tasten gleichzeitig abfragen, doch kommt es bei dem Gedrückthalten der Schifttaste zu dem Efekt, dass die ganze Zeile als High markiert wird. Verstehe ich irgendwie nicht. Also noch einmal ans Reizbrett.

[ArduinoBastler]

So die Tastatur funktioniert jetzt. Habe im Netz ein Sketch gefunden, welches eine ZX81 Tastatur ansteuert. Habe das Sketch jetzt an die C64 Tastatur angepasst und hey es läuft.

Jetzt habe ich nur noch eine Kleinigkeit. Irgendwie wird der Arduino von VICE nicht als Tastatur erkannt. Kann man den Arduino als echtes Keyboard anmelden?

"Mein" neuer Quellcode:
// ZX81 USB Keyboard for Leonardo
// © Dave Curran
// 2013-04-27

#define NUM_ROWS 8
#define NUM_COLS 8

byte keyMap[NUM_ROWS][NUM_COLS] = {
{'1',KEY_BACKSPACE,KEY_TAB,KEY_ESC,' ',KEY_LEFT_CTRL,'q','2'},
{'3','w','a','Shift','z','s','e','4'},
{'5','r','d','x','c','f','t','6'},
{'7','y','g','v','b','h','u','8'},
{'9','i','j','n','m','k','o','0'},
{'+','p','l',',','.',':','@','-'},
{'€','*',';','/','shift','=',KEY_DELETE,KEY_HOME},
{KEY_BACKSPACE,KEY_RETURN,KEY_LEFT_ARROW,KEY_UP_ARROW,KEY_F1,KEY_F3,KEY_F5,KEY_F​7}
};

// keymap if shift is pressed
// # gives £, \\ gives #
byte keyMapShifted[NUM_ROWS][NUM_COLS] = {
{'!',KEY_BACKSPACE,KEY_TAB,KEY_ESC,' ',KEY_LEFT_CTRL,'Q',34},
{'#','W','A',KEY_LEFT_SHIFT,'Z','S','E','$'},
{'%','R','D','X','C','F','T','&'},
{' ','Y','G','V','B','H','U','('},
{')','I','J','N','M','K','O','0'},
{'+','P','L','<','>','[','@','-'},
{'€','*',']','?','Shift','=',KEY_DELETE,KEY_HOME},
{KEY_BACKSPACE,KEY_RETURN,KEY_RIGHT_ARROW,KEY_DOWN_ARROW,KEY_F2,KEY_F4,KEY_F6,KE​Y_F8}
};

int debounceCount[NUM_ROWS][NUM_COLS];

// define the row and column pins
byte rowPins[NUM_ROWS] = {2, 3, 4, 5, 6, 7, 8, 9};
byte colPins[NUM_COLS] = {10, 11, A5, A4, A3, A2, A1, A0};

// where is the shift key
#define SHIFT_COL 3
#define SHIFT_ROW 1

// how many times does a key need to register as pressed?
#define DEBOUNCE_VALUE 200
#define REPEAT_DELAY 400

/* */
/* setup */
/* */
void setup()
{
//Serielle Verbindung aufbauen
//Serial.begin(9600);
// set all pins as inputs and activate pullups
for (byte c = 0; c < NUM_COLS; c++)
{
pinMode(colPins[c], INPUT);
digitalWrite(colPins[c], HIGH);

// clear debounce counts
for (byte r = 0; r < NUM_ROWS; r++)
{
debounceCount[r][c] = 0;
}
}

// set all pins as inputs
for (byte r = 0; r < NUM_ROWS; r++)
{
pinMode(rowPins[r], INPUT);
}

// initialize control over the keyboard:
Keyboard.begin();
}

/* */
/* loop */
/* */
void loop()
{
// check for shift
bool shifted = false;
bool keyPressed = false;
pinMode(rowPins[SHIFT_ROW], OUTPUT);

if (digitalRead(colPins[SHIFT_COL]) == LOW)
{
shifted = true;
}
pinMode(rowPins[SHIFT_ROW], INPUT);

// foreach row
for (byte r = 0; r < NUM_ROWS; r++)
{
// turn the row on
pinMode(rowPins[r], OUTPUT);
digitalWrite(rowPins[r], LOW);

for (byte c = 0; c < NUM_COLS; c++)
{
if (digitalRead(colPins[c]) == LOW)
{
// increase the debounce count
debounceCount[r][c]++;

// has the switch been pressed continually for long enough?
int count = debounceCount[r][c];
if (count == DEBOUNCE_VALUE)
{
// first press
keyPressed = true;
pressKey(r, c, shifted);
}
else if (count > DEBOUNCE_VALUE)
{
// check for repeats
count -= DEBOUNCE_VALUE;
if (count % REPEAT_DELAY == 0)
{
// send repeat
keyPressed = true;
pressKey(r, c, shifted);
}
}
}
else
{
// not pressed, reset debounce count
debounceCount[r][c] = 0;
}
}

// turn the row back off
pinMode(rowPins[r], INPUT);
}

digitalWrite(rowPins[SHIFT_ROW], LOW);
}

// Send the keypress
void pressKey(byte r, byte c, bool shifted)
{
byte key = shifted ? keyMapShifted[r][c] : keyMap[r][c];
if (key > 0)
{
// send the key

//Keyboard.write(key);
Keyboard.press(key);
Keyboard.releaseAll();
//Serial.println(key);
}
}

[Thorsten Pferdekämper]

(24.11.2014 18:39)ArduinoBastler schrieb:  Jetzt habe ich nur noch eine Kleinigkeit. Irgendwie wird der Arduino von VICE nicht als Tastatur erkannt. Kann man den Arduino als echtes Keyboard anmelden?

Ich glaube, dass das nur mit dem Leonardo oder Micro geht, möglicherweise noch mit dem Duo.
Siehe hier: http://arduino.cc/en/Reference/MouseKeyboard
Vielleicht kann man über die serielle Schnittstelle direkt noch was erreichen, aber wohl nicht per USB.
Gruß,
Thorsten

[ArduinoBastler]

Habe ja einen Leonardo.
Mein Problem äußert sich folgend.
In Linux sowie in Windows kann ich im Browser Konsole etc. alle eingaben tätigen. Einzig bei Emulatoren, die direkt auf die Tastatur zugreifen zum Beispiel deren Interups abfragen kommt die HID-Emulation nicht mehr hin.
Habe schon showkey laufen lassen und alle Scancodes kommen direkt und passend an. Denke wird wohl an der Emulation der HID liegen.
Doch da bin ich überfragt, was man da noch machen könnte.