VDI Pico EVA Workshops

Konzept

Dies ist ein Wiki für Interessierte und Workshop-Teilnehmende.

Titel des Vorhabens

• Programmier-Projekte in Theorie und Praxis mit dem Raspberry Pi Pico (EVA-1 und EVA-2) für Einsteiger ohne Programmierkenntnisse
• ein innovatives Angebot des VDI Mittelrhein BV

Was ist das Ziel der Workshops?

• Ziel ist es, dass ihr eigene Projekte mit dem Pico selbst planen und umsetzen könnt.

Für welches Alter ist der Workshop gedacht?

• Ihr solltet zwischen 10 und 14 Jahre alt sein.
• Bei besonders großem Interesse (und bei Verfügbarkeit) können auch VDInis unter 10 und Zukunftspiloten über 14 Jahre teilnehmen.

Gibt es eine Teilnehmerbegrenzung?

• Um mit genügend Zeit auf Fragen und Anregungen eingehen zu können, sind die Workshops auf 20 Teilnehmer/innen begrenzt.

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

Wie finden die Workshops statt und welche Voraussetzungen sind dafür nötig?

• Die Workshops erfolgen als Jitsi-Webmeeting, also online von PC zu PC.
• Dafür ist es wichtig, dass ihr einen Raspberry Pi oder einen Windows- oder Apple-PC (für den Programmier-Editor) und einen Internetanschluss (für die Teilnahme am Jitsi-Meeting) während der Workshops zur Verfügung habt.

Wer führt euch durch die zwei Workshops?

• Karin Peiter (Leiterin Zukunftspiloten im VDI Mittelrhein BV)
• Beate Schumacher (Leiterin VDIni-Club im VDI Mittelrhein BV)
• Dieter Carbon, Dipl. Ing. Elektrotechnik (Comidio GmbH, Arbeitskreis-Leiter „Internet-Sicherheit“ im VDI Rheingau-BV)

Was kosten diese Workshops?

• Wir besorgen das notwendige „Pico-Material“ und senden es euch rechtzeitig vor dem ersten Workshop per Post nach Hause.
• Die Kosten für den Pico sowie die weiteren Materialien einschließlich Versandkosten betragen 20 €.
• VDInis und Zukunftspiloten des Mittelrheinischen BV Koblenz werden wir nach Abschluss der Workshops bei nachgewiesener Teilnahme die Kosten zurückerstatten.
• Wenn ihr noch kein Mitglied seid, habt ihr die Möglichkeit, für 24 € Jahresbeitrag einem der beiden Clubs (des Vereins) beizutreten. Somit könnt ihr ebenfalls in den Genuss der Geldrückzahlung kommen und gleichzeitig noch viele weitere Vorteile der Vereine nutzen.

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

Wann finden die Workshops statt?

• erster Workshop (EVA-1) am Dienstag 09.11.2021 von 17.00 – 20.00 Uhr.
• PicoBello (Fragestunde) am Dienstag 23.11.2021 von 17.00 – 19.00 Uhr.
• zweiter Workshop (EVA-2) am Dienstag 07.12.2021 von 17.00 – 20.00 Uhr.

Was ist im Teilnahmebeitrag von 20 € enthalten?

• Raspberry Pi Pico, RP2040 Mikrocontroller mit angelöteten Stiftleisten
• Micro USB Kabel (Verbindung zum PC)
• Steckbrett mit 830 Kontakten
• 20 Stecker-Stecker-Kabel
• 5 Stecker-Buchsen-Kabel
• 3 LEDs (rot, gelb und grün)
• 7 LEDs (weiß)
• 10 Widerstände (für LEDs)
• 1 Potentiometer
• 5 Taster
• 1 Bewegungsmelder
• 1 Summer
• 1 Temperatursensor
• 1 Relais (für später)

und die Versandkosten.

An wen kann ich mich bei Fragen wenden?

• eine E-Mail an: vdini.zukunftspiloten@vdi-koblenz.de

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

Leitung Workshop Mittelrheinischer BV

Funktion	Name	E-Mail
Leitung & Organisation	Karin Peiter (KP)	vdini.zukunftspiloten@vdi-koblenz.de
Leitung & Organisation	Beate Schumacher (BS)	vdini.zukunftspiloten@vdi-koblenz.de
Durchführung	Dieter Carbon (DC)	dieter.carbon@comidio.de

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

Fragen & Antworten

Nr	Frage	Antwort
1	Lerne ich da programmieren?	Wir steigen ein in die Micro-Python Programmierung und entwickeln verschiedene Programme, die Du selbst erweitern oder ergänzen kannst.
2	Muss ich den Pico wieder zurückgeben?	Nein, der gehört Dir.
3	Gibt es noch weitere Wopkshops?	Das hängt davon ab, ob der Workshop den Teilnehmenden Spaß macht.
4	Kann ich auch später einsteigen?	Leider Nein, die Workshops bauen aufeinander auf.

-> Inhaltsverzeichnis (dieses VDI-Pico-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 VDI-Pico-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 VDI-Pico-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 VDI-Pico-Wikis)

---

