christoph/lecture-operating-system-development
1
Fork 0
Code Activity

add Vorgabe02

Browse Source
This commit is contained in:
churl
2022-04-25 20:52:34 +02:00
parent 263563c105
commit 356625e647
8 changed files with 552 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
c_os/devices/Key.h Normal file
View File

@ -0,0 +1,117 @@
/*****************************************************************************
* *
* K E Y *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Taste, bestehend aus ASCII-, Scan-Code und Modifier-Bits.*
* *
* Autor: Olaf Spinczyk, TU Dortmund *
*****************************************************************************/
#ifndef __Key_include__
#define __Key_include__
class Key {
// Kopieren erlaubt!
unsigned char asc; // ASCII code
unsigned char scan; // scan code
unsigned char modi; // modifier
// Bit-Masken fuer die Modifier-Tasten
struct mbit {
enum {
shift = 1,
alt_left = 2,
alt_right = 4,
ctrl_left = 8,
ctrl_right = 16,
caps_lock = 32,
num_lock = 64,
scroll_lock = 128
};
};
public:
// DEFAULT-KONSTRUKTOR: setzt ASCII, Scancode und Modifier auf 0
// und bezeichnet so einen ungueltigen Tastencode
Key() : asc(0), scan(0), modi(0) {}
// VALID: mit Scancode = 0 werden ungueltige Tasten gekennzeichnet.
bool valid() { return scan != 0; }
// INVALIDATE: setzt den Scancode auf Null und sorgt somit fuer einen
// ungueltigen Tastencode.
void invalidate() { scan = 0; }
// ASCII, SCANCODE: Setzen und Abfragen von Ascii und Scancode
void ascii(unsigned char a) { asc = a; }
void scancode(unsigned char s) { scan = s; }
unsigned char ascii() { return asc; }
unsigned char scancode() { return scan; }
//
// Funktionen zum Setzen und Loeschen von SHIFT, ALT, CTRL usw.
//
void shift(bool pressed) {
modi = pressed ? modi | mbit::shift : modi & ~mbit::shift;
}
void alt_left(bool pressed) {
modi = pressed ? modi | mbit::alt_left : modi & ~mbit::alt_left;
}
void alt_right(bool pressed) {
modi = pressed ? modi | mbit::alt_right : modi & ~mbit::alt_right;
}
void ctrl_left(bool pressed) {
modi = pressed ? modi | mbit::ctrl_left : modi & ~mbit::ctrl_left;
}
void ctrl_right(bool pressed) {
modi = pressed ? modi | mbit::ctrl_right : modi & ~mbit::ctrl_right;
}
void caps_lock(bool pressed) {
modi = pressed ? modi | mbit::caps_lock : modi & ~mbit::caps_lock;
}
void num_lock(bool pressed) {
modi = pressed ? modi | mbit::num_lock : modi & ~mbit::num_lock;
}
void scroll_lock(bool pressed) {
modi = pressed ? modi | mbit::scroll_lock : modi & ~mbit::scroll_lock;
}
//
// Funktionen zum Abfragen von SHIFT, ALT, CTRL usw.
//
bool shift() { return modi & mbit::shift; }
bool alt_left() { return modi & mbit::alt_left; }
bool alt_right() { return modi & mbit::alt_right; }
bool ctrl_left() { return modi & mbit::ctrl_left; }
bool ctrl_right() { return modi & mbit::ctrl_right; }
bool caps_lock() { return modi & mbit::caps_lock; }
bool num_lock() { return modi & mbit::num_lock; }
bool scroll_lock() { return modi & mbit::scroll_lock; }
bool alt() { return alt_left() | alt_right(); }
bool ctrl() { return ctrl_left() | ctrl_right(); }
operator char() { return (char)asc; }
// Scan-Codes einiger spezieller Tasten
struct scan {
enum {
f1 = 0x3b,
del = 0x53,
up = 72,
down = 80,
left = 75,
right = 77,
div = 8
};
};
};
#endif

307
c_os/devices/Keyboard.cc Normal file
View File

@ -0,0 +1,307 @@
/*****************************************************************************
* *
* K E Y B O A R D *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Treiber für den Tastaturcontroller des PCs. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
*****************************************************************************/
#include "devices/Keyboard.h"
/* Tabellen fuer ASCII-Codes (Klassenvariablen) intiialisieren */
unsigned char Keyboard::normal_tab[] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 225, 39, '\b',
0, 'q', 'w', 'e', 'r', 't', 'z', 'u', 'i', 'o', 'p', 129, '+', '\n',
0, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 148, 132, '^', 0, '#',
'y', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '-', 0,
'*', 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '-',
0, 0, 0, '+', 0, 0, 0, 0, 0, 0, 0, '<', 0, 0};
unsigned char Keyboard::shift_tab[] = {
0, 0, '!', '"', 21, '$', '%', '&', '/', '(', ')', '=', '?', 96, 0,
0, 'Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', 'O', 'P', 154, '*', 0,
0, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 153, 142, 248, 0, 39,
'Y', 'X', 'C', 'V', 'B', 'N', 'M', ';', ':', '_', 0,
0, 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '>', 0, 0};
unsigned char Keyboard::alt_tab[] = {
0, 0, 0, 253, 0, 0, 0, 0, '{', '[', ']', '}', '\\', 0, 0,
0, '@', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '~', 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 230, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '|', 0, 0};
unsigned char Keyboard::asc_num_tab[] = {
'7', '8', '9', '-', '4', '5', '6', '+', '1', '2', '3', '0', ','};
unsigned char Keyboard::scan_num_tab[] = {
8, 9, 10, 53, 5, 6, 7, 27, 2, 3, 4, 11, 51};
/*****************************************************************************
* Methode: Keyboard::key_decoded *
*---------------------------------------------------------------------------*
* Beschreibung: Interpretiert die Make- und Break-Codes der Tastatur. *
* *
* Rueckgabewert: true bedeutet, dass das Zeichen komplett ist *
* false es fehlen noch Make- oder Break-Codes. *
*****************************************************************************/
bool Keyboard::key_decoded() {
bool done = false;
// Die Tasten, die bei der MF II Tastatur gegenueber der aelteren
// AT Tastatur hinzugekommen sind, senden immer erst eines von zwei
// moeglichen Prefix Bytes.
if (code == prefix1 || code == prefix2) {
prefix = code;
return false;
}
// Das Loslassen einer Taste ist eigentlich nur bei den "Modifier" Tasten
// SHIFT, CTRL und ALT von Interesse, bei den anderen kann der Break-Code
// ignoriert werden.
if (code & break_bit) {
code &= ~break_bit; // Der Break-Code einer Taste ist gleich dem
// Make-Code mit gesetzten break_bit.
switch (code) {
case 42:
case 54:
gather.shift(false);
break;
case 56:
if (prefix == prefix1)
gather.alt_right(false);
else
gather.alt_left(false);
break;
case 29:
if (prefix == prefix1)
gather.ctrl_right(false);
else
gather.ctrl_left(false);
break;
}
// Ein Prefix gilt immer nur fuer den unmittelbar nachfolgenden Code.
// Also ist es jetzt abgehandelt.
prefix = 0;
// Mit einem Break-Code kann man nichts anfangen, also false liefern.
return false;
}
// Eine Taste wurde gedrueckt. Bei den Modifier Tasten wie SHIFT, ALT,
// NUM_LOCK etc. wird nur der interne Zustand geaendert. Durch den
// Rueckgabewert 'false' wird angezeigt, dass die Tastatureingabe noch
// nicht abgeschlossen ist. Bei den anderen Tasten werden ASCII
// und Scancode eingetragen und ein 'true' fuer eine erfolgreiche
// Tastaturabfrage zurueckgegeben, obwohl genaugenommen noch der Break-
// code der Taste fehlt.
switch (code) {
case 42:
case 54:
gather.shift(true);
break;
case 56:
if (prefix == prefix1)
gather.alt_right(true);
else
gather.alt_left(true);
break;
case 29:
if (prefix == prefix1)
gather.ctrl_right(true);
else
gather.ctrl_left(true);
break;
case 58:
gather.caps_lock(!gather.caps_lock());
set_led(led::caps_lock, gather.caps_lock());
break;
case 70:
gather.scroll_lock(!gather.scroll_lock());
set_led(led::scroll_lock, gather.scroll_lock());
break;
case 69: // Numlock oder Pause ?
if (gather.ctrl_left()) { // Pause Taste
// Auf alten Tastaturen konnte die Pause-Funktion wohl nur
// ueber Ctrl+NumLock erreicht werden. Moderne MF-II Tastaturen
// senden daher diese Codekombination, wenn Pause gemeint ist.
// Die Pause Taste liefert zwar normalerweise keinen ASCII-
// Code, aber Nachgucken schadet auch nicht. In jedem Fall ist
// die Taste nun komplett.
get_ascii_code();
done = true;
} else { // NumLock
gather.num_lock(!gather.num_lock());
set_led(led::num_lock, gather.num_lock());
}
break;
default: // alle anderen Tasten
// ASCII-Codes aus den entsprechenden Tabellen auslesen, fertig.
get_ascii_code();
done = true;
}
// Ein Prefix gilt immer nur fuer den unmittelbar nachfolgenden Code.
// Also ist es jetzt abgehandelt.
prefix = 0;
if (done)
return true; // Tastaturabfrage abgeschlossen
else
return false;
}
/*****************************************************************************
* Methode: Keyboard::get_ascii_code *
*---------------------------------------------------------------------------*
* Beschreibung: Ermittelt anhand von Tabellen aus dem Scancode und den *
* gesetzten Modifier-Bits den ASCII-Code der Taste. *
*****************************************************************************/
void Keyboard::get_ascii_code() {
// Sonderfall Scancode 53: Dieser Code wird sowohl von der Minustaste
// des normalen Tastaturbereichs, als auch von der Divisionstaste des
// Ziffernblocks gesendet. Damit in beiden Faellen ein Code heraus-
// kommt, der der Aufschrift entspricht, muss im Falle des Ziffern-
// blocks eine Umsetzung auf den richtigen Code der Divisionstaste
// erfolgen.
if (code == 53 && prefix == prefix1) { // Divisionstaste des Ziffernblocks
gather.ascii('/');
gather.scancode(Key::scan::div);
}
// Anhand der Modifierbits muss die richtige Tabelle ausgewaehlt
// werden. Der Einfachheit halber hat NumLock Vorrang vor Alt,
// Shift und CapsLock. Fuer Ctrl gibt es keine eigene Tabelle
else if (gather.num_lock() && !prefix && code >= 71 && code <= 83) {
// Bei eingeschaltetem NumLock und der Betaetigung einer der
// Tasten des separaten Ziffernblocks (Codes 71-83), sollen
// nicht die Scancodes der Cursortasten, sondern ASCII- und
// Scancodes der ensprechenden Zifferntasten geliefert werden.
// Die Tasten des Cursorblocks (prefix == prefix1) sollen
// natuerlich weiterhin zur Cursorsteuerung genutzt werden
// koennen. Sie senden dann uebrigens noch ein Shift, aber das
// sollte nicht weiter stoeren.
gather.ascii(asc_num_tab[code - 71]);
gather.scancode(scan_num_tab[code - 71]);
} else if (gather.alt_right()) {
gather.ascii(alt_tab[code]);
gather.scancode(code);
} else if (gather.shift()) {
gather.ascii(shift_tab[code]);
gather.scancode(code);
} else if (gather.caps_lock()) {
// Die Umschaltung soll nur bei Buchstaben gelten
if ((code >= 16 && code <= 26) || (code >= 30 && code <= 40) || (code >= 44 && code <= 50)) {
gather.ascii(shift_tab[code]);
gather.scancode(code);
} else {
gather.ascii(normal_tab[code]);
gather.scancode(code);
}
} else {
gather.ascii(normal_tab[code]);
gather.scancode(code);
}
}
/*****************************************************************************
* Konstruktor: Keyboard::Keyboard *
*---------------------------------------------------------------------------*
* Beschreibung: Initialisierung der Tastatur: alle LEDs werden ausge- *
* schaltet und die Wiederholungsrate auf maximale *
* Geschwindigkeit eingestellt. *
*****************************************************************************/
Keyboard::Keyboard() : ctrl_port(0x64), data_port(0x60) {
// alle LEDs ausschalten (bei vielen PCs ist NumLock nach dem Booten an)
set_led(led::caps_lock, false);
set_led(led::scroll_lock, false);
set_led(led::num_lock, false);
// maximale Geschwindigkeit, minimale Verzoegerung
set_repeat_rate(0, 0);
}
/*****************************************************************************
* Methode: Keyboard::key_hit *
*---------------------------------------------------------------------------*
* Beschreibung: Diese Methode soll einen Tastendruck zurueckliefern. *
* Hierzu soll die Tastatur in einer Schleife "gepollt" *
* werden, bis ein Zeichen eingegebn wurde. *
* *
* Das Byte von der Tastatur soll in dem Attribut 'code' *
* (siehe Keyboard.h) gespeichert werden. Die Dekodierung *
* soll mithilfe der vorgegebenen Funktion 'key_decoded' *
* erfolgen. *
* *
* Rückgabewert: Wenn der Tastendruck abgeschlossen ist und ein Scancode, *
* sowie gegebenenfalls ein ASCII-Code emittelt werden *
* konnte, werden diese in 'gather' (siehe Keyboard.h) *
* zurueckgeliefert. Anderenfalls liefert key_hit () einen *
* ungueltigen Wert zurueck, was mit Key::valid () *
* ueberprueft werden kann. *
*****************************************************************************/
Key Keyboard::key_hit() {
Key invalid; // nicht explizit initialisierte Tasten sind ungueltig
/* Hier muss Code eingefuegt werden. */
return invalid;
}
/*****************************************************************************
* Methode: Keyboard::reboot *
*---------------------------------------------------------------------------*
* Beschreibung: Fuehrt einen Neustart des Rechners durch. *
*****************************************************************************/
void Keyboard::reboot() {
int status;
// Dem BIOS mitteilen, dass das Reset beabsichtigt war
// und kein Speichertest durchgefuehrt werden muss.
*(unsigned short*)0x472 = 0x1234;
// Der Tastaturcontroller soll das Reset ausloesen.
do {
status = ctrl_port.inb(); // warten, bis das letzte Kommando
} while ((status & inpb) != 0); // verarbeitet wurde.
ctrl_port.outb(cpu_reset); // Reset
}
/*****************************************************************************
* Methode: Keyboard::set_repeat_rate *
*---------------------------------------------------------------------------*
* Beschreibung: Einstellen der Wiederholungsrate der Tastatur. *
* *
* Parameter: *
* delay: Bestimmt, wie lange eine Taste gedrueckt werden muss, *
* bevor die Wiederholung einsetzt. Erlaubt sind Werte *
* zw. 0 (minimale Wartezeit) und 3 (maximale Wartezeit). *
* speed: Bestimmt, wie schnell die Tastencodes aufeinander folgen *
* sollen. Erlaubt sind Werte zwischen 0 (sehr schnell) *
* und 31 (sehr langsam). *
*****************************************************************************/
void Keyboard::set_repeat_rate(int speed, int delay) {
/* Hier muss Code eingefuegt werden. */
}
/*****************************************************************************
* Methode: Keyboard::set_led *
*---------------------------------------------------------------------------*
* Beschreibung: Setzt oder loescht die angegebene Leuchtdiode. *
* *
* Parameter: *
* led: Welche LED? (caps_lock, num_lock, scroll_lock) *
* on: 0 = aus, 1 = an *
*****************************************************************************/
void Keyboard::set_led(char led, bool on) {
/* Hier muss Code eingefuegt werden. */
}

89
c_os/devices/Keyboard.h Normal file
View File

@ -0,0 +1,89 @@
/*****************************************************************************
* *
* K E Y B O A R D *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Treiber für den Tastaturcontroller des PCs. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
*****************************************************************************/
#ifndef __Keyboard_include__
#define __Keyboard_include__
#include "devices/Key.h"
#include "kernel/IOport.h"
class Keyboard {
private:
Keyboard(const Keyboard& copy); // Verhindere Kopieren
unsigned char code; // Byte von Tastatur
unsigned char prefix; // Prefix von Tastatur
Key gather; // letzter dekodierter Key
char leds; // Zustand LEDs
// Benutzte Ports des Tastaturcontrollers
const IOport ctrl_port; // Status- (R) u. Steuerregister (W)
const IOport data_port; // Ausgabe- (R) u. Eingabepuffer (W)
// Bits im Statusregister
enum { outb = 0x01,
inpb = 0x02,
auxb = 0x20 };
// Kommandos an die Tastatur
struct kbd_cmd {
enum { set_led = 0xed,
set_speed = 0xf3 };
};
enum { cpu_reset = 0xfe };
// Namen der LEDs
struct led {
enum { caps_lock = 4,
num_lock = 2,
scroll_lock = 1 };
};
// Antworten der Tastatur
struct kbd_reply {
enum { ack = 0xfa };
};
// Konstanten fuer die Tastaturdekodierung
enum { break_bit = 0x80,
prefix1 = 0xe0,
prefix2 = 0xe1 };
// Klassenvariablen
static unsigned char normal_tab[];
static unsigned char shift_tab[];
static unsigned char alt_tab[];
static unsigned char asc_num_tab[];
static unsigned char scan_num_tab[];
// Interpretiert die Make und Break-Codes der Tastatur.
bool key_decoded();
// Ermittelt anhand von Tabellen den ASCII-Code.
void get_ascii_code();
public:
// Initialisierung der Tastatur.
Keyboard();
// Tastaturabfrage (vorerst Polling)
Key key_hit();
// Fuehrt einen Neustart des Rechners durch.
void reboot();
// Einstellen der Wiederholungsrate der Tastatur.
void set_repeat_rate(int speed, int delay);
// Setzt oder loescht die angegebene Leuchtdiode.
void set_led(char led, bool on);
};
#endif

1
c_os/kernel/Globals.cc Executable file → Normal file
View File

@ -13,3 +13,4 @@
CPU cpu; // CPU-spezifische Funktionen
PCSPK pcspk; // PC-Lautsprecher
CGA_Stream kout; // Ausgabe-Strom fuer Kernel
Keyboard kb; // Tastatur

2
c_os/kernel/Globals.h Executable file → Normal file
View File

@ -11,11 +11,13 @@
#define __Globals_include__
#include "devices/CGA_Stream.h"
#include "devices/Keyboard.h"
#include "devices/PCSPK.h"
#include "kernel/CPU.h"
extern CPU cpu; // CPU-spezifische Funktionen
extern PCSPK pcspk; // PC-Lautsprecher
extern CGA_Stream kout; // Ausgabe-Strom fuer Kernel
extern Keyboard kb; // Tastatur
#endif

7
c_os/main.cc
View File

@ -11,6 +11,7 @@
*****************************************************************************/
#include "kernel/Globals.h"
#include "user/KeyboardDemo.h"
#include "user/SoundDemo.h"
#include "user/TextDemo.h"
@ -22,10 +23,10 @@ int main() {
// TODO: Startmeldung ausgeben
text_demo();
// text_demo();
// sound_demo();
keyboard_demo();
while (1)
;
while (1);
return 0;
}

16
c_os/user/KeyboardDemo.cc Normal file
View File

@ -0,0 +1,16 @@
/*****************************************************************************
* *
* K E Y B O A R D D E M O *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Testausgaben für den CGA-Treiber. *
* *
* Autor: Michael Schoettner, HHU, 26.10.2018 *
*****************************************************************************/
#include "kernel/Globals.h"
void keyboard_demo() {
/* Hier muess Code eingefuegt werden */
}

16
c_os/user/KeyboardDemo.h Normal file
View File

@ -0,0 +1,16 @@
/*****************************************************************************
* *
* K E Y B O A R D D E M O *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Testausgaben für den CGA-Treiber. *
* *
* Autor: Michael Schoettner, HHU, 26.10.2018 *
*****************************************************************************/
#ifndef __KeyboardDemo_include__
#define __KeyboardDemo_include__
void keyboard_demo();
#endif