Lass die LED leuchten in C (PI4)

Einführung

Unser Ziel ist es, die fest eingebaute LED des Raspberry Pi 4 zum Blinken zu bringen. Ich werde jeden Schritt erklären und die Gründe für die implementierten Schritte näher erläutern.

Vorbereitung des Verzeichnisses

Erstellen Sie zunächst ein neues Verzeichnis, z.B. LED, und platzieren Sie darin das Makefile und die Datei linker.ld. Erzeugen Sie auch das Verzeichnis "include" innerhalb von LED, um unsere Header-Dateien zu organisieren.

Programmierung des Startverhaltens des Raspberry Pi (boot.S)

Leider kommen wir nicht ganz ohne Assembler aus. Der erste Code, der ausgeführt wird, sollte in Assembler geschrieben sein. In der Regel werden einige Eigenschaften der CPU definiert, die nur in Assembler möglich sind. Für dieses Beispiel benötigen wir das noch nicht, aber wir erstellen diese Datei, um für spätere Projekte vorbereitet zu sein. Erstellen Sie die Datei boot.S:

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// boot.S
//

#include "config.h"

.section .init                // Ensure the linker places this at the beginning of the kernel image
.global _start                // Execution starts here

_start:
  ldr x0, =MEM_KERNEL_STACK
  mov sp, x0                  // init its stack	
  b sysinit

Erklärung:

• #include "config.h": Inkludiert die Konfigurationsdatei, in der benötigte Parameter definiert sind.
• .section .init: Definiert einen Abschnitt, der am Anfang des Kernel-Images platziert wird.
• .global _start: Deklariert _start als global, damit es von allen Teilen des Programms verwendet werden kann.
• _start:: Label, das den Startpunkt der Ausführung markiert.
• ldr x0, =MEM_KERNEL_STACK: Lädt die Adresse von MEM_KERNEL_STACK in das Register x0.
• mov sp, x0: Initialisiert den Stack-Zeiger (SP).
• b sysinit: Springt zur Funktion sysinit, die später implementiert wird.

Wenn das Programm startet, wird zunächst mit ldr (Load Register) das Register x0 mit dem Wert aus MEM_KERNEL_STACK belegt, der in der Include-Datei definiert wurde, und anschließend in den Stack-Zeiger (SP) abgelegt. Mit b (Branch) wird der Code zum Label sysinit verzweigt.

Konfigurationsdatei config.h (eine Header-Datei)

Bedeutung und Struktur von Header-Dateien

Unsere "config.h" ist eine Header-Datei. Header-Dateien werden verwendet, um Code zu organisieren und wieder verwendbar zu machen.

Hauptgründe sind:

• Strukturierung: Header-Dateien helfen dabei, den Code in kleinere, übersichtliche Teile zu gliedern.
• Wiederverwendbarkeit: Einmal geschriebener Code kann in mehreren Programmen oder Dateien verwendet werden.
• Vereinfachung: Macht den Code übersichtlicher und leichter verständlich.
• Vermeidung von Doppelarbeit: Änderungen müssen nur in der Header-Datei vorgenommen werden.

Unsere "config.h" ist wie folgt beschrieben:

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// config.h
//

#ifndef _config_h
#define _config_h

#define MEGABYTE          0x100000

#define MEM_KERNEL_START  0x80000          // Startadresse des Hauptprogramms
#define KERNEL_MAX_SIZE   (2 * MEGABYTE)
#define MEM_KERNEL_END    (MEM_KERNEL_START + KERNEL_MAX_SIZE)
#define KERNEL_STACK_SIZE 0x20000
#define MEM_KERNEL_STACK  (MEM_KERNEL_END + KERNEL_STACK_SIZE)

#endif

Erklärung:

• #ifndef _config_h ... #endif: Verhindert, dass die Datei mehrfach inkludiert wird.
• #define: Weist Symbolen konstante Werte zu.
• MEM_KERNEL_STACK: Berechnet den Start des Kernel-Stacks basierend auf der Startadresse des Kernels und seiner maximalen Größe.

