Das Terminal in C (PI5)

Das Terminal

Nachdem wir nun Zeichen auf den Bildschirm anzeigen können, werden wir ein Terminal bauen. Ein Terminal ist ein Bereich auf dem Bildschirm, in dem Texte angezeigt werden können und später auch Eingaben erfolgen können. Ein Beispiel für ein Terminal ist die Eingabeaufforderung, die beim Starten von Linux erscheint.

Wie sieht ein Terminal aus?

Zuerst müssen wir uns überlegen, wie das Terminal aussehen soll. Da wir die Bildschirmauflösung kennen, verwenden wir diese. Unsere Schriftart (Font) hat eine Größe von 8x8 Pixeln pro Zeichen. Damit die Zeichen nicht zu eng beieinander stehen, nutzen wir im Terminal eine Auflösung von 8x10 Pixeln pro Zeichen.

#define CHAR_WIDTH 8
#define CHAR_HEIGHT 10

Damit können wir festlegen, wie viele Zeichen in einer Zeile und wie viele Zeilen auf dem Bildschirm dargestellt werden können:

#define NUM_COLS (SCREEN_X / CHAR_WIDTH)
#define NUM_ROWS (SCREEN_Y / CHAR_HEIGHT)

Um die aktuelle Position des Cursors (die Stelle, an der das nächste Zeichen erscheinen wird) zu speichern, verwenden wir zwei Variablen. Diese setzen wir anfangs auf 0,0 (oben links):

u32 cursor_x = 0;
u32 cursor_y = 0;

Zeichen im Terminal zeichnen

Als erstes schreiben wir eine Funktion, die ein Zeichen im Terminal an der aktuellen Cursor-Position zeichnet. Die Funktion bekommt einfach das Zeichen übergeben, das gezeichnet werden soll:

void DrawCharAtCursor(char c)
{
    // Funktion zum Zeichnen eines Zeichens
}

Steuerzeichen beachten

Beim Zeichnen von Texten müssen wir verschiedene Steuerzeichen berücksichtigen, wie zum Beispiel "neue Zeile" (Enter), "Tab" und "Backspace". Diese Steuerzeichen fangen wir ab und reagieren entsprechend darauf:

1. Neue Zeile (`\n`):

   Wenn das Zeichen ein Zeilenumbruch (`\n`) ist, setzen wir den Cursor an den Anfang der nächsten Zeile:

    if (c == '\n') // Neue Zeile
    {
        cursor_x = 0;
        cursor_y++;
    }

1. Zeilenanfang (`\r`):

   Wenn das Zeichen ein Wagenrücklauf (`\r`) ist, setzen wir den Cursor an den Anfang der aktuellen Zeile:

    else if (c == '\r') // Zeilenanfang
    {
        cursor_x = 0;
    }

3. **Tabulator (`\t`)**:

   Wenn das Zeichen ein Tabulator (`\t`) ist, bewegen wir den Cursor um vier Positionen nach rechts:
   ```c
   else if (c == '\t') // Tabulator
   {
       cursor_x += 4;
   }
   ```

4. **Rückschritt (`\b`)**:

   Wenn das Zeichen ein Rückschritt (`\b`) ist, bewegen wir den Cursor um ein Zeichen nach links, es sei denn, der Cursor steht bereits am Anfang der Zeile:
   ```c
   else if (c == '\b') // Rückschritt
   {
       if (cursor_x > 0) {
           cursor_x--;
       }
   }
   ```

5. **Seitenvorschub (`\f`)**:

   Wenn das Zeichen ein Seitenvorschub (`\f`) ist, löschen wir den Bildschirm. Früher wurde dieses Zeichen verwendet, um auf Nadeldruckern eine neue Seite zu beginnen. Hier verwenden wir es, um den Bildschirm zu löschen:
   ```c
   else if (c == '\f') // Seitenvorschub (Bildschirm löschen)
   {
       ClearScreen();
   }
   ```

6. **Normales Zeichen**:

   Wenn das Zeichen kein Steuerzeichen ist, zeichnen wir es an der aktuellen Cursor-Position und bewegen den Cursor um eine Position nach rechts. Wenn das Ende der Zeile erreicht ist, setzen wir den Cursor an den Anfang der nächsten Zeile:
   ```c
   else // Normales Zeichen
   {
       DrawChar(c, cursor_x * CHAR_WIDTH, cursor_y * CHAR_HEIGHT);
       cursor_x++;
       if (cursor_x >= NUM_COLS) {
           cursor_x = 0;
           cursor_y++;
       }
   }
   ```

1. 1. 1. 1. Bildschirmende erreichen

Wenn der Cursor das Ende des Bildschirms erreicht, müssen wir den Text nach oben scrollen, um Platz für neue Zeilen zu schaffen:

```c if (cursor_y >= NUM_ROWS) {

   ScrollScreen();
   cursor_y = NUM_ROWS - 1;

} ```

1. 1. 1. 1. ClearScreen-Funktion

Die `ClearScreen`-Funktion löscht den gesamten Bildschirm und setzt den Cursor wieder auf die Anfangsposition:

```c void ClearScreen() {

   DrawColor = BackColor;
   for (u32 y = 0; y < SCREEN_Y; y++) {
       for (u32 x = 0; x < SCREEN_X; x++) {
           DrawPixel(x, y);
       }
   }
   cursor_x = 0;
   cursor_y = 0;

} ```

1. 1. 1. 1. ScrollScreen-Funktion

Die `ScrollScreen`-Funktion verschiebt den Text um eine Zeile nach oben und löscht die unterste Zeile:

```c void ScrollScreen() {

   for (u32 y = 0; y < SCREEN_Y - CHAR_HEIGHT; y++) {
       for (u32 x = 0; x < SCREEN_X; x++) {
           DrawColor = GetPixel(x, y + CHAR_HEIGHT);
           DrawPixel(x, y);
       }
   }
   DrawColor = BackColor;
   for (u32 y = SCREEN_Y - CHAR_HEIGHT; y < SCREEN_Y; y++) {
       for (u32 x = 0; x < SCREEN_X; x++) {
           DrawPixel(x, y);
       }
   }

} ```

1. 1. 1. 1. GetPixel-Funktion

Die `GetPixel`-Funktion liest den Farbwert eines Pixels an der angegebenen Position:

```c u32 GetPixel(u32 x, u32 y) {

   if ((x < SCREEN_X) && (y < SCREEN_Y)) {
       return read32(graphicsAddress + (((SCREEN_X * y) + x) * 4));
   } else {
       return 0;
   }

} ```

1. 1. 1. 1. DrawString-Funktion

Um ganze Texte (Strings) im Terminal anzuzeigen, verwenden wir die `DrawString`-Funktion. Diese Funktion durchläuft den String und zeichnet jedes Zeichen:

```c void DrawString(const char* str) {

   while (*str) {
       DrawCharAtCursor(*str++);
   }

} ```

1. 1. 1. 1. Testen der Funktion

Zum Testen dieser Funktionen schreiben wir eine `main`-Funktion:

```c // main.c

1. include "led.h"
2. include "screen.h"
3. include "types.h"

int main(void) {

   LED_off();
   Init_Screen();
   
   DrawString("Hallo Welt!");
   
   LED_Error(2);

} ```

1. 1. 1. Zusammenfassung

Mit diesem Code haben wir ein einfaches Terminal programmiert. Der Code verwaltet die Anzeige der Zeichen und ermöglicht es uns, Meldungen wie Fehler besser und lesbar darzustellen. Im nächsten Kapitel werden wir die Funktion `printf` einbinden, um noch bessere Auswertungen der Daten zu bekommen und auch Variablen anzeigen zu lassen.