Ich bau grad an nem Programm für nen Mikroprozessor welches eine 101-Tasten Matrixtastatur ausliest, es soll das entsprechende ASCII-Zeichen per RS232 senden...

Funktioniert auch alles prima, nur jetzt steh ich vor einem Rätsel - Was sendet die Tastatur bei Tasten wie F1..F12, PrtSc, Pause, Insert, Home, PgUp, Delete, End, PgDn, Pfeiltasten, Num-Block, ...
Und werden Tasten wie Shift und CapsLock, NumLock, ScrollLock, Tastaturintern verarbeitet oder auch nochmal an den PC übergeben?

Es müssen ja mindestens zwei Byte sein. Dass die Tastatur nicht über RS232 sendet weiss ich auch, aber es geht eher drum was der PC drauß interpretiert... (Nicht das OS!!). Wenn sich das nicht aufklären lässt, oder wenn es dann doch vom OS interpretiert wird, soll mir das auch recht sein, nur solange es Standards gibt möcht ich nicht mein eigenes Süppchen kochen. Hab leider nichts konkretes zu dem Thema gefunden, da ich ja nicht im Gray-Code arbeite...

shielding people from their own stupidity is an evolutionary step backwards anyway.

/* God is dead!............Nietzsche */
/* Nietzsche is dead!......God */
/* Nietzsche is God!.......The Dead */

mal schauen, ob ich es noch richtig weiss...

prinzipiell ist eine taste eine taste, ob A, ESC, Strg oder Pause, alle sind von der sicht des tastatursteckers (z.b. bei PCs auf port 0x60 (iirc) abgebildet) gleich:
- jede taste bekommt eine nummer zugeordnet
- wenn eine taste gedrueckt wird, produziert das einen make-code, das ist ein wort, bei dem das hoechste bit gesetzt ist und die anderen sind die nummer der taste
- wenn eine taste losgelassen wird, produziert das einen break-code, genauso wie make-code, ausser, dass das hoechste bit geloescht ist

daraus folgt, dass eine tastatur nur den make-code fuer A kennt, weder gros noch klein, einfach nur der make-code fuer A, erst das bios (bzw. ein tastaturtreiber) wandelt das in ASCII 97 (a), bzw falls shift ebenfalls als gedrueckt erkannt wurde ASCII 65 (A), um.

je nach auslegung der kontakt-matrix in der tastatur, kann es sein, dass sich einige tasten gegenseitig blockieren oder nur eine maximale anzahl an gleichzeitig niedergedrueckten tasten (mit bestimmten verteilungsmustern auf der tastatur) moeglich ist, in extremen faellen kann es sogar zu phantom-tasten kommen, aber alle diese effekte treten bei 'normaler' benutzung (also texteingabe, nicht mehrere-leute-zocken-an-einer-tastatur) nicht auf.