Die #ifndef-Anweisung (if not defined) stellt sicher, dass die Datei nur einmal verarbeitet wird. Danach wird die Variable mit #define _config_h definiert und ist dem Compiler bekannt.

Funktion sysinit

Erstellen Sie die Funktion sysinit, die das System initialisiert:

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// sysinit.S
//

.section .text
.globl sysinit
sysinit:
  b main

Erklärung:

• .section .text: Definiert einen Abschnitt für ausführbaren Code.
• .globl sysinit: Deklariert sysinit als global.
• b main: Springt zur Funktion main.

Das Label "sysinit" wird global definiert, damit es auch außerhalb der Datei bekannt ist. Der einzige Befehl b main bedeutet, dass das Programm einen Sprung zum Label main macht. Später werden wir hier mehr Code einfügen.

Hauptprogramm main

Erstellen Sie nun das Hauptprogramm:

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// kernel.c
//

#include "led.h"
#include "time.h"

int main (void)
{
  while(1)
  {
    LED_off();
    wait(0x1F0000);
    LED_on();
    wait(0x1F0000);
  }
}

Erklärung

• while(1): Erzeugt eine Endlosschleife.
• LED_off(): Schaltet die LED aus.
• wait(0x1F0000): Ruft die Wartefunktion auf.
• LED_on(): Schaltet die LED ein.

Mit int main (void) erstellen wir das Label, welches von sysinit aufgerufen wird. Die Endlosschleife while(1) bedeutet, dass der Code innerhalb der Schleife fortlaufend ausgeführt wird. LED_off(), wait(), LED_on() und erneut wait() wiederholen den Zyklus unendlich.

LED-Steuerungsfunktionen

Auf dem Raspberry Pi 4 können wir auf die GPIO-PINs direkt zugreifen, die für die Kommunikation mit der Außenwelt verwendet werden. Da eine PIN mit einer fest eingebauten LED verbunden ist, können wir auf externe Hardware verzichten.

Zugriff auf die GPIO-Pins

Der Raspberry Pi 4 hat 40 GPIO-Pins, von denen 26 als Ausgang oder Eingang programmiert werden können. Zusätzlich gibt es interne GPIO-Adressen, die per Programmierschnittstelle programmiert werden können. Eine davon ist die grüne LED, die über den Port 42 angesteuert wird.

Konfiguration des GPIO-Registers

Um die LED zu steuern, müssen wir das Register GPFSEL verwenden. Das Register GPFSEL4 ist für GPIO-Adresse 42 zuständig und jede GPIO-Adresse wird durch 3 Bits konfiguriert:

Status des GPIO-Registers

000	PIN ist ein Eingang
001	PIN ist ein Ausgang
100	PIN hat die alternative Funktion 0
101	PIN hat die alternative Funktion 1
110	PIN hat die alternative Funktion 2
111	PIN hat die alternative Funktion 3
011	PIN hat die alternative Funktion 4
010	PIN hat die alternative Funktion 5

Funktion zur Konfiguration von GPIO-Pins (SetGPIOFunction)

void SetGPIOFunction(u32 Pin, u32 Function)
{
  u32 GPSEL = GPIO_GPFSEL0;
  while (Pin >= 10)
  {
    Pin -= 10;
    GPSEL += 4;
  }
  Pin *= 3;
  Function <<= Pin;
  u32 mask = 0b111 << Pin;
  mask = ~mask; // Bitweise negieren

  u32 sel = read32(GPSEL);
  sel &= mask;
  sel |= Function;
  write32(GPSEL, sel);
}

Erklärung

Diese Funktion bestimmt das richtige GPFSEL-Register und setzt die entsprechende Funktion für den Pin. Zunächst wird die Basis-Adresse für GPIO_GPFSEL0 geladen, und durch eine Schleife die richtige Registeradresse und Pin-Position ermittelt. Der Inhalt des Registers wird gelesen, die entsprechenden Bits gelöscht und mit der neuen Funktion überschrieben.