EVA-1 Dienstag, 09.11.2021 von 17.00 bis 20.00 Uhr

Projekte / Programme

Im Folgenden sind die in diesem Workshop besprochenen Programme aufgeführt (TLN = Teilnehmende; WSL = Workshop-Leiter).

Die Projekt-/Programm-Beschreibungen umfassen:

• Screenshot des Programms in Thonny, speziell, wenn in der Kommandozeile Programm-Eingaben und -Ausgaben gezeigt werden sollen,
• kopierfähiger Programmcode im Bereich "MicroPython Programm-Code für Thommy",
• Steckbrett-Graphik mit benötigten Kabel-Verbindungen und Bauteilen,
• Steckbrett-Foto mit einer Beispiel-"Steckung".

In den Workshops gehen wir folgendermaßen vor:

• Der WSL erklärt kurz Sinn und Zweck des nächsten Projekts.
• Der WSL zeigt seine Projekt-Steckung live per Video, startet das Programm und zeigt und erklärt die Programm-Auswirkungen.
• Die TLN kopieren den Programm-Code in ihren eigenen Thonny-Editor.
• Die TLN bauen ihre eigene Steckung anhand der Steckbrett-Graphik und des Steckbrett-Fotos.
• Die TLN starten jeweils ihr Programm und beobachten die Programm-Auswirkungen.
• Die TLN bestätigen die planmäßige Ausführung, oder beschreiben ein Problem oder einen Fehler.
• Gemeinsam werden Problem oder Fehler besprochen und GEKLÄRT.
• Erst wenn alle TLN-Programme planmäßig laufen, wird das nächste Programm in Anmgriff genommen.
• Abhängig vom Workshop-Verlauf bestimmt der WSL Projekt-Inhalte und -Folge des Workshops.

Die Projekte / Programme sollen die Basis dafür bieten, dass die TLN die Programme anschließend selbständig nachvollziehen und erweitern, sowie eigene Projekte planen und durchführen können.

1. Was macht das Programm? erklärt, was das jeweilige Programm bewirkt.
   
2. Beschreibung der Befehle erläutert kurz benutzte Programm-Befehle .
   
3. 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.

Was probieren ...?

• Text in Anführungszeichen ändern,
• print Befehl mehrfach anwenden.

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

---

0020 Schleife 0-9.py

Media:0020 Schleife 0-9.txt

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
• 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 VDI-Pico-Wikis)

---

0030 Schleife 1-10.py

Media:0030 Schleife 1-10.txt

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 VDI-Pico-Wikis)

---

0040 Endlos-Schleife.py

Media:0040 Endlos-Schleife.txt

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 VDI-Pico-Wikis)

---

0050 Eingabe Supermann.py

Media:0050 Eingabe Supermann.txt

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 VDI-Pico-Wikis)

---

0060 bedingte Schleife.py

Media:0060 bedingte Schleife.txt

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 VDI-Pico-Wikis)

---

0070 Zufallszahl.py

Media:0070 Zufallszahl.txt

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 VDI-Pico-Wikis)

---

0080 Was tun Generator.py

Media:0080 Was tun Generator.txt

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 VDI-Pico-Wikis)

---

0210 LED_auf_Pico an aus.py

Media:0210 LED_auf_Pico an aus.txt

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 VDI-Pico-Wikis)

---

0211 LED_auf_Pico an aus mit Variablen.py

Media:0211 LED_auf_Pico an aus mit Variablen.txt

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 VDI-Pico-Wikis)

---

0310 LED ext an aus.py

Media:0310 LED ext an aus.txt

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 VDI-Pico-Wikis)

---

PicoBello (Fragestunde) am 23.11.2021

• Termin: Dienstag, 23.11.2021 von 17.00 bis 19.00 Uhr

Media:0420 Adventskalender manuell.txt

Media:0421 Adventskalender 1-24 auto.txt

EVA-2 Dienstag, 07.12.2021 von 17.00 bis 20.00 Uhr

Projekte / Programme

Im Folgenden sind die in diesem Workshop besprochenen Programme aufgeführt (TLN = Teilnehmende; WSL = Workshop-Leiter).

Die Projekt-/Programm-Beschreibungen umfassen:

• Screenshot des Programms in Thonny, speziell, wenn in der Kommandozeile Programm-Eingaben und -Ausgaben gezeigt werden sollen,
• kopierfähiger Programmcode im Bereich "MicroPython Programm-Code für Thommy",
• Steckbrett-Graphik mit benötigten Kabel-Verbindungen und Bauteilen,
• Steckbrett-Foto mit einer Beispiel-"Steckung".

In den Workshops gehen wir folgendermaßen vor:

