Das Terminal (PI5)

Aus C und Assembler mit Raspberry

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, definieren wir unter .section .data zwei Variablen. Diese setzen wir anfangs auf 0,0 (oben links): 

// Terminal
cursor_x:
	.int 0
cursor_y:
	.int 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)
//Zeichne den Char an die aktuelle Position in der Konsole
//Berücksichtige auch Sonderzeichen
.globl DrawCharAtCursor
DrawCharAtCursor:
	stp x29, x30, [sp, -16]!
	mov x29, sp
...
...
...
	ldp x29, x30, [sp], 16
	ret

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: 

    //Vergleiche auf Zeilenumbruch
	cmp w0,#'\n'
    //Wenn nicht, weitere Abfrage
	bne 1f

    //Setze den cursor_x auf 0
	ldr x1,=cursor_x
	mov w2,#0
	str w2,[x1]

    //Und den cursor_y um eins höher, für die Zeile
	ldr x1,=cursor_y
	ldr w2,[x1]
	add w2,w2,#1
	str w2,[x1]

	b 7f

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

1:
    //Vergleiche auf Carriage Return
	cmp w0,#'\r'
	bne 2f
    //Setzt den Cursor an den Anfang der aktuellen Zeile.
	ldr x1,=cursor_x
	mov w2,#0
	str w2,[x1]

	b 7f

3. Tabulator (`\t`): Wenn das Zeichen ein Tabulator (`\t`) ist, bewegen wir den Cursor um vier Positionen nach rechts: 

2:
    //Vergleiche, ob TAB angezeigt werden soll
	cmp w0,#'\t'
	bne 3f

    //Erhöht den cursor_x um 4
    //DOTO: Fester Wert in allen Zeilen
	ldr x1,=cursor_x
	ldr w2,[x1]
	add w2,w2,#4
	str w2,[x1]

	b 7f

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: 

3:
    //Vergleich auf Backspace
	cmp w0,#'\b'
	bne 4f

    //Bewegt den Cursor um ein Zeichen nach links
    //nur wenn cursor_x > 0 ist
	ldr x1,=cursor_x
	ldr w2,[x1]
	cmp w2,#0
	ble 8f

    // cursor_x -1
	sub w2,w2,#1
	str w2,[x1]
8:
	b 7f

5. Seitenvorschub (`\f`): Wenn das Zeichen ein Seitenvorschub (`\f`) ist, löschen wir den Bildschirm. Früher wurde dieses Zeichen verwendet, um zum Beispiel auf Nadeldruckern eine neue Seite zu beginnen. Hier verwenden wir es, um den Bildschirm zu löschen: 

4:
    //Vergleich auf Form Feed)
	cmp w0,#'\f'
	bne 5f

    // Neue Seite
	bl ClearScreen

	b 7f

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: 

6:
    //Wenn hier angelangt, müsste es sich um ein druckbares Zeichen handeln
    // Char in w0
	mov w0,w0

    // Berechnung der x-Pos (cursor_x * CHAR_WIDTH)
	ldr x1,=cursor_x
	ldr w1,[x1]
	mov w2,#CHAR_WIDTH
	mul w1,w1,w2

    // Berechnung der y-Pos (cursor_y * CHAR_HEIGHT)
	ldr x2,=cursor_y
	ldr w2,[x2]
	mov w3,#CHAR_HEIGHT
	mul w2,w2,w3
	bl DrawChar

    //Addiere cursor_x um 1
	ldr x0,=cursor_x
	ldr w1,[x0]
	add w1,w1,#1
	str w1,[x0]

    // Wenn cursor_x >= NUM_COLS ist
	cmp w1,NUM_COLS
	blt 9f

    // dann cursor_x = 0
	ldr x0,=cursor_x
	mov w1,#0
	str w1,[x0]
    
    // und neue Zeile (cursor_y + 1)
	ldr x0,=cursor_y
	ldr w1,[x0]
	add w1,w1,#1
	str w1,[x0]
9:

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: 

7:  //Für alle:
    //Wenn cursor_y >= max Anzahl Zeilen
	ldr x0,=cursor_y
	ldr w1,[x0]
	cmp w1,NUM_ROWS
	blt 10f

    //Dann Scrolle den Bildscirm
	bl ScrollScreen

    //Setze die Cursorposition auf Vorletzte Zeile (cursor_y = NUM_ROWS - 1)
	mov w0,NUM_ROWS
	sub w0,w0,#1
	ldr x1,=cursor_y
	str w0,[x1]
10:

Damit haben wir bereits unser Terminalprogramm beschrieben. In diesem SourceCode sind ein paar Funktionsaufrufe, die wir nun beschreiben:

ClearScreen-Funktion

Die ClearScreen-Funktion löscht den gesamten Bildschirm und setzt den Cursor wieder auf die Anfangsposition. Zuerst setzen wir die Zeichenfarbe auf die Hintergrundfarbe. Dann durchlaufen wir den gesamten Bildschirm mit einer Schleife und zeichnen an jeder Position die Hintergrundfarbe. Schließlich setzen wir den Cursor auf die obere linke Ecke. 

//void ClearScreen()
//Löscht den Inhalt des Screens in der Hintergrundfarbe
.globl ClearScreen
ClearScreen:
	stp x29, x30, [sp, -16]!
	stp x10, x11, [sp, -16]!
	mov x29, sp

    //Setze die Zeichenfarbe auf die Hintergrundfarbe
    ldr x10,=BackColor
	ldr w10,[x10]
	ldr x11,=DrawColor
	str w10,[x11]

    //for (w11 = 0; w11 < SCREEN_Y; w11++)
	mov w11,#0
1:
	cmp w11,#SCREEN_Y
	bge 2f

    //for (w10 = 0; w10 < SCREEN_X; w10++)
	mov w10,#0
3:
	cmp w10,#SCREEN_X
	bge 4f

    //DrawPixel(x, y);
	mov w0,w10
	mov w1,w11
	bl DrawPixel

    //end_for w10
	add w10,w10,#1
	b 3b
4:
    //end_for w11
	add w11,w11,#1
	b 1b
2:
    //Setze cursor_x auf 0
    mov x10,#0
    ldr x11,=cursor_x
    str w10,[x11]
    //Setze cursor_y auf 0
    ldr x11,=cursor_y
    str w10,[x11]

	ldp x10, x11, [sp], 16
	ldp x29, x30, [sp], 16
	ret

ScrollScreen-Funktion

Die ScrollScreen-Funktion verschiebt den Text um eine Zeile nach oben und löscht die unterste Zeile. Zuerst durchlaufen wir alle Zeilen bis 10 Pixel vor dem Ende des Bildschirms und kopieren den Farbwert des Pixels, das 10 Pixel unter der aktuellen Zeile liegt, in die aktuelle Zeile. Danach löschen wir die letzte Zeile, indem wir diese Zeile mit "Leerzeichen" füllen. 

// void ScrollScreen()
// Schiebe den Inhalt des Screens um eine Zeichenzeile nach oben
.globl ScrollScreen
ScrollScreen:
	stp x29, x30, [sp, -16]!
	stp x10, x11, [sp, -16]!
	mov x29, sp

// for (u32 y = 1; y < NUM_ROWS; y++)
	mov x10,#1
1:
	cmp x10,#NUM_ROWS
	bge 2f

// for (u32 x = 0; x < NUM_COLS; x++)
	mov x11,#0
3:
	cmp x11,#NUM_COLS
	bge 4f

// DrawColor = GetPixel(x * CHAR_WIDTH, y * CHAR_HEIGHT);
	mov w0,w11
	mov w2,#CHAR_WIDTH
	mul w0,w0,w2
	mov w1,w10
	mov w2,#CHAR_HEIGHT
	mul w1,w1,w2
	bl GetPixel
	ldr x1,=DrawColor
	str w0,[x1]

// DrawPixel(x * CHAR_WIDTH, (y - 1) * CHAR_HEIGHT);
	mov w0,w11
	mov w2,#CHAR_WIDTH
	mul w0,w0,w2
	mov w1,w10
	sub w1,w1,#1
	mov w2,#CHAR_HEIGHT
	mul w1,w1,w2
	bl DrawPixel
//
	add x11,x11,#1
	b 3b
4:
// 
	add x10,x10,#1
	b 1b
2:

// Clear the last line
// for (u32 x = 0; x < NUM_COLS; x++)
	mov w10,#0
5:
	cmp w10,NUM_COLS
	bge 6f 

// DrawChar(' ', x * CHAR_WIDTH, (NUM_ROWS - 1) * CHAR_HEIGHT);
	mov w0,#' '
	mov w1,w10
	mov w3,#CHAR_WIDTH
	mul w1,w1,w3
	mov w2,#NUM_ROWS
	sub w2,w2,#1
	mov w3,#CHAR_HEIGHT
	mul w2,w2,w3
	bl DrawChar
// 
	add w10,w10,#1
	b 5b
6:
// 
	ldp x10, x11, [sp], 16
	ldp x29, x30, [sp], 16
	ret

Bemerkung: Diese Routine ist extremst Zeitaufwendig. Wir werden hier später eine neue Methode (DMA) verwenden, die dies viel schneller durchführen kann.

GetPixel-Funktion

Die GetPixel-Funktion liest den Farbwert eines Pixels an der angegebenen Position. Zuerst prüfen wir, ob der Pixel, der abgefragt wird, auch tatsächlich auf dem Bildschirm ist. Falls nicht, geben wir 0 zurück. Ansonsten berechnen wir die Position des Pixels im Speicher und lesen den Wert aus. 

//u32 GetPixel(u32 x, u32 y)
//Abfrage, der Farbe des Pixels im Screen
.globl GetPixel
GetPixel:
	stp x29, x30, [sp, -16]!
	stp x10, x11, [sp, -16]!
	mov x29, sp
    
    //Überprüfe, ob der Pixel im Screen ist
	cmp w0,#SCREEN_X
	bge 1f
	cmp w1,#SCREEN_Y
	bge 1f

    //Berechne Position des Pixels: graphicsAddress+(((SCREEN_X*y)+x)*4)
	mov w10,SCREEN_X
	mul w10,w10,w1
	add w10,w10,w0
	lsl w10,w10,#2
	ldr x11,=graphicsAddress
	ldr w11,[x11]
	add w10,w10,w11

    //Lade die Farbe des Pixels nach w0
	ldr w0,[x10]
	b 2f
1:
    //Wenn Position des Pixel nicht im Screen ist, dann NULL zurück 
	mov w0,#0
2:
	ldp x10, x11, [sp], 16
	ldp x29, x30, [sp], 16
	ret

DrawString-Funktion

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

//void DrawString(const char* str)
.globl DrawString
DrawString:
	stp x29, x30, [sp, -16]!
	stp x10, x11, [sp, -16]!
	mov x29, sp

	mov x10,x0
//    while (*str)
2:
	ldrb w0,[x10]
	cmp w0,#0
	beq 1f
	bl DrawCharAtCursor
	add x10,x10,#1
	b 2b
1:
	ldp x10, x11, [sp], 16
	ldp x29, x30, [sp], 16
	ret

Testen

Um nun das alles zu testen, schreiben wir unseren kernel.S Code um: 

//
// kernel.S
//

.section .text
.globl main
main:

    bl LED_off
	bl Init_Screen

	ldr x0,=message
	bl DrawString

	mov w0,#2
	bl LED_Error
	 
999:
   b 999b

.section .data
message:
.asciz "Hallo, Welt!\nDies ist eine neue Zeile.\tMit Tab.\nUnd noch mehr Text."
Abgerufen von „https://satyria.de/arm/index.php?title=Das_Terminal_(PI5)&oldid=733“