Funktionen zur Steuerung der LED (LED_on, LED_off)

void LED_on(void)
{
  u32 LED_Pin = 42;
  SetGPIOFunction(LED_Pin, GPIO_output);

  u32 GPSET = GPIO_GPSET0;
  if (LED_Pin > 31)
  {
    GPSET += 4;
    LED_Pin -= 32;
  }
  write32(GPSET, 1 << LED_Pin);
}

void LED_off(void)
{
  u32 LED_Pin = 42;
  SetGPIOFunction(LED_Pin, GPIO_output);

  u32 GPCLR = GPIO_GPCLR0;
  if (LED_Pin > 31)
  {
    GPCLR += 4;
    LED_Pin -= 32;
  }
  write32(GPCLR, 1 << LED_Pin);
}

Erklärung

Wir erstellen zwei Funktionen, LED_on und LED_off, um die LED ein- und auszuschalten. Beide Funktionen setzen den entsprechenden Pin (42) auf "Output", ermitteln das richtige GPSET oder GPCLR-Register und setzen bzw. löschen das entsprechende Bit, um die LED zu steuern.

Basiskonfigurationsdatei base.h

Die Datei base.h enthält Basisadressen für den Raspberry Pi:

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// base.h
//

#ifndef _base_h
#define _base_h

#define RPI_BASE 0xFE000000

// General Purpose I/O (GPIO)                 
#define GPIO_BASE                           (RPI_BASE + 0x200000)
#define GPIO_GPFSEL0                        (GPIO_BASE + 0x00) // GPIO Function Select 0        
#define GPIO_GPFSEL1                        (GPIO_BASE + 0x04) // GPIO Function Select 1        
#define GPIO_GPFSEL2                        (GPIO_BASE + 0x08) // GPIO Function Select 2        
#define GPIO_GPFSEL3                        (GPIO_BASE + 0x0c) // GPIO Function Select 3        
#define GPIO_GPFSEL4                        (GPIO_BASE + 0x10) // GPIO Function Select 4        
#define GPIO_GPFSEL5                        (GPIO_BASE + 0x14) // GPIO Function Select 5        
#define GPIO_GPSET0                         (GPIO_BASE + 0x1c) // GPIO Pin Output Set 0       
#define GPIO_GPSET1                         (GPIO_BASE + 0x20) // GPIO Pin Output Set 1       
#define GPIO_GPCLR0                         (GPIO_BASE + 0x28) // GPIO Pin Output Clear 0       
#define GPIO_GPCLR1                         (GPIO_BASE + 0x2c) // GPIO Pin Output Clear 1       
#define GPIO_GPLEV0                         (GPIO_BASE + 0x34) // GPIO Pin Level 0        
#define GPIO_GPLEV1                         (GPIO_BASE + 0x38) // GPIO Pin Level 1        
#define GPIO_GPEDS0                         (GPIO_BASE + 0x40) // GPIO Pin Event Detect Status 0      
#define GPIO_GPEDS1                         (GPIO_BASE + 0x44) // GPIO Pin Event Detect Status 1      
#define GPIO_GPREN0                         (GPIO_BASE + 0x4c) // GPIO Pin Rising Edge Detect Enable 0     
#define GPIO_GPREN1                         (GPIO_BASE + 0x50) // GPIO Pin Rising Edge Detect Enable 1     
#define GPIO_GPFEN0                         (GPIO_BASE + 0x58) // GPIO Pin Falling Edge Detect Enable 0     
#define GPIO_GPFEN1                         (GPIO_BASE + 0x5c) // GPIO Pin Falling Edge Detect Enable 1     
#define GPIO_GPHEN0                         (GPIO_BASE + 0x64) // GPIO Pin High Detect Enable 0      
#define GPIO_GPHEN1                         (GPIO_BASE + 0x68) // GPIO Pin High Detect Enable 1      
#define GPIO_GPLEN0                         (GPIO_BASE + 0x70) // GPIO Pin Low Detect Enable 0      
#define GPIO_GPLEN1                         (GPIO_BASE + 0x74) // GPIO Pin Low Detect Enable 1      
#define GPIO_GPAREN0                        (GPIO_BASE + 0x7c) // GPIO Pin Async. Rising Edge Detect 0     
#define GPIO_GPAREN1                        (GPIO_BASE + 0x80) // GPIO Pin Async. Rising Edge Detect 1     
#define GPIO_GPAFEN0                        (GPIO_BASE + 0x88) // GPIO Pin Async. Falling Edge Detect 0     
#define GPIO_GPAFEN1                        (GPIO_BASE + 0x8c) // GPIO Pin Async. Falling Edge Detect 1     
#define GPIO_GPIO_PUP_PDN_CNTRL_REG0        (GPIO_BASE + 0xe4) // GPIO Pull-up / Pull-down Register 0      
#define GPIO_GPIO_PUP_PDN_CNTRL_REG1        (GPIO_BASE + 0xe8) // GPIO Pull-up / Pull-down Register 1      
#define GPIO_GPIO_PUP_PDN_CNTRL_REG2        (GPIO_BASE + 0xec) // GPIO Pull-up / Pull-down Register 2      
#define GPIO_GPIO_PUP_PDN_CNTRL_REG3        (GPIO_BASE + 0xf0) // GPIO Pull-up / Pull-down Register 3      
// Information from BCM2835 ARM Peripherals                 
#define GPIO_GPPUD                          (GPIO_BASE + 0x94) // GPIO Pin Pull-up/down Enable        
#define GPIO_GPPUDCLK0                      (GPIO_BASE + 0x98) // GPIO Pin Pull-up/down Enable Clock 0      
#define GPIO_GPPUDCLK1                      (GPIO_BASE + 0x9c) // GPIO Pin Pull-up/down Enable Clock 1      