• Der WSL erklärt kurz Sinn und Zweck des nächsten Projekts.
• Der WSL zeigt seine Projekt-Steckung live per Video, startet das Programm und zeigt und erklärt die Programm-Auswirkungen.
• Die TLN kopieren den Programm-Code in ihren eigenen Thonny-Editor.
• Die TLN bauen ihre eigene Steckung anhand der Steckbrett-Graphik und des Steckbrett-Fotos.
• Die TLN starten jeweils ihr Programm und beobachten die Programm-Auswirkungen.
• Die TLN bestätigen die planmäßige Ausführung, oder beschreiben ein Problem oder einen Fehler.
• Gemeinsam werden Problem oder Fehler besprochen und GEKLÄRT.
• Erst wenn alle TLN-Programme planmäßig laufen, wird das nächste Programm in Anmgriff genommen.
• Abhängig vom Workshop-Verlauf bestimmt der WSL Projekt-Inhalte und -Folge des Workshops.

Die Projekte / Programme sollen die Basis dafür bieten, dass die TLN die Programme anschließend selbständig nachvollziehen und erweitern, sowie eigene Projekte planen und durchführen können.

1. Was macht das Programm? erklärt, was das jeweilige Programm bewirkt.
   
2. Beschreibung der Befehle erläutert kurz benutzte Programm-Befehle .
   
3. 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

Media:0311 LED ext und Summer an aus.txt

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 VDI-Pico-Wikis)

---

0351 Morsen Worte mit Summer.py

Media:0351 Morsen Worte mit Summer.txt





Was macht das Programm?

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

---

0421 Adventskalender 1-24 auto.py

Media:0421 Adventskalender 1-24 auto.txt





Was macht das Programm?

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

---

0401 Würfel linear.py

Media:0401 Würfel linear.txt





Was macht das Programm?

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

---

EVA-3 Dienstag, 15.03.2022 von 17.00 bis 19.00 / 20.00 Uhr

Projekte / Programme

Im Folgenden sind die in diesem Workshop besprochenen Programme aufgeführt (TLN = Teilnehmende; WSL = Workshop-Leiter).

Die Projekt-/Programm-Beschreibungen umfassen:

• Screenshot des Programms in Thonny, speziell, wenn in der Kommandozeile Programm-Eingaben und -Ausgaben gezeigt werden sollen,
• kopierfähiger Programmcode im Bereich "MicroPython Programm-Code für Thommy",
• Steckbrett-Graphik mit benötigten Kabel-Verbindungen und Bauteilen,
• Steckbrett-Foto mit einer Beispiel-"Steckung".

In den Workshops gehen wir folgendermaßen vor:

• Der WSL erklärt kurz Sinn und Zweck des nächsten Projekts.
• Der WSL zeigt seine Projekt-Steckung live per Video, startet das Programm und zeigt und erklärt die Programm-Auswirkungen.
• Die TLN kopieren den Programm-Code in ihren eigenen Thonny-Editor.
• Die TLN bauen ihre eigene Steckung anhand der Steckbrett-Graphik und des Steckbrett-Fotos.
• Die TLN starten jeweils ihr Programm und beobachten die Programm-Auswirkungen.
• Die TLN bestätigen die planmäßige Ausführung, oder beschreiben ein Problem oder einen Fehler.
• Gemeinsam werden Problem oder Fehler besprochen und GEKLÄRT.
• Erst wenn alle TLN-Programme planmäßig laufen, wird das nächste Programm in Anmgriff genommen.
• Abhängig vom Workshop-Verlauf bestimmt der WSL Projekt-Inhalte und -Folge des Workshops.

Die Projekte / Programme sollen die Basis dafür bieten, dass die TLN die Programme anschließend selbständig nachvollziehen und erweitern, sowie eigene Projekte planen und durchführen können.

1. Was macht das Programm? erklärt, was das jeweilige Programm bewirkt.
   
2. Beschreibung der Befehle erläutert kurz benutzte Programm-Befehle .
   
3. 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 ...

---

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)

---

20220315 Justus-Stoppuhr.py

==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==

import machine
import utime

TasterStart = machine.Pin(16, machine.Pin.IN, machine.Pin.PULL_DOWN)
TasterStop = machine.Pin(17, machine.Pin.IN, machine.Pin.PULL_DOWN)

Start = 0
Stop = 0
Zeit = 0

def TasterStartProg(p):
    global Start
    print("Interrupt Start")
    Start = 1
        
def TasterStopProg(p):
    global Stop
    print("Interrupt Stop")
    Stop = 1
        
TasterStart.irq(trigger = machine.Pin.IRQ_RISING, handler = TasterStartProg)
TasterStop.irq(trigger = machine.Pin.IRQ_RISING, handler = TasterStopProg)

while Start == 0:
    print("noch kein Start",Start)
    utime.sleep(0.1)
    
while Stop == 0:
    Zeit=Zeit+ 0.1
    utime.sleep(0.1)
    print("Zeit: ",Zeit)
    utime.sleep(0.1)

print("gemessene Zeit: ", Zeit)
    


===Ende============ MicroPython Programm-Code für Thommy ============Ende===

Was macht das Programm?

-> 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)

---

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)
---

EVA-4 Dienstag, 03.05.2022 von 17.00 bis 19.00 / 20.00 Uhr

Projekte / Programme

Im Folgenden sind die in diesem Workshop besprochenen Programme aufgeführt (TLN = Teilnehmende; WSL = Workshop-Leiter).

Die Projekt-/Programm-Beschreibungen umfassen:

