Das Terminal in C (PI5) - Versionsgeschichte

Satyria: /* Zusammenfassung */

2024-08-23T09:56:37Z

Zusammenfassung

← Nächstältere Version		Version vom 23. August 2024, 10:56 Uhr
Zeile 202:		Zeile 202:

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

			-----

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

Satyria: /* Zusammenfassung */

2024-08-20T18:43:04Z

Zusammenfassung

← Nächstältere Version		Version vom 20. August 2024, 19:43 Uhr
Zeile 200:		Zeile 200:

	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 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/C/terminal.zip

Satyria: /* Steuerzeichen beachten */

2024-08-19T11:12:54Z

Steuerzeichen beachten

Änderungen zeigen

Satyria: /* Steuerzeichen beachten */

2024-08-19T10:58:17Z

Steuerzeichen beachten

← Nächstältere Version		Version vom 19. August 2024, 11:58 Uhr
Zeile 42:		Zeile 42:

	# Neue Zeile (`\n`):		# 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 49:		Zeile 49:
	cursor_y++;		cursor_y++;
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	# Zeilenanfang (`\r`):		# 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:

Satyria am 19. August 2024 um 10:57 Uhr

2024-08-19T10:57:36Z

← Nächstältere Version		Version vom 19. August 2024, 11:57 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 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?		== 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.		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.

	~~```c~~		<syntaxhighlight lang="C">
	#define CHAR_WIDTH 8		#define CHAR_WIDTH 8
	#define CHAR_HEIGHT 10		#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:		Damit können wir festlegen, wie viele Zeichen in einer Zeile und wie viele Zeilen auf dem Bildschirm dargestellt werden können:

	~~```c~~		<syntaxhighlight lang="C">
	#define NUM_COLS (SCREEN_X / CHAR_WIDTH)		#define NUM_COLS (SCREEN_X / CHAR_WIDTH)
	#define NUM_ROWS (SCREEN_Y / CHAR_HEIGHT)		#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):		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):

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

	~~####~~ 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 einfach das Zeichen übergeben, das gezeichnet werden soll:

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

	~~####~~ Steuerzeichen beachten		=== 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:		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`):		# 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:
	~~```c~~		<syntaxhighlight lang="C">
	if (c == '\n') // Neue Zeile		if (c == '\n') // Neue Zeile
	{		{
Zeile 49:		Zeile 49:
	cursor_y++;		cursor_y++;
	}		}
	~~```~~		</syntaxhighlight>
			# 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:
	~~```c~~		<syntaxhighlight lang="C">
	else if (c == '\r') // Zeilenanfang		else if (c == '\r') // Zeilenanfang
	{		{
	cursor_x = 0;		cursor_x = 0;
	}		}
	~~```~~		</syntaxhighlight>

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

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 Bildsch…“

2024-08-19T09:54:20Z

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 Bildsch…“

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.

```c
#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:

```c
#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):

```c
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:

```c
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:
```c
if (c == '\n') // Neue Zeile
{
cursor_x = 0;
cursor_y++;
}
```

2. **Zeilenanfang (`\r`)**:
Wenn das Zeichen ein Wagenrücklauf (`\r`) ist, setzen wir den Cursor an den Anfang der aktuellen Zeile:
```c
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++;
}
}
```

#### 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;
}
```

#### 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;
}
```

#### 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);
}
}
}
```

#### 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;
}
}
```

#### 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++);
}
}
```

#### Testen der Funktion

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

```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);
}
```

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