mal schnell gegoogelt, vielleicht hilft dir das weiter (hab's net genau gelesen):
http://www.ece.uah.edu/~milenka/cpeee_422522_02S/labs/lab2.htm
http://members.iweb.net.au/~pstorr/pcbook/book3/keyboard.htm

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

Danke, das hat mir schon weiter geholfen...

Die sache ist ja dass ich keine PC-Tastatur nachbauen will, eher ein Eingabegerät (=Tastatur) für einen Systemrechner. Was er intern damit macht ist ja eigentlich ziemlich wurscht, währe nur praktisch gewesen wenn die eigene Verarbeitung mit dem Standard konform wäre...

Die Tastatur ist als X(12)Y(16)-Matrix aufgebau in dem jede Taste einen Konotenpunkt besitzt. Ich hab jetzt einen Oszillator mit Zähler und 1of12 Decoder... Die Ausgänge sitzen auf den X-Leitungen von der Tastatur und gleichzeitig auf 12 Input-Pins des Mikroprozessors.. die 16 Y-Leitungen sitzen ebenfalls an 2 Ports des Prozessors... Wenn nun eine der Y-Leitungen Hi liegt, wurde mindestens eine Taste gedrückt. Dann frage ich hiermit ab welche es ist:Quellcode:if (KEY_3 && KEY_K)
{
    if (!sft)
        // '\'
        uart_sendchr(0x5C);
    else
        // '~'
        uart_sendchr(0x7E);
}

if (KEY_4 && KEY_I)
{
    if (!sft)
        // '1'
        uart_sendchr(0x31);
    else
        // '!'
        uart_sendchr(0x21);
}

if (KEY_3 && KEY_I)
{
    if (!sft)
        // '2'
        uart_sendchr(0x32);
    else
        // '@'
        uart_sendchr(0x40);
}

if (KEY_4 && KEY_H)
{
    if (!sft)
        // '3'
        uart_sendchr(0x33);
    else
        // '#'
        uart_sendchr(0x23);
}Als netter Nebeneffekt ist somit auch schon die Behandelung von mehreren gedrückten Tasten abgefangen..

Dann werd ich jetzt für Sondertasten einfach zwei Byte senden... Somit ist dann auch alles machbar.. Danke für deine Hilfe!

shielding people from their own stupidity is an evolutionary step backwards anyway.

/* God is dead!............Nietzsche */
/* Nietzsche is dead!......God */
/* Nietzsche is God!.......The Dead */

deine elektronik haengt _direkt_ an der kontakt-matrix? nicht hinter der ueblichen tastatur-elektronik?
dann solltest du unbedingt ueber phantom-tasten nachdenken, also wenn mehrere tasten gedrueckt sind, kann es dazu kommen, dass weitere gedrueckt scheinen.

waere es nicht geschickter, das ganze als 2dimensionales array zu realisieren? diese unmenge an ifs ist weder schnell noch platzsparend

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

Richtig, die Elektronik stellt die "Ansteuerung" für die Tastatur dar, Phantomtasten sind durch meinen Aufbau nicht möglich... Es ist immer nur eine einzige X-Leitung und für jede gedrückte Taste eine Y-Leitung Hi. Da liegt ja der sinn des externen Zählers, ich hätte ja genausogut die Y-Pins des Prozessors als Ausgang definieren können, dann währe die Phantomtastenproblematik aber vorhanden.

Bzw. funktioniert es ja schon bestens, ich wusste nur noch nicht was ich bei Sondertasten senden soll...

Mit nem Array könnte ich mir da auch keine Arbeit spaaren, hinter KEY_X verbirgt sich nämlich ein Makro:Quellcode:#define KEY_A    bit_is_set(PINA, 1)
#define KEY_B    bit_is_set(PINA, 2)
#define KEY_C    bit_is_set(PINA, 3)
#define KEY_D    bit_is_set(PINA, 4)
#define KEY_E    bit_is_set(PINA, 5)
#define KEY_F    bit_is_set(PINA, 6)
#define KEY_G    bit_is_set(PINA, 7)
#define KEY_H    bit_is_set(PINA, 8)
#define KEY_I    bit_is_set(PIND, 6)
#define KEY_K    bit_is_set(PIND, 7)
#define KEY_L    bit_is_set(PIND, 8)
#define KEY_M    bit_is_set(PINE, 1)

#define KEY_1    bit_is_set(PINB, 1)
#define KEY_2    bit_is_set(PINB, 2)
#define KEY_3    bit_is_set(PINB, 3)
#define KEY_4    bit_is_set(PINB, 4)
#define KEY_5    bit_is_set(PINB, 5)
#define KEY_6    bit_is_set(PINB, 6)
#define KEY_7    bit_is_set(PINB, 7)
#define KEY_8    bit_is_set(PINB, 8)
#define KEY_9    bit_is_set(PINC, 1)
#define KEY_10    bit_is_set(PINC, 2)
#define KEY_11    bit_is_set(PINC, 3)
#define KEY_12    bit_is_set(PINC, 4)
#define KEY_13    bit_is_set(PINC, 5)
#define KEY_14    bit_is_set(PINC, 6)
#define KEY_15    bit_is_set(PINC, 7)
#define KEY_16    bit_is_set(PINC, 8)Dann müsste ich zuerst das Array setzen und dann trotzdem die IFs benutzen um eine Taste über die Schnittstelle zu senden..

Platzsparend ist das wirklich nicht, aber ich hab 8kB speicher, also genug.. Der Mikroprozessor läuft mit 8MIPS bei 8MHz und ein IF benötigt nur 2 Taktzyklen... Also mehr oder weniger egal, so schnell wie die Elektronik läuft kann _kein_ Mensch tippen ;)

shielding people from their own stupidity is an evolutionary step backwards anyway.

/* God is dead!............Nietzsche */
/* Nietzsche is dead!......God */
/* Nietzsche is God!.......The Dead */