• Screenshot des Programms in Thonny, speziell, wenn in der Kommandozeile Programm-Eingaben und -Ausgaben gezeigt werden sollen,
• kopierfähiger Programmcode im Bereich "MicroPython Programm-Code für Thommy",
• Steckbrett-Graphik mit benötigten Kabel-Verbindungen und Bauteilen,
• Steckbrett-Foto mit einer Beispiel-"Steckung".

In den Workshops gehen wir folgendermaßen vor:

• Der WSL erklärt kurz Sinn und Zweck des nächsten Projekts.
• Der WSL zeigt seine Projekt-Steckung live per Video, startet das Programm und zeigt und erklärt die Programm-Auswirkungen.
• Die TLN kopieren den Programm-Code in ihren eigenen Thonny-Editor.
• Die TLN bauen ihre eigene Steckung anhand der Steckbrett-Graphik und des Steckbrett-Fotos.
• Die TLN starten jeweils ihr Programm und beobachten die Programm-Auswirkungen.
• Die TLN bestätigen die planmäßige Ausführung, oder beschreiben ein Problem oder einen Fehler.
• Gemeinsam werden Problem oder Fehler besprochen und GEKLÄRT.
• Erst wenn alle TLN-Programme planmäßig laufen, wird das nächste Programm in Anmgriff genommen.
• Abhängig vom Workshop-Verlauf bestimmt der WSL Projekt-Inhalte und -Folge des Workshops.

Die Projekte / Programme sollen die Basis dafür bieten, dass die TLN die Programme anschließend selbständig nachvollziehen und erweitern, sowie eigene Projekte planen und durchführen können.

1. Was macht das Programm? erklärt, was das jeweilige Programm bewirkt.
   
2. Beschreibung der Befehle erläutert kurz benutzte Programm-Befehle .
   
3. 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 ...

---

---

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===

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

---

0431 Temperaturmessung onboard und speichern.py

==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)
k=0

DateiT = open("Keller-Temperaturen.txt","w")
DateiT.write("Temperaturen im Keller\n")

# Endlos-Schleife starten
while True:
    k=k+1
    # 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()
    
    STRk=str(k)
    STRtemperatur = str(temperatur)[:5]
    SpeicherZeile=STRk+"  "+STRtemperatur+"\n"
    DateiT.write(SpeicherZeile)
    DateiT.flush()
    
    # 2 Sekunden warten
    sleep(2)

===Ende============ MicroPython Programm-Code für Thommy ============Ende===

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

---

0455 Temperatur-Speicher-Werte einlesen.py

==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)

---

0460 Reaktionsspiel mit 2 Tastern.py

==Anfang=========== MicroPython Programm-Code für Thommy ===========Anfang==

import machine
import utime
import random

tasterLi=0
tasterRe=0

LEDblau = machine.Pin(20, machine.Pin.OUT)
LEDliRot = machine.Pin(19, machine.Pin.OUT)
LEDliGruen = machine.Pin(18, machine.Pin.OUT)
LEDreRot = machine.Pin(17, machine.Pin.OUT)
LEDreGruen = machine.Pin(16, machine.Pin.OUT)
TasterLi = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)
TasterRe = machine.Pin(15, machine.Pin.IN, machine.Pin.PULL_DOWN)

def taster_links_prog(p):
    global tasterLi
    global LiZeit
    print("Interrupt tasterLi")
    LiZeit = utime.ticks_ms()
    tasterLi = 1
    utime.sleep(0.1)

def taster_rechts_prog(p):
    global tasterRe
    global ReZeit
    print("Interrupt tasterRe")
    ReZeit = utime.ticks_ms()
    tasterRe = 1
    utime.sleep(0.1)

TasterLi.irq(trigger = machine.Pin.IRQ_RISING, handler = taster_links_prog)
TasterRe.irq(trigger = machine.Pin.IRQ_RISING, handler = taster_rechts_prog)

print("Hauptprogramm startet")

while True:
    LEDblau.value(0)
    LEDliRot.value(0)
    LEDliGruen.value(0)
    LEDreRot.value(0)
    LEDreGruen.value(0)
 
    for i in range(1,6):
        LEDblau.value(1)
        utime.sleep(0.1)
        LEDblau.value(0)
        utime.sleep(0.1)
    Zufallszeit = random.randint(2,5)
    print("Zufallszeit in Sek.: ",Zufallszeit)
    utime.sleep(Zufallszeit)
    LEDblau.value(1)
    tasterLi = 0
    tasterRe = 0
    while (tasterLi * tasterRe) == 0:
        if tasterLi == 1:
            LEDliGruen.value(1)
        elif tasterRe == 1:
            LEDreGruen.value(1)
        utime.sleep(0.1)
    if LiZeit < ReZeit:
        LEDreRot.value(1)
    else:
        LEDliRot.value(1)
    print(tasterLi,tasterRe)
    print("LiZeit = ",LiZeit," und ReZeit = ",ReZeit)
    print("beide gedrückt")
    utime.sleep(2)


===Ende============ MicroPython Programm-Code für Thommy ============Ende===

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

---

EVA-X Fehlersuche

