16. Arduino für die Produktion!! Wie man ein LCD an den ARM-Mikrocontroller anschließt Teil 2
Teilen
Dieses Tutorial wird sich ein wenig von den typischen Arduino-Tutorials und der Toolchain, mit denen Sie vielleicht vertraut sind, unterscheiden. Das hat einen guten Grund, denn ich bringe Ihnen bei, wie man ein Produktionsentwickler und -ingenieur wird, anstatt ein einmaliger Projektbastler zu sein. Mit diesen Informationen lernen Sie, wie Sie in diesem Bereich effizient und kostengünstig arbeiten können.
Hier ist die grundlegende Schaltung, die zeigt, wie der Strom entlang der Breadboard-Stromschienen und der Platine mit dem Arduino ARM Mikrocontroller verteilt wird. Wie Sie dies verkabeln, erfahren Sie im Tutorial ___________.
Wir werden uns auf die Pins 33, 34, 35, 36, 37, 38, 39 und 40 konzentrieren. Wir wollen diese Pins auf Befehl zum Leuchten bringen, daher müssen wir jedem der zugehörigen Host-Anschlussstreifen einen Widerstand und eine LED hinzufügen. Da die LEDs größer sind als der Abstand der Anschlussstreifen, sollten Sie die Anschlussdrähte so biegen, dass die LED versetzt ist. Achten Sie genau darauf, die Anschlussdrähte so zu biegen, dass alle Anoden auf einer Seite und die Kathoden auf der anderen Seite sind, der LED-Teil jedoch versetzt ist. Fahren Sie fort und setzen Sie die LEDs wie im Bild gezeigt ein.
Da nun alle LEDs mit dem Breadboard verbunden sind und Verbindungen zu den Pins 33-40 des Arduino ARM Mikrocontrollers herstellen, erstellen wir ein neues Projekt und einen neuen Code, damit wir die Ausgabe sehen und die LEDs testen können.
Erstellen Sie ein neues Projekt in CoIDE.
Wählen Sie den STM32F030R8T8 Arduino ARM Mikrocontroller oder den Arduino, den Sie verwenden.
Auf der Bibliotheksseite gibt es ein paar Änderungen, wo Sie bestimmte Bibliotheken für das Projekt hinzufügen oder entfernen. Sie sehen unten auf der Seite eine Bibliothek, die speziell mit dem von Ihnen verwendeten Arduino-Mikrocontroller verbunden ist und STM32F030x8_CUBELIB heißt. Der Dateiname, den Sie sehen, kann anders sein, wenn Sie einen anderen Arduino als meinen verwenden; er sollte jedoch immer noch CUBELIB als Suffix haben. Fügen Sie diese Bibliotheksdatei hinzu, und Sie werden sehen, dass sie auch automatisch die cmsis_core-Bibliothek sowie die Bibliothek mit dem Suffix CUBELIB enthält.
Nachdem Sie die Bibliotheken hinzugefügt haben, können Sie im linken Bereich der Entwicklungsumgebung auf main.c doppelklicken. Dadurch wird die Datei main.c geöffnet und Ihnen der Gerüstcode im Programmiercodebereich angezeigt, der einfach sein wird:
int main(void)
{
{
while(1)
{
}
} {
}
Der erste Code, den wir schreiben müssen, ist das Hinzufügen der Include-Datei an den Anfang unseres Programms. Dieses Include holt alle Register-Spezifikationen, Makros und definierten Variablen des Arduino MCU in das Programm, so dass wir im Programm auf diese Register zugreifen können. Die Register sind nur einfache Bit-Level-Schalter, die wir ein- und ausschalten werden, um verschiedene Funktionen im Arduino ARM Mikrocontroller zu steuern. Dieser Code steht in der ersten Zeile des Programms.
#include "stm32f0xx.f"
Der nächste Code, den wir schreiben müssen, ist, die LEDs zu testen, um zu sehen, ob sie auf Befehl ein- und ausgeschaltet werden. Es gibt eine Reihe von Registern, um die Pins für General Purpose Input and Output (GPIO) zu steuern. In diesem Fall werden wir diese Pins auf Ausgang setzen, da wir ein High oder Low an die LEDs ausgeben wollen und keine Informationen von den LEDs empfangen. Der GPIO-Port muss mit dem RCC (Reset Clock and Control Register) unter dem AHB (Advanced High Performance Bus) aktiviert werden, aber machen Sie sich keine Sorgen über den komplizierten Jargon, es ist einfach. Die Register, die wir ändern müssen, sind der Modus, der Typ, die Geschwindigkeit und der PUPD (Pull-up oder Pull-down) für jeden Pin. Dann werden wir ein High (3,3 Volt) an jedem Pin ausgeben.
Beginnend mit der Aktivierung des GPIO Port B und Port C:
RCC_>AHBENR |= RCC_AHBENR_GPIOBEN;
RCC_>AHBENR |= RCC_AHBENR_GPIOBEN;
RCC_>AHBENR |= RCC_AHBENR_GPIOBEN;
Jetzt wollen wir den Pin (welchen Pin wir steuern wollen) auf Ausgang stellen. Dazu müssen wir den spezifischen Pin finden, den wir als Ausgang einstellen wollen. In diesem Fall interessieren wir uns für Pin 12 an Port B.
Da wir möchten, dass Bit 0 von Pin 12 eine 1 und Bit 1 von Pin 12 eine 0 ist, verwenden wir das bitweise "oder" oder "|" um das Bit zu setzen und die bitweise Operation "und nicht" oder "& ~" um zu setzen.
GPIOB->MODER |= GPIO+MODER_MODER12_0;
GPIOB->MODER &= ~GPIO+MODER_MODER12_1;
GPIOB->MODER &= ~GPIO+MODER_MODER12_1;
Da wir wissen, welche Bits auf 01 gesetzt werden müssen, können wir einfach alle Pins in einer Zeile mit einer Standard-Binärzahl für dieses Register setzen:
GPIOB->MODER = 0b01010101000000000000000000000000;
Wenn Sie stattdessen eine Hexadezimalzahl für diese Anweisung verwenden möchten, können Sie einen Online-Binär-zu-Hexadezimal-Konverter verwenden, und Sie werden feststellen, dass diese Zahl 0x55000000 ist.
Werfen wir nun einen Blick auf die Typ-, Geschwindigkeits- und PUPD-Register. Da wir in allen Bits des Typ-Registers Nullen benötigen, ist das Ausgangs-Typ-Register einfach gleich Null. Seien Sie vorsichtig, wenn Sie alle Bits auf diese Weise zuweisen. Wenn Sie Bits für andere Funktionen oder Operationen setzen, werden diese Bits ebenfalls gelöscht. Der hier eingestellte Ausgabetyp ist Output-Push-Pull.
GPIOB->OTYPER = 0;
Weiter geht es mit dem Geschwindigkeitsregister. Wenn Sie das Datenblatt für das Ausgangsgeschwindigkeitsregister betrachten, werden Sie feststellen, dass der Reset-Wert für dieses Register 0x0c000000 beträgt. Das C in dieser Zahl steht für die Programmierpins. Diese müssen gesetzt und dürfen nicht geändert werden (es sei denn, Sie möchten den Chip nicht neu programmieren). Hinweis: Wenn Sie diesen Reset-Wert an diesen Pins ändern, können Sie eine spezielle Löschung des Flash-Speichers durchführen. Die anderen Register für Port A haben ebenfalls einen speziellen Reset-Wert für die Programmierpins.
Der Code für das Ausgangsgeschwindigkeitsregister für alle Hochgeschwindigkeits-Pins, die uns interessieren, lautet:
GPIOB->OSPEEDR = 0b11111111000000000000000000000000;
Das PUPD (Pull Up Pull Down) Register sollte laut Datenblatt ebenfalls ausschließlich Nullen enthalten:
Der Code für die PUPD-Register an Port B ist einfach:
GPIOB->PUPD = 0;
Port C muss auf die gleiche Weise eingestellt werden, aber mit anderen Pins. Werfen wir einen Blick darauf, welche Pins wir an Port C verwenden.
Da wir die zu setzenden Bits kennen und das Datenblatt zur Hand haben, um zu sehen, wo die Bits für die Pins 6, 7, 8 und 9 an Port C gesetzt werden müssen, können wir einfach GPIOB kopieren und ein Set von Anweisungen für GPIOC erstellen.
GPIOC->MODER = 0b00000000000001010101000000000000;
GPIOC->OTYPER = 0;
GPIOC->OSPEEDR = 0b00000000000011111111000000000000;
GPIOC->PUPD = 0;
GPIOC->OTYPER = 0;
GPIOC->OSPEEDR = 0b00000000000011111111000000000000;
GPIOC->PUPD = 0;
Jetzt sind wir bereit, die LEDs einzuschalten. Dazu müssen wir auf das BSRR (Bit Set/Reset Register) für Port B und Port C zugreifen. Die BS (Bit Set) Bits schalten den Pin ein (bringen den Pin auf High, so dass die LED leuchtet). Um den Pin auszuschalten, würden Sie das BR (Bit Reset) Bit verwenden, indem Sie dieses Bit auf "1" setzen, was den Pin auf Low setzt.
GPIOB->BSRR = 0b00000000000000001111000000000000;
GPIOC->BSRR = 0b00000000000000000000001111000000;
GPIOC->BSRR = 0b00000000000000000000001111000000;
Bislang ist hier der Code zur Konfiguration der Pins 33-40 als Ausgang und zum Einschalten der Pins:
#include "stm32f0xx.f"
int main(void)
{
int main(void)
{
RCC_>AHBENR |= RCC_AHBENR_GPIOBEN;
RCC_>AHBENR |= RCC_AHBENR_GPIOBEN;
GPIOB->MODER = 0b01010101000000000000000000000000;
GPIOB->OTYPER = 0;
GPIOB->OSPEEDR = 0b11111111000000000000000000000000;
GPIOB->PUPD = 0;
GPIOC->MODER = 0b00000000000001010101000000000000;
GPIOC->OTYPER = 0;
GPIOC->OSPEEDR = 0b00000000000011111111000000000000;
GPIOC->PUPD = 0;
while(1)
{
}
}RCC_>AHBENR |= RCC_AHBENR_GPIOBEN;
GPIOB->MODER = 0b01010101000000000000000000000000;
GPIOB->OTYPER = 0;
GPIOB->OSPEEDR = 0b11111111000000000000000000000000;
GPIOB->PUPD = 0;
GPIOC->MODER = 0b00000000000001010101000000000000;
GPIOC->OTYPER = 0;
GPIOC->OSPEEDR = 0b00000000000011111111000000000000;
GPIOC->PUPD = 0;
while(1)
{
}
Hier ist das Ergebnis, nachdem wir den Code erstellt (den Code kompiliert) und den STM32 Arduino Mikrocontroller geflasht haben:
[[TUTORIALMENU(tutorial-arm" frameborder="0" allowfullscreen>