#endif

Erklärung

In dieser Header-Datei wurden alle Funktionen (Adressen) definiert, die GPIO betreffen. Diese Datei wird im Verlauf unseres Kurses kontinuierlich erweitert; aktuell benötigen wir jedoch nur die Daten für unsere LED.

Mit #define RPI_BASE 0xFE000000 legen wir die Basisadresse der Peripheriegeräte fest. Dies dient als Grundlage für alle anderen Geräte, die wir verwenden. #define GPIO_BASE (RPI_BASE + 0x200000) legt die Basisadresse des GPIO fest.

read32 und write32

Diese zwei Funktionen ermöglichen direkten Zugriff auf den Speicher des Raspberry Pi 4. Wir definieren diese Funktionen in Assembler, um einfacher auf die Hardware zugreifen zu können.

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// util.S
//

.globl write32
write32:
  stp x29, x30, [sp, -16]!
  mov x29, sp
  str w1, [x0]
  ldp x29, x30, [sp], 16
  ret

.globl read32
read32:
  stp x29, x30, [sp, -16]!
  mov x29, sp
  ldr w0, [x0]
  ldp x29, x30, [sp], 16
  ret

Speichern Sie die Datei als util.S.

Erklärung

write32 nutzt die Zeile str w1,[x0] (store), um den zweiten Wert an die Adresse des ersten Wertes zu schreiben. read32 nutzt die Zeile ldr w0,[x0] (load), um den Wert an der übergebenen Adresse zu laden und zurückzugeben.

Damit C weiß, welche Werte hier erwartet werden, müssen wir in einer Header-Datei festlegen, was wir erwarten:

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// util.h
//

#ifndef _ms_util_h
#define _ms_util_h

#include "types.h"

void write32(u32 a, u32 b);
u32 read32(u32 a);

#endif

Wartefunktion wait

Zuletzt erstellen wir die Datei time.c für die Wartefunktion:

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// time.c
//

#include "types.h"

void wait(u32 zyklen) 
{
  volatile u32 i;
  for (i = 0; i < zyklen; i++) 
  {
    // Leere Schleife zur Verzögerung
  }
}

Erklärung

volatile u32 i: Erzeugt die Variable i. Durch volatile wird die Schleife bei der Code-Optimierung nicht optimiert. for (i = 0; i < zyklen; i++): Erzeugt eine Schleife und zählt i hoch, solange i kleiner als zyklen ist. {...}: Leere Schleife zur Verzögerung.

Weitere Header-Dateien

In C werden Funktionen häufig in Header-Dateien (mit der Endung .h) deklariert, bevor sie in den eigentlichen Quellcodedateien (mit der Endung .c) definiert werden. Dies hat mehrere wichtige Gründe:

• Modularität und Wiederverwendbarkeit: Header-Dateien ermöglichen es, den Code in verschiedene Module zu unterteilen. Dadurch können Funktionen und Datenstrukturen in mehreren Quellcodedateien wiederverwendet werden, ohne den Code duplizieren zu müssen.
• Trennung von Deklaration und Definition: Die Deklaration einer Funktion in einer Header-Datei informiert den Compiler über die Existenz und das Interface der Funktion (Name, Rückgabewert, Parameter), ohne den vollständigen Funktionscode zur Verfügung zu stellen. Die Definition, die den eigentlichen Code enthält, befindet sich in der entsprechenden .c-Datei. Dies unterstützt das Prinzip der Informationsverbergung (Encapsulation), indem es die Implementierungsdetails von der Schnittstelle trennt.
• Vermeidung von Mehrfachdeklarationen: Durch das Einfügen der Header-Datei in mehrere Quellcodedateien (#include "header.h") wird sichergestellt, dass alle Quellcodedateien die gleichen Funktionsdeklarationen verwenden. Dies verhindert Fehler durch inkonsistente Deklarationen.
• Erleichterung der Wartung: Änderungen an der Funktionsdeklaration (z.B. Änderung der Parameter) müssen nur in der Header-Datei vorgenommen werden. Alle Quellcodedateien, die diese Header-Datei einbinden, verwenden automatisch die aktualisierte Deklaration.
• Kompilierung und Linken: Während des Kompilierens überprüft der Compiler die Header-Dateien, um sicherzustellen, dass die Funktionsaufrufe korrekt sind. Beim Linken werden dann die tatsächlichen Funktionsdefinitionen aus den Quellcodedateien zusammengeführt. Dies ermöglicht es auch, große Projekte effizient zu kompilieren, indem nur die geänderten Dateien neu kompiliert werden müssen, während die unveränderten Dateien aus der letzten Kompilierung wiederverwendet werden können.
• Interne und Externe Sichtbarkeit: Header-Dateien können genutzt werden, um die Sichtbarkeit von Funktionen und Variablen zu steuern. Funktionen, die in einer Header-Datei deklariert sind, sind für alle Quellcodedateien sichtbar, die diese Header-Datei einbinden. Funktionen, die nur in der Quellcodedatei definiert sind, sind dagegen nur in dieser Datei sichtbar (statische Funktionen).

In unserem Code fehlen nun noch drei Header-Dateien: led.h, time.h und types.h.

Die led.h

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// led.h
//

#ifndef _ms_led_h
#define _ms_led_h

#include "types.h"

#define GPIO_input  0b000      // Input
#define GPIO_output 0b001      // Output
#define GPIO_alt0   0b100      // Alternate function 0
#define GPIO_alt1   0b101      // Alternate function 1
#define GPIO_alt2   0b110      // Alternate function 2
#define GPIO_alt3   0b111      // Alternate function 3
#define GPIO_alt4   0b011      // Alternate function 4
#define GPIO_alt5   0b010      // Alternate function 5

#define GPPUD_OFF    0b00      // Pull-up/down disable

void LED_off(void);
void LED_on(void);
void SetGPIOFunction(u32 Pin, u32 Function);

#endif

Erklärung

Diese Header-Datei definiert die Funktionsaufrufe LED_off, LED_on und SetGPIOFunction. Die Funktionsaufrufe LED_off und LED_on erwarten keine Parameter und geben keine Parameter zurück, was durch das Schlüsselwort void erkennbar ist. SetGPIOFunction erwartet den PIN und die Funktion als u32-Wert.

Die time.h

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// time.h
//

#ifndef _ms_time_h
#define _ms_time_h

#include "types.h"

void wait(u32 zyklen);

#endif

Erklärung

Hier wird der Funktionsaufruf wait definiert. Diese Funktion gibt keinen Wert zurück, erwartet aber einen u32-Wert als Parameter. Der Typ u32 wird im nächsten Header types.h definiert. Deswegen wurde diese Datei inkludiert, damit der Compiler weiß, was u32 bedeutet.

Die types.h

//
// The LED program for RPI4
// 20.02.2025 www.satyria.de
//
// types.h
//

#ifndef _ms_types_h
#define _ms_types_h

typedef unsigned char   u8;
typedef unsigned short  u16;
typedef unsigned int    u32;

typedef signed char     s8;
typedef signed short    s16;
typedef signed int      s32;

typedef unsigned long   u64;
typedef signed long     s64;

typedef long            intptr;
typedef unsigned long   uintptr;

typedef unsigned long   size_t;
typedef long            ssize_t;

typedef char            boolean;

#define ALIGN(n)  __attribute__((aligned (n)))

#define FALSE     0
#define TRUE      1

#endif

Erklärung

Der Header types.h definiert verschiedene Datentypen und einige Makros, die in einem C-Programm verwendet werden können:

• Typdefinitionen:
  • Unsigned Types:
    • u8: ein Alias für unsigned char (8-Bit)
    • u16: ein Alias für unsigned short (16-Bit)
    • u32: ein Alias für unsigned int (32-Bit)
    • u64: ein Alias für unsigned long (64-Bit)
  • Signed Types:
    • s8: ein Alias für signed char (8-Bit)
    • s16: ein Alias für signed short (16-Bit)
    • s32: ein Alias für signed int (32-Bit)
    • s64: ein Alias für signed long (64-Bit)
  • Pointer Types:
    • intptr: ein Alias für long, um einen Integer zu speichern, der groß genug ist, um einen Zeiger zu halten
    • uintptr: ein Alias für unsigned long, für einen unsigned Integer, der groß genug ist, um einen Zeiger zu halten
  • Size Types:
    • size_t: ein Alias für unsigned long, typischerweise verwendet für die Größe von Objekten
    • ssize_t: ein Alias für long, typischerweise verwendet für signierte Größenangaben
  • Boolean Type:
    • Ein neuer Typ boolean als Alias für char
• Makros für Alignment:
  • ALIGN(n): ein Makro, das das GCC-spezifische __attribute__((aligned(n))) verwendet, um die Ausrichtung eines Datentyps auf n Bytes zu erzwingen
• Boolean Values:
  • FALSE und TRUE werden als 0 und 1 definiert

Zusammengefasst definiert dieser Header eine Reihe von neuen Typen und Makros, die die Lesbarkeit und Portabilität des Codes verbessern, indem sie standardisierte Namen und Werte bereitstellen.

Kompilieren und Ausführen

Wechseln Sie in das Verzeichnis LED und kompilieren Sie das Programm mit dem Befehl make. Wenn alles erfolgreich war, erhalten Sie eine Datei kernel8.img, die auf eine SD-Karte kopiert und im Raspberry Pi verwendet wird. Schalten Sie den Raspberry Pi ein, und die LED sollte blinken.

Sie können den Source-Code als ZIP-Datei mit folgendem Link herunterladen: https://www.satyria.de/arm/sources/RPI4/C/2.zip

---

< Zurück (Unser erstes Programm in C (PI4))

< Hauptseite >

Weiter (Fehlerbehandlung in C (PI4)) >