Arduino mit Python: Erste Schritte

Microcontrollers gibt es schon seit langer Zeit und sie werden in allen Bereichen eingesetzt, von komplexen Maschinen bis hin zu herkömmlichen Haushaltsgeräten. Die Arbeit mit ihnen ist jedoch traditionell denjenigen vorbehalten, die eine formelle technische Ausbildung haben, wie z. B. Techniker und Elektrotechniker. Das Aufkommen von Arduino hat das elektronische Anwendungsdesign für alle Entwickler viel zugänglicher gemacht. In diesem Tutorial erfahren Sie, wie Sie mit Arduino mit Python Ihre eigenen elektronischen Projekte entwickeln.

*Sie werden die Grundlagen von Arduino mit Python behandeln und lernen, wie Sie:*

Richten Sie elektronische Schaltkreise ein
Richten Sie das Firmata-Protokoll auf Arduino ein
Schreiben Sie grundlegende Anwendungen für Arduino in Python
Steuern Sie analoge und digitale Ein- und Ausgänge
Integrieren Sie Arduino-Sensoren und -Schalter in übergeordnete Apps

Lösen Sie Benachrichtigungen auf Ihrem PC aus und senden Sie E-Mails mit Arduino

*Kostenloser Bonus:* Link: [5 Gedanken zur Python-Meisterschaft], ein kostenloser Kurs für Python-Entwickler, der Ihnen die Roadmap und die Denkweise zeigt, die Sie benötigen, um Ihre Python-Fähigkeiten auf die nächste Stufe zu bringen.

Die Arduino-Plattform

Arduino ist eine Open-Source-Plattform aus Hardware und Software, die die schnelle Entwicklung interaktiver Elektronikprojekte ermöglicht. Das emergence of Arduino zog die Aufmerksamkeit von Fachleuten aus vielen verschiedenen Branchen auf sich, https://readwrite.com/2014/05/12/arduino-massimo-banzi-diy-electronics-hardware -hacking-builders/[Beitrag] zum Start der Maker Movement.

Mit der wachsenden Popularität der Maker-Bewegung und dem Konzept des Internet of Things hat sich Arduino zu einer der Hauptplattformen für elektronisches Prototyping und die Entwicklung von MVPs entwickelt.

Arduino verwendet eine eigene Programmiersprache, die C ++ ähnelt. Es ist jedoch möglich, Arduino mit Python oder einer anderen höheren Programmiersprache zu verwenden. In der Tat funktionieren Plattformen wie Arduino gut mit Python, insbesondere für Anwendungen, die die Integration mit Sensoren und anderen physischen Geräten erfordern.

Alles in allem können Arduino und Python eine effektive Lernumgebung ermöglichen, die Entwickler dazu ermutigt, sich mit Elektronikdesign zu befassen. Wenn Sie bereits https://realpython.com/learning-paths/python3-introduction/[die Grundlagen von Python kennen, können Sie mit Arduino beginnen, indem Sie Python verwenden, um es zu steuern.

Die Arduino-Plattform umfasst sowohl hardware als auch Softwareprodukte. In diesem Tutorial verwenden Sie Arduino-Hardware und Python-Software, um grundlegende Schaltkreise sowie digitale und analoge Ein- und Ausgänge kennenzulernen.

Arduino Hardware

Um die Beispiele auszuführen, müssen Sie die Schaltkreise zusammenbauen, indem Sie elektronische Komponenten anschließen. Sie finden diese Artikel im Allgemeinen in Geschäften für elektronische Komponenten oder in guten Arduino-Starter-Kits. Du brauchst:

Ein Arduino Uno oder ein anderes kompatibles Board
Eine Standard-LED jeder Farbe
Ein Druckknopf
Ein 10 KOhm Potentiometer
Ein 470 Ohm Widerstand
Ein 10 KOhm Widerstand
Ein Steckbrett
Überbrückungsdrähte in verschiedenen Farben und Größen

Schauen wir uns einige dieser Komponenten genauer an.

Komponente 1 ist eine *Arduino Uno * oder eine andere kompatible Karte. Arduino ist ein Projekt, das viele boards und Module für verschiedene Zwecke enthält, und Arduino Uno ist das grundlegendste unter diesen. Es ist auch das am häufigsten verwendete und am meisten dokumentierte Board der gesamten Arduino-Familie. Daher ist es eine gute Wahl für Entwickler, die gerade erst mit Elektronik beginnen.

