Lær at programmere i Rust · Lektion

HAL'er og device drivers

Lær at bruge Hardware Abstraction Layers (HAL'er) og skrive simple device drivers til at kommunikere med periferiudstyr på mikrokontrollere.

Lektion 2 af 311 trin

HAL'er og device drivers er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 2 af 3. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 3 lektioner i alt.

Hardwareabstraktionslag (HAL'er)

Velkommen til Embedded Rust-verdenen! Når du arbejder med mikrokontrollere, møder du et vigtigt begreb: hardwareabstraktionslag (HAL'er).

En HAL er et softwarelag, der leverer en standardiseret grænseflade til en mikrokontrollers periferiudstyr, f.eks. GPIO-pins, I2C, SPI og UART. Det skjuler de besværlige detaljer ved direkte manipulation af registre.

Hvorfor har vi brug for HAL'er?

Forestil dig, at du prøver at få en LED til at blinke. På én mikrokontroller skal du måske sætte en bit i registret GPIO_PORTA_DR. På en anden kan det være PIND_OUT.

Kompleksitet: Direkte registeradgang er besværlig og fejlbehæftet.
Portabilitet: Uden HAL'er virker kode, der er skrevet til én chip, ikke på en anden, selv hvis de tilhører samme familie.

HAL'er løser dette ved at give dig en ensartet måde at interagere med hardware på, uanset hvilken chip der ligger under.

Rusts økosystem for Embedded HAL

I Rust definerer craten embedded-hal et sæt traits (svarende til grænseflader) til almindelige handlinger med periferiudstyr. Disse traits fungerer som en kontrakt, som specifikke HAL'er til mikrokontrollere skal implementere.

embedded-hal: Leverer generiske traits (f.eks. DigitalOutputPin og I2c).
Chipspecifikke HAL'er: Crates som rp-hal (til Raspberry Pi Pico) eller stm32f4xx-hal implementerer disse traits til deres respektive hardware.

Denne adskillelse gør det muligt at skrive enhedsdrivere generisk!

Grundlæggende HAL-interaktion: GPIO

Lad os se, hvordan en HAL kan abstrahere en GPIO-pin. I rigtig indlejret kode henter du et pin-objekt fra din chips HAL og konfigurerer det.

Dette eksempel simulerer, hvordan du interagerer med et 'pin'-objekt for at styre en LED.

struct GpioPin {
    name: String,
    state: bool,
}

impl GpioPin {
    fn new(name: &str) -> Self {
        println!("Configuring {} as output...", name);
        GpioPin { name: name.to_string(), state: false }
    }
    fn set_high(&mut self) {
        self.state = true;
        println!("{} set to HIGH (LED ON)", self.name);
    }
    fn set_low(&mut self) {
        self.state = false;
        println!("{} set to LOW (LED OFF)", self.name);
    }
    fn toggle(&mut self) {
        if self.state { self.set_low(); } else { self.set_high(); }
    }
}

fn main() {
    let mut led_pin = GpioPin::new("LED_GPIO_PIN");
    println!("\n--- Blinking LED Simulation ---");
    led_pin.set_high();
    led_pin.set_low();
    led_pin.toggle();
    led_pin.toggle();
    println!("-----------------------------");
}

Forståelse af GPIO-pin-tilstande

GPIO-pins bruges ikke kun til at tænde og slukke for ting! De har forskellige tilstande:

Output: Til styring af eksterne komponenter (f.eks. en LED).
Input: Til læsning af signaler fra eksterne komponenter (f.eks. en knap).
Input med pull-up/pull-down: Til at sikre en stabil tilstand, når intet er tilsluttet, så 'flydende' input undgås.
Analog: Til læsning af kontinuerlige spændingsniveauer (f.eks. fra en sensor).

HAL'er leverer metoder til sikker konfiguration af disse tilstande.

Hvad er enhedsdrivere?

Mens HAL'er giver dig lavniveaukontrol over periferiudstyr, bygger enhedsdrivere oven på HAL'er for at levere funktionalitet på højere niveau til bestemte eksterne enheder (f.eks. en temperatursensor eller en LCD-skærm).

En enhedsdriver abstraherer kommunikationsprotokollen (f.eks. I2C eller SPI) og de specifikke kommandoer, der kræves af en bestemt chip. Den omdanner rå byteoverførsler til meningsfulde handlinger som sensor.read_temperature().

Standardisering af drivere med `embedded-hal`

Den virkelige styrke ved embedded-hal viser sig, når du skriver drivere. I stedet for at en driver kender det specifikke HAL til en STM32 eller en RP2040, behøver den kun at kende traits i embedded-hal.

En driver til en I2C-temperatursensor kræver for eksempel et objekt, der implementerer traiten embedded_hal::i2c::I2c. Det betyder, at den samme driverkode kan fungere på alle mikrocontrollere, hvis HAL implementerer denne trait!

Drivereksempel: I2C-sensor (konceptuelt)

Forestil dig, at du har en temperatursensor, der kommunikerer via I2C. En enhedsdriver til den skal:

Modtage et embedded_hal::i2c::I2c-objekt som input.
Implementere metoder som read_temperature() eller set_config().
Internt bruge metoderne i2c.write_read() eller i2c.write(), som det underliggende HAL stiller til rådighed via traiten embedded-hal.

Det skaber en ren og genanvendelig grænseflade til sensoren.

Trin til at oprette en grundlæggende driver

Hvis du ville skrive en simpel enhedsdriver til en ny komponent, kunne den konceptuelle fremgangsmåde se sådan ud:

Definér en driverstruktur: Gem periferigrænsefladen (for eksempel dit HAL's I2C-objekt) samt eventuel driverspecifik tilstand.
Implementér `new()`: Initialisér driveren, eventuelt ved at konfigurere periferien.
Tilføj interaktionsmetoder: Opret funktioner som read_data() og write_config(), der bruger HAL-metoderne.
Håndtér fejl: Brug Rusts Result-type til at håndtere kommunikations- eller enhedsfejl på en kontrolleret måde.

Hurtigt tjek: HAL'er og drivere

Test din forståelse af hardwareabstraktionslag og enhedsdrivere.

Besvar den i den interaktive lektion

Opsummering: HAL'er og drivere

I denne lektion undersøgte vi, hvordan hardwareabstraktionslag (HAL'er) udgør et vigtigt abstraktionslag, der forenkler arbejdet med mikrocontrollerens periferienheder og gør koden mere portabel.

Vi lærte også, hvordan enhedsdrivere bygger videre på HAL'er og traits i embedded-hal for at tilbyde avancerede, genanvendelige grænseflader til bestemte eksterne komponenter, så du slipper for detaljer om kommunikation på lavt niveau. Denne lagdelte tilgang er afgørende for robust udvikling i embedded Rust!

Gratis at komme i gang

Lær Rust med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 39
Lektioner: 144

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “HAL'er og device drivers” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “HAL'er og device drivers”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 3 lektioner i alt.

Hvad lærer jeg i “HAL'er og device drivers”?

Lær at bruge Hardware Abstraction Layers (HAL'er) og skrive simple device drivers til at kommunikere med periferiudstyr på mikrokontrollere. Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær at programmere i Rust?

Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 3.

Hvor lang tid tager lektionen “HAL'er og device drivers”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?

Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Introduktion til Embedded Rust
HAL'er og device drivers
Koncepter inden for operativsystemudvikling

← Tilbage til Lær at programmere i Rust