Wenn "Etwas" nicht funktioniert, kann dies eine oder mehrere Ursachen haben. Erfolgreiche Pico-Projekte benötigen das funktionierende Zusammenwirken folgender Komponenten:

Stromversorgung

Nr	Frage	wie feststellen?	wie abstellen?
1	Liegt am Pico die notwendige Spannung an?	mit Messgerät Spannung messen; Test-Programm	USB-Verbindungskabel prüfen; externe Stromquelle prüfen
2	Liegt an den Komponenten die notwendige Spannung an?	mit Messgerät Spannung messen
3
4

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

PC

Nr	Frage	wie feststellen?	wie abstellen?
1	Läuft Thonny?	Editor sichtbar?	Thonny (erneut) aufrufen
2	Hat Thonny Verbindung mit dem Pico?	ist "lila Dreifach-Pfeil" sichtbar?	unten rechts "Pico" auswählen; "Stop" drücken; Thonny neu starten; PCneu starten
3
4

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

Verbindungskabel

Nr	Frage	wie feststellen?	wie abstellen?
1	Ist das USB-Verbindungskabel mit dem PC verbunden?	nicht verbunden oder lose	anderen USB-Anschluss probieren; erneut einstecken
2	Ist das USB-Verbindungskabel mit dem Pico verbunden?	nicht verbunden oder lose	erneut einstecken; Kabel tauschen
3
4

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

Pico

Nr	Frage	wie feststellen?	wie abstellen?
1	Liegt am Pico die notwendige Spannung an?	Test-Programm	Pico wechseln
2	Funktioniert der Pico?	Test-Programm	Pico wechseln
3	Ist das Programm gestartet, läuft es?	Test-Programm	Pico wechseln
4
5

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

Steckbrett

Nr	Frage	wie feststellen?	wie abstellen?
1	Funktionieren die Steckbrettverbindungen zum Pico?	mit Messgerät testen
2	Funktionieren die Steckbrettverbindungen zu den Bauteilen?		Steckkabel tauschen
3
4

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

Bauteile

Nr	Frage	wie feststellen?	wie abstellen?
1	Funktioniert die interne LED?	Test-Programm	Pico wechseln
2	Funktioniert die LED?	"Einzel-Test" an 3,3V	LED wechseln
3	Funktioniert der Widerstand?	Widerstandswert messen	Widerstand wechseln
4	Funktioniert der Summer?	"Einzel-Test" an 3,3V	Summer wechseln
5	Funktioniert der Taster?	Durchgang messen	Taster wechseln
6	Funktioniert das Potentiometer?	Widerstandswert messen	Poti wechseln
7
8
9
10

-> Inhaltsverzeichnis (dieses PicoBello-Wikis)

Glossar

Nr	Begriff	Beschreibung	Beispiel
1	Abfrage	Ein Abfrage-Ergebnis (auf kleiner, größer, gleich oder un-gleich) kann, falls „wahr“ (= „true“) zu einer Weiterführung oder Beendigung von Schleifen-Durchläufen führen.	Beispiel
2	abspeichern	Daten (z.B. Messwerte) können auf dem Pico gespeichert werden.	Beispiel
3	Abzweigung	Abhängig von Werte-Abfragen können Schleifendurchläufe beendet werden.	Beispiel
4	Adresse	Adressen sind relevant bei der Kommunikation z.B. mit Sensoren, anderen Picos oder mit einem Raspberry Pi.	Beispiel
5	Aktor, Aktuator	Bauelement, welches elektrische Signale in mechanische Bewegung umwandelt, z.B. Stellglied, Ventil, Relais, Servomotor, Pumpe.	Beispiel
6	analog/digital Wandler	Umwandlung analoger Signale (z.B. Temperatur, Potentiometer-Widerstand) in digitale Werte. Der Pico besitzt mehrere A/D-Kanäle.	Beispiel
7	Anfangswert	Ein Anfangswert kann hoch sein und wird heruntergezählt, oder er startet bei „0“ oder „1“ und wird heraufgezählt.	Beispiel
8	Anweisung	Eine Anweisung ist z.B. eine Befehlszeile in einem Programm. Ist eine Befehlszeile erledigt, folgt die nächste Zeile.	Beispiel
9	Anweisung, bedingte	Eine bedingte Anweisung ist z.B. eine Befehlszeile in einem Programm, welche nur unter gewissen Bedingungen „erreicht“ und somit ausgeführt wird.	Beispiel
10	Anzeige	Im engeren Sinn sind Anzeigen „Zahlen- und Buchstaben-Ausgaben“, welche über die „Thonny-Kommandozeile“ des PCs erfolgen, oder über direkt am Pico angeschlossene ein- oder mehrzeilige Displays. Im weiteren Sinn gehören auch z.B. LEDs zu „Anzeigen“.	Beispiel
11	aufrufen	Beschreibung	Beispiel
12	Ausgabe	Ausgabe ist ein Ergebnis, welches aufgrund einer Eingabe und einer darauffolgenden Verarbeitung erfolgt. Ausgaben können aus Buchstaben und Zahlen bestehen, oder auch in Form von Steuerungen (z.B. von Heizungen, Ventilen, Schließanlagen	Beispiel
13	Befehl	Anweisung, die vom Pico „verstanden“ wird und in einer Programm-Zeile steht. Ein Befehl kann eine Ein- oder Ausgabe zur Folge haben, oder einen Vergleich oder eine Berechnung durchführen.	Beispiel
14	Berechnung	In der Regel eine mathematische Funktion, welche z.B. Sensorwerte und Messgrößen in allgemein-gebräuchliche Umgangswerte (z.B. Temperatur) berechnet.	Beispiel
15	Betriebssystem	IT-Basis-Softwaresystem (wie z.B. Microsoft Windows), welches die Programm- und Datennutzung auf einer bestimmten Hardware ermöglicht. Im Fall des Pico ist dies MicroPython, welches über die Entwicklungsumgebung Thonny programmiert werden kann.	Beispiel
16	Bibliothek	Im Sinn des Pico: eine themen-orientierte Programmsammlung, die der Programmierer je nach Bedarf in seinen Programmen nutzen kann, wie z.B. zeit-, IO-, Zufalls- oder Interrupt-bezogene Programmfunktionen.	Beispiel
17	Compiler	Programm, das ein Quell-Programm in Gesamtheit in ausführbaren Code umrechnet, welcher dann auf einem Rechner abläuft. Im Gegensatz hierzu übersetzt ein Interpreter, wie MicroPython, zeilenweise ein Programm in ausführbaren Programmcode.	Beispiel
18	Datei	Programme können als Dateien sowohl auf dem PC als auch auf dem Pico abgelegt werden. Zudem können Informationen wie z.B. Messwerte als Datendateien auf dem Pico gespeichert und auch wieder abgerufen werden.	Beispiel
19	Definition	Beschreibung	Beispiel
20	Editor	Beschreibung	Beispiel
21	Eingabe	Beschreibung	Beispiel
22	Entwicklungsumgebung	Beschreibung	Beispiel
23	flashen	Beschreibung	Beispiel
24	Formatierung	Beschreibung	Beispiel
25	Gespeichertes nutzen	Beschreibung	Beispiel
26	GPIO	Beschreibung	Beispiel
27	Hauptprogramm	Beschreibung	Beispiel
28	Integer	Beschreibung	Beispiel
29	Interpreter	Beschreibung	Beispiel
30	Interrupt	Beschreibung	Beispiel
31	Jumper	Beschreibung	Beispiel
32	Kommentar	Beschreibung	Beispiel
33	Kommunikation	Beschreibung	Beispiel
34	Konstante	Beschreibung	Beispiel
35	LED	Beschreibung	Beispiel
36	main.py	Beschreibung	Beispiel
37	Microcontroller	Beschreibung	Beispiel
38	Microprozessor	Beschreibung	Beispiel
39	MicroPython	Beschreibung	Beispiel
40	Objekt	Beschreibung	Beispiel
41	Pin	Beschreibung	Beispiel
42	Potentiometer	Beschreibung	Beispiel
43	Programm	Beschreibung	Beispiel
44	Programmier-Editor	Beschreibung	Beispiel
45	Programm-Name	Beschreibung	Beispiel
46	Raute	Beschreibung	Beispiel
47	Re-Engineering	Beschreibung	Beispiel
48	Schleife, bedingt	Beschreibung	Beispiel
49	Schleife, endlos	Beschreibung	Beispiel
50	Sensor	Beschreibung	Beispiel
51	Shell	Beschreibung	Beispiel
52	Steckerleiste	Beschreibung	Beispiel
53	Stiftleiste	Beschreibung	Beispiel
54	Summer	Beschreibung	Beispiel
55	Thonny	Beschreibung	Beispiel
56	übermitteln	Beschreibung	Beispiel
57	Umwandlung	Beschreibung	Beispiel
58	Variable	Beschreibung	Beispiel
59	Verarbeitung	Beschreibung	Beispiel
60	Verbindungskabel	Beschreibung	Beispiel
61	Wert	Beschreibung	Beispiel
62	Widerstand	Beschreibung	Beispiel
100	Begriff	Beschreibung	Beispiel

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

Material

Theorie

In welchen Geräten kommen Mikrocontroller zum Einsatz?

1. Abflusssensor
2. Anwesenheitssimulation
3. Außenbewegungsmelder
4. Auto
5. Beleuchtung
6. Belüftung
7. Bewässerung
8. Bewegungsalarm
9. Fensterkontakte
10. Fernseher
11. Feuchtemesser
12. Fitness Uhr
13. Fotoapparat
14. Futterautomat
15. Garagentore
16. Gasmelder
17. Geschirrspüler
18. Haarbürste
19. Heimtrainer
20. Heizung
21. Kaffeebecher
22. Kaffeemaschine
23. Kameras
24. Kinderpuppe
25. Klimatisierung
26. Küchenmaschine
27. Kühlung
28. Lautsprecher
29. Licht
30. Luftbefeuchter
31. Luftmessung
32. Luftreiniger
33. Mähroboter
34. Markise
35. Musikanlage
36. Navigationssystem
37. Ofen
38. Pflegeroboter
39. Radio
40. Rasensprenger
41. Rauchmelder
42. Schalter
43. Schlösser
44. Schnarchmelder
45. Schnellkochtopf
46. Sensoren
47. Sicherheitssystem
48. Smart Lock
49. Sprach-Assistent
50. Steckdose
51. Strom-Verbrauchsmessung
52. Temperaturmesser
53. Thermomix
54. Thermostat
55. Toaster
56. Türklingel
57. Türkommunikation
58. Uhr
59. Umfeldsteuerung
60. Ventilator
61. Verschattung
62. Videokameras
63. Visualisierung
64. Waage
65. Wasserhahn
66. Wasserkocher
67. Wassermelder
68. Wecker
69. Wetterstation
70. Windelsensor

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)

1. Doppel-Klick (mit linker Maustaste) auf Symbol über Name „INDEX.HTM“.
2. Die Seite „Welcome to your Raspberry Pi Pico“ öffnet sich.
3. Klicken (wenn nicht vermerkt, immer mit linker Maustaste) auf „Getting started with MicroPython“.
4. 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).
5. Klick auf diesen Button.
6. Die UF2-Datei wird in den Download-Ordner heruntergeladen.
7. Download-Ordner öffnen und Download-Fenster neben (automatisch geöffnetem) USB-Laufwerk-Fenster anordnen.
8. Datei mit „.UF2“ Endung vom Download-Fenster in das USB-Laufwerk-Fenster „ziehen“ (= kopieren).
9. Kurz darauf verschwindet das USB-Laufwerk-Fenster … und somit wurde MicroPython auf den Pico geladen.

Entwicklungsumgebung "Thonny" auf PC herunterladen und installieren

1. Von thonny.org die für das Betriebssystem passende Thonny-Programmier-Umgebung herunterladen.
2. Das heruntergeladene Thonny (durch Doppel-Klick auf die Datei) installieren.
3. Thonny starten.
4. Sicherstellen, dass das USB-Kabel Pico mit PC (noch) verbindet.
5. Im Thonny-Fenster unten rechts auswählen:
   “MicroPython (Raspberry Pi Pico)“
6. Klick auf grünen Plus-Button („New“) startet neues, leeres Thonny-Programmier-Fenster.
7. Über „Load“ und „Save“ können (auch eigene) Programme geladen, bzw. gespeichert werden … sowohl auf dem PC, wie auch auf dem Pico.

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)

Pico Internet-Ressourcen

Nr	Titel	Quelle	Bemerkung
1	Erste Schritte mit dem Raspberry Pi Pico (D)	https://www.blog.berrybase.de/blog/2021/02/08/erste-schritte-mit-dem-raspberry-pi-pico/
2	Raspberry Pi Pico (E)	https://how2electronics.com/micropython-projects/raspberry-pi-pico-projects/	The section covers Raspberry Pi Pico Based Projects and tutorials/guide.
3	Raspberry Pi Pico Getting Started Tutorial with MicroPython (E)	https://how2electronics.com/raspberry-pi-pico-getting-started-tutorial-with-micropython/
4	Schlauer Zwerg: Maschinelles Lernen mit dem Raspberry Pi Pico, Teil 1 (D)	https://www.heise.de/hintergrund/Schlauer-Zwerg-Maschinelles-Lernen-mit-dem-Raspberry-Pi-Pico-Teil-1-6143330.html?seite=all	Mit TinyML lässt sich der Raspi Pico ohne Internetanbindung für Machine-Learning-Anwendungen nutzen.
5	Grove Shield for Pi Pico V1.0 - Seeed Wiki (E)	https://wiki.seeedstudio.com/Grove_Shield_for_Pi_Pico_V1.0/#specification
6	eBay (D)	https://www.ebay.de/itm/284314540163
7	Raspberry Pi Pico Essentials + GRATIS Raspberry Pi Pico (frei Haus) - Elektor (D)	https://www.elektor.de/raspberry-pi-pico-essentials
8	Erste Schritte mit dem Raspberry Pi Pico - BerryBase Blog (D)	https://www.blog.berrybase.de/blog/2021/02/08/erste-schritte-mit-dem-raspberry-pi-pico/
9	zisternen-fuellstand-mit-ultraschall-raspberry-messen-teil-1 (D)	https://www.dax.la/wordpress/2018/07/13/zisternen-fuellstand-mit-ultraschall-raspberry-messen-teil-1/
10	Getting started with Raspberry Pi Pico - Meet Raspberry Pi Pico, Raspberry Pi Projects (E)	https://projects.raspberrypi.org/en/projects/getting-started-with-the-pico/1
11	raspberrypi.de/forum piezo-summer-an-gpio-problem (D)	https://forum-raspberrypi.de/forum/thread/7220-piezo-summer-an-gpio-problem/
12	burster.de miniatur-zug-und-druckkraftsensoren (D)	https://www.burster.de/de/sensoren/kraftsensoren/miniatur-zug-und-druckkraftsensoren/p/detail/8417
13	exp-tech.de/sensoren/druck (D)	https://www.exp-tech.de/sensoren/druck/
14	seeedstudio raspberry-pi-pico-projects (E)	https://www.seeedstudio.com/blog/2021/03/26/10-raspberry-pi-pico-projects/
15	Getting Started with RP2040 – Raspberry Pi (E)	https://www.raspberrypi.org/documentation/rp2040/getting-started/
16	Pi Pico Soil Moisture Indicator (E)	https://andywarburton.co.uk/raspberry-pi-pico-soil-moisture-sensor/
17	Hier kann "Get Started with MicroPython on Raspberry Pi Pico" und die Fehlerkorrektur zum Buch heruntergeladen werden.	https://hackspace.raspberrypi.org/books/micropython-pico
18	Quick MicroPython reference for the RP2	https://docs.micropython.org/en/latest/rp2/quickref.html
19
20

-> Inhaltsverzeichnis (dieses VDI-Pico-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 VDI-Pico-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 VDI-Pico-Wikis)

Bezugsmöglichkeit für Nachbestellungen (nicht notwendig für EVA-1 und EVA-2)

Nr	Produkt	Foto	Preis	Link
1	Raspberry Pi Pico		3,95 €	https://www.berrybase.de/neu/raspberry-pi-pico-rp2040-mikrocontroller-board?c=2461
2	offizielles Raspberry Pi Micro USB Kabel, rot, 1,0m		1,80 €	https://www.berrybase.de/raspberry-pi/raspberry-pi-computer/kabel-adapter/usb-kabel-adapter/offizielles-raspberry-pi-micro-usb-kabel-rot-1-0m
3	Stiftleisten / Pin Header Set für Raspberry Pi Pico		0,50 €	https://www.berrybase.de/raspberry-pi/raspberry-pi-mikrocontroller/zubehoer/stiftleisten/pin-header-set-f-252-r-raspberry-pi-pico
4	Breadboard mit 830 Kontakten		3,90 €	https://www.berrybase.de/raspberry-pi/raspberry-pi-computer/prototyping/breadboard-mit-830-kontakten
5	40pin Jumper / Dupont Kabel Male – Male trennbar		1,60 €	https://www.berrybase.de/raspberry-pi/raspberry-pi-computer/kabel-adapter/gpio-csi-dsi-kabel/40pin-jumper/dupont-kabel-male-150-male-trennbar
6	40pin Jumper / Dupont Kabel Male – Female trennbar		1,60 €	https://www.berrybase.de/raspberry-pi/raspberry-pi-computer/kabel-adapter/gpio-csi-dsi-kabel/40pin-jumper/dupont-kabel-male-150-female-trennbar
7	Optosupply Round Super LED, 5mm, rot		0,11 €	https://www.berrybase.de/bauelemente/aktive-bauelemente/leds/standard-leds/optosupply-round-super-led-5mm-rot
8	Optosupply Round Super LED, 5mm, gelb		0,11 €	https://www.berrybase.de/bauelemente/aktive-bauelemente/leds/standard-leds/optosupply-round-super-led-5mm-gelb
9	Optosupply Round Super LED, 5mm, grün		0,11 €	https://www.berrybase.de/bauelemente/aktive-bauelemente/leds/standard-leds/optosupply-round-super-led-5mm-gr-252-n
10	POPESQ® 100 Stk. x Widerstand 330 Ohm (330R) 0.6W		5,49 €	https://www.amazon.de/POPESQ%C2%AE-Widerstand-Verwendbar-Metall-A2410/dp/B07KX4W2DG/ref=sr_1_25_mod_primary_new?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=metallschichtwiderstand+330+ohm&qid=1631114744&sbo=RZvfv%2F%2FHxDF%2BO5021pAnSA%3D%3D&sr=8-25
11	Kurzhubtaster, Printmontage, vertikale Montage, 12x12mm, H 7,30mm		0,21 €	https://www.berrybase.de/bauelemente/schalter-taster/mikroschalter-taster/kurzhubtaster-printmontage-vertikale-montage-12x12mm-h-7-30mm
12	HC-SR501 PIR Sensor - Infrarot Bewegungsmelder		2,15 €	https://www.berrybase.de/sensoren-module/bewegung-distanz/hc-sr501-pir-sensor-infrarot-bewegungsmelder
13	KY-012, Aktives Buzzer-Modul		1,30 €	https://www.berrybase.de/sensoren-module/audio-schall/ky-012-aktives-buzzer-modul
14	TMP36, Temperatursensor, -40 - 125°C, TO-92, 3-Pin		1,15 €	https://www.berrybase.de/sensoren-module/temperatur/tmp36-temperatursensor-40-125-176-c-to-92-3-pin

-> Inhaltsverzeichnis (dieses VDI-Pico-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 VDI-Pico-Wikis)

Pico Offene Fragen

Nr	Frage	Vermutung	Antwort	Quelle	Referenzen
1	Kann ein funktionstüchtges Laptop-Display als Monitor für einen Pi400 verwendet werden?
2
3
4
5
6
7
8
9

-> Inhaltsverzeichnis (dieses VDI-Pico-Wikis)