*Hinweis:* Arduino ist eine offene Hardwareplattform, daher gibt es viele andere Anbieter, die kompatible Boards verkaufen, mit denen die hier gezeigten Beispiele ausgeführt werden können. In diesem Tutorial erfahren Sie, wie Sie das Arduino Uno verwenden.

Die Komponenten 5 und 6 sind Widerstände. Die meisten Widerstände sind durch farbige Streifen gemäß einem color code gekennzeichnet. Im Allgemeinen repräsentieren die ersten drei Farben den Wert eines Widerstands, während die vierte Farbe seine Toleranz repräsentiert. Bei einem 470-Ohm-Widerstand sind die ersten drei Farben Gelb, Violett und Braun. Bei einem 10-KOhm-Widerstand sind die ersten drei Farben Braun, Schwarz und Orange.

Komponente 7 ist ein Steckbrett , mit dem Sie alle anderen Komponenten anschließen und die Schaltkreise zusammenbauen. Obwohl kein Steckbrett erforderlich ist, wird empfohlen, dass Sie eines erwerben, wenn Sie mit Arduino arbeiten möchten.

Arduino Software

Zusätzlich zu diesen Hardwarekomponenten müssen Sie Software installieren. Die Plattform umfasst unter anderem die Arduino IDE, eine integrierte Entwicklungsumgebung zum Programmieren von Arduino-Geräten.

Arduino wurde entwickelt, damit Sie die Boards ohne große Schwierigkeiten programmieren können. Im Allgemeinen führen Sie die folgenden Schritte aus:

Verbinden Sie die Karte mit Ihrem PC
Installieren und öffnen Sie die Arduino IDE
Konfigurieren Sie die Karteneinstellungen
Schreiben Sie den Code
Drücken Sie eine Taste auf der IDE, um das Programm auf die Karte hochzuladen

Laden Sie zum Installieren der Arduino IDE auf Ihrem Computer die entsprechende Version für Ihr Betriebssystem von der Website Arduino herunter. In der Dokumentation finden Sie Installationsanweisungen:

Wenn Sie Windows verwenden, verwenden Sie das Windows-Installationsprogramm, um sicherzustellen, dass Sie die erforderlichen Treiber für die Verwendung von Arduino unter Windows herunterladen. Weitere Informationen finden Sie in der https://www.arduino.cc/en/guide/windows[Arduino-Dokumentation.
Wenn Sie Linux verwenden, müssen Sie Ihren Benutzer möglicherweise zu einigen Gruppen hinzufügen, um die serielle Schnittstelle zum Programmieren von Arduino zu verwenden. Dieser Vorgang wird im https://www.arduino.cc/en/Guide/Linux[Arduino Installationshandbuch für Linux beschrieben.

Wenn Sie macOS verwenden, können Sie Arduino IDE installieren, indem Sie dem https://www.arduino.cc/en/Guide/MacOSX[Arduino Installationshandbuch für OS X folgen.

*Hinweis:* In diesem Lernprogramm wird die Arduino-IDE verwendet. Arduino bietet jedoch auch einen https://create.arduino.cc/getting-started/plugin[web-Editor], mit dem Sie Arduino-Boards über den Browser programmieren können .

Nachdem Sie die Arduino IDE installiert und alle erforderlichen Komponenten gesammelt haben, können Sie mit Arduino beginnen! Als Nächstes laden Sie ein "Hallo Welt!" Programm auf Ihr Board.

"Hallo Welt!" Mit Arduino

Die Arduino IDE enthält mehrere Beispiel Skizzen , mit denen Sie die Grundlagen von Arduino erlernen können. Eine Skizze ist der Begriff, den Sie für ein Programm verwenden, das Sie auf ein Board hochladen können. Da dem Arduino Uno kein Display angeschlossen ist, benötigen Sie eine Möglichkeit, die physische Ausgabe Ihres Programms anzuzeigen. Sie verwenden die Beispielskizze Blinken , um eine integrierte LED auf der Arduino-Platine zum Blinken zu bringen.

Hochladen der Blink-Beispielskizze

Schließen Sie zunächst die Arduino-Karte mit einem USB-Kabel an Ihren PC an und starten Sie die Arduino IDE. Um die Blink-Beispielskizze zu öffnen, rufen Sie das Menü Datei auf und wählen Sie Beispiele, dann 01.Basics und schließlich Blink:

Der Blink-Beispielcode wird in ein neues IDE-Fenster geladen. Bevor Sie die Skizze auf die Karte hochladen können, müssen Sie die IDE konfigurieren, indem Sie Ihre Karte und den angeschlossenen Anschluss auswählen.

Um die Karte zu konfigurieren, rufen Sie das Menü Tools und dann Board auf. Für Arduino Uno sollten Sie Arduino/Genuino Uno auswählen:

Nachdem Sie die Karte ausgewählt haben, müssen Sie den entsprechenden Port einstellen. Rufen Sie das Menü Tools erneut auf und wählen Sie diesmal Port:

Die Namen der Ports können je nach Betriebssystem unterschiedlich sein. In Windows heißen die Ports "+ COM4 ", " COM5 " oder ähnliches. Unter MacOS oder Linux sehen Sie möglicherweise etwas wie "/dev/ttyACM0 " oder "/dev/ttyUSB0 +". Wenn Sie Probleme beim Einstellen des Ports haben, lesen Sie die Arduino Troubleshooting Page.

Nachdem Sie die Karte und den Port konfiguriert haben, können Sie die Skizze auf Ihr Arduino hochladen. Dazu müssen Sie nur die Schaltfläche Upload in der IDE-Symbolleiste drücken:

Wenn Sie Upload drücken, kompiliert die IDE die Skizze und lädt sie auf Ihr Board hoch. Wenn Sie nach Fehlern suchen möchten, können Sie Verify vor Upload drücken, wodurch nur Ihre Skizze kompiliert wird.

Das USB-Kabel bietet eine serielle Verbindung, um das Programm hochzuladen und die Arduino-Karte mit Strom zu versorgen. Während des Uploads blinken LEDs auf der Platine. Nach einigen Sekunden wird das hochgeladene Programm ausgeführt und einmal pro Sekunde blinkt ein LED-Licht:

Nach Abschluss des Uploads wird das Arduino-Board weiterhin mit dem USB-Kabel mit Strom versorgt. Das Programm wird im Flash-Speicher des Arduino-Mikrocontrollers gespeichert. Sie können auch eine Batterie oder ein anderes externes power Versorgung verwenden, um die Anwendung ohne USB-Kabel auszuführen.

Externe Komponenten anschließen

Im vorherigen Abschnitt haben Sie eine LED verwendet, die bereits auf der Arduino-Platine vorhanden war. In den meisten praktischen Projekten müssen Sie jedoch externe Komponenten an die Platine anschließen. Um diese Verbindungen herzustellen, verfügt Arduino über mehrere Pins verschiedener Typen:

]

Obwohl diese Verbindungen üblicherweise als Pins bezeichnet werden, können Sie feststellen, dass es sich nicht genau um physische Pins handelt. Die Stifte sind vielmehr Löcher in einer Buchse, an die Sie Überbrückungsdrähte anschließen können. In der Abbildung oben sehen Sie verschiedene Gruppen von Stiften:

Orange Rechteck: Dies sind 13 digitale Pins , die Sie als Ein- oder Ausgänge verwenden können. Sie sollen nur mit digitalen Signalen arbeiten, die zwei verschiedene Ebenen haben:
1. Stufe 0: dargestellt durch die Spannung 0V
2. Stufe 1: dargestellt durch die Spannung 5V
Grünes Rechteck: Dies sind 6 analoge Pins , die Sie als analoge Eingänge verwenden können. Sie sollen mit einer beliebigen Spannung zwischen 0 V und 5 V arbeiten.
Blaues Rechteck: Dies sind 5 Power Pins . Sie werden hauptsächlich zur Stromversorgung externer Komponenten verwendet.

Um mit der Verwendung externer Komponenten zu beginnen, schließen Sie eine externe LED an, um die Blink-Beispielskizze auszuführen. Die eingebaute LED ist mit Digital Pin # 13 verbunden. Schließen wir also eine externe LED an diesen Pin an und prüfen, ob sie blinkt. (Eine Standard-LED ist eine der Komponenten, die unter earlier aufgeführt sind.)

Bevor Sie etwas an das Arduino-Board anschließen, sollten Sie es vom Computer trennen. Wenn das USB-Kabel abgezogen ist, können Sie die LED an Ihre Platine anschließen:

Beachten Sie, dass die Abbildung die Karte mit den digitalen Stiften zeigt, die jetzt zu Ihnen zeigen.

Verwenden eines Steckbretts

Bei Projekten für elektronische Schaltungen werden normalerweise mehrere Ideen getestet, wobei Sie neue Komponenten hinzufügen und unterwegs Anpassungen vornehmen. Es kann jedoch schwierig sein, Komponenten direkt anzuschließen, insbesondere wenn die Schaltung groß ist.

Um das Prototyping zu vereinfachen, können Sie die Komponenten über breadboard verbinden. Dies ist ein Gerät mit mehreren Löchern, die auf eine bestimmte Weise verbunden sind, sodass Sie Komponenten einfach über Überbrückungskabel verbinden können:

Sie können anhand der farbigen Linien sehen, welche Löcher miteinander verbunden sind. Sie werden die Löcher an den Seiten des Steckbretts verwenden, um die Schaltung mit Strom zu versorgen:

*Verbinden Sie ein Loch in der* roten Linie * mit der Stromquelle.
*Verbinden Sie ein Loch in der* blauen Linie *mit dem Boden.

Anschließend können Sie Komponenten einfach an die Stromquelle oder den Boden anschließen, indem Sie einfach die anderen Löcher in den roten und blauen Linien verwenden. Die Löcher in der Mitte des Steckbretts sind wie durch die Farben angegeben verbunden. Sie werden diese verwenden, um Verbindungen zwischen den Komponenten der Schaltung herzustellen. Diese beiden internen Abschnitte sind durch eine kleine Vertiefung getrennt, über die Sie integrierte Schaltkreise (ICs) anschließen können.

Sie können ein Steckbrett verwenden, um die in der Blink-Beispielskizze verwendete Schaltung zusammenzusetzen:

Bei dieser Schaltung ist zu beachten, dass die LED entsprechend ihrer Polarität angeschlossen werden muss, da sie sonst nicht funktioniert. Der positive Anschluss der LED wird als* Anode bezeichnet und ist im Allgemeinen der längere. Der negative Anschluss wird als Kathode * bezeichnet und ist kürzer. Wenn Sie eine wiederhergestellte Komponente verwenden, können Sie die Anschlüsse auch identifizieren, indem Sie auf der LED selbst nach einer flachen Seite suchen. Dies zeigt die Position des Minuspols an.

Wenn Sie eine LED an einen Arduino-Pin anschließen, benötigen Sie immer einen Widerstand, um den Strom zu begrenzen und ein vorzeitiges Durchbrennen der LED zu vermeiden. Hier verwenden Sie dazu einen 470 Ohm Widerstand. Sie können den Verbindungen folgen und überprüfen, ob die Schaltung identisch ist:

Der Widerstand ist mit dem digitalen Pin 13 auf der Arduino-Platine verbunden.
Die LED-Anode ist mit dem anderen Anschluss des Widerstands verbunden.
Die LED-Kathode ist über die blaue Lochlinie mit Masse (GND) verbunden.

Eine ausführlichere Erklärung finden Sie unter How to Use a Breadboard.

Nachdem Sie die Verbindung hergestellt haben, schließen Sie das Arduino wieder an den PC an und führen Sie die Blink-Skizze erneut aus:

Da beide LEDs mit dem digitalen Pin 13 verbunden sind, blinken sie zusammen, wenn die Skizze ausgeführt wird.

"Hallo Welt!" Mit Arduino und Python

Im vorherigen Abschnitt haben Sie die Blink-Skizze auf Ihr Arduino-Board hochgeladen. Arduino-Skizzen werden in einer C ++ - ähnlichen Sprache geschrieben und beim Drücken von Upload im Flash-Speicher des Mikrocontrollers kompiliert und aufgezeichnet. Sie können zwar another language verwenden, um den Arduino-Mikrocontroller direkt zu programmieren, dies ist jedoch keine triviale Aufgabe!

Es gibt jedoch einige Ansätze, mit denen Sie Arduino mit Python oder anderen Sprachen verwenden können. Eine Idee ist, das Hauptprogramm auf einem PC auszuführen und über die serielle Verbindung über das USB-Kabel mit Arduino zu kommunizieren. Die Skizze ist dafür verantwortlich, die Eingaben zu lesen, die Informationen an den PC zu senden und Updates vom PC zu erhalten, um die Arduino-Ausgaben zu aktualisieren.

Um Arduino vom PC aus zu steuern, müssen Sie ein Protokoll für die Kommunikation zwischen dem PC und Arduino entwerfen. Sie könnten beispielsweise ein Protokoll mit Nachrichten wie den folgenden in Betracht ziehen:

WERT VON PIN 13 IST HOCH: Wird verwendet, um den PC über den Status der digitalen Eingangspins zu informieren
SET PIN 11 LOW: wird verwendet, um Arduino anzuweisen, die Zustände der Ausgangspins einzustellen

Wenn das Protokoll definiert ist, können Sie eine Arduino-Skizze schreiben, um Nachrichten an den PC zu senden und die Zustände der Pins gemäß dem Protokoll zu aktualisieren. Auf dem PC können Sie ein Programm zur Steuerung des Arduino über eine serielle Verbindung schreiben, das auf dem von Ihnen entworfenen Protokoll basiert. Hierfür können Sie eine beliebige Sprache und Bibliothek verwenden, z. B. Python und die Bibliothek PySerial.

Glücklicherweise gibt es Standardprotokolle, um all dies zu tun! Firmata ist einer von ihnen. Dieses Protokoll legt ein serielles Kommunikationsformat fest, mit dem Sie digitale und analoge Eingänge lesen sowie Informationen an digitale und analoge Ausgänge senden können.

Die Arduino-IDE enthält vorgefertigte Skizzen, die Arduino mit dem Firmata-Protokoll durch Python führen. Auf der PC-Seite gibt es Implementierungen des Protokolls in mehreren Sprachen, einschließlich Python. Um mit Firmata zu beginnen, implementieren wir damit ein "Hallo Welt!" Programm.

Hochladen der Firmata-Skizze

Bevor Sie Ihr Python-Programm für Arduino schreiben, müssen Sie die Firmata-Skizze hochladen, damit Sie dieses Protokoll zur Steuerung der Karte verwenden können. Die Skizze ist in den integrierten Beispielen der Arduino IDE verfügbar. Um es zu öffnen, greifen Sie auf das Menü Datei zu, dann auf Beispiele, gefolgt von Firmata und schließlich StandardFirmata:

Die Skizze wird in ein neues IDE-Fenster geladen. Um es auf das Arduino hochzuladen, können Sie die gleichen Schritte wie zuvor ausführen:

Stecken Sie das USB-Kabel in den PC.
Wählen Sie die entsprechende Karte und den entsprechenden Port in der IDE aus.
Drücken Sie Upload.

Nach Abschluss des Uploads werden Sie keine Aktivitäten auf dem Arduino bemerken. Zur Steuerung benötigen Sie noch ein Programm, das über die serielle Verbindung mit der Karte kommunizieren kann. Um mit dem Firmata-Protokoll in Python arbeiten zu können, benötigen Sie das Paket pyFirmata, das Sie mit installieren können + pip +:

$ pip install pyfirmata

Nach Abschluss der Installation können Sie eine entsprechende Blink-Anwendung mit Python und Firmata ausführen:

 1 import pyfirmata
 2 import time
 3
 4 board = pyfirmata.Arduino('/dev/ttyACM0')
 5
 6 while True:
 7     board.digital[13].write(1)
 8     time.sleep(1)
 9     board.digital[13].write(0)
10     time.sleep(1)

So funktioniert dieses Programm: works. Sie importieren + pyfirmata + und stellen damit eine serielle Verbindung mit der Arduino-Karte her, die in Zeile 4 durch das Objekt + board + dargestellt wird. Sie konfigurieren den Port in dieser Zeile auch, indem Sie ein Argument an + pyfirmata.Arduino () + übergeben. Sie können die Arduino IDE verwenden, um den Port zu finden.

+ board.digital + ist eine Liste, deren Elemente die digitalen Pins des Arduino darstellen. Diese Elemente haben die Methoden "+ read () " und " write () +", die den Zustand der Pins lesen und schreiben. Wie die meisten Programme für eingebettete Geräte besteht dieses Programm hauptsächlich aus einer Endlosschleife:

In Zeile 7 wird der digitale Pin 13 eingeschaltet, wodurch die LED für eine Sekunde eingeschaltet wird.
In Zeile 9 ist dieser Pin ausgeschaltet, wodurch die LED für eine Sekunde ausgeschaltet wird.

Nachdem Sie nun die Grundlagen zur Steuerung eines Arduino mit Python kennen, gehen wir einige Anwendungen durch, um mit seinen Ein- und Ausgängen zu interagieren.

Digitale Eingänge lesen

*Digitale Eingänge* können nur zwei mögliche Werte haben. In einer Schaltung wird jeder dieser Werte durch eine andere Spannung dargestellt. Die folgende Tabelle zeigt die Darstellung des digitalen Eingangs für eine Standard-Arduino Uno-Karte:

Value	Level	Voltage
0	Low	0V
1	High	5V

Value

Level

Voltage

Low

High

Zur Steuerung der LED verwenden Sie einen Druckknopf , um digitale Eingabewerte an das Arduino zu senden. Die Taste sollte 0 V an die Karte senden, wenn sie losgelassen wird, und 5 V an die Karte, wenn sie gedrückt wird. Die folgende Abbildung zeigt, wie der Knopf mit dem Arduino-Board verbunden wird:

Möglicherweise stellen Sie fest, dass die LED wie zuvor an Digital Ar 13 mit dem Arduino verbunden ist. Der digitale Pin 10 wird als digitaler Eingang verwendet. Um den Druckknopf anzuschließen, müssen Sie den 10-KOhm-Widerstand verwenden, der in dieser Schaltung als pull down fungiert. Ein Pulldown -Widerstand stellt sicher, dass der digitale Eingang 0 V erhält, wenn die Taste losgelassen wird.

Wenn Sie die Taste loslassen, öffnen Sie die Verbindung zwischen den beiden Drähten der Taste. Da kein Strom durch den Widerstand fließt, wird Pin 10 nur mit Masse (GND) verbunden. Der digitale Eingang erhält 0 V, was den Zustand 0 (oder low ) darstellt. Wenn Sie die Taste drücken, legen Sie 5 V sowohl an den Widerstand als auch an den Digitaleingang an. Ein Strom fließt durch den Widerstand und der digitale Eingang erhält 5 V, was den Zustand 1 (oder high ) darstellt.

Sie können auch ein Steckbrett verwenden, um die obige Schaltung zusammenzubauen:

Nachdem Sie die Schaltung zusammengebaut haben, müssen Sie ein Programm auf dem PC ausführen, um sie mit Firmata zu steuern. Dieses Programm schaltet die LED basierend auf dem Status des Druckknopfs ein:

 1 import pyfirmata
 2 import time
 3
 4 board = pyfirmata.Arduino('/dev/ttyACM0')
 5
 6 it = pyfirmata.util.Iterator(board)
 7 it.start()
 8
 9 board.digital[10].mode = pyfirmata.INPUT
10
11 while True:
12     sw = board.digital[10].read()
13     if sw is True:
14         board.digital[13].write(1)
15     else:
16         board.digital[13].write(0)
17     time.sleep(0.1)

Lassen Sie uns dieses Programm durchgehen:

Zeilen 1 und 2 importieren + pyfirmata + und + time +.
Zeile 4 verwendet + pyfirmata.Arduino () +, um die Verbindung mit der Arduino-Karte herzustellen.
Zeile 6 weist einen Iterator zu, der zum Lesen des Status der Eingänge der Schaltung verwendet wird.
Zeile 7 startet den Iterator, der eine Schleife parallel zu Ihrem Hauptcode laufen lässt. Die Schleife führt + board.iterate () + aus, um die von der Arduino-Karte erhaltenen Eingabewerte zu aktualisieren.
Zeile 9 setzt Pin 10 als digitalen Eingang mit + pyfirmata.INPUT +. Dies ist erforderlich, da in der Standardkonfiguration digitale Pins als Ausgänge verwendet werden.
Zeile 11 startet eine Endlosschleife + while +. Diese Schleife liest den Status des Eingangspins, speichert ihn in + sw + und verwendet diesen Wert, um die LED durch Ändern des Werts von Pin 13 ein- oder auszuschalten.
Zeile 17 wartet 0,1 Sekunden zwischen den Iterationen der Schleife + while +. Dies ist nicht unbedingt erforderlich, aber es ist ein guter Trick, um eine Überlastung der CPU zu vermeiden, die 100% Last erreicht, wenn sich kein Wartebefehl in der Schleife befindet.

+ pyfirmata + bietet auch eine kompaktere Syntax für die Arbeit mit Eingabe- und Ausgabepins. Dies ist möglicherweise eine gute Option, wenn Sie mit mehreren Pins arbeiten. Sie können das vorherige Programm neu schreiben, um eine kompaktere Syntax zu erhalten:

 1 import pyfirmata
 2 import time
 3
 4 board = pyfirmata.Arduino('/dev/ttyACM0')
 5
 6 it = pyfirmata.util.Iterator(board)
 7 it.start()
 8
 9 digital_input = board.get_pin('d:10:i')
10 led = board.get_pin('d:13:o')
11
12 while True:
13     sw = digital_input.read()
14     if sw is True:
15         led.write(1)
16     else:
17         led.write(0)
18     time.sleep(0.1)

In dieser Version verwenden Sie + board.get_pin () +, um zwei Objekte zu erstellen. + digital_input + repräsentiert den digitalen Eingangszustand und + led + repräsentiert den LED-Zustand. Wenn Sie diese Methode ausführen, müssen Sie ein Zeichenfolgenargument übergeben, das aus drei durch Doppelpunkte getrennten Elementen besteht:

Der Typ des Pins (+ a + für analog oder + d + für digital)
Die Nummer des Pins
Der Modus des Pins (+ i + für die Eingabe oder + o + für die Ausgabe)

Da "+ digital_input " ein digitaler Eingang mit Pin 10 ist, übergeben Sie das Argument "" d: 10: i "". Der LED-Status wird über Pin 13 auf einen digitalen Ausgang gesetzt, daher lautet das Argument " led " "" d: 13: o "+".

Wenn Sie "+ board.get_pin () " verwenden, müssen Sie Pin 10 nicht explizit als Eingabe einrichten, wie Sie es zuvor mit " pyfirmata.INPUT " getan haben. Nachdem die Pins gesetzt wurden, können Sie mit ` read () ` auf den Status eines digitalen Eingangspins zugreifen und mit ` write () +` den Status eines digitalen Ausgangspins einstellen.

Digitale Eingänge werden häufig in Elektronikprojekten verwendet. Mehrere Sensoren liefern digitale Signale wie Anwesenheits- oder Türsensoren, die als Eingänge für Ihre Schaltkreise verwendet werden können. In einigen Fällen müssen Sie jedoch analoge Werte messen, z. B. Entfernung oder physikalische Größen. Im nächsten Abschnitt erfahren Sie, wie Sie analoge Eingänge mit Arduino mit Python lesen.

Analoge Eingänge lesen

Im Gegensatz zu digitalen Eingängen, die nur ein- oder ausgeschaltet werden können, werden analoge Eingänge zum Lesen von Werten in einem bestimmten Bereich verwendet. Beim Arduino Uno liegt die Spannung an einem Analogeingang zwischen 0 V und 5 V. Geeignete Sensoren werden verwendet, um physikalische Größen wie Entfernungen zu messen. Diese Sensoren sind dafür verantwortlich, diese physikalischen Größen im richtigen Spannungsbereich zu codieren, damit sie vom Arduino gelesen werden können.

Zum Lesen einer analogen Spannung verwendet der Arduino einen *analog-to-digital wandler (ADC) *, der die Eingangsspannung in eine digitale Zahl umwandelt mit einer festen Anzahl von Bits. Dies bestimmt die Auflösung der Konvertierung. Der Arduino Uno verwendet einen 10-Bit-ADC und kann 1024 verschiedene Spannungspegel bestimmen.

Der Spannungsbereich für einen Analogeingang wird in Zahlen zwischen 0 und 1023 codiert. Wenn 0 V angelegt werden, codiert das Arduino es mit der Nummer 0 . Wenn 5 V angelegt werden, lautet die codierte Nummer 1023 . Alle Zwischenspannungswerte sind proportional codiert.

Ein potentiometer ist ein variabler Widerstand, mit dem Sie die an einen Arduino-Analogeingang angelegte Spannung einstellen können. Sie schließen es an einen Analogeingang an, um die Frequenz einer blinkenden LED zu steuern:

In dieser Schaltung wird die LED wie zuvor eingerichtet. Die Endanschlüsse des Potentiometers sind mit Masse (GND) und 5-V-Pins verbunden. Auf diese Weise kann der zentrale Anschluss (der Cursor) abhängig von seiner Position eine beliebige Spannung im Bereich von 0 V bis 5 V haben, die über den analogen Pin A0 mit dem Arduino verbunden ist.

Mit einem Steckbrett können Sie diese Schaltung wie folgt zusammenbauen:

Bevor Sie die LED steuern, können Sie mithilfe der Schaltung die verschiedenen Werte überprüfen, die der Arduino basierend auf der Position des Potentiometers liest. Führen Sie dazu das folgende Programm auf Ihrem PC aus:

 1 import pyfirmata
 2 import time
 3
 4 board = pyfirmata.Arduino('/dev/ttyACM0')
 5 it = pyfirmata.util.Iterator(board)
 6 it.start()
 7
 8 analog_input = board.get_pin('a:0:i')
 9
10 while True:
11     analog_value = analog_input.read()
12     print(analog_value)
13     time.sleep(0.1)

In Zeile 8 richten Sie + analog_input + als analogen A0-Eingangspin mit dem Argument` + 'a: 0: i' + `ein. In der Endlosschleife "+ while " lesen Sie diesen Wert, speichern ihn in " analog_value " und zeigen die Ausgabe mit " print () +" auf der Konsole an. Wenn Sie das Potentiometer bewegen, während das Programm ausgeführt wird, sollten Sie Folgendes ausgeben:

Die gedruckten Werte ändern sich von 0, wenn sich die Position des Potentiometers an einem Ende befindet, bis 1, wenn es sich am anderen Ende befindet. Beachten Sie, dass dies Float-Werte sind, die je nach Anwendung möglicherweise konvertiert werden müssen.

Um die Frequenz der blinkenden LED zu ändern, können Sie mit + analog_value + steuern, wie lange die LED ein- oder ausgeschaltet bleibt:

 1 import pyfirmata
 2 import time
 3
 4 board = pyfirmata.Arduino('/dev/ttyACM0')
 5 it = pyfirmata.util.Iterator(board)
 6 it.start()
 7
 8 analog_input = board.get_pin('a:0:i')
 9 led = board.get_pin('d:13:o')
10
11 while True:
12     analog_value = analog_input.read()
13     if analog_value is not None:
14         delay = analog_value + 0.01
15         led.write(1)
16         time.sleep(delay)
17         led.write(0)
18         time.sleep(delay)
19     else:
20         time.sleep(0.1)

Hier berechnen Sie "+ Verzögerung " als " Analogwert + 0,01 ", um zu vermeiden, dass " Verzögerung " gleich Null ist. Andernfalls ist es üblich, in den ersten Iterationen einen " analogen_Wert " von " keine " zu erhalten. Um beim Ausführen des Programms einen Fehler zu vermeiden, verwenden Sie eine Bedingung in Zeile 13, um zu testen, ob ` analog_value ` ` None +` ist. Dann steuern Sie die Periode der blinkenden LED.

Führen Sie das Programm aus und ändern Sie die Position des Potentiometers. Sie werden feststellen, wie häufig sich die blinkende LED ändert:

Inzwischen haben Sie gesehen, wie Sie digitale Eingänge, digitale Ausgänge und analoge Eingänge in Ihren Schaltkreisen verwenden. Im nächsten Abschnitt erfahren Sie, wie Sie analoge Ausgänge verwenden.

Analoge Ausgänge verwenden

In einigen Fällen ist ein analoger Ausgang erforderlich, um ein Gerät anzusteuern, für das ein analoges Signal erforderlich ist. Arduino enthält keinen echten Analogausgang, bei dem die Spannung auf einen beliebigen Wert in einem bestimmten Bereich eingestellt werden kann. Arduino enthält jedoch mehrere *Pulse Width Modulation * (PWM) -Ausgänge.

PWM ist eine Modulationstechnik, bei der ein digitaler Ausgang verwendet wird, um ein Signal mit variabler Leistung zu erzeugen. Dazu wird ein digitales Signal konstanter Frequenz verwendet, bei dem der duty Cycle * entsprechend der gewünschten Leistung geändert wird. Das Tastverhältnis repräsentiert den Bruchteil der Periode, in der das Signal auf *hoch

TOC

Arduino mit Python: Erste Schritte