Um die Benutzerfreundlichkeit der funktionsreichen und energieeffizienten Mikrocontroller-Familie STM32 zu verbessern, hat ST 2019 das STM32Cube-Software-Ökosystem um ein kostenloses, multifunktionales STM32-Entwicklungstool erweitert: die STM32CubeIDE.
Um genauso gut zu funktionieren wie kommerzielle integrierte Entwicklungsumgebungen (IDE-Tools), nutzt STM32CubeIDE die Technologie von Atollic® voll aus, einem Anbieter von Embedded-Entwicklungstools, der 2017 von STMicroelectronics übernommen wurde. Unter Verwendung von offenen Lizenzbedingungen nach Industriestandard bietet diese IDE-Software STM32-spezifische Funktionen zur Vereinfachung und Beschleunigung von STM32-basierten Embedded-Designs, darunter leistungsstarke STM32CubeMX-Mikrocontroller-Konfigurations- und Projektmanagement-Tools.
Durch die Integration von STM32CubeMX in STM32CubeIDE hat ST eine leistungsfähigere Entwicklungsumgebung geschaffen. Das komplette STM32Cube-Ökosystem umfasst auch den Code-Brenner STM32CubeProgrammer und die Code-Run-Monitor-Familie STM32CubeMonitor sowie zahlreiche eigenständige MCU-Firmware-Pakete.
Was ist STM32CubeIDE?
STM32CubeIDE ist ein offizielles kostenloses Software-Entwicklungswerkzeug von ST, das auf dem Eclipse®/CDT-Framework, der GCC-Kompilierungswerkzeugkette und dem GDB-Debugging-Werkzeug basiert und das Hinzufügen von Funktions-Plug-ins von Drittanbietern unterstützt. Gleichzeitig integriert STM32CubeIDE einige der Funktionen von STM32CubeMX und STM32CubeProgrammer.
Mit STM32CubeIDE können Entwickler alles von der Chipauswahl über die Projektkonfiguration und Codegenerierung bis hin zur Code-Bearbeitung, Kompilierung, Fehlerbehebung und Brennen durchführen.
STM32CubeIDE-Funktionen
1. STM32CubeMX integrieren:
- Auswahl des STM32-Mikrocontrollers
- Pin-Zuweisungen, Takte, IP- und Middleware-Konfiguration
- Projekterstellung und Generierung des Initialisierungscodes
2. Basierend auf Eclipse/CDT, Unterstützung von Eclipse-Plug-ins, Verwendung der ARM-Toolkette und des GDB-Debuggers in GNU C/C++.
3. Weitere erweiterte Debugging-Funktionen:
- CPU-Kerne, IP-Register und Speicheransichten
- Live-Variablenüberwachung
- Systemanalyse und Live-Tracking (SWV)
- CPU-Fehleranalyse-Tool
4. Unterstützung von ST-LINK- und J-Link-Debug-Probe
5. Unterstützung für den Import von Projekten aus TrueSTUDIO und AC6 (SW4STM32)
6. Unterstützte Betriebssysteme: Windows, Linux und MacOS
STM32CubeIDE herunterladen
Hier ist der offizielle Download-Link:
https://www.stmicroelectronics.com.cn/en/development-tools/stm32cubeide.html
STM32CubeIDE-Arbeitsbereich
STM32CubeIDE ist ein Eclipse-basiertes Framework, das einige der Funktionen von Eclipse übernimmt, die den Benutzern nicht vertraut sind, wie z. B. Perspektivenansichten, Arbeitsbereiche usw.
Arbeitsbereich: STM32CubeIDE verwaltet Projekte über Arbeitsbereiche. Beim Öffnen von STM32Cube wird ein neuer Standardarbeitsbereich erstellt. Das neue oder importierte Projekt gehört zu diesem Arbeitsbereich. Die Projekte im selben Arbeitsbereich haben die gleiche IDE-Konfiguration (festgelegt unter „Window→Preferences“), z. B. die Einstellungen für die Anzeige und den Bearbeitungsstil. Aus Sicht des Dateisystems ist ein Arbeitsbereich ein Ordner, der mehrere Projektordner und einen Ordner namens „.metadata“ enthält, der Informationen zu allen Projekten in diesem Arbeitsbereich enthält. Der Ordner „.metadata“ enthält Informationen zu allen Projekten im Arbeitsbereich. Der Benutzer kann über das Menü „Datei→Arbeitsbereich wechseln“ zwischen Arbeitsbereichen wechseln.
Perspektive: Eine Perspektive ist eine Reihe von Fenstern, die sich auf eine bestimmte Art von Funktion beziehen. Häufig verwendet werden die C/C++-Bearbeitungsperspektive, die Debug-Perspektive und die CubeMX-Konfigurationsperspektive.
Die C/C++-Bearbeitungsperspektive umfasst den Projektmanager, das Bearbeitungsfenster, das Gliederungsfenster usw. Mit dem Projektmanager können Sie alle Projekte im aktuellen Arbeitsbereich anzeigen und bearbeiten. Doppelklicken Sie, um eine Datei im Projekt zu öffnen. Der Inhalt der Datei wird im Bearbeitungsfenster angezeigt, wo Sie ihn bearbeiten können. Das Gliederungsfenster ganz rechts listet alle Funktionen, Variablen und Makros auf, die in der aktuell geöffneten Datei definiert sind.
Über das Menü „Fenster anzeigen“ können Sie die Fenster öffnen und schließen, die in der C/C++-Bearbeitungsperspektive angezeigt werden sollen.
Sie können zwischen verschiedenen Perspektivenansichten wechseln, indem Sie die Symbole oben rechts verwenden. Wenn Sie beispielsweise auf das Crawler-Symbol klicken, können Sie zur Debug-Perspektivenansicht wechseln. Durch Klicken auf die Schaltfläche „Debug“ in der Symbolleiste unter der C/C++-Bearbeitungsansicht wird nach dem Start des Debuggens ebenfalls automatisch zur Debug-Perspektivenansicht gewechselt.
Wie verwendet man STM32CubeIDE?
1. Projektmanagement
Neues Projekt erstellen
Mit STM32CubeIDE können Benutzer auf verschiedene Weise ein neues Projekt starten. Der Begrüßungsbildschirm von STM32CubeIDE listet die Verknüpfungseinstiegspunkte zum Erstellen/Importieren eines Projekts auf, die den vier unten aufgeführten Szenarien entsprechen. Die entsprechenden Funktionen können auch über „Neu“ und „Importieren“ im Menü „Datei“ aufgerufen werden.
- Ein neues STM32-Projekt von Grund auf neu erstellen
- Es gibt bereits eine STM32CubeMX-Konfigurationsdatei (*.ioc-Datei) und Sie möchten ein neues STM32-Projekt auf Basis dieser ioc-Datei erstellen.
- Ich habe bereits ein SW4STM32- oder TrueSTUDIO-Projekt und möchte es in ein STM32CubeIDE-Projekt konvertieren.
- Erstellen Sie ein neues Projekt basierend auf den Routinen in der STM32Cube-Bibliothek
STM32CubeIDE-Projektstruktur
STM32CubeIDE verfügt über zwei Projektstrukturen, wie in der folgenden Abbildung dargestellt.
Die Single-Core-MCUs sind flache Strukturen.
Bei Dual-Core-Architektur-MCUs oder Sicherheits-MCUs wie den Serien STM32H7, STM32L5 und STM32MP1 ist das STM32CubeIDE-Projekt eine hierarchische Struktur. Nehmen wir STM32H7 als Beispiel: Nach dem Erstellen oder Importieren eines STM32H7-Projekts sehen Sie in der Projekt-Explorer-Leiste eine dreistufige Projektstruktur: Die oberste Ebene ist das „Stammprojekt“, darunter befinden sich zwei „Unterprojekte“, die jeweils den CM7- und CM4-Kernen entsprechen. Die oberste Ebene ist das „Stammprojekt“, darunter befinden sich zwei „Unterprojekte“, die den CM7- und CM4-Kernen entsprechen, und die Projektdateien befinden sich unter den „Unterprojekten“. Diese beiden CM7- und CM4-„Unterprojekte“ sind die eigentlichen kompilierbaren und debugbaren Projekte, während das „Stammprojekt“ lediglich ein „Container“ ist, der die CM7- und CM4-„Unterprojekte“ enthält. AN5361, AN5394, AN5360 und AN5564 beschreiben, wie man STM32H7-Dual-Core-, STM32L5-, STM32MP1- und STM32WL-Projekte in STM32CubeIDE erstellt, importiert, kompiliert und debuggt.
Verwaltung der Firmware-Bibliothek
STM32CubeIDE integriert einige der Funktionen von STM32CubeMX, sodass Sie ein neues Projekt erstellen können, indem Sie direkt das Chip-/Entwicklungsboard-Modell oder eine Routine auswählen. Der Treiber und der Routinecode, die zum Erstellen eines Projekts mit STM32CubeIDE erforderlich sind, stammen aus den Firmware-Bibliotheken der jeweiligen STM32-Familie.
Unter „Hilfe→Embedded-Softwarepakete verwalten” können alle STM32-Firmware-Bibliotheken und andere Plug-ins verwaltet werden (Firmware-Bibliotheken installieren/entfernen).
Mit der Schaltfläche „Jetzt installieren“ kann STM32CubeIDE automatisch aus dem Netzwerk herunterladen und installieren, und mit der Schaltfläche „Von lokal“ können Sie vorab heruntergeladene Firmware-Bibliotheken installieren.
Mit der Schaltfläche „Jetzt entfernen“ können Sie die ausgewählte Firmware-Bibliothek entfernen.
Unter der Registerkarte „STM32Cube Firmware Updater“ im Fenster „Window Preferences“ können Sie den Pfad zur Installation der Firmware-Bibliothek und die Art der Aktualisierung festlegen.
Netzwerkkonfiguration
Standardmäßig versucht STM3CubeIDE beim Öffnen und Erstellen eines neuen Projekts, eine Verbindung zum Netzwerk herzustellen. Sie können auch den „Offline-Modus“ wählen, um zu verhindern, dass STM32CubeIDE eine Verbindung zum Netzwerk herstellt. Allerdings müssen Sie die vorab heruntergeladenen Firmware-Bibliotheken über die Schaltfläche „From Local“ im Fenster „Embedded Software Packages Manager“ im vorherigen Bild installieren, da sonst der Code für das neue STM32-Projekt nicht automatisch generiert wird.
Klicken Sie auf die Schaltfläche „Verbindung prüfen“, um den aktuellen Status der Netzwerkverbindung zu überprüfen. Wenn am Ende der Überprüfung ein rotes X angezeigt wird, bedeutet dies, dass ein Problem mit der Netzwerkkonfiguration vorliegt und wir zur Seite „Netzwerkverbindung“ gehen müssen, um diese einzustellen.
Zusätzlich zur zuvor aktiven Netzwerkstatuserkennung sollten Sie bei einem Fehlschlag des Firmware-Downloads auch überprüfen, ob die Netzwerkkonfiguration von STM32CubeIDE korrekt ist.
Die Konfigurationsschritte sind in der folgenden Abbildung dargestellt:
1. Gehen Sie zum Menü „Window Preferences“ (Fenster-Einstellungen) und wählen Sie die Registerkarte „General Network Connections“ (
Allgemeine Netzwerkverbindungen). 2. Wählen Sie die manuelle Methode
. 3. Wählen Sie „HTTP“ und doppelklicken Sie, um das Bearbeitungsfenster zu öffnen und die Netzwerkverbindungsparameter festzulegen.
STM32CubeIDE-Projekte öffnen/schließen/löschen/umschalten/exportieren
Im Projekt-Explorer-Fenster können Sie alle Projekte unter dem aktuellen Arbeitsbereich sehen. Benutzer können in diesem Fenster jedes Projekt öffnen/schließen/löschen/importieren/exportieren/umbenennen.
2. Code-Kompilierung
Eigenschaften einstellen und kompilieren
Wählen Sie ein Projekt im Projekt-Explorer aus, klicken Sie mit der rechten Maustaste darauf und öffnen Sie das Eigenschaftenmenü, in dem Sie die Kompilierungselemente konfigurieren können.
Sobald die Konfiguration abgeschlossen ist, kann das Projekt kompiliert werden. Sie können die Kompilierung auf drei Arten starten: –
Methode 1: Wählen Sie das Projekt aus, klicken Sie mit der rechten Maustaste darauf und wählen Sie „Projekt erstellen”.
– Methode 2: Wählen Sie das Projekt aus, rufen Sie es über das Menü „Projekt” auf und wählen Sie dann „Projekt erstellen”.
– Methode 3: Wählen Sie das Projekt aus und klicken Sie auf das Symbol „Erstellen” in der Symbolleiste.
Kompilierungsgeschwindigkeit verbessern
Durch die Aktivierung der parallelen Kompilierung können Sie die Kompilierungsgeschwindigkeit der STM32Cube IDE verbessern.
Wählen Sie das Projekt aus, klicken Sie mit der rechten Maustaste darauf und öffnen Sie das Eigenschaftenmenü. Wählen Sie „C/C++ Build“ und aktivieren Sie unter der Registerkarte „Verhalten“ die Option „Parallele Kompilierung aktivieren“.
Hilfswerkzeuge für die Kompilierung
Nach der Kompilierung des Projekts zeigt das Fenster „Build Analyzer“ die Nutzung aller in der Link-Datei definierten Speicherbereiche und -abschnitte an, einschließlich der Ladeadresse, der Ausführungsadresse, der belegten Bytes, der verbleibenden Bytes usw.
Das Fenster „Static Stack Analyzer“ zeigt die Nutzung des statischen Stacks an.
STM32CubeIDE bietet auch eine Headless-Build-Funktion, mit der Sie über die Befehlszeile kompilieren können, ohne die CubeIDE-GUI zu öffnen.
3. Code-Debugging und Brennen
Debug- und Ausführungskonfiguration
Nachdem das STM32CubeIDE-Projekt ohne Fehler kompiliert wurde, ist es bereit für das Debuggen und Herunterladen.
In der Symbolleiste der C/C++-Perspektive gibt es drei Schaltflächen für das Herunterladen und Debuggen: Debug, Run und External Tools.
Das kleine Dreieck neben der Schaltfläche „Debug“ öffnet das Menü „Debug Configurations“ (Debug-Konfigurationen), in dem Sie Debugging-Parameter wie Debugger-Auswahl, GDB-Verbindungseinstellungen, ST-LINK-Einstellungen, externe Flash-Loader-Einstellungen usw. konfigurieren und das Debugging starten können.
Mit der Schaltfläche „Ausführen“ können Sie das Programm nur herunterladen, ohne das Debugging zu starten.
Mit der Schaltfläche „Externe Tools“ können Sie externe Befehlszeilentools aufrufen.
Debugging starten
STM32CubeIDE verwendet GDB zum Debuggen, unterstützt STLink- und SEGGER J-Link-Debugger und ermöglicht die Verbindung zur Ziel-MCU über die SWD- oder JTAG-Schnittstelle.
Nachdem das STM32CubeIDE-Projekt kompiliert wurde, kann das Debugging direkt durch Klicken auf das Crawler-Symbol in der Symbolleiste oder durch Auswahl des Menüs „Run–>Debug“ gestartet werden.
Wenn Sie das aktuelle Projekt zum ersten Mal debuggen, kompiliert STM32CubeIDE zunächst das Projekt und öffnet dann das Debug-Konfigurationsfenster. Das Debug-Konfigurationsfenster enthält Optionen für die Auswahl der Debug-Schnittstelle, STLink-Einstellungen, Reset-Einstellungen und externe Flash-Loader-Einstellungen usw. Benutzer können die Konfigurationen überprüfen oder ändern. Nachdem Sie sich vergewissert haben, dass alle Konfigurationen korrekt sind, können Sie auf „OK“ klicken, um mit dem Debuggen zu beginnen.
Anschließend lädt STM32CubeIDE zunächst das Programm auf die MCU herunter und startet dann die Ausführung ab dem in der Link-Datei (*.ld) angegebenen Programmeinstieg. Das Programm startet die Ausführung standardmäßig ab Reset_Handler und pausiert an der ersten Zeile der Hauptfunktion, wo es auf den nächsten Debug-Befehl wartet.
Grundlegende Debugging-Vorgänge
Nach dem Start des Debuggens wechselt STM32CubeIDE automatisch zur Debug-Perspektive, und die Schaltflächen für den Debug-Vorgang werden in der Symbolleiste der Debug-Perspektive angezeigt. Wie in der Abbildung unten dargestellt.
4. Verwendung von Plugins
STM32CubeIDE unterstützt auch Eclipse-Plugins. Es gibt zwei Methoden, um diese zu installieren:
- Installation über den „Eclipse Marketplace” im Menü „Hilfe”;
- Installation über „Neue Software installieren” im Menü „Hilfe”.
STM32CubeIDE-Programmierbeispiel
Lassen Sie uns den Prozess der Softwareentwicklung mit STM32CubeIDE anhand einer LED-Blinkroutine erleben.
Die Routine verwendet das Entwicklungsboard NUCLEO-H743ZI und erstellt über STM32CubeIDE ein neues Projekt von Grund auf. Das Projekt implementiert dann eine einfache Funktion: Die integrierte LED1 blinkt automatisch in Intervallen von 500 ms.
Aus diesem Programmierbeispiel können wir Folgendes lernen:
- Erstellen eines neuen STM32CubeIDE-Projekts
- Konfigurieren Sie den STM32-Chip
- Benutzercode hinzufügen und kompilieren
- Debug-Parameter festlegen
- Code debuggen (Variablen und Register anzeigen)
- Setzen Sie Breakpoints
Wählen Sie zunächst „Datei“ –> „Neu“ –> „STM32-Projekt“. STM32CubeIDE öffnet das Fenster zur Auswahl der MCU. In diesem Fenster können Sie ein bestimmtes Chipmodell oder ein bestimmtes ST-Entwicklungsboard oder eine bestimmte Routine auswählen. Hier geben wir „STM32H743ZI“ in das Suchfeld ein. Sie können diesen Chip direkt auswählen und dann auf „Weiter“ klicken.
Im nächsten Popup-Fenster müssen Sie den Projektnamen, den Typ und den Speicherort für das Projekt festlegen. Standardmäßig wird das neue Projekt im aktuellen Arbeitsbereich gespeichert, aber Sie können auch die Option „Standardort verwenden“ deaktivieren und den Speicherort des Projekts wie unten gezeigt anpassen. Beachten Sie, dass es bei der Erstellung später zu einem Fehler kommen kann, wenn Sie versuchen, zwei Projekte unter demselben Pfad abzulegen. Sie können daher den Projektnamen zum Pfad hinzufügen, um verschiedene Projekte zu unterscheiden.
Nachdem die Einrichtung abgeschlossen ist, klicken Sie auf „Fertigstellen“ und STM32CubeIDE erstellt ein Projekt für uns und öffnet die Konfigurationsoberfläche des Chips, die mit der von STM32CubeMX identisch ist.
Währenddessen wird möglicherweise ein Popup-Fenster angezeigt, in dem Sie die CubeMX-Konfigurationsperspektive öffnen können. Klicken Sie auf „Ja“, und Sie sind fertig.
Als Nächstes müssen Sie die Uhr, GPIO, Peripheriegeräte, Middleware usw. gemäß den funktionalen Anforderungen im Chip-Konfigurationsbildschirm konfigurieren. In dieser Routine verwenden wir nur PB0, das als Ausgang zur Steuerung von LED1 dient, sodass wir nur dieses konfigurieren müssen. Die Uhr verwendet einfach die Standardkonfiguration.
Unter „Pinout View“ kann der zu konfigurierende Pin mithilfe der Suchleiste schnell im Chip-Paketdiagramm gefunden werden.
Wählen Sie den Pin aus, klicken Sie mit der rechten Maustaste darauf und wählen Sie die Funktion „GPIO_Output“.
Gehen Sie dann zur Systemansicht, klicken Sie auf das GPIO-Modul, und Sie sehen den soeben konfigurierten PB0-Pin. In diesem Fenster können Sie auch weitere Parameter von PB0 anpassen, z. B. Pull-up/Pull-down, Geschwindigkeit usw. Es ist auch möglich, eine Benutzerbezeichnung LDE1 dafür zu definieren, die im Code leicht zu referenzieren ist.
Nachdem alle Konfigurationen vorgenommen wurden, wählen Sie „Projekt“ –> „Code generieren“, um den Code neu zu generieren. An dieser Stelle wechselt STM32Cube zur C/C++-Perspektive, und Sie können die Benutzerdatei hinzufügen oder Änderungen an einer C-Datei vornehmen.
Hier fügen wir einen Code hinzu, der PB0 umschaltet. Beachten Sie, dass der gesamte vom Benutzer hinzugefügte Code zwischen den Deklarationen „USER CODE BEGIN xxx“ und „USER CODE END xxx“ platziert werden muss. Auf diese Weise geht dieser Teil des Codes nicht verloren, wenn der Code erneut generiert wird.
Nachdem der Code hinzugefügt wurde, klicken Sie auf „Build”, um die Kompilierung zu starten.
Wenn die Kompilierung abgeschlossen ist und keine Fehler gemeldet werden, können Sie auf „Debug“ klicken, um mit dem Debuggen zu beginnen.
Wenn Sie das Debugging zum ersten Mal starten, wird ein Fenster zur Konfiguration der Debug-Parameter angezeigt. Vergewissern Sie sich, dass alle Parameter korrekt sind, klicken Sie auf „OK“, und STM32CubeIDE wechselt automatisch von der Bearbeitungsoberfläche zur Debug-Oberfläche. Wie in der Abbildung unten gezeigt.
In der Debug-Oberfläche können Sie mit den Aktionsschaltflächen in der Symbolleiste in einem einzigen Schritt debuggen.
Doppelklicken Sie auf die Markierungsleiste ganz links in einer Codezeile, um an dieser Stelle einen Haltepunkt einzufügen.
Auf der rechten Seite werden mehrere Debugging-Fenster geöffnet, darunter: lokale Variablen, Haltepunkte, globale Variablen und Register usw. Diese Fenster können im Menü „Fenster –> Ansicht anzeigen“ geöffnet oder geschlossen werden.
STM32CubeIDE vs. STM32CubeMX
STM32Cube IDE ist eine integrierte Entwicklungsumgebung (IDE) für die Entwicklung von Anwendungen auf STM32-Mikrocontrollern. Basierend auf der Eclipse-Plattform integriert STM32Cube IDE STM32CubeMX, Debugger, Editoren, Compiler und andere Tools und bietet Entwicklern eine umfassende Umgebung. Die STM32Cube IDE bietet Debugging-Funktionen, Versionskontrolle, Code-Bearbeitung und Build-Funktionen, sodass Entwickler den gesamten Entwicklungsprozess in einer einheitlichen Oberfläche durchführen können.
STM32CubeMX ist ein grafisches Konfigurationstool zur Initialisierung von STM32-Mikrocontrollern und zur Generierung von Initialisierungscode. Es bietet eine intuitive Benutzeroberfläche, über die Anwender Mikrocontroller-Modelle auswählen, Peripheriegeräte und Pin-Zuordnungen konfigurieren und den entsprechenden Initialisierungscode generieren können. STM32CubeMX kann auch FreeRTOS-Konfigurationsdateien generieren, den Taktbaum konfigurieren und Interrupt-Prioritäten festlegen. Der generierte Code kann in verschiedene integrierte Entwicklungsumgebungen (IDEs) wie Keil oder IAR integriert werden, um die Anwendungsentwicklung fortzusetzen.
| Feature | STM32CubeMX | STM32Cube IDE |
|---|---|---|
| Purpose | Configuration tool for STM32 MCUs | Full IDE for application development |
| Functionality | Initializes MCUs, configures peripherals, generates code | Code writing, debugging, building, and compiling |
| Platform | Standalone, integrates with Keil, IAR | Built on Eclipse, integrates CubeMX, debugging tools |
| Code Generation | Generates initialization code for external IDEs | Develops and compiles applications directly |
| User Interface | Graphical interface for configuration | Full IDE with editing and debugging tools |
| Use Case | Set up peripherals and generate base code | Write, build, and debug applications |
Häufig gestellte Fragen zu STM32CubeIDE
Kann STM32CubeIDE nach der Kompilierung BIN- oder HEX-Dateien generieren?
Standardmäßig generiert STM32CubeIDE nach der Kompilierung ELF-Dateien. Es unterstützt jedoch auch die Generierung von HEX- oder BIN-Dateien. Der Konfigurationsprozess läuft wie folgt ab: Gehen Sie zum Hauptmenü Project > Properties > C/C++ Buildund öffnen Sie die Einstellungen, in denen Sie das Ausgabeformat konfigurieren können.
Unterstützt es die Integration mit STM32CubeMX?
Ja, auf jeden Fall. STM32CubeIDE integriert STM32CubeMX tatsächlich als Modul in seine Entwicklungsumgebung. Beim Erstellen eines neuen Projekts in CubeIDE wird STM32CubeMX automatisch aufgerufen, damit Benutzer grafische Initialisierungskonfigurationen vornehmen können.
Warum generiert STM32CubeIDE keinen Code?
Es kann mehrere Gründe geben, warum STM32CubeIDE keinen Code generiert:
- Stellen Sie sicher, dass STM32CubeMX ordnungsgemäß integriert ist und während der Projekterstellung aufgerufen wird.
- Überprüfen Sie, ob Sie den Mikrocontroller und seine Peripheriegeräte in STM32CubeMX ordnungsgemäß konfiguriert haben, bevor Sie versuchen, den Code zu generieren.
- Überprüfen Sie die Einstellungen im Abschnitt
Project > Properties, insbesondere die Optionen zur Codegenerierung. - Stellen Sie sicher, dass keine Fehler oder fehlenden Konfigurationen vorliegen, die die Codegenerierung verhindern könnten.
