🙇🏻 🔀 🌬️ STM32MP1 - Kernel + Linux = perfekter Mikrocontroller 💰 ⬜️ 🌧️

Aufgrund meiner Tätigkeit beschäftige ich mich mit der Entwicklung verschiedener Geräte: Messen, Steuern, Steuern usw. Die überwiegende Mehrheit des Geräts besteht aus zwei Teilen:

Hochleistungsfähiger Mikrocontroller, der keine grafische Echtzeit-Benutzeroberfläche (GUI) benötigt.
Verbraucht nur wenige Ressourcen und arbeitet mit harter Echtzeithardware des Geräts.

In der Regel wurde der Übergang zu einer neuen Serie von Mikrocontrollern durch die Verbesserung der GUI bestimmt: mehr Farben, höhere Auflösung, komplexere Designelemente. Zu einer Zeit bestand die Idee darin, eine Art Himbeer-Board als grafische Oberfläche zu verwenden.

Aber mit dem Aufkommen der neuen STM32MP1-Mikrocontroller von STM endete meine Qual und genau das ist bisher passiert.

Perfekter Controller

Ein idealer Controller für mich sollte die folgenden Eigenschaften haben:

haben anständige Grafikfunktionen, wie einfache Unterstützung für verschiedene Grafikformate, Unterstützung für Vektorschriftarten
viel Speicher für Grafiken
USB-Tastatur- und Mausunterstützung
Ethernet-Unterstützung
eine große Anzahl von Hardware-Timern
PWM-Erzeugung
eine große Anzahl von GPIO
16 Bit ADC

Es sind diese Anforderungen, die erforderlich sind, um verschiedene Geräte mit einer anständigen grafischen Benutzeroberfläche zu erstellen.

Und so freute ich mich sehr über eine neue Serie von STM: STM32MP1.

Erstes Treffen

Um sich mit dem neuen Chip vertraut zu machen, wurde die Karte STM32MP157C-DK2 gekauft. Hier ist eines (Foto aus dem Internet): Das

Demo-Board basiert auf einem STM32MP157CAC-Chip, der Folgendes umfasst:

2 Kerne A7, jeweils 650 MHz
1 Kern M4, 208 MHz

Erinnerung

Der allererste Unterschied, der auffällt, ist der Mangel an Flash-Speicher auf dem Chip. Für den A7-Kern, der im Wesentlichen ein Mikroprozessor ist, ist dies eine normale Situation und der Code wird immer vom DRAM ausgeführt. Auf M4 basierende Mikrocontroller enthalten normalerweise einen Flash-Speicher, in dem ausführbarer Code gespeichert ist.

In diesem Kristall hat der M4-Kernel nur RAM und der Code wird daraus ausgeführt (aus dem Datenblatt):

708 KByte interner SRAM: 256 KByte
AXI-SYSRAM + 384 KByte AHB-SRAM +
64 KByte AHB-SRAM in der Sicherungsdomäne
und 4 KByte SRAM in der Sicherungsdomäne

Der A7-Kern verfügt über einen integrierten DDR-Controller (aus einem Datenblatt):

Die STM32MP157C / F-Geräte enthalten einen Controller für externes SDRAM, der die
folgenden Geräte unterstützt:

LPDDR2 oder LPDDR3, 16- oder 32-Bit-Daten, bis zu 1 GByte, bis zu 533 MHz Takt.
DDR3 oder DDR3L, 16- oder 32-Bit-Daten, bis zu 1 GByte, bis zu 533 MHz Takt.

Einerseits scheint der Speicher des M4-Kernels geringer zu sein als der der Version im Flash-Speicher, andererseits läuft der RAM-Speicher mit der Kernfrequenz. Der Flash-Speicher kann dies nicht, und dort müssen Sie einen Frequenzteiler verwenden.

Organisation am Arbeitsplatz

Da Linux für die Arbeit mit dem Board benötigt wird, musste ich eine zusätzliche Festplatte in meinem Computer installieren und Ubuntu 16.04 darauf bereitstellen. Dieses Betriebssystem wird von STM empfohlen.

Engineering & Produktionsmodus

Die Karte kann in einem von zwei Modi starten (bestimmt durch DIP-Schalter). Im Engineering-Modus arbeitet der M4-Kern separat. Im Produktionsmodus läuft der M4-Kern unter der Kontrolle des A7-Kerns. Ich habe den Engineering-Modus nicht verwendet, sondern nur im Produktionsmodus gearbeitet. In diesem Modus müssen Sie sich keine Gedanken über das Einstellen der Kerntaktung machen. Das Timing wird während des Startvorgangs auf Maximalwerte konfiguriert. Ich überprüfte mehrere Register im Debugger, leitete einige der Frequenzen auf dem MCO ab und schaute auf das Oszilloskop. A7 arbeitet mit einer Frequenz von 650 MHz, M4 mit einer Frequenz von 208 MHz.

Kernel M4. Laden Sie Programme herunter und führen Sie sie aus

Da auf dem M4-Kern A7 ausgeführt wird, bedeutet dies, dass OpenSTLinux ausgeführt wird. Das Linux Remoteproc Framework (RPROC) wird zur Steuerung des M4-Kerns verwendet. Mit diesem Framework können Sie die Kernel-, Download- und Debug-Software (ELF-Dateien) aktivieren und deaktivieren.

Verwenden Sie den folgenden Befehl, um das Programm in den M4-Kernel zu laden:

echo -n <firmware_name.elf >> / sys / class / remoteproc / remoteproc0 / firmware

So starten Sie das Programm:

echo start> / sys / class / remoteproc / remoteproc0 / state

So stoppen Sie:

echo stop> / sys / class / remoteproc / remoteprocX / state

Kernel M4. SW4STM32

Die oben genannten Befehle wurden ausprobiert, alles funktioniert :) Aber um zu funktionieren, benötigen Sie eine Art normale IDE. STM empfiehlt hierfür die Verwendung der Software AC6 SW4STM32. Gleichzeitig hat die OpenSTM32-Website einen sehr coolen Titel:

Mit System Workbench für Linux war Embedded Linux in der STM32MP1-MPU-Familie von ST selbst für Neulinge in der Linux-Welt noch nie so einfach zu erstellen und zu warten.
Wenn Sie System Workbench für Linux in System Workbench für STM32 installieren, können Sie asymmetrische Anwendungen, die teilweise unter Linux, teilweise auf Cortex-M4 ausgeführt werden, nahtlos entwickeln und debuggen.

Das heißt, Sie können Code sowohl für den m4-Kern als auch für A7 schreiben. Dies ist jedoch eine kostenpflichtige Version. Mit der kostenlosen Version, die zum Download zur Verfügung steht, können Sie Code nur für den M4-Kern schreiben und debuggen.

IDE SW4STM32 wurde heruntergeladen, installiert und ausprobiert. Alles funktioniert, der Prozess des Schreibens und Kompilierens unterscheidet sich nicht von der Version unter Windows.
Der einzige Unterschied ist das Laden und Debuggen von Code, da Ethenet- und SSH-Verbindungen zum Schreiben von Software verwendet werden. Zum Debuggen und Stoppen von Punkten wird die integrierte ST LINK-Karte verwendet.

Kernel A7. Cross-Compiler

Zum Kompilieren von Programmen auf einem PC bietet STM einen Cross-Compiler an. Das Laden und Ausführen des Cross-Compiler-Skripts wird im STM32MP1-Wiki (Link unten) ausführlich beschrieben. Alles wurde nach den Anweisungen gemacht, alles funktioniert wie es sollte. :)

Wenn Sie den Cross-Compiler für das Ökosystem v1.1.0 ausführen:

Quell-SDK / Umgebungs-Setup-Cortexa7t2hf-Neon-Vfpv4-Openstlinux_Wweston-Linux-Gnueabi
, werden der
Befehl make
und der Quellcode laut Makefile in ARM-Codes kompiliert :)

Kernel A7. Laden Sie Programme herunter und führen Sie sie aus

Verwenden Sie zum Laden des Programms in die Demo-

Karte den folgenden Befehl: scp gtk_hello_world root@192.168.1.18: / usr / local

Dieser Befehl lädt die Datei gtk_hello_world in den Abschnitt / usr / local, der sich auf der Karte mit der IP-Adresse 192.168.1.18 befindet. Root - das Passwort, das sich standardmäßig auf der Karte befindet.

Datenaustausch zwischen den Kernen

Die meiste Zeit wurde damit verbracht, den Mechanismus des Datenaustauschs zwischen den Kernen zu verstehen. In den von STM bereitgestellten Beispielen gibt es verschiedene Möglichkeiten, einen solchen Austausch zu implementieren. Sie können direkt mit dem Treiber von OpenSTLinux aus arbeiten oder den virtuellen UART-Mechanismus verwenden. Ich habe beschlossen, das Teilen über virtuelle Ports so einfach wie möglich zu gestalten.

Auf der Linux-Seite sieht es so aus:

Öffnen Sie das Gerät:

fd = open ("/ dev / ttyRPMSG0", O_RDWR);

Dann schreiben wir darauf oder lesen:

schreiben (fd, "LED_Toggle \ r \ 0", 10);
len = read (fd, buf, sizeof (buf));

Alles ist ganz einfach, aber es gibt eine kleine Nuance. Damit das ttyRPMSG0-Gerät angezeigt wird, benötigen Sie den M4-Kern, um in dieser Form auf den A7-Kern zuzugreifen:

Dies sind die Zeilen des M4-Kerncodes:

VIRT_UART_Init(&huart0); //  
VIRT_UART_RegisterCallback(&huart0, VIRT_UART_RXCPLT_CB_ID, VIRT_UART0_RxCpltCallback) //      .

Empfang von Daten von einem virtuellen Port durch den M4-Kern:

if (VirtUart0RxMsg)
{
      //     VirtUart0ChannelBuffRx
     
      VirtUart0RxMsg = 0;
}

Daten in den virtuellen Port schreiben:

VIRT_UART_Transmit(&huart0, TxArray, TXCounter);

Alles funktioniert, aber es gibt eine kleine Nuance, die ich noch nicht verstehen kann. Der Empfang von Daten durch den A7-Kern, der vom M4-Kern übertragen wird, startet erst, wenn der A7-Kern zuvor Daten in den Port geschrieben hat.

Dieser gesamte Mechanismus wird von einer Reihe von OpenAMP-Bibliotheken von Drittanbietern implementiert. Diese Bibliothek sollte in das M4-Kernel-Projekt aufgenommen und entsprechend initialisiert werden.

Zukunftspläne

Installieren und konfigurieren Sie Eclipse zum Schreiben und Debuggen von Code für A7.
Schreiben Sie eine normale grafische Demo, z. B. ein Oszilloskop von einem M4-ADC.
Und schließlich machen Sie Ihre Controller-Karte basierend auf diesem Chip. :) Wiki

Nützliche Links

STM32MP1
OpenSTM32
ST Community
AC6

STM32MP1 - Kernel + Linux = perfekter Mikrocontroller