PicoBello Workshops
Version vom 14. März 2022, 16:36 Uhr von Carbon (Diskussion | Beiträge) (→0455 Temperatur-Speicher-Werte einlesen.py)
PicoBello-Konzept
Dies ist ein Wiki für Interessierte und PicoBello-Workshop-Teilnehmende.
Programmier-Projekte in Theorie und Praxis mit dem Raspberry Pi Pico für Einsteiger ohne Programmierkenntnisse
Die Workshops erfolgen als Jitsi-Webmeeting, also online von PC zu PC.
Ziel der Workshops
- Ziel ist, dass Teilnehmende eigene Projekte mit dem Pico selbst planen und umsetzen können.
- Die Workshops PicoBello-01 und -02 sind Voraussetzungen für die weiteren PicoBello-Workshops.
Teilnahmevoraussetzungen für PicoBello-01
- Teilnehmende: Lesen und Schreiben können und INTERESSE haben.
- Technik:
- Windows- oder Apple-PC (für den Programmier-Editor) mit
- Internetanschluss (für die Teilnahme am Jitsi-Meeting).
Workshop-Termine
Aktuelle PicoBello-Termine, siehe:
https://www.elektronik-kompendium.de/service/events/
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Material-Set Pico
- 1 Raspberry Pi Pico, RP2040 Mikrocontroller mit angelöteten Stiftleisten auf Steckbrett mit 830 Kontakten
- 1 Steckbrett mit 400 Kontakten
- 1 USB-Kabel 1,5 m mit Micro USB Stecker
- 40 Verbindungskabel 10 cm
- 5 Taster
- 10 Widerstände 470 Ohm
- 5 Widerstände 10 kOhm
- 15 LEDs (5 rote, 5 gelbe und 5 grüne)
- 1 aktiver Summer
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Prinzipieller Ablauf: Pico-Vorbereitung, -Programmierung und -Betrieb
- Zunächst (1) das Progammiersystem "MicroPython" (Datei: rp2-pico-20210902-v1.17.uf2) von https://micropython.org/download/rp2-pico über den PC auf den Pico installieren; Link zur detaillierteren Vorgehensweise
- Dann (2) die Entwicklungsumgebung "Thonny" (Datei: thonny-3.3.13.exe) von https://thonny.org herunterladen, und aufrufen.
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
- Das Thonny-Fenster ist in der Basis-Version zweigeteilt: in der oberen Hälfte (3) wird das aktuell bearbeitete Programm angezeigt; Programme können aufgerufen, bearbeitet, abgespeichert, gestartet oder gestoppt/beendet werden.
- In der unteren Hälfte (4), welche mit "Kommandozeile" (oder "Shell") überschrieben ist, können Direkt-Befehle an den Pico gegeben, Programm-Eingaben abgefragt und Programm-Ausgaben angezeigt werden.
- Auf dem Pico-Steckbrett (5) werden die im Programm angesprochenen Ein- und Ausgabegeräte sowie Anzeigen mit Verbindungskabeln verbunden.
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
- Nach der Programm-Fertigstellung kann der Pico vom PC getrennt werden, um selbständig zu "laufen". Vorher muss das beabsichtigte Programm unter "main.py" auf dem Pico gespeichert werden, denn bei Anschluss einer externen Stromversorgung (6) per Batterien oder USB-Netzteil (oder Onboard-Netzteil) startet der Pico automatisch das Programm "main.py".
- Das Programm "main.py" läuft dann (7) selbständig mit allen programmierten Ein- und Ausgaben, sowie Anzeigen.
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Workshop PicoBello-01
Projekte / Programme
Im Folgenden sind die in PicoBello-01 besprochenen Programme aufgeführt.
Folgende zwei Varianten beschreiben, wie die hier vorgestellten Programme in den eigenen Thonny-Editor gelangen können:
- Durch einen Klick mit der linken Maus-Taste auf den Media: xyz .txt –Link öffnet sich ein Browser-Fenster mit den genutzten MicroPython-Programm-Befehlen, die von dort in den Thonny-Editor kopiert werden können ...
oder ...
- Durch einen Klick mit der rechten Maus-Taste auf den Media: xyz .txt –Link öffnet sich ein anderes Browser-Fenster, über welches über „Ziel speichern unter …“ die Text-Dateien mit den MicroPython-Programm-Befehlen auf den eigenen PC heruntergeladen werden können. Von dort können die Befehle in den Thonny-Editor kopiert werden.
- Was macht das Programm? erklärt, was das jeweilige Programm bewirkt.
- Beschreibung der Befehle erläutert kurz benutzte Programm-Befehle .
- Was probieren ...? gibt Anregungen zum selber experimentieren .
Mit eckigen Klammern [ ] werden Programm-Befehle beschrieben; "Z4" steht für Zeile 4.
Viel Spaß beim Testen und Ausprobieren ...
0010 HalloWelt.py
Media:0010 HalloWelt.txt
Was macht das Programm?
- Es testet, ob die Verbindung PC (mit Thonny) zu Pico (MicroPython) funktioniert, und meldet bei Erfolg: erstes Lebenszeichen des Picos.
Beschreibung der Befehle
- Durch den Befehl [print] zeigt der Pico Informationen in der Kommandozeile des Thonny-Editors an
- in anschließender Klammer folgt die anzuzeigende Ausgabe-Information:
- Text in Anführungszeichen wird angezeigt, z.B. print("Hallo Welt") ergibt Hallo Welt in der Kommandozeile.
- in anschließender Klammer folgt die anzuzeigende Ausgabe-Information:
Was probieren ...?
- Text in Anführungszeichen ändern,
- print Befehl mehrfach anwenden.
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0020 Schleife 0-9.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
print("Schleife startet!")
for Nummer in range(10):
print("Schleifen-Nummer", Nummer)
print("Schleife beendet!")
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es bildet eine Schleife mit einer Anzahl von Durchläufen.
Beschreibung der Befehle
- Der Befehl [print] zeigt Informationen im Thonny-Bereich Kommandozeile
- in anschließender Klammer folgt die anzuzeigende Ausgabe-Information:
- Text in Anführungszeichen wird angezeigt, z.B. print("Schleife startet!") ergibt Schleife startet! in der Kommandozeile
- Variable werden mit ihrem Variablen-Namen angegeben, z.B. print(Nummer) ergibt z.B. 3 in der Kommandozeile
- Anzeige-Informationen werden durch "," getrennt, z.B. print("Schleifen-Nummer ", Nummer) ergibt z.B. Schleifen-Nummer 3 in der Kommandozeile
- in anschließender Klammer folgt die anzuzeigende Ausgabe-Information:
- Der Befehl [for Nummer in range(10):] bildet eine bedingte Schleife,
- was in der Schleife passiert, wird 4 Leerzeichen eingerückt
- die Variable "Nummer" (Variablen-Name ist frei wählbar) läuft von "0" bis "9" (Achtung: 10 mal, aber nicht bis "10"!)
- wenn in der range-Klammer nur ein Wert steht, ist dies der "End"-Wert (der nicht erreicht wird) und der Anfangs-Wert ist "0".
- was nach der Schleife erfolgt, hat die selbe Einrückung wie "for"
Was probieren ...?
- Den Schleifen-Zähler End-Wert (anfangs "10") verändern.
- Die Variable "Nummer" umbenennen.
- Den Mitteilungstext in der print-Klammer verändern.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0030 Schleife 1-10.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
print("Schleife startet!")
for Nummer in range(1,11):
print("Schleifen-Nummer", Nummer)
print("Schleife beendet!")
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es bildet eine Schleife mit einer Anzahl von Durchläufen, wie "0020 Schleife 0-9.py".
Beschreibung der Befehle
- In der range-Klammer sind (im Gegensatz zu Programm 0020) zwei Werte eingetragen; der erste ist der Start-Wert und der zweite ist der End-Wert.
- Die Variable "Nummer" (Variablen-Name ist frei wählbar) läuft von "1" bis "11" (Achtung: 10 mal, aber nicht bis "11"!)
Was probieren ...?
- Start-Wert und End-Wert verändern.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0040 Endlos-Schleife.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import utime
print("Schleife starten!")
while True:
print("Schleife läuft!")
utime.sleep(1)
print("Schleife beendet!")
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es bildet eine Endlos-Schleife, d.h. es kommt nicht zu einem Ende, sondern muss abgebrochen, bzw. gestoppt werden.
- Es schreibt im Sekundentakt und endlos (in die Kommandozeile) "Schleife läuft".
Beschreibung der Befehle
- Mit [import] werden sogenannte "Bibliotheken" (Programmpakete) eingebunden, durch die der Pico zusätzliche, spezielle Programm-Befehle nutzen kann.
- Die Bibliothek "utime" bietet zeitbezogene Befehle, wie z.B. Zeitverzögerungen, quasi "Pausen".
- Der Schleifen-Befehl [while] prüft eine Bedingung auf "Wahrheit", ob ein Zeit- oder Wert-Vergleich zutrifft, also "wahr" ist; solange die Bedingung "wahr", also zutreffend ist, wird die Schleife durchlaufen. Wenn nicht (mehr) "wahr", wird der Folge-Befehl mit [while]-Einrückung - also [print] in Z6 - ausgeführt.
- "True" hinter [while] bedeutet quasi automatische und andauernde Bedingungs-Erfüllung. Daher wird der Folge-Befehl [print] in Zeile 6 NIE erreicht.
- Die Schleifen-Befehle [print] und [utime.sleep] in Z4 und Z5 werden durchlaufen und nach Z5 wird "hochgesprungen" zu Z4 und so wird die Schleife endlos durchlaufen.
- Der [print]-Befehl in Z6 wird nicht erreicht.
- Das Programm kann nur durch Stoppen beendet werden.
- [utime.sleep] bedeutet eine Pause in Anzahl Sekunden, deren Wert in der Folge-Klammer steht; Dezimal-Angaben werden mit "." angegeben, also z.B. [utime.sleep(0.8)] bedeutet eine Pause von 0,8 Sekunden.
Was probieren ...?
- Den Pausenwert (Klammerwert hinter [utime.sleep]) variieren.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0050 Eingabe Supermann.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
Eingabe_Name = input ("Wie heißt Du? ")
if Eingabe_Name == "Clark Kent":
print("TOLL, Du bist Supermann!")
else:
print(Eingabe_Name," ??? Du bist nicht Supermann!")
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es fragt eine Namens-Eingabe ab und prüft auf Übereinstimmung, also "Gleichheit" mit "Clark Kent".
- Abhängig von der Eingabe ist man Supermann oder nicht.
- Das Programm läuft nur ein Mal durch, unabhängig von der Eingabe.
Beschreibung der Befehle
- Der Befehl [input] bewirkt die Anzeige des Klammertextes in der Kommandozeile, und ordnet die Eingabe der frei wählbaren Variablen "Eingabe_Name" zu.
- Das Zeichen "=" ordnet Werte zu, wie in Z1.
- Das Zeichen "==" wird in der Abfrage, ob 2 Werte identisch sind, benutzt, wie in Z2.
- [if ...:][else:] ist ein Abfrage-Befehl, der aufgrund des Abfrageergebnisses verzweigt, und den einen oder den anderen "Ast" durchläuft.
- Wenn die Abfrage in Z2 stimmt, wird Z3 durchlaufen ... und dann Z6 ... und Ende.
- Wenn die Abfrage in Z2 NICHT stimmt, wird Z5 (und NICHT Z3) durchlaufen ... und dann Z6 ... und Ende.
Was probieren ...?
- Den Abfrage-Text verändern.
- Weitere Zeilen nach Z3 oder Z5 einfügen.
- Die Variable "Eingabe_Name" verändern.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0060 bedingte Schleife.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
Name = input("Wie heißt Du? ")
while Name != "Clark Kent":
print("Du bist nicht Supermann - Versuchs nochmal!")
Name = input("Wie heißt Du? ")
print("Du bist Supermann!")
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es prüft, wie 0050, ob die Eingabe mit "Clark Kent" übereinstimmt.
- Es loopt (= wiederholt die Schleife; von engl. loop = Schleife, Kreis, Kreislauf) und läuft so lange mit Abfragen, bis die "richtige" Eingabe erfolgt.
Beschreibung der Befehle
- Der Vergleichs-Operator "!=" bedeutet "ist NICHT identisch".
- Also bedeutet Z2: Solange die Variable "Name" ungleich "Clark Kent" ist, ist die [while]-Bedingung erfüllt, die Schleife Z3+Z4 wird durchlaufen, und Z3 fortwährend abgefragt.
- Wenn die Variable "Name" GLEICH "Clark Kent" ist, die [while]-Bedingung also NICHT erfüllt ist, wird die Schleife Z3+Z4 NICHT MEHR durchlaufen, Z5 angesprungen ... und danach das Programm beendet.
Was probieren ...?
- Eingabe-Variable "Name" umbenennen.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0070 Zufallszahl.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import utime
import random
while True:
Zufallszahl = random.randint(0,10)
print(Zufallszahl)
utime.sleep(1)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es listet Zufallszahlen im Sekundentakt auf.
Beschreibung der Befehle
- Die Bibliothek [random] bietet Funktionen zur Erzeugung von Zufallszahlen.
- [while true:] erzeugt, da mit "True" automatisch erfüllt, eine Endlos-Schleife.
- [random.randint] bietet eine Integer-Zahl (also Ganzzahl) zwischen und einschließlich des Anfangs-Werts (im Beispiel: 0) und des End-Werts (im Beispiel: 10).
- Durch [print] in Z6 wird die Zufallszahl in der Kommandozeile angezeigt.
- [utime.sleep(1)] verursacht eine 1-Sekunden-Pause bevor das Programm wieder zu Z5 springt um die nächste Zufallszahl zu erzeugen.
Was probieren ...?
- Die Anfangs- und End-Werte des Zufallszahlen-Bereichs in Z5 verändern.
- Die Pausenzeit in Z7 variieren.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0080 Was tun Generator.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import random
import utime
wort1 = ["Ich gehe", "Wir gehen", "Oma geht", "Unsere Familie geht", "Papa geht"]
wort2 = ["heute", "morgen", "nächste Woche", "an Weihnachten", "an meinem Geburtstag", "übermorgen"]
wort3 = ["ins Schwimmbad.", "ins Kino.", "Pizza essen.", "in Urlaub.", "Ski fahren.", "in die Kirche."]
while True:
zufall1 = random.randint(0,len(wort1)-1)
zufall2 = random.randint(0,len(wort2)-1)
zufall3 = random.randint(0,len(wort3)-1)
print()
# print(zufall1,zufall2,zufall3)
print(wort1[zufall1],wort2[zufall2],wort3[zufall3])
utime.sleep(2)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es bietet einen "Vorschlags-Generator", welcher Empfehlungen zu Freizeit-Aktivitäten im 2-Sekunden-Rhytmus anzeigt.
- 3 vorbestimmte Zeichengruppen werden jeweils zufällig ausgesucht und aneinandergereiht.
- Es ist ein Beispiel für die Anwendung von 3 Zufalls-Generatoren.
Beschreibung der Befehle
- wort1,2,3 in Z5-Z7 bilden jeweils Zeichen-Gruppen mit verschiedenen Anzahlen von Zeichen in Hochkommas, jeweils getrennt durch Kommas.
- Im Beispiel besteht "wort1" aus 5 Zeichengruppen und "wort2" und "wort3" aus jeweils 6 Zeichengruppen.
- [len(wort1)] ermittelt die Anzahl der Zeichengruppen in wort1, also im Beispiel: 5.
- "zufall1" ist ein Zufallswert zwischen 0 und (5-1=) 4.
- [wort1["0"]] bietet den ersten Wert und [wort1["4"]] bietet den fünften Wert jeweils aus wort1.
- [print] in Z16 setzt die drei Zeichen-Gruppen zusammen und zeigt so einen ganzen Satz in der Kommandozeile.
Was probieren ...?
- Personen & Aktivitäten in wort1, Zeitpunkte in wort2 und Orte in wort3 (jeweils in Anführungszeichen und durch Komma getrennt) ergänzen und/oder rausnehmen.
- Durch Entfernen/Setzen der Raute in Z15 die Zufalls-Zahlen zeigen/verbergen.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0210 LED_auf_Pico an aus.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
LED_auf_Pico = machine.Pin(25, machine.Pin.OUT)
while True:
LED_auf_Pico.value(1)
utime.sleep(0.1)
LED_auf_Pico.value(0)
utime.sleep(0.7)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es schaltet die sich auf dem Pico befindliche LED ein und aus.
Beschreibung der Befehle
- Die Bibliothek [machine] bietet die Nutzung von Ein- und Ausgabe-Funktionen auf dem Pico.
- Die Zuweisung in Z4 [machine.Pin(25, machine.Pin.OUT)] definiert einerseits (OUT) eine Signal-Ausgabe und andererseits das genutzte GPIO-Pin, nämlich 25, welches die interne LED ansteuert.
- [while true:] erzeugt, da mit "True" automatisch erfüllt, eine Endlos-Schleife, welche die danach eingerückten Befehle nacheinander wiederholend durchläuft.
- Die in Z4 definierte LED-Funktion kann mittels [.value(1)] eingeschaltet und mittels [.value(0)] ausgeschaltet werden.
- Die Pause in Z8 nach dem Einschalt-Befehl in Z7 definiert die LED-An-Dauer.
- Die Pause in Z10 nach dem Ausschalt-Befehl in Z9 definiert die LED-Aus-Dauer.
- Der Zyklus in der [while True:]-Schleife: einschalten - warten - ausschalten - warten - ... läuft endlos.
Was probieren ...?
- Beide [utime.sleep]-Werte verändern.
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0211 LED_auf_Pico an aus mit Variablen.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
LED_auf_Pico = machine.Pin(25, machine.Pin.OUT)
an=0.1
aus=1
while True:
LED_auf_Pico.value(1)
utime.sleep(an)
LED_auf_Pico.value(0)
utime.sleep(aus)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es macht das selbe wie 0210: die sich auf dem Pico befindliche LED ein- und aus-schalten.
Beschreibung der Befehle
- Doch mit einem gewissen Unterschied: die Werte von [utime.sleep] in der jeweils folgenden Klammer werden nicht als Zahlenwerte (wie in 0210) eingegeben, sondern als Variable (z.B. "an" und " aus") die zu Beginn des Programms mit Werten belegt werden, und dann von den einzelnen Befehlen genutzt werden können. Dies ist besonders hilfreich, wenn die selben Zeit-Dauern öfters genutzt werden, wie z.B. beim Morse-Projekt.
Was probieren ...?
- Verändern der Werte, die den Variablen zugeordnet werden (in Z6 und Z7).
- Ändern der Variablen-Namen "an" und "aus".
- ...
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0310 LED ext an aus.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
externeLED = machine.Pin(15, machine.Pin.OUT)
while True:
externeLED.value(1)
utime.sleep(0.9)
externeLED.value(0)
utime.sleep(0.1)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Es macht fast das selbe wie 0210, nämlich eine LED ein- und ausschalten, aber dieses Mal eine externe LED.
Beschreibung der Befehle
- In Z4 wird nun GP15 adressiert, und zwar durch "Pin.OUT" als Ausgang, an den z.B. eine LED angeschlossen werden kann.
- Die LED wird dort mit ihrer "Plus-Seite", der "Anode" (das ist der längere Draht) über einen 330 Ohm-Widerstand angeschlossen.
- Die LED wird mit ihrer "Minus-Seite", der "Kathode" (das ist der kürzere Draht) mit der Minus-Längsleiste des Steckbretts verbunden.
Was probieren ...?
- GP Pin ändern und entsprechend den Widerstand "umstecken".
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Workshop PicoBello-02
Projekte / Programme
Im Folgenden sind die in PicoBello-02 besprochenen Programme aufgeführt.
Folgende zwei Varianten beschreiben, wie die hier vorgestellten Programme in den eigenen Thonny-Editor gelangen können:
- Durch einen Klick mit der linken Maus-Taste auf den Media: xyz .txt –Link öffnet sich ein Browser-Fenster mit den genutzten MicroPython-Programm-Befehlen, die von dort in den Thonny-Editor kopiert werden können ...
oder ...
- Durch einen Klick mit der rechten Maus-Taste auf den Media: xyz .txt –Link öffnet sich ein anderes Browser-Fenster, über welches über „Ziel speichern unter …“ die Text-Dateien mit den MicroPython-Programm-Befehlen auf den eigenen PC heruntergeladen werden können. Von dort können die Befehle in den Thonny-Editor kopiert werden.
- Was macht das Programm? erklärt, was das jeweilige Programm bewirkt.
- Beschreibung der Befehle erläutert kurz benutzte Programm-Befehle .
- Was probieren ...? gibt Anregungen zum selber experimentieren .
Mit eckigen Klammern [ ] werden Programm-Befehle beschrieben; "Z4" steht für Zeile 4.
Viel Spaß beim Testen und Ausprobieren ...
0311 LED ext und Summer an aus.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
#Dieses Programm schaltet im Wechsel eine LED und einen Summer ein und aus.
#Laden der Bibliothek "machine" zur Nutzung der GPIO-Pins 14 und 15
import machine
#Laden der Bibliothek "utime" zur Nutzung von Pausen-Funktionen
import utime
#Definition der Variablen "externeLED" zur Vorbereitung einer Ausgabe auf GPIO-15
externeLED = machine.Pin(15, machine.Pin.OUT)
#Definition der Variablen "Piepsi" zur Vorbereitung einer Ausgabe auf GPIO-14
Piepsi = machine.Pin(14, machine.Pin.OUT)
#Start Endlos-Schleife
while True:
#Ein-Schalten der LED auf GPIO-15
externeLED.value(1)
#Pause von ... Sekunden, also LED so lange an
utime.sleep(0.9)
#Aus-Schalten der LED auf GPIO-15
externeLED.value(0)
#Ein-Schalten des Summers auf GPIO-14
Piepsi.value(1)
#Pause von ... Sekunden, also piepst so lange
utime.sleep(0.1)
#Aus-Schalten des Summers auf GPIO-14
Piepsi.value(0)
#Weiter mit Zeile 15
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
- Wie in 0210 wird eine externe LED ein- und ausgeschaltet und zusätzlich ein aktiver Summer.
Was machen die Befehle?
- Z4...
Was auf dem Steckbrett beachten?
- Widerstand: sollte größer 300 Ohm sein.
- LED: auf Polung achten: kurzes Bein an "-" und langes Bein an "+"; nur mit Vorwiderstsnd betreiben.
- Summer: auf Polung achten: äußere Anschlüsse sind mit "-" und "+" gekennzeichnet; mittlerer Anschluss bleibt frei.
Was probieren ...?
- GP Pin.
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0351 Morsen Worte mit Summer.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
externeLED = machine.Pin(15, machine.Pin.OUT)
Piepsi = machine.Pin(14, machine.Pin.OUT)
# https://en.wikipedia.org/wiki/Morse_code
# International Morse code is composed of five elements:
# short mark, dot or dit: "dit duration" is one time unit long
# long mark, dash or dah: three time units long
# inter-element gap between the dits and dahs within a character: one dot duration or one unit long
# short gap (between letters): three time units long
# medium gap (between words): seven time units long
# A .-
# B -...
# C -.-.
# D -..
# E .
# F ..-.
# G --.
# H ....
# I ..
# J .---
# K -.-
# L .-..
# M --
# N -.
# O ---
# P .--.
# Q --.-
# R .-.
# S ...
# T -
# U ..-
# V ...-
# W .--
# X -..-
# Y -.--
# Z --..
# 0 -----
# 1 .----
# 2 ..---
# 3 ...--
# 4 ....-
# 5 .....
# 6 -....
# 7 --...
# 8 ---..
# 9 ----.
Faktor = 0.1
dit = 1 * Faktor
dah = 3 * Faktor
PauzwiZei = 1 * Faktor # Theorie: 1
PauzwiBu = 5 * Faktor # Theorie: 3
PauzwiWo = 9 * Faktor # Theorie: 7
Wort = input("Bitte Wort eingeben: ")
Länge = len(Wort)
print("Wortlänge: ",Länge)
Zähler = 0
while Zähler < Länge:
print(Wort[Zähler])
if (Wort[Zähler]) == "a": #.-
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "b": #-...
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "c": #-.-.
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "d": #-..
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "e": #.
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "f": #..-.
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "g": #--.
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "h": #....
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "i": #..
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "j": #.---
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
elif (Wort[Zähler]) == "k": #-.-
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "l": #.-..
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "m": #--
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "n": #-.
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "o": #---
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "p": #.--.
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "q": #--.-
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "r": #.-.
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "s": #...
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
elif (Wort[Zähler]) == "t": #-
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "u": #..-
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "v": #...-
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "w": #.--
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "x": #-..-
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "y": #-.--
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
elif (Wort[Zähler]) == "z": #z: --..
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#lang
Piepsi.value(1)
utime.sleep(dah)
Piepsi.value(0)
#ende lang
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
utime.sleep(PauzwiZei)
#kurz
Piepsi.value(1)
utime.sleep(dit)
Piepsi.value(0)
#ende kurz
else:
utime.sleep(PauzwiWo)
utime.sleep(PauzwiBu)
Zähler = Zähler + 1
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0421 Adventskalender 1-24 auto.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import utime
import machine
LED1_1 = machine.Pin(16, machine.Pin.OUT)
LED2_2 = machine.Pin(17, machine.Pin.OUT)
LED3_4 = machine.Pin(18, machine.Pin.OUT)
LED4_8 = machine.Pin(19, machine.Pin.OUT)
LED5_16 = machine.Pin(20, machine.Pin.OUT)
LED1_1.value(0)
LED2_2.value(0)
LED3_4.value(0)
LED4_8.value(0)
LED5_16.value(0)
while True:
dez=1
while dez<25:
print("dez-Wert in Zeile 18 :",dez)
# dez_str=input("der wievielte Dezember ist heute? ")
# dez = int(dez_str)
LED1_1.value(0)
LED2_2.value(0)
LED3_4.value(0)
LED4_8.value(0)
LED5_16.value(0)
if dez==1:
print(dez,". Dezember")
LED1_1.value(1)
LED2_2.value(0)
LED3_4.value(0)
LED4_8.value(0)
LED5_16.value(0)
elif dez==2:
print(dez,". Dezember")
LED2_2.value(1)
elif dez==3:
print(dez,". Dezember")
LED1_1.value(1)
LED2_2.value(1)
elif dez==4:
print(dez,". Dezember")
LED3_4.value(1)
elif dez==5:
print(dez,". Dezember")
LED1_1.value(1)
LED3_4.value(1)
elif dez==6:
print(dez,". Dezember")
LED2_2.value(1)
LED3_4.value(1)
elif dez==7:
print(dez,". Dezember")
LED1_1.value(1)
LED2_2.value(1)
LED3_4.value(1)
elif dez==8:
print(dez,". Dezember")
LED4_8.value(1)
elif dez==9:
print(dez,". Dezember")
LED1_1.value(1)
LED4_8.value(1)
elif dez==10:
print(dez,". Dezember")
LED2_2.value(1)
LED4_8.value(1)
elif dez==11:
print(dez,". Dezember")
LED1_1.value(1)
LED2_2.value(1)
LED4_8.value(1)
elif dez==12:
print(dez,". Dezember")
LED3_4.value(1)
LED4_8.value(1)
elif dez==13:
print(dez,". Dezember")
LED1_1.value(1)
LED3_4.value(1)
LED4_8.value(1)
elif dez==14:
print(dez,". Dezember")
LED2_2.value(1)
LED3_4.value(1)
LED4_8.value(1)
elif dez==15:
print(dez,". Dezember")
LED1_1.value(1)
LED2_2.value(1)
LED3_4.value(1)
LED4_8.value(1)
elif dez==16:
print(dez,". Dezember")
LED5_16.value(1)
elif dez==17:
print(dez,". Dezember")
LED1_1.value(1)
LED5_16.value(1)
elif dez==18:
print(dez,". Dezember")
LED2_2.value(1)
LED5_16.value(1)
elif dez==19:
print(dez,". Dezember")
LED1_1.value(1)
LED2_2.value(1)
LED5_16.value(1)
elif dez==20:
print(dez,". Dezember")
LED3_4.value(1)
LED5_16.value(1)
elif dez==21:
print(dez,". Dezember")
LED1_1.value(1)
LED3_4.value(1)
LED5_16.value(1)
elif dez==22:
print(dez,". Dezember")
LED2_2.value(1)
LED3_4.value(1)
LED5_16.value(1)
elif dez==23:
print(dez,". Dezember")
LED1_1.value(1)
LED2_2.value(1)
LED3_4.value(1)
LED5_16.value(1)
else:
print(dez,". Dezember")
LED1_1.value(0)
LED2_2.value(0)
LED3_4.value(0)
LED4_8.value(1)
LED5_16.value(1)
print("nach if Schleife")
utime.sleep(1)
dez=dez+1
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0401 Würfel linear.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import utime
import machine
import random
LED1_1 = machine.Pin(16, machine.Pin.OUT)
LED2_2 = machine.Pin(17, machine.Pin.OUT)
LED3_4 = machine.Pin(18, machine.Pin.OUT)
LED4_8 = machine.Pin(19, machine.Pin.OUT)
LED5_16 = machine.Pin(20, machine.Pin.OUT)
LED1_1.value(0)
LED2_2.value(0)
LED3_4.value(0)
LED4_8.value(0)
LED5_16.value(0)
Start = 1
Ende = 6
while True:
Augen = random.randint(Start,Ende)
print("gewürfelt: ",Augen)
LED1_1.value(0)
LED2_2.value(0)
LED3_4.value(0)
if Augen==1:
LED1_1.value(1)
elif Augen==2:
LED2_2.value(1)
elif Augen==3:
LED1_1.value(1)
LED2_2.value(1)
elif Augen==4:
LED3_4.value(1)
elif Augen==5:
LED1_1.value(1)
LED3_4.value(1)
elif Augen==6:
LED2_2.value(1)
LED3_4.value(1)
utime.sleep(1)
)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0430 Temperaturmessung onboard.py
- Analog-Digital-Converter (ADC)
Tabelle 1 zeigt die Auflösungsmöglichkeiten der 4 im Pico eingebauten 16-Bit AD-WAndler:
- Temperaturberechnung (Temperatursensor mit negativem Temperaturkoeffizienten)
Tabelle 2 erklärt die Formel zur Temperaturberechnung:
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
# Bibliotheken laden
from machine import ADC
from utime import sleep
# Initialisierung des ADC4 (Analog-Digital-Converter, Kanal 4),
# welcher mit dem on-board Temperatursensor verbunden ist.
Temperatursensor = ADC(4)
# Bekannte Werte:
#Temperatursensor mit negativem Temperaturkoeffizienten, d.h.
# höhere Spannung - > niedirigere Temperatur, und
# niedrigere Spannung - > höhere Temperatur.
# 0,706 Volt entsprechen 27 Grad Celsius;
# + 1,721 mV = + 0,001721 V entspricht 1 Grad Celsius minus-Abweichung;
# - 1,721 mV = - 0,001721 V entspricht 1 Grad Celsius plus-Abweichung.
Umrechnungsfaktor = 3.3 / (65535)
# Endlos-Schleife starten
while True:
# Temparatur-Sensor als Dezimalzahl lesen:
# EinlesewertDigi geht von 0 - 65535
EinlesewertDigi = Temperatursensor.read_u16()
# EinlesewertDigi in Spannung umrechnen:
# Spannung beträgt zwischen
# 0 Volt bei EinlesewertDigi = 0, und
# 3,3 Volt bei EinlesewertDigi = 65535.
Spannung = EinlesewertDigi * Umrechnungsfaktor
# Spannung in Temperatur umrechnen:
# a. wenn Spannung um 0,001721 höher ist als 0.706, also 0,707721
# ist Klammer: 0,001721, und
# Bruch ergibt: 1, und
# Temperatur somit 27 - 1 = 26 Grad Celsius.
# b. wenn Spannung um 0,001721 geringer ist als 0.706, also 0,704279
# ist Klammer: - 0,001721, und
# Bruch ergibt: - 1, und
# Temperatur somit 27 - -1 = 28 Grad Celsius.
temperatur = 27 - (Spannung - 0.706) / 0.001721
# Ausgabe in der Kommandozeile/Shell
print("EinlesewertDigi: ", EinlesewertDigi)
print("Spannung (V): ", Spannung)
print("Temperatur (°C): ", temperatur)
print()
# 2 Sekunden warten
sleep(2)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0510 2 LEDs mit 2 Taster-Interrupts ein-aus.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
#===============================================================================
#Ein-/Aus-Schalten von 2 LEDs aufgrund von Interrupts von 2 Tastern.
#
#Zweck: zeigt Komponenten der Interrupt-Steuerung (zur Weiterverwendung)
#
#===============================================================================
#
import machine
import utime
taster1=0
taster2=0
LED1 = machine.Pin(15, machine.Pin.OUT)
LED2 = machine.Pin(14, machine.Pin.OUT)
Taster1an = machine.Pin(16, machine.Pin.IN, machine.Pin.PULL_DOWN)
Taster2an = machine.Pin(17, machine.Pin.IN, machine.Pin.PULL_DOWN)
def tast1prog(p):
global taster1
if taster1 == 1:
taster1 = 0
utime.sleep(0.1)
elif taster1 == 0:
taster1 = 1
utime.sleep(0.1)
def tast2prog(p):
global taster2
if taster2 == 1:
taster2 = 0
utime.sleep(0.1)
elif taster2 == 0:
taster2 = 1
utime.sleep(0.1)
Taster1an.irq(trigger = machine.Pin.IRQ_RISING, handler = tast1prog)
Taster2an.irq(trigger = machine.Pin.IRQ_RISING, handler = tast2prog)
while True:
if taster1 == 1:
LED1.value(1)
elif taster1 == 0:
LED1.value(0)
if taster2 == 1:
LED2.value(1)
elif taster2 == 0:
LED2.value(0)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
... und hier das selbe Programm, jetzt mit Kommentaren:
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
#==============================================================================================
#Ein-/Aus-Schalten von 2 LEDs aufgrund von Interrupts von 2 Tastern.
#
#Zweck: zeigt Komponenten der Interrupt-Steuerung (zur Weiterverwendung)
#==============================================================================================
#Importieren der benötigten Bibliotheken
#==============================================================================================
#Modul "machine" zur
# * GPIO Ausgabe-Steuerung an die LEDs,
# * GPIO Eingabe-Steuerung durch die Taster,
# * Konfiguration der Interrupts.
import machine
#Modul "utime" zum Einbau von Verzögerungen.
import utime
#==============================================================================================
#Definieren bzw. Vorbelegen der Default-Werte
#==============================================================================================
#Default-Werte für die Taster-Variablen; "0" bedeutet ausgeschaltet, nicht gedrückt.
#Da diese Variablen zur Wert-Übergabe aus den Interrupt-Unterprogrammen genutzt werden,
#müssen sie in den Interrupt-Unterprogrammen als globale Variablen definiert werden.
taster1=0
taster2=0
#==============================================================================================
#Definieren der zu benutzenden GPIO-Pins
#==============================================================================================
#Objekt-Definition der Klasse "Pin" mit Variablen-Namen (hier "LEDx") zur Bestimmung
# * welcher GPIO-Pin soll benutzt werden (hier GPIO "15" +"14"), und
# * wie soll er benutzt werden (hier "Pin.OUT"), also zur Ausgabe (hier an LEDs).
#ALSO hier: LEDs an GP15 und GP14 werden zur Anzeige benutzt werden.
LED1 = machine.Pin(15, machine.Pin.OUT)
LED2 = machine.Pin(14, machine.Pin.OUT)
#Objekt-Definition der Klasse "Pin" mit Variablen-Namen (hier "Tasterxan") zur Bestimmung
# * welcher GPIO-Pin soll benutzt werden (hier GPIO "16" +"17"), und
# * wie soll er benutzt werden (hier "Pin.IN"), also zur Eingabe (hier durch Taster).
# * ob "0 Volt" oder "3,3 Volt" am GPIO erwartet werden.
# (hier: 3,3 Volt), daher hat der leerlaufende Eingang 0 Volt, was "PULL_DOWN" entspricht).
#ALSO hier: Taster an GP16 und GP17 werden zur Eingabe benutzt werden.
Taster1an = machine.Pin(16, machine.Pin.IN, machine.Pin.PULL_DOWN)
Taster2an = machine.Pin(17, machine.Pin.IN, machine.Pin.PULL_DOWN)
#==============================================================================================
#Definieren der zu benutzenden UNTERPROGRAMME
#==============================================================================================
#Definition der (hier 2) Interrupt-Unterprogramme, welche durch Interrupt aufgerufen werden.
#Der gewählte Name beschreibt, dass das Unterprogramm durch Drücken des Tasters gestartet wird.
#Nach Durchlauf des Unterprogramms springt der Programmlauf wieder zurück an diejenige Stelle
#im Hauptprogramm, an der die Unterbrechung erfolgte und "macht" dort weiter.
#ALSO hier: wenn der Taster gedrückt wird,
# * wird die Variable "tasterx" von 0 auf 1 bzw. von 1 auf 0 geschaltet, und
# * wartet das Programm eine Zehntelsekunde zur Vermeidung von Taster-Prellungen.
def tast1prog(p):
#Variablen (hier "taster1" + "taster2"), die zur Kommunikation mit dem Hauptprogramm genutzt
#werden, müssen "global" (also in allen Programmteilen gültig und nutzbar) definiert werden.
global taster1
if taster1 == 1:
taster1 = 0
utime.sleep(0.1)
elif taster1 == 0:
taster1 = 1
utime.sleep(0.1)
def tast2prog(p):
global taster2
if taster2 == 1:
taster2 = 0
utime.sleep(0.1)
elif taster2 == 0:
taster2 = 1
utime.sleep(0.1)
#==============================================================================================
#Definieren des Interupt-Triggers (= Auslöser)
#==============================================================================================
#"Taster1/2an" sind erwartete GPIO-Eingänge, welche hier
# * zum Trigger eines Interrupts definiert werden,
# * einen Anstieg (= steigende Flanke) "RISING" also "0" auf "1" erwarten, und
# * im Eintritts-Fall die Unterprogramme "tast1/2prog" aufrufen.
Taster1an.irq(trigger = machine.Pin.IRQ_RISING, handler = tast1prog)
Taster2an.irq(trigger = machine.Pin.IRQ_RISING, handler = tast2prog)
#==============================================================================================
# HAUPTPROGRAMM * HAUPTPROGRAMM * HAUPTPROGRAMM * HAUPTPROGRAMM * HAUPTPROGRAMM
#==============================================================================================
#Die Endlos-Schleife schaltet die jewelige LED aufgrind des Wertes der Variablen
#"tasterx" ein und aus.
while True:
#print("Hauptprogramm läuft", "taster1= ", taster1, "taster2= ",taster2)
if taster1 == 1:
LED1.value(1)
elif taster1 == 0:
LED1.value(0)
if taster2 == 1:
LED2.value(1)
elif taster2 == 0:
LED2.value(0)
print("Hauptprogramm läuft; ", "taster1= ", taster1,"; taster2= ",taster2, "; LED1=", LED1.value(), "; LED2=", LED2.value())
utime.sleep(.1)
#==============================================================================================
# Ende HAUPTPROGRAMM * Ende HAUPTPROGRAMM * Ende HAUPTPROGRAMM * Ende HAUPTPROGRAMM * Ende
#==============================================================================================
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0520 Ampel mit Anforderung.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
import _thread
led_rot = machine.Pin(15, machine.Pin.OUT)
led_gelb = machine.Pin(14, machine.Pin.OUT)
led_gruen = machine.Pin(13, machine.Pin.OUT)
button = machine.Pin(16, machine.Pin.IN, machine.Pin.PULL_DOWN)
buzzer = machine.Pin(12, machine.Pin.OUT)
global button_pressed
button_pressed = False
def button_reader_thread():
global button_pressed
while True:
if button.value() == 1:
button_pressed = True
utime.sleep(0.01)
_thread.start_new_thread(button_reader_thread, ())
while True:
if button_pressed == True:
led_rot.value(1)
for i in range(10):
buzzer.value(1)
utime.sleep(0.2)
buzzer.value(0)
utime.sleep(0.2)
global button_pressed
button_pressed = False
led_rot.value(1)
utime.sleep(5)
led_gelb.value(1)
utime.sleep(2)
led_rot.value(0)
led_gelb.value(0)
led_gruen.value(1)
utime.sleep(5)
led_gruen.value(0)
led_gelb.value(1)
utime.sleep(5)
led_gelb.value(0)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
Was macht das Programm?
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Workshop PicoBello-03
Projekte / Programme
Im Folgenden sind die in PicoBello-03 besprochenen Programme aufgeführt.
Folgende zwei Varianten beschreiben, wie die hier vorgestellten Programme in den eigenen Thonny-Editor gelangen können:
- Durch einen Klick mit der linken Maus-Taste auf den Media: xyz .txt –Link öffnet sich ein Browser-Fenster mit den genutzten MicroPython-Programm-Befehlen, die von dort in den Thonny-Editor kopiert werden können ...
oder ...
- Durch einen Klick mit der rechten Maus-Taste auf den Media: xyz .txt –Link öffnet sich ein anderes Browser-Fenster, über welches über „Ziel speichern unter …“ die Text-Dateien mit den MicroPython-Programm-Befehlen auf den eigenen PC heruntergeladen werden können. Von dort können die Befehle in den Thonny-Editor kopiert werden.
- Was macht das Programm? erklärt, was das jeweilige Programm bewirkt.
- Beschreibung der Befehle erläutert kurz benutzte Programm-Befehle .
- Was probieren ...? gibt Anregungen zum selber experimentieren .
Mit eckigen Klammern [ ] werden Programm-Befehle beschrieben; "Z4" steht für Zeile 4.
Viel Spaß beim Testen und Ausprobieren ...
GS_102 Fading LED with PWM.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
poti = machine.ADC(0)
led = machine.PWM(machine.Pin(15))
led.freq(1000)
while True:
wertpoti = poti.read_u16()
print(wertpoti)
led.duty_u16(wertpoti)
utime.sleep(0.05)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
GS_103 Fading LED with PWM auto.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
#poti = machine.ADC(0)
led = machine.PWM(machine.Pin(15))
led.freq(1000)
zuwachs=1000
pause=2
while True:
print("es wird: heller ...")
utime.sleep(pause)
for hell in range(1,65536,zuwachs):
led.duty_u16(hell)
print("heller: ",hell)
utime.sleep(0.05)
print("es wird: dunkler ...")
utime.sleep(pause)
for hell in range(65536,1,-zuwachs):
led.duty_u16(hell)
print("dunkler: ",hell)
utime.sleep(0.05)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
GS_085 HC-SR501 PIR-Alarm LED.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
import machine
import utime
k=0
sensor_pir = machine.Pin(28, machine.Pin.IN, machine.Pin.PULL_DOWN)
led = machine.Pin(15, machine.Pin.OUT)
def pir_handler(pin):
global k
utime.sleep_ms(100)
if pin.value():
print("ALARM! Motion detected!")
for i in range(20):
led.toggle()
utime.sleep_ms(100)
k=0
sensor_pir.irq(trigger=machine.Pin.IRQ_RISING, handler=pir_handler)
while True:
print(k,"kein Interrupt")
k=k+1
utime.sleep(.2)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0440 Temperaturmessung TMP36.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
from machine import ADC
import utime
AnalogIn = ADC(0)
Umw_DigitalIn_in_mV = 3300 / 65535
k=0
while True:
k=k+1
DigiV_0_bis_65535 = AnalogIn.read_u16()
mV = DigiV_0_bis_65535 * Umw_DigitalIn_in_mV
Temp = (mV - 500.0) / 10.0
print(k," DigiV_0_bis_65535 = ",DigiV_0_bis_65535," mV = ", mV," Temperatur = ", Temp," Grad Celsius")
utime.sleep(1)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0450 Temperaturmessung TMP36 und Werte speichern.py
Steckung wie zuvor 0440 Temperaturmessung TMP36.py
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
from machine import ADC
import utime
AnalogIn = ADC(0)
Umw_DigitalIn_in_mV = 3300 / 65535
k=0
DateiT = open("Keller-Temperaturen.txt","w")
DateiT.write("Temperaturen im Keller\n")
while True:
k=k+1
DigiV_0_bis_65535 = AnalogIn.read_u16()
mV = DigiV_0_bis_65535 * Umw_DigitalIn_in_mV
Temp = (mV - 500.0) / 10.0
TempStr = str(Temp)[:5]
SpeicherZeile = str(k) + " " + TempStr + "\n"
DateiT.write(SpeicherZeile)
DateiT.flush()
print(k," DigiV_0_bis_65535 = ",DigiV_0_bis_65535," mV = ", mV," Temperatur = ", Temp," Grad Celsius")
print(k," ", TempStr," Grad Celsius")
utime.sleep(1)
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
0455 Temperatur-Speicher-Werte einlesen.py
... ohne, bzw. beliebige Steckung ...
==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==
DateiIn = open("Keller-Temperaturen.txt","r")
for i in range(11):
print(DateiIn.readline())
DateiIn.close()
===Ende============ MicroPython Programm-Code für Thommy ============Ende===
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Ressourcen
Pin Belegung am Pico
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
MicroPython auf Pico und Thonny auf PC installieren
MicroPython auf Pico installieren
1) USB-Kabel zuerst an Pico einstecken (Achtung: breite Stecker-Seite nach oben).
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
2) „BOOTSEL“-Taster auf Pico drücken und gedrückt halten, und während gedrückt: USB-Kabel an PC einstecken … und bis 3 zählen.
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
3) „BOOTSEL“-Taster auf Pico loslassen.
4) Neues USB-Laufwerk erscheint mit Dateien:
INDEX.HTM und INFO_UF2.TXT
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
- Doppel-Klick (mit linker Maustaste) auf Symbol über Name „INDEX.HTM“.
- Die Seite „Welcome to your Raspberry Pi Pico“ öffnet sich.
- Klicken (wenn nicht vermerkt, immer mit linker Maustaste) auf „Getting started with MicroPython“.
- Nach unten scrollen, bis grüner Button mit weißer Schrift „Download UF2 file“ erscheint.
(Die Datei-Endung "UF2" steht für "USB Flashing Format", einem von Microsoft entwickelten Datei-Format, um Microcontroller-Bertriebssysteme über USB-Speicher zu "flashen" (= in den Speicher des Microcontrollers zu laden). - Klick auf diesen Button.
- Die UF2-Datei wird in den Download-Ordner heruntergeladen.
- Download-Ordner öffnen und Download-Fenster neben (automatisch geöffnetem) USB-Laufwerk-Fenster anordnen.
- Datei mit „.UF2“ Endung vom Download-Fenster in das USB-Laufwerk-Fenster „ziehen“ (= kopieren).
- Kurz darauf verschwindet das USB-Laufwerk-Fenster … und somit wurde MicroPython auf den Pico geladen.
Entwicklungsumgebung "Thonny" auf PC herunterladen und installieren
- Von thonny.org die für das Betriebssystem passende Thonny-Programmier-Umgebung herunterladen.
- Das heruntergeladene Thonny (durch Doppel-Klick auf die Datei) installieren.
- Thonny starten.
- Sicherstellen, dass das USB-Kabel Pico mit PC (noch) verbindet.
- Im Thonny-Fenster unten rechts auswählen:
“MicroPython (Raspberry Pi Pico)“ - Klick auf grünen Plus-Button („New“) startet neues, leeres Thonny-Programmier-Fenster.
- Über „Load“ und „Save“ können (auch eigene) Programme geladen, bzw. gespeichert werden … sowohl auf dem PC, wie auch auf dem Pico.
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Pico Internet-Ressourcen
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Equipment Anbieter
- https://www.blog.berrybase.de
- https://www.blog.berrybase.de/blog/2021/02/08/erste-schritte-mit-dem-raspberry-pi-pico/
- https://www.elektor.de/raspberry-pi-pico-rp2040
- https://www.reichelt.de/raspberry-pi-pico-rp2040-cortex-m0-microusb-rasp-pi-pico-p295706.html?CCOUNTRY=445&LANGUAGE=de
- https://www.pollin.de/p/neigungssensor-sw-660-180123
- https://www.makershop.de/sensoren/page/2/
- https://www.welectron.com/Raspberry-Pi-Pico
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Pico Video-Links
| Nr | Titel | Quelle | Bemerkung |
|---|---|---|---|
| 1 | Raspberry Pi Pico Complete Guide, Pinout+Features+ADC+I2C+OLED+Internal Temperature Sensor+DHT11 - YouTube | https://www.youtube.com/watch?v=oaM80GyVIwA&t=844s | |
| 2 | Raspberry Pi PICO, Starting With MicroPython + Examples; I2C OLED, ADC, PWM - YouTube | https://www.youtube.com/watch?v=zlKJ5hvfs6s | |
| 3 | Raspberry Pi Pico - YouTube | https://www.youtube.com/watch?v=peLH-HNza44 | LED Lauflicht |
| 4 | Raspberry Pi Pico: Inputs & Servo Control - YouTube | https://www.youtube.com/watch?v=TDj2kcSA-68 | |
| 5 | Raspberry Pi Pico - Control the (I/O) World - YouTube | https://www.youtube.com/watch?v=Zy64kZEM_bg | |
| 6 | Raspberry Pi Pico der interne Temperatursensor - YouTube | https://www.youtube.com/watch?v=J8AuGEGgqYM | |
| 7 | Raspberry Pi Pico Einführung mit dem LCD 1602 (16x2) + HD44780 I2C Adapter in Thonny MicroPython - YouTube | https://www.youtube.com/watch?v=IkDhN8EbOUs | |
| 8 | Raspberry Pi Pico (RP2040) SPI Example with MicroPython and C/C++, Digi-Key Electronics - YouTube | https://www.youtube.com/watch?v=jdCnqiov6es | |
| 9 | How to Use WS2812B RGB LEDs with Raspberry Pi Pico (using MicroPython) - YouTube | https://www.youtube.com/watch?v=PCHahR7jBbQ | |
| 10 | Talk to Your Pico Over Serial, Raspberry Pi Pico UART Tutorial - YouTube | https://www.youtube.com/watch?v=pbWhoJdYA1s | |
| 11 | How to set up a wake word on the Raspberry Pi Pico - Easy as AI - YouTube | https://www.youtube.com/watch?v=V0KXZGhHUQY | |
| 12 | Raspberry Pi Pico Interrupt Problems - YouTube | https://www.youtube.com/watch?v=-8sWuLtXS08 | |
| 13 | USB Serial Input on the Raspberry Pi Pico - YouTube | https://www.youtube.com/watch?v=NHwMJZwRo7k | |
| 14 | Beginners Guide to SPI on the Raspberry Pi Pico (BMP280 Example) - YouTube | https://www.youtube.com/watch?v=s7Lud1Gqrqw | |
| 15 | using Interrupts on the raspberry Pi pico, Micropython, simple Demo and code - YouTube | https://www.youtube.com/watch?v=Qw2xr5a2rSA | |
| 16 | Raspberry Pi Pico UART setup, Send data to PC with UART, Real time data plotting, Matplotlib - YouTube | https://www.youtube.com/watch?v=PFdJvAbHB5c | |
| 17 | How to read the temperature sensor on the Raspberry Pi Pico - YouTube | https://www.youtube.com/watch?v=PYOaO1yW0rY | |
| 18 | Using I2C between Raspberry Pi computer, a Pico microcontroller and an Arduino - YouTube | https://www.youtube.com/watch?v=Wh-SjhngILU | |
| 19 | raspberry pi pico, raspberry pi pico ultrasonic sensor, raspberry pi pico micropython - YouTube | https://www.youtube.com/watch?v=Uti3s0XGsEY | |
| 20 | Raspberry Pi Pico #1 - Der leichte Einstieg! | https://www.youtube.com/watch?v=HigJJ5HhaAA | |
| 21 | Raspberry Pi Pico Servo Motors via PWM | https://www.youtube.com/watch?v=NqchLYWHCzA | |
| 22 | LED anschließen und Vorwiderstand berechnen | https://www.youtube.com/watch?v=DBQBNj3xJR8 | |
| 23 | Alles über Widerstände und wie man die Farbringe liest. | https://www.youtube.com/watch?v=C-Ywtr2ftxA | |
| 24 | |||
| 25 | |||
| 26 | |||
| 27 | |||
| 28 |
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Fotos
- Pico „pur“ mit USB-Kabel zum PC
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
- Pico mit anzulötenden Stiftleisten
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
- Pico mit angelöteten Stiftleisten
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
- Pico auf Breadboard mit Ampel und USB-Kabel
-> Inhaltsverzeichnis (dieses Ressourcen-Wikis)
Pico Projekt-Ideen
| Nr | Idee | Initiator | Status | Weiter-Verfolgung |
|---|---|---|---|---|
| 1 | Temperatur-Messung "am" Pico | |||
| 2 | Überwachungs-Thermometer für Innenräume,
für Gefrier- und Kühlschrank (mit Schwelle und Alarm) |
|||
| 3 | Analyse von Holzkäfer-Geräuschen z.B. im Dachstuhl | |||
| 4 | Garagentor-Status abfragen z.B. für Garage | |||
| 5 | Briefkasten (Posteingang) | |||
| 6 | Füllstandsmesser z.B. für Brunnen | |||
| 7 | Abstandsmesser z.B. Corona | |||
| 8 | Feuchtigkeits-Monitoring Pflanzenerde | |||
| 9 | Wasserwerfer z.B. "für" Katze | |||
| 10 | Lauflichtsteuerung | |||
| 11 | Nametag (feststehend; mit Durchlauf) | |||
| 12 | Rhytmus-Schalter (z.B. mit Klatsch- oder Taster-Erkennung) | |||
| 13 | Druckmessung z.B. Nordic-Walking-Stöcke | |||
| 14 | logische Schaltungen, Gatter | |||
| 15 | Messung Sonnenscheinausbeute (Stärke, Dauer, Zeiten, usw.) | |||
| 16 | Messung Wasserparameter z.B. für einen Teich (Temperatur, Sauerstoffgehalt, Wasserdichte, usw.) | |||
| 17 | Dämmerungsschalter (z.B. Beleuchtung ermöglichen) | |||
| 18 | Zahlenschloss mit Zahlenfeld (z.B. für Türöffner) | |||
| 19 | Morse-Dekodierer (z.B. per Taster oder Mikrofon) | |||
| 20 | GPS-Logger (z.B. für Alibi: wo war ich wann?) | |||
| 21 | Diebstahl-/Bewegungs-Warner (z.B. am Gepäckstück) | |||
| 22 | Annäherungsschalter (z.B. Wasserhahn schalten) | |||
| 23 | Bewegungsmelder (z.B. Raumlicht oder Alarm schalten) | |||
| 24 | Detektion und Aufnahme von Tier (und Mensch) im Garten | |||
| 25 | Integration mit bestehender Haus-Automation | |||
| 26 | Töne erzeugen "Klavier"? | |||
| 27 | Zimmer-Ampel mit Anforderung | |||
| 28 | Entscheidungshilfe (mit Zufallszahlengenerator) | |||
| 29 | Weihnachts-LED-Bäumchen | |||
| 30 | Eier-Uhr | |||
| 31 | Springbrunnen-Steuerung | |||
| 32 | Zeit- und annäherungs-gesteuerter Adventskranz | |||
| 33 | Eisenbahn-Anwendungen | |||
| 34 | ||||
| 35 | ||||
| 36 | ||||
| 37 | ||||
| 38 | ||||
| 39 |
-> Inhaltsverzeichnis (dieses PicoBello-Wikis)
Pico Offene Fragen
| Nr | Frage | Vermutung | Antwort | Quelle | Referenzen |
|---|---|---|---|---|---|
| 1 | |||||
| 2 | |||||
| 3 | |||||
| 4 | |||||
| 5 | |||||
| 6 | |||||
| 7 | |||||
| 8 | |||||
| 9 |