Thema: kbc hilfe

[mineorbit]

Hallo lowlevel community!
Hoffentlich störe ich euch nicht mit dem Thema,allerdings habe ich 3 Fragen zur kbc:
1:Zeichen ausgeben
Letztes mal habe ich euch gefragt wie man den Keycode die Zeichen umwandle, allerdings, kann es sein das irgendwas falsch mache.
Das ganze funktioniert doch so; scancode -> Keycode -> Zeichenkette ?
Wie trage ich die Zeichen richtig in den Array ein?
Das ist jetzt so bisher:

Code: [Auswählen]

#include "console.h"
#include "keyboard.h"
#include "stdint.h"
char list[] = {
"01"
};
char getsym(int keycode)
{
if(keycode == 0x1c)
{
kexit();
}
  return list[keycode];
}
}
static uint8_t sc_to_kc[][128] = {
{ 0, 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, 84, 00, 00, 86, 87, 88, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00 },  { 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 96, 97, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00, 00, 100, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 102, 103, 104, 00, 105, 00, 106, 00, 107, 108, 109, 110, 111, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00 }, }; 
uint8_t translate_scancode(int set, uint16_t scancode)
{
uint8_t keycode = 0;
switch (set) { 
case 0:
 keycode = sc_to_kc[0][scancode];
 break;
case 1:
  keycode = sc_to_kc[1][scancode];
 break;
   switch (scancode) {
  case 0x451D: keycode = 119; break; default: keycode = 0x0; }; break; }
if (keycode == 0) {
 } return keycode;
}
 
void init_keyboard(void);
static void keyboard_command(uint8_t command);
void keyboard_interrupt(void);
void init_keyboard(void)
{
 
    while (inb(0x64) & 0x1) {
        inb(0x60);
    }   
 
 
    keyboard_command(0xF4);
}
 
static void keyboard_command(uint8_t command)
{
   
    while ((inb(0x64) & 0x2))
{
}
    outb(0x60, command);
}
void keyboard_interrupt(void){
     char text;
    uint8_t scancode;
    int keycode;
    uint8_t break_code = 0;
 
    // Status-Variablen fuer das Behandeln von e0- und e1-Scancodes
    static int     e0_code = 0;
    // Wird auf 1 gesetzt, sobald e1 gelesen wurde, und auf 2, sobald das erste
    // Datenbyte gelesen wurde
    static int      e1_code = 0;
    static uint16_t  e1_prev = 0;
 
    scancode = inb(0x60);
 
    if ((scancode & 0x80) &&
        (e1_code || (scancode != 0xE1)) &&
        (e0_code || (scancode != 0xE0)))
    {
        break_code = 1;
        scancode &= ~0x80;
    }
 
    if (e0_code) {
        if ((scancode == 0x2A) || (scancode == 0x36)) {
            e0_code = 0;
            return;
        }
 
        keycode = translate_scancode(1, scancode);
        e0_code = 0;
    } else if (e1_code == 2) {
     /*
        e1_prev |= ((uint16_t) scancode <<;
        keycode = translate_scancode(2, e1_prev);
        e1_code = 0;
*/
    } else if (e1_code == 1) {
       
        e1_prev = scancode;
        e1_code++;
    } else if (scancode == 0xE0) {
        // Anfang eines e0-Codes
        e0_code = 1;
    } else if (scancode == 0xE1) {
        // Anfang eines e1-Codes
        e1_code = 1;
    } else {
        // Normaler Scancode
        keycode = translate_scancode(0, scancode);
       
    }
      text = getsym(keycode);
        if(break_code == 0)
 {
 
        kprintf("%c",text);
  }
        else
 {
       
 }     
}
 
2:Speziell Zeichen abfragen
Im Code steht:
if(keycode == 0x1c)
{
kexit();
}
kexit habe ich als Funktion gemacht um den PC runter zu fahren
Damit möchte ich erreichen ,dass beim Tasten druck von Enter der Computer heruntergefahren wird, dies funktioniert aber nicht,wie würde ich das Problem lösen?
3:Lesechar
Ansonsten, hätte jemand von euch einen Denk anstoß um ein char namens kreadf() zu machen?Das wäre spitze 
Freundliche Grüße,
 Mineorbit!
EDIT:
3 ist gelöst,ich hatte nur einen syntaxfehler gemacht.
 

[Jidder]

Hoffentlich störe ich euch nicht mit dem Thema,allerdings habe ich 3 Fragen zur kbc:

Niemals. Dafür ist das Forum da

Deine translate_scancode-Funktion könnte etwas aufgeräumt werden. Das zweite switch wird nie ausgeführt. Und das ist auch besser so, weil es keycode überschreibt.

Im Prinzip sollte der Code funktionieren. Das Array list solltest du mit den Werten aus der ersten Spalte von hier befüllen (nicht kopieren, die Arrays sind nicht kompatibel):

http://git.tyndur.org/?p=tyndur.git;a=blob;f=src/modules/vterm/keymaps/de.c;h=53612b6a8cad464ae8e93625e624879520bc59f0;hb=HEAD

Dann hast du alle Tasten ohne Shift. Wenn du Shift unterstützen willst, musst du das Array ähnlich wie tyndur entweder zweidimensional machen oder zwei Arrays anlegen. Und dann musst du eine Status-Variable haben, die gesetzt und gelöscht wird wenn Shift gedrückt bzw. losgelassen wird.

Oder du experimentierst selbst rum: Wenn du keycode beim Tastendruck ausgeben lässt, kannst du dir selbst so eine Tabelle anlegen, die besagt, welcher keycode zu welcher Taste gehört. Ist natürlich etwas Fleißarbeit.

Oder du nimmst die Werte von hier (für englisches Layout) http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html#ss1.4 Die fettgedruckte Zahl ist der keycode und du nimmst entweder das erste oder das zweite dahinterstehende Zeichen (für kein Shift bzw. Shift gedrückt). Die Zeichen schreibst du an die entsprechende Stelle des Arrays. Bei Tasten die keinem Zeichen entsprechen (ESC, Shift, Alt, Strg, Caps, Backspace, ...) kannst du natürlich nur 0 eintragen.

Zu der Sache mit dem Herunterfahren: Funktioniert das Herunterfahren allgemein nicht, oder das Herunterfahren auf Tastendruck? Im ersteren Fall, kann dir keiner ohne Code von kexit weiterhelfen, und im zweiten Fall würde ich sagen, dass du erstmal andere Probleme lösen solltest.

[mineorbit]

Vielen Dank für die Hilfe
Denn Array füll ich jetzt erstmal aus,wie gesagt.
Die funktion herunterfahren also kexit läuft, nur weiß ich nicht wie ich einzelne Tasten abfrage ob sie gedrückt wurden.Das würde ich später auch noch gerne in ein treiber reinbringen. Wie würde ich so ein lese-char machen? Ich hab das mal so versucht,dass ich alles in einen array eintragen lasse und das dann ausgebe,aber meine kprintf funktion kann noch keine arrays zurück geben. ich wollte erstmal nur in der test.bin,die ich umfunklt habe in console.bin umfunktioniert habe, mache ich nur gerade ein kommandozeile draus!
Vielen Dank,
Mineorbit

[Jidder]

Also ich interpretiere die Frage mal so, dass du wissen willst, wie die Tastendrücke vom Treiber in die Programme kommen.

Im Prinzip brauchst du einen Puffer, in den du an das eine Ende Zeichen reinschreiben kannst, und am anderen Ende Zeichen wieder auslesen kannst. Das Teil heißt Double-Ended Queue (Deque). Also eine Queue. Zum Beispiel das BIOS implementiert das allerdings als Ringpuffer, welche nur rund 30 Zeichen oder so aufnehmen kann. Das kann einfacher sein, muss es aber nicht.

Dein Treiber muss also im IRQ-Handler das Zeichen für die gedrückte Taste in den Puffer schreiben, und wenn dein Programm eine getchar()-Funktion (oder so) aufruft, dann liest die Funktion das älteste Zeichen aus dem Puffer aus, und entfernt es aus dem Puffer.

Wenn du ein Programm mit Eingabeaufforderung bauen willst, dann brauchst du eine Funktion, die in einer Schleife getchar() aufruft, das gelesene Zeichen ausgibt und in einen eigenen Puffer schreibt. Die Schleife terminiert, wenn getchar() Enter zurück gibt. Danach interpretierst du den Inhalt des Puffers je nach dem welche Funktion das Programm haben soll.

[Svenska]

Hallo,

der Tastaturtreiber muss nicht wissen, welche Tasten gerade gedrückt sind, sondern nur, welche Tasten gerade gedrückt oder losgelassen werden. Ausgenommen davon sind die Modifikatortasten (also Shift, Strg und so), für diese kannst du im Tastaturtreiber den Zustand nochmal extra speichern, wenn du möchtest. Übrigens funktioniert nicht jede Taste als Modikatortaste. Welche Tasten gehen und welche nicht, hängt vom elektrischen Aufbau der Tastatur ab.

Gruß,
Svenska

[kevin]

Im Prinzip brauchst du einen Puffer, in den du an das eine Ende Zeichen reinschreiben kannst, und am anderen Ende Zeichen wieder auslesen kannst. Das Teil heißt Double-Ended Queue (Deque).

Ist eine Deque nicht das Ding, wo man auf beiden Seiten sowohl lesen als auch schreiben kann? Auf der einen Seite reinschreiben und auf der anderen auslesen ist bei mir eine normale Queue.

[Jidder]

Hast Recht. Ich hab bei Queue an Stack gedacht...

[mineorbit]

Vielen Dank!
Als erstes nehm ich mal den Bios-buffer(das kann ich ja später noch ändern!).
Wie fülle ich ihn auf und wie lese ich ihn aus?
Vielen Dank,
Mineorbit
Edit:
Das mit der zweiten Switch funtkion und ersten verstehe ich noch nicht.
die Funktion getsym, die den array list nutzt, soll ich weglassen, abeer list soll ich auffüllen,wofür?
Dede eh jetzt so aus:

Code: [Auswählen]

#include "console.h"
#include "keyboard.h"
#include "stdint.h"
static uint8_t sc_to_kc[][128] = {
{ 0, 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, 84, 00, 00, 86, 87, 88, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00 },  { 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 96, 97, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00, 00, 100, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 102, 103, 104, 00, 105, 00, 106, 00, 107, 108, 109, 110, 111, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00 }, };
uint8_t translate_scancode(int set, uint16_t scancode)
{
uint8_t keycode = 0;
switch (set) { 
case 0:
 keycode = sc_to_kc[0][scancode];
 break;
case 1:
  keycode = sc_to_kc[1][scancode];
 break;
   switch (scancode) {
  case 0x451D: keycode = 119; break; default: keycode = 0x0; }; break; }
if (keycode == 0) {
 } return keycode;
}
 
void init_keyboard(void);
static void keyboard_command(uint8_t command);
void keyboard_interrupt(void);
void init_keyboard(void)
{
 
    while (inb(0x64) & 0x1) {
        inb(0x60);
    }   
 
 
    keyboard_command(0xF4);
}
 
static void keyboard_command(uint8_t command)
{
   
    while ((inb(0x64) & 0x2))
{
}
    outb(0x60, command);
}
void keyboard_interrupt(void){
     
    uint8_t scancode;
    int keycode;
    uint8_t break_code = 0;
 
    // Status-Variablen fuer das Behandeln von e0- und e1-Scancodes
    static int     e0_code = 0;
    // Wird auf 1 gesetzt, sobald e1 gelesen wurde, und auf 2, sobald das erste
    // Datenbyte gelesen wurde
    static int      e1_code = 0;
    static uint16_t  e1_prev = 0;
 
    scancode = inb(0x60);
 
    if ((scancode & 0x80) &&
        (e1_code || (scancode != 0xE1)) &&
        (e0_code || (scancode != 0xE0)))
    {
        break_code = 1;
        scancode &= ~0x80;
    }
 
    if (e0_code) {
        if ((scancode == 0x2A) || (scancode == 0x36)) {
            e0_code = 0;
            return;
        }
 
        keycode = translate_scancode(1, scancode);
        e0_code = 0;
    } else if (e1_code == 2) {
     /*
        e1_prev |= ((uint16_t) scancode <<;
        keycode = translate_scancode(2, e1_prev);
        e1_code = 0;
*/
    } else if (e1_code == 1) {
       
        e1_prev = scancode;
        e1_code++;
    } else if (scancode == 0xE0) {
        // Anfang eines e0-Codes
        e0_code = 1;
    } else if (scancode == 0xE1) {
        // Anfang eines e1-Codes
        e1_code = 1;
    } else {
        // Normaler Scancode
        keycode = translate_scancode(0, scancode);
       
    }
     
        if(break_code == 0)
 {
 
        kprintf("%c",keycode);
  }
        else
 {
       
 }     
}
 
 
Vielen Dank,
Mineorbit

[Jidder]

Das mit der zweiten Switch funtkion und ersten verstehe ich noch nicht.

Vielleicht fällt dir das Problem auf, wenn der Code mal ordentlich formatiert ist. Ich hab einfach mal Leerzeichen und Zeilenumbrüche eingefügt:

Code: [Auswählen]

uint8_t translate_scancode(int set, uint16_t scancode)
{
  uint8_t keycode = 0;

  switch (set) { 
    case 0:
      keycode = sc_to_kc[0][scancode];
      break;
    case 1:
      keycode = sc_to_kc[1][scancode];
      break;
      switch (scancode) {
        case 0x451D:
          keycode = 119;
          break;
        default:
          keycode = 0x0;
      };
      break;
    }

    if (keycode == 0) {

    }

    return keycode;
}
Ich weiß ja auch nicht, was der Code tun soll.

Als erstes nehm ich mal den Bios-buffer(das kann ich ja später noch ändern!).
Wie fülle ich ihn auf und wie lese ich ihn aus?

Ich kann dir hier keinen Ringpuffer erklären. Ich hab aber mal auf die Schnelle ein einfaches Programm gebastelt, das eine ähnliche Funktion erfüllt, und dich vielleicht inspiriert: http://codepad.org/4X9gbxCc Das hat eine add-Funktion, die Einträge in den Puffer schreibt, und eine read-Funktion, die wieder Einträge ausliest. Du kannst dir ja mal die Ausgabe ganz unten angucken, und das vergleichen mit dem, was die main-Funktion macht. Wenn du willst, kannst du dir auch so ähnliche Funktionen schreiben, ansonsten musst du dir mal ein Tutorial zu Ringpuffern zu Gemüte führen.

[mineorbit]

Vielen Dank für den Code Jidder
Das konnte ich in zwischen einbinden.Also eigentlich soll translate scancode den scancode in keycode umwandlen. Meine Frage war nurnoch, muss ich den keycode auch noch weiter verarbeiten,oder ist er das zeichen oder der modifikator den ich ausgeben b.z.w prüfen will?

Vielen Dank,
Mineorbit

[micha]

Meine Frage war nur noch, muss ich den Keycode auch noch weiter verarbeiten,oder ist er das zeichen oder der modifikator den ich ausgeben b.z.w prüfen will?

Ja, wenn du die Scancodes nicht direkt in ASCII umwandelst, sondern erst in Keycodes. (was sinnvoller ist).
Der Scancode ist bloß eine Nummer, die die Tastatur sendet. Diesen wandelst du dann um in einen Keycode, welcher dazu dient, eine Taste (z.b.: 'A', 'B', F1) zu identifizieren. Diese keycodes kannst du dann (falls es überhaupt ein buchstabe ist) in ASCII-Zeichen umwandeln und ausgeben.

[mineorbit]

Vielen Dank!
Also bräüchte ich dann doch eine zweite Switch?Wie müsste die gemacht sein?
Vielen Dank für die Lösung der 2 anderen Fragen,
Mineorbit

[micha]

einen Switch bräuchtest du nicht. einfach ein Array, bei dem der Index der Einträge dem Keycode entspricht und das ASCII -zeichen als Wert drin steht.

[mineorbit]

Aha!
Wie wird dann der keycode zum Zeichen gemacht werden? Könntet ihr mir einen Beispielcode zeigen?Also brauch ich beide Switches(besser gesagt, ist das was man beim Interrupt erhält schon der scancode)? Was muss ich von dem momentanen Quellcode ändern damit es funktioniert.(Wenn ihr das machen würdet wäre das super!)
Viele Grüße,
Mineorbit
Edit:
Habe bereits auf google geguckt und in eurem forum, aber wie mache ich einen interrupt handler für irq's?.
Das einzigste was ich bisher finden konnte war, die funktion register_interrupt_handler().
Viele Grüße,
Mineorbit

[Jidder]

Wie sieht denn dein Interrupthandler zur Zeit aus? Wenn du z.B. unser Tutorial befolgt hast, reicht es erstmal aus, wenn du das letzte Code-Beispiel wie folgt anpasst:

Code: [Auswählen]

if (cpu->intr >= 0x20 && cpu->intr <= 0x2f) {

    // Diese if-Abfrage ist neu.
    if (cpu->intr == 0x21) {
        keyboard_interrupt();
    }

    if (cpu->intr >= 0x28) {
        outb(0xa0, 0x20);
    }
    outb(0x20, 0x20);
}

[mineorbit]

Aha danke,
Habt ihr zufällig eine liste mit den interrupt nummern für alle irqs?
Ansonsten, wie muss ich den Array für die umwandlung von keycode in ascii zeichen, und wie mache ich die umwandlungsfunktion
(Ich bekomme das einfach nicht hin )
Den buffer habe ich schon vielen Dank für eure Hilfe!
Viele Grüße,
Mineorbit

[Jidder]

Liste der IRQs

Ansonsten, wie muss ich den Array für die umwandlung von keycode in ascii zeichen, und wie mache ich die umwandlungsfunktion

Ich habe mal angefangen für die diese Tabelle in ein Array zu übertragen. Das Prinzip ist eigentlich ganz einfach.

Die fett gedruckten Zahlen auf der Seite sind der Scancode. Daneben steht entweder die Taste (ESC, Enter...) oder die beiden Zeichen die man bekommt wenn man die zum Scancode gehörige Taste drückt und dabei entweder Shift nicht gedrückt hält oder Shift gedrückt hält.

Beispielsweise steht da 02 (1!). Das heißt Scancode 2 ist die Taste 1! und dein Code muss jenachdem ob Shift gedrückt ist, entweder 1 oder ! als Zeichen zurück geben.

Ich habe dazu diese beiden Arrays angefangen zu befüllen. Im ersten Array stehen die Zeichen ohne Shift. Wie du siehst, habe ich für Tasten wie ESC, Ctrl, etc. einfach nur 0 eingetragen.

Code: [Auswählen]

char keymap[] = {
0, /* nicht belegt */
0, /* ESC */
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=',
'\b', /* backspace */
'\t', /* tab */
'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', ['', ']'
'\n', /* enter */
0, /* lctrl */
'a', 's', 'd', ....
};

Code: [Auswählen]

char keymap_shift[] = {
0, /* nicht belegt */
0, /* ESC */
'!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+',
'\b', /* backspace */
'\t', /* tab */
'Q', 'W', 'E', 'R', 'T', 'Y', ...
};

Code: [Auswählen]

char keycode_to_char(int keycode)
{
   /* wenn shift gedrückt wurde eine andere keymap nehmen */
   if (!shift) {
       return keymap[keycode];
   } else {
       return keymap_shift[keycode];
   }
}
Damit das funktioniert, musst du in keyboard_handler schauen ob Shift gedrückt oder losgelassen wurde, und dafür eine globale Variable, die ich mal shift genannt habe, auf true oder false setzen. Du musst also den Inhalt der verlinkten Seite weiter in das Array einfüllen, und dann solltest du die Funktion keycode_to_char benutzen können.

Edit: Die Funktion sollte keycode_to_char heißen nicht scancode_to_keycode. (Oder meintewegen scancode_to_char, wenn du auf keycodes verzichtest.) Siehe auch Svenskas Erläuterung.

[mineorbit]

Vielen ,vielen Dank Jidder!
Jetzt hab ichs endlich verstanden, also ist es so, dass man als erstes den scancode bekommt und dann der keycode das zeichen ist was man haben will z.b A,B,C usw.
Viele Grüße,
Mineorbit

[Svenska]

Normalerweise läuft das so:

Der Scancode ist eine Bytefolge, die von der Tastatur abhängt (z.B. die Lauter- oder Leiser-Tasten an Notebooks sind von Hersteller zu Hersteller unterschiedlich). Um also die Eigenheiten der Tastatur zu aus den Programmen rauszunehmen, wandelt der Tastaturtreiber diesen Scancode in einen Keycode um.

Der Keycode ist eine Zahl, die für jede Taste eindeutig und dem Kernel bekannt ist. Nicht jede Tastatur kann jeden Keycode erzeugen (verschiedene Tastaturen haben verschiedene Tasten, z.B. hat deine Tastatur keine F13-Taste), aber verschiedene Tastaturen erzeugen mit den gleichen Tasten immer den gleichen Keycode.

Wenn ein Programm also die Keycodes direkt bekommen kann ("RAW-Modus"), dann kann es auf jede Taste reagieren, die es kennt. Braucht man für Spiele (z.B. Pfeiltasten, ...), deswegen wird das immer angeboten.

Den meisten Programmen sind die Tasten ziemlich egal, die möchten nur die Bedeutung haben ("COOKED-Modus"). Das Tastaturlayout gibt den einzelnen Keycodes eine Bedeutung. Gleiche Tasten können verschiedene Dinge bedeuten: Mit der Taste A auf meiner Tastatur kann ich die ASCII-Zeichen a, A, á, Á, æ oder Æ erzeugen, je nach Zustand von Shift, Alt und AltGr.

Also: Im Tastaturtreiber wird der Scancode in einen Keycode gewandelt, im Eingabesystem wird der Keycode dann entweder an die Anwendung durchgereicht oder erst in Zeichen gewandelt (vorverarbeitet) und dann weitergereicht - je nachdem, was die Anwendung wünscht. Die Vorverarbeitung kann auch erst innerhalb der Anwendung (z.B. Bibliothek) geschehen. Dann kannst du pro Anwendung verschiedene Tastaturlayouts haben.

Gruß,
Svenska

[mineorbit]

Danke für die Erklärung Svenska,
Habe schon eine idee wie ich das dann später als char in meine system lib einbauen kann.
Vielen Dank bisher,
Mineorbit
(Kann der thread bitte noch einwenig aufbleiben für den fall das nochimmer was nicht stimmt?)