Das Terminal in C (PI4) - Versionsgeschichte

Satyria am 6. März 2025 um 12:42 Uhr

2025-03-06T12:42:26Z

← Nächstältere Version		Version vom 6. März 2025, 13:42 Uhr
Zeile 152:		Zeile 152:
	</syntaxhighlight>		</syntaxhighlight>
	== GetPixel-Funktion ==		== 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.		Die GetPixel-Funktion liest den Farbwert eines Pixels an der angegebenen Position. Zuerst prüfen wir, ob der Pixel, der abgefragt wird, tatsächlich auf dem Bildschirm liegt. Falls nicht, geben wir 0 zurück. Ansonsten berechnen wir die Position des Pixels im Speicher und lesen den Wert aus.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	u32 GetPixel(u32 x, u32 y)		u32 GetPixel(u32 x, u32 y)
Zeile 169:		Zeile 169:
	== DrawString-Funktion ==		== DrawString-Funktion ==

	Um ganze Texte (Strings) im Terminal anzuzeigen, verwenden wir die `DrawString`-Funktion. Diese Funktion durchläuft den String und zeichnet jedes Zeichen:		Um ganze Texte (Strings) im Terminal anzuzeigen, verwenden wir die DrawString-Funktion. Diese Funktion durchläuft den String und zeichnet jedes Zeichen:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	void DrawString(const char* str) {		void DrawString(const char* str) {
Zeile 178:		Zeile 178:
	</syntaxhighlight>		</syntaxhighlight>
	== Testen der Funktion ==		== Testen der Funktion ==
	Zum Testen dieser Funktionen schreiben wir eine `main`-Funktion:		Zum Testen dieser Funktionen schreiben wir eine main-Funktion:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	// main.c		// main.c
Zeile 199:		Zeile 199:
	== Zusammenfassung ==		== 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.		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 leserlich 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.

	Du kannst den Source-Code als ZIP-Datei mit folgenden Link downloaden: https://www.satyria.de/arm/sources/RPI4/C/6.zip		Du kannst den Source-Code als ZIP-Datei mit folgenden Link downloaden: https://www.satyria.de/arm/sources/RPI4/C/6.zip

Satyria am 6. März 2025 um 12:39 Uhr

2025-03-06T12:39:58Z

← Nächstältere Version		Version vom 6. März 2025, 13:39 Uhr
Zeile 28:		Zeile 28:
	== Zeichen im Terminal zeichnen ==		== 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:		Als erstes schreiben wir eine Funktion, die ein Zeichen im Terminal an der aktuellen Cursor-Position zeichnet. Die Funktion bekommt das Zeichen übergeben, das gezeichnet werden soll:

	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 42:		Zeile 42:

	1. '''Neue Zeile (`\n`)''':		1. '''Neue Zeile (`\n`)''':
	Wenn das Zeichen ein Zeilenumbruch (`\n`) ist, setzen wir den Cursor an den Anfang der nächsten Zeile:		Wenn das Zeichen ein Zeilenumbruch (\n) ist, setzen wir den Cursor an den Anfang der nächsten Zeile:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	if (c == '\n') // Neue Zeile		if (c == '\n') // Neue Zeile
Zeile 51:		Zeile 51:
	</syntaxhighlight>		</syntaxhighlight>
	2. '''Zeilenanfang (`\r`)''':		2. '''Zeilenanfang (`\r`)''':
	Wenn das Zeichen ein Wagenrücklauf (`\r`) ist, setzen wir den Cursor an den Anfang der aktuellen Zeile:		Wenn das Zeichen ein Wagenrücklauf (\r) ist, setzen wir den Cursor an den Anfang der aktuellen Zeile:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	else if (c == '\r') // Zeilenanfang		else if (c == '\r') // Zeilenanfang
Zeile 59:		Zeile 59:
	</syntaxhighlight>		</syntaxhighlight>
	3. '''Tabulator (`\t`)''':		3. '''Tabulator (`\t`)''':
	Wenn das Zeichen ein Tabulator (`\t`) ist, bewegen wir den Cursor um vier Positionen nach rechts:		Wenn das Zeichen ein Tabulator (\t) ist, bewegen wir den Cursor um vier Positionen nach rechts:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	else if (c == '\t') // Tabulator		else if (c == '\t') // Tabulator
Zeile 67:		Zeile 67:
	</syntaxhighlight>		</syntaxhighlight>
	4. '''Rückschritt (`\b`)''':		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:		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:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	else if (c == '\b') // Rückschritt		else if (c == '\b') // Rückschritt
Zeile 77:		Zeile 77:
	</syntaxhighlight>		</syntaxhighlight>
	5. '''Seitenvorschub (`\f`)''':		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:		Wenn das Zeichen ein Seitenvorschub (\f) ist, löschen wir den Bildschirm. Dieses Zeichen wurde früher verwendet, um auf Nadeldruckern eine neue Seite zu beginnen. Hier verwenden wir es, um den Bildschirm zu löschen:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
	else if (c == '\f') // Seitenvorschub (Bildschirm löschen)		else if (c == '\f') // Seitenvorschub (Bildschirm löschen)

Satyria am 6. März 2025 um 12:34 Uhr

2025-03-06T12:34:59Z

← Nächstältere Version		Version vom 6. März 2025, 13:34 Uhr
Zeile 1:		Zeile 1:
	== Das Terminal ==		== 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.		Nachdem wir nun Zeichen auf dem 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? ==		== Wie sieht ein Terminal aus? ==
Zeile 19:		Zeile 19:
	</syntaxhighlight>		</syntaxhighlight>

	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):		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):

	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">

Satyria: Die Seite wurde neu angelegt: „== 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 Bild…“

2025-03-05T08:09:14Z

Die Seite wurde neu angelegt: „== 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 Bild…“

Neue Seite

== 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.

<syntaxhighlight lang="C">
#define CHAR_WIDTH 8
#define CHAR_HEIGHT 10
</syntaxhighlight>

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

<syntaxhighlight lang="C">
#define NUM_COLS (SCREEN_X / CHAR_WIDTH)
#define NUM_ROWS (SCREEN_Y / CHAR_HEIGHT)
</syntaxhighlight>

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):

<syntaxhighlight lang="C">
u32 cursor_x = 0;
u32 cursor_y = 0;
</syntaxhighlight>

== 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:

<syntaxhighlight lang="C">
void DrawCharAtCursor(char c)
{
// Funktion zum Zeichnen eines Zeichens
}
</syntaxhighlight>

=== 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:
<syntaxhighlight lang="C">
if (c == '\n') // Neue Zeile
{
cursor_x = 0;
cursor_y++;
}
</syntaxhighlight>
2. '''Zeilenanfang (`\r`)''':
Wenn das Zeichen ein Wagenrücklauf (`\r`) ist, setzen wir den Cursor an den Anfang der aktuellen Zeile:
<syntaxhighlight lang="C">
else if (c == '\r') // Zeilenanfang
{
cursor_x = 0;
}
</syntaxhighlight>
3. '''Tabulator (`\t`)''':
Wenn das Zeichen ein Tabulator (`\t`) ist, bewegen wir den Cursor um vier Positionen nach rechts:
<syntaxhighlight lang="C">
else if (c == '\t') // Tabulator
{
cursor_x += 4;
}
</syntaxhighlight>
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:
<syntaxhighlight lang="C">
else if (c == '\b') // Rückschritt
{
if (cursor_x > 0) {
cursor_x--;
}
}
</syntaxhighlight>
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:
<syntaxhighlight lang="C">
else if (c == '\f') // Seitenvorschub (Bildschirm löschen)
{
ClearScreen();
}
</syntaxhighlight>
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:
<syntaxhighlight lang="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++;
}
}
</syntaxhighlight>
=== 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:
<syntaxhighlight lang="C">
if (cursor_y >= NUM_ROWS)
{
ScrollScreen();
cursor_y = NUM_ROWS - 1;
}
</syntaxhighlight>

== 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.
<syntaxhighlight lang="C">
void ClearScreen()
{
// Setze die Zeichenfarbe auf die Hintergrundfarbe
DrawColor = BackColor;

// Lösche den gesamten Bildschirm
for (u32 y = 0; y < SCREEN_Y; y++) {
for (u32 x = 0; x < SCREEN_X; x++) {
DrawPixel(x, y);
}
}

// Setze den Cursor auf die obere linke Ecke
cursor_x = 0;
cursor_y = 0;
}
</syntaxhighlight>

== 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 sie mit der Hintergrundfarbe füllen.
<syntaxhighlight lang="C">
void ScrollScreen()
{
// Verschiebe den Bildschirminhalt um eine Zeile nach oben
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);
}
}

// Lösche die letzte Zeile
DrawColor = BackColor;
for (u32 y = SCREEN_Y - CHAR_HEIGHT; y < SCREEN_Y; y++) {
for (u32 x = 0; x < SCREEN_X; x++) {
DrawPixel(x, y);
}
}
}
</syntaxhighlight>
== 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.
<syntaxhighlight lang="C">
u32 GetPixel(u32 x, u32 y)
{
// Prüfe, ob die Pixelkoordinaten innerhalb des Bildschirms liegen
if ((x < SCREEN_X) && (y < SCREEN_Y)) {
// Berechne die Speicheradresse des Pixels und lese den Farbwert
return read32(graphicsAddress + (((SCREEN_X * y) + x) * 4));
} else {
// Pixel liegt außerhalb des Bildschirms, gib 0 zurück
return 0;
}
}
</syntaxhighlight>

== DrawString-Funktion ==

Um ganze Texte (Strings) im Terminal anzuzeigen, verwenden wir die `DrawString`-Funktion. Diese Funktion durchläuft den String und zeichnet jedes Zeichen:
<syntaxhighlight lang="C">
void DrawString(const char* str) {
while (*str) {
DrawCharAtCursor(*str++);
}
}
</syntaxhighlight>
== Testen der Funktion ==
Zum Testen dieser Funktionen schreiben wir eine `main`-Funktion:
<syntaxhighlight lang="C">
// main.c

#include "led.h"
#include "screen.h"
#include "types.h"

int main(void)
{
LED_off();
Init_Screen();

DrawString("Hallo Welt!");

LED_Error(2);
}
</syntaxhighlight>

== 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.

Du kannst den Source-Code als ZIP-Datei mit folgenden Link downloaden: https://www.satyria.de/arm/sources/RPI4/C/6.zip

-----

{| style="width: 100%;
| style="width: 33%;" | [[Chars in C (PI4)|< Zurück (Chars in C (PI4))]]
| style="width: 33%; text-align:center;" | [[Hauptseite|< Hauptseite >]]
| style="width: 33%; text-align:right;" | [[printf in BareMetal (PI4)|Weiter (printf in BareMetal (PI4)) >]]
|}