Physical Computing

Die vorliegenden Materialien wurden von Daniel Hoherz und André Tempel erstellt. Sollten andere Editoren die Materialien erstellt haben, werden diese explizit genannt.
Physical Computing – Einstieg
Ein modernes Gewächshaus hat verschiedene Sensoren und Aktoren. Gerade mit Hilfe von digitaler Technik lassen sich damit die Wachstumsprozesse der Pflanzen optimal regulieren. Das Gewächshaus wird so zu einem smarten Gewächshaus, welches automatisiert alle möglichen Dinge regeln kann.

Aufgaben
Überlege dir mit deinem Sitznachbarn, warum man ein Gewächshaus „smart“ machen, also automatisieren, möchte.
Überlege dir mit deinem Sitznachbarn, welche Aspekte für ein gutes Pflanzenwachstum relevant sind.
Überlegt mit eurem Tischnachbarn, welche Art von Informationen ein Computer hierfür mit den Sensoren aufnehmen muss und welche Dinge ein Computer mit den Aktoren steuern können muss.
Zusammenfassung
Für das Pflanzenwachstum sind für uns zunächst die folgenden Informationen relevant, wofür wir Sensoren benötigen, welche diese Werte messen können:
| Intensität des Lichts | Feuchtigkeit im Boden | Feuchtigkeit in der Luft |
| CO2-Sensor | Temperatur des Bodens | Temperatur der Luft |
Damit unser Gewächshaus auf verschiedene Messwerte reagieren kann, benötigen wir für die folgenden Aspekte Aktoren, welche Dinge ausführen können:
| Lichtzufuhr regeln | Pflanzen wässern | Fenster öffnen/schließen |
| Heizung steuern | Luftfeuchtigkeit regulieren | Informationen auf einem Display anzeigen |
Übungen
Vermutlich kennst du das. Du gehst im Dunkeln an einem Haus vorbei und plötzlich geht die Außenbeleuchtung an.
Erläutere, welche Sensoren und Aktoren daran beteiligt sind.
Unter einem Karton ist ein Gerät, welches ein lautes Geräusch von sich gibt, wenn der Karton hochgehoben wird.
Erläutere, welche Sensoren und Aktoren daran beteiligt sind.
| Inhalt | So gut kann ich das: | ||||
|---|---|---|---|---|---|
| ++ | + | 〇 | – | — | |
| Ich kann erklären, was Sensoren sind. | |||||
| Ich kann Beispiele für Sensoren benennen. | |||||
| Ich kann erklären, was Aktoren sind. | |||||
| Ich kann Beispiele für Aktoren benennen. | |||||
Calliope mini
Um unsere Anforderungen umzusetzen, nutzen wir einen Mikrocontroller, also einen sehr kleinen Computer, den Calliope mini. Er besteht aus einer einzigen kleinen Platine, auf der sich alle Komponenten des Mini-Computers inkl. aller Sensoren und Aktoren befinden, welche programmiert werden können. Hier eine Übersicht über den Calliope:

Aufgaben
Identifiziere mit deinem Sitznachbarn Bauteile (Sensoren u. Aktoren) auf dem Calliope mini, mit denen wir die Funktionen eines smarten Gewächshauses realisieren können.
Zusammenfassung
Im folgenden Unterrichtsverlauf werden wir nach und nach die folgenden Sensoren und Aktoren für die jeweilige Funktionalität unseres Gewächshauses (s. Zusammenfassung vorheriges Kapitel) nutzen.
| Funktion | Sensor | Aktor |
|---|---|---|
| Anzeigedisplay für verschiedene Informationen | Funkmodul zum Empfangen | 5×5 LED-Display, Funkmodul zum Senden |
| Lichtzufuhr regeln | Helligkeitssensor | Servomotor, 5×5 LED-Display |
| Heizung steuern | Temperatursensor | RGB LED und Servomotor, 5×5 LED-Display |
| Fenster öffnen/schließen | CO2-Sensor, Temperatursensor | Servomotor, 5×5 LED-Display |
| Bewässerung | Feuchtigkeitssensor | Servomotor, 5×5 LED-Display |
| Luftfeuchtigkeit regulieren | CO2-Sensor | RGB LED und Servomotor, 5×5 LED-Display |
Nun wird es aber erst einmal darum gehen, wie du mit dem Calliope mini arbeitest.
Einstieg in die grafische Programmierung
Beim Programmieren denkt jeder sofort an wilde Codezeilen, welche bloß für Eingeweihte lesbar sind. Aber das ist nicht richtig. Programmierung ist erst einmal nur die Tätigkeit, eine Handlungsabfolge festzulegen, welche von einem Computer ausgeführt werden kann. Dies kann auf ganz verschiedene Arten erfolgen.
So kann man entweder diese Anweisungen per Text eingeben (textuelle Programmierung) oder es gibt bereits vorgefertigte Bausteine, welche diese Anweisungen vorgeben. Mit einer dieser grafischen Programmierumgebungen werden wir starten und das Programmieren lernen.
Programmierumgebung kennenlernen
- Calliope mini anschließen: Verbinde deinen Calliope mini mit einem USB-Kabel mit deinem Computer.
- Automatischer Start: Sobald der Calliope mini Strom bekommt, startet sofort das aktuell gespeicherte Programm. Es gibt keinen „Einschalt-Knopf“.
- Laufwerk anzeigen: Der Calliope mini erscheint als zusätzliche Laufwerke auf deinem Computer: „Mini“ und „Flash“, ähnlich wie ein USB-Stick.

- Editor öffnen: Öffne folgenden Link: Open Roberta Lab
- System auswählen:
- Du siehst den Startbildschirm von Open Roberta Lab
- Scrolle nach unten, bis du das Calliope mini System siehst (roter Kasten)
- Klicke auf „loslegen“ (zweiter roter Kasten)

- Ansicht: Nach der Auswahl öffnet sich die Entwicklungsumgebung, in der du den Calliope mini programmieren kannst.
- Zusätzliche Blöcke aktivieren: Auf der linken Seite findest du die Blöcke und durch das Klicken auf die „2“ erhältst du zusätzliche Blöcke (s. roter Kasten rechts)

- Programm übertragen: Klicke unten rechts auf das Play-Symbol
- Zielort bestimmen: Mache einen Rechtsklick auf „NEPOprog.hex“ und wähle „Ziel speichern unter“ oder ähnliches aus
- Calliope bestimmen: Scrolle in der linken Leiste nach unten, bis du „MINI“ findest. Diesen auswählen und dann auf „Speichern“ klicken
- Auf Calliope blicken: Sollte alles geklappt haben, sollte das Programm nun auf dem Calliope angezeigt werden (in diesem Beispiel wird nichts auf dem Calliope erscheinen)

- Simulation öffnen: Rechts sind einige Symbole zu sehen. Dort auf das Symbol mit dem Schriftzug „SIM“ klicken
- Programm simulieren: Auf den Play-Button klicken und das Programm wird simuliert

- Menü öffnen: Klicke auf das Menü-Symbol oben links (links neben „Bearbeiten“)
- Datei speichern: Klicke auf „exportiere Programm“ und das Programm wird unter „Downloads“ auf deinem Computer gespeichert.

- Menü öffnen: Klicke auf das Menü-Symbol oben links (links neben „Bearbeiten“)
- Programm öffnen: Klicke auf „importiere Programme“ und wähle im sich öffnenden Fenster das Programm aus (ggf. musst du zu „Downloads“ navigieren). Klicke auf „Öffnen“, um das ausgewählte Programm zu öffnen.

Aufgaben
Nun versuchen wir, die Funktionsweise des 5×5 LED-Displays zu verstehen.
Erstelle ein Programm für den Calliope mini in Open Roberta Lab, das deinen Namen auf der LED-Matrix ausgibt.
Erstelle ein Programm, das auf dem LED-Display einen glücklichen Smiley anzeigt.
Erstelle ein Programm, das auf dem LED-Display erst den glücklichen Smiley anzeigt und anschließend einen anderen Smiley.
Beschreibe deine Beobachtung aus Aufgabenteil c.
Verändere dein Programm, sodass beide Smileys nach einer kurzen Wartezeit angezeigt werden.
Erstelle ein Programm, das „an“ auf dem Display anzeigt, wenn der A-Button gedrückt wird und „aus“, wenn der B-Button gedrückt wird.
(Partnerarbeit) Calliope mini können auch mittels eines Funk-Moduls miteinander kommunizieren. Dieses wollen wir nun einmal machen. Einer von euch ist der Sender und der andere der Empfänger der Nachricht. Teilt euch auf und bearbeitet die entsprechenden Aufgaben. Ihr findet unter Nachrichten nötige Blöcke.
Als erstes müsst ihr beide euch auf einen Funk-Kanal einigen und diesen dem Programm mitteilen, dafür gibt es unter Nachrichten einen passenden Block.
Als nächstes sollte dafür gesorgt werden, dass die zukünftige Nachricht immer wieder gesendet wird, da es sonst passieren kann, dass die Nachricht gesendet wird, aber der Empfänger noch gar nicht bereit war.
Es gibt einen Block unter Nachrichten, mit dem du die Nachricht senden kannst. Füge diesen passend ein und ergänze noch die Text-Nachricht, die gesendet werden soll.
Als erstes müsst ihr beide euch auf einen Funk-Kanal einigen und diesen dem Programm mitteilen, dafür gibt es unter Nachrichten einen passenden Block.
Als Empfänger solltest du dauerhaft „horchen“, ob eine Nachricht angekommen ist, dazu kannst du eine Schleife nutzen.
Die empfangene Nachricht soll ein Text sein und dieser sollte angezeigt werden. Dafür findest du unter Nachrichten und unter Anzeige passende Blöcke.
Übungen
| Inhalt | So gut kann ich das: | ||||
|---|---|---|---|---|---|
| ++ | + | 〇 | – | — | |
| Ich kann auf dem LED-Display Text und Smileys anzeigen lassen. | |||||
| Ich kann erklären, wann ein „warte“-Befehl sinnvoll ist. | |||||
| Ich kann die Schleife „Wiederhole unendlich oft…“ gezielt einsetzen. | |||||
| Ich kann ein Programm erstellen, das auf einen Knopfdruck unterschiedliche Sachen ausführt. | |||||
Bedingte Anweisungen
Wenn der Knopf gedrückt wurde, dann schalte die Belüftung an.
Wenn die Erde trocken ist, dann gieße die Pflanze.
Wenn es dunkel ist, dann schalte das Licht ein.
- Überlegt, was diese drei Aussagen gemeinsam haben.
- Überlegt, warum solche Entscheidungsfragen wichtig sind.
- Überlegt, warum solche Entscheidungen auch in der Programmierung wichtig sind.
- Überlegt, inwiefern die Hausaufgabe hier anknüpft.
Erklärung
Was man macht, hängt häufig von bestimmten Bedingungen ab. Einen Regenschirm wird man dann einpacken, wenn Regen gemeldet ist und das Mathebuch kommt nur dann in die Schultasche, wenn man am Tag eine Mathestunde hat. Auch in der Programmierung hängt der weitere Programmverlauf oft von einer Entscheidungsfrage ab.
Da der Computer aber allein nicht in der Lage ist, „spontan“ auf eine Situation zu reagieren, kann eine bedingte Anweisung oder Entscheidung genutzt werden. Durch diese kann schon während der Programmierung festgelegt werden, was beim Eintreten eines bestimmten Falles getan werden soll. Hierzu werden die folgenden Blöcke genutzt:

Du findest die Blöcke im Reiter „Kontrolle“ und hast sie bereits in Aufgabe 1f im vorherigen Abschnitt genutzt. Die Blöcke, die in den „wenn“-Teil eingehängt werden, werden nur dann ausgeführt, wenn die Bedingung erfüllt ist. Einen wenn…mache…-Block nennen wir eine einfache bedingte Anweisung. Sofern ein „sonst“-Teil vorhanden ist, wird dieser nur dann ausgeführt, sofern die Bedingung nicht erfüllt ist. Dieser wenn…mache…sonst…-Block wird auch Verzweigung genannt. Als Bedingung können alle Blöcke verwendet werden, die eine hellblaue Nase haben.
Manchmal muss man auch Werte miteinander vergleichen, bspw. wenn die Temperatur größer als 20°C ist, dann soll eine LED grün leuchten oder wenn der Helligkeitssensor den Wert 30 misst, dann soll ein Smiley angezeigt werden. Dafür werden Vergleichsoperatoren genutzt. Sie werden genutzt, um Werte miteinander abzugleichen und dadurch wahr oder falsch zu liefern, sodass eine Bedingung erfüllt oder nicht erfüllt ist. Folgende Vergleichsoperatoren gibt es:

Die beiden oben genannten Beispiele mit der Temperatur und der Helligkeit sehen mit den Vergleichsoperatoren dann wie folgt aus:


Der Wert mit dem verglichen wird (dunkelblau) wird auch Schwellenwert genannt. Erst wenn dieser Wert erreicht wird, passiert etwas.
Aufgaben 1/2
Im Folgenden soll mit dem Lichtsensor die Helligkeit durchgängig gemessen werden. Befolge dazu die folgenden Schritte:
Wenn der Wert des Lichtsensors größer als 50% ist, dann soll die RGB-LED gelb leuchten.
Implementiere diesen Sachverhalt in Open Roberta Lab.
Verändere das Programm so, dass die RGB-LED gelb leuchtet, wenn der Wert des Lichtsensors größer als 50% ist, und ansonsten blau.
Mit dem Calliope mini soll nun eine kleine Ampelschaltung realisiert werden. Der Calliope mini zeigt durchgängig ein rotes Licht an. Wenn nun der A-Knopf gedrückt wird, wechselt das Licht erst auf orange und dann auf grün. Nach einer kurzen Zeit geschieht der Wechsel wieder zu orange und dann wird wieder durchgängig rot angezeigt.
Implementiere die Ampelschaltung.
Wir werden nun ein kleines Schnelligkeitsspiel entwickeln. Das Spiel geht wie folgt: Eine Lampe leuchtet und sobald die Lampe erlischt, müssen die beiden Spieler so schnell wie möglich ihren Knopf drücken und der schnellere Spieler gewinnt. Folge den Anweisungen, um das Spiel zu entwickeln.
Als erstes soll unser Programm die Lampe aufleuchten lassen und kurz warten und dann soll mittels des Blocks „Setze Zeitgeber 1 zurück“ die Zeit gestartet werden. Nun soll geprüft werden, ob die Person den A-Knopf gedrückt hat, wenn die Person den A-Knopf drückt, soll die Zeit mittels des Blocks „…gib Wert ms Zeitgeber 1“ auf dem Display angezeigt werden.
Implementiere diesen Sachverhalt. Die beiden genannten Blöcke sind unter Sensor zu finden und sehen so aus:


Nun verändern wir das Programm. Das Programm soll genauso starten, allerdings sollen nun zwei Leute das Spiel spielen können, indem eine Person den A-Knopf drücken muss und die andere den B-Knopf. Je nachdem, wer von beiden schneller ist, dessen Knopf-Buchstabe soll angezeigt werden und dessen gebrauchte Zeit.
Verändere dein Programm entsprechend und teste es mit einem Mitlernenden.
Tagsüber wird unser Gewächshaus ganz schön warm und nachts recht frostig. Damit wir darauf hingewiesen werden, soll der Calliope mini die Temperatur messen und uns informieren, ob alles in Ordnung ist.
Implementiere eine erste Variante, bei der der Calliope mini, wenn die Temperatur unter 5°C gemessen wird, ein rotes Licht anschaltet und sonst ein grünes Licht.
Wir erweitern das Programm etwas: Wenn der Calliope mini eine Temperatur unter 5°C misst, soll das rote Licht angemacht werden, wenn die Temperatur nur unter 15°C ist, soll ein gelbes Licht leuchten und sonst ein grünes Licht.
Wir erweitern das Programm nochmal: Wenn die Temperatur unter 5°C ist, dann soll die rote Lampe leuchten, ansonsten soll geprüft werden, ob die Temperatur unter 15°C ist, dann soll die Lampe gelb leuchten (soweit wie gehabt). Nun soll danach noch geprüft werden, ob die Temperatur unter 20°C ist und die Helligkeit unter 20% ist, dann soll die Lampe lila leuchten und ansonsten ist alles in Ordnung und die Lampe soll grün leuchten.
Erweitere dein Programm entsprechend.
Logische Operatoren
Manchmal ist es notwendig, dass Bedingungen nicht nur eine Sache prüfen, sondern zeitgleich mehrere Sachen. So musste in Aufgabe 4c geprüft werden, ob die Temperatur einen bestimmten Wert hat und zeitgleich sollte auch noch die Helligkeit einen bestimmten Wert haben.
Solche Abfragen lassen sich mit zwei bedingten Anweisungen lösen, wie hier zu sehen ist:

Erst wird die eine Bedingung geprüft und wenn die zutreffend ist, dann wird die zweite Bedingung geprüft. Aber so etwas wird schnell unübersichtlich und komplex.
Daher gibt es sogenannte logische Operatoren. Mit ihnen lassen sich mehrere Bedingungen kombinieren und zu einer großen Bedingung zusammenfassen. Es gibt drei logische Operatoren:
- UND
- Ein UND wird dann wahr, wenn beide Bedingungen, links und rechts, „wahr“ antworten.
Stell dir vor, du darfst nur dann ins Kino gehen, wenn du deine Hausaufgaben gemacht und dein Zimmer aufgeräumt hast. Beide Bedingungen müssen erfüllt sein, damit du ins Kino gehen kannst. In der Programmierung bedeutet das, dass die Aussage nur dann wahr ist, wenn beide Bedingungen wahr sind. - ODER
- Ein ODER wird dann wahr, wenn mindestens eine der beiden Bedingungen, links oder rechts, „wahr“ antwortet.
Angenommen, du kannst entweder Pizza oder Pasta zum Abendessen haben. Wenn du Pizza hast, musst du nicht auch Pasta haben, und umgekehrt. Hier reicht es aus, wenn eine der beiden Bedingungen wahr ist, damit du zufrieden bist. In der Programmierung bedeutet das, dass die Aussage wahr ist, wenn mindestens eine Bedingung wahr ist. - NICHT
- Ein NICHT kehrt die Antwort der angehängten Bedingung um. Er antwortet „wahr“, wenn die angehängte Bedingung „falsch“ antwortet und andersherum.
Stell dir vor, du bist nicht müde. Der NICHT-Operator kehrt die Bedeutung um. Wenn du müde bist, wird die Aussage „nicht müde“ falsch, und wenn du nicht müde bist, wird sie wahr. In der Programmierung bedeutet das, dass der NICHT-Operator den Wahrheitswert einer Bedingung umkehrt.

Somit kann man aus dem Beispiel oben mittels eines UND die beiden bedingten Anweisungen so formulieren:

Aufgaben 2/2
Eine Heckenschere funktioniert nur dann, wenn zwei Knöpfe zeitgleich gedrückt werden. Das soll nun mit dem Calliope nachempfunden werden.
Implementiere ein Programm, das die grüne LED anzeigt, wenn A- und B-Knopf zusammen gedrückt werden und ansonsten soll die LED rot leuchten.
Hinweis: Den Test des Programms sollte man hier besser in der Simulation machen, da wir Menschen nicht so synchron drücken.
Wir nehmen uns nochmal den Helligkeitssensor: Wenn der Wert des Helligkeitssensors größer als 50% ist, soll die RGB-LED gelb leuchten. Ist der Helligkeitswert kleiner oder gleich 50% und gleichzeitig größer als 20%, soll die RGB-LED rot leuchten. Ansonsten soll sie blau leuchten.
Unten sind verschiedene Lösungsvorschläge für die vorherige Aufgabe abgebildet.
Entscheide begründet, welche der Varianten korrekt sind und erläutere, was bei den nicht korrekten Varianten zu Fehlern führt.






Wenn der Pin 0 (goldener Kreis im lila Kasten) berührt wird, soll die RGB-LED rot leuchten, bei Pin 1 grün, bei Pin 2 blau, bei Pin 3 gelb und sonst weiß. Drei Lösungsvorschläge sind im Folgenden dargestellt.
Analysiere die Programme hinsichtlich der Funktionalität und entscheide begründet, welches die effizienteste Lösung ist.




Übung
Ständig fehlen in deiner Federmappe Stifte. Irgendwer nimmt sich ständig die Stifte raus. Mit dem Calliope mini soll nun eine Alarmanlage gebaut werden. Wenn die Helligkeit zu hoch wird, also die Federmappe geöffnet wird, dann soll der Calliope mini blinken und ein Geräusch von sich geben.
Implementiere diese Funktionalität und teste sie.
Für ein Spiel brauchen wir dringend einen Würfel, aber wir haben gerade keinen da. Wir haben aber unseren Calliope mini da. Wenn wir nun beim Calliope mini den A-Knopf drücken, soll eine zufällige Zahl auf dem Display erscheinen. Den unten abgebildeten Block wirst du brauchen, du findest ihn unter „Mathematik“.

Implementiere nun den Würfel auf dem Calliope mini.
| Inhalt | So gut kann ich das: | ||||
|---|---|---|---|---|---|
| ++ | + | 〇 | – | — | |
| Ich kenne die verschiedenen Formen der bedingten Anweisungen (einfache bedingte Anweisung und Verzweigung) und kann sie passend verwenden. | |||||
| Ich kenne die logischen Operatoren und kann sie verwenden, um mehrere Bedingungen zu verbinden. | |||||
| Ich kann auch mehrere bedingte Anweisungen ineinander verschachteln, um mehrere Abfragen nacheinander zu realisieren. | |||||
| Ich kann die Vergleichsoperatoren nutzen, um eine Bedingung zu formulieren. | |||||
Variablen
In unserem Gewächshaus wird es natürlich auch sehr warm und daher wäre es mal interessant herauszufinden, was denn so über den Tag die höchste Temperatur ist.
Das soll nun mit Hilfe des Calliopes umgesetzt werden.
Der Calliope misst durchgängig die Temperatur in dem Gewächshaus und vergleicht, ob der neue gemessene Temperaturwert größer ist als der bisher größte Temperaturwert. Wenn der neue Temperaturwert größer ist als der bisher gemessene (alte) Temperaturwert, wird sich dieser neu gemessene Temperaturwert als der größte Temperaturwert gemerkt. Ich möchte dann beim Calliope auf den A-Knopf drücken und dieser soll mir den größten gemessenen Wert anzeigen.
- Erklärt kurz, warum es in einem Gewächshaus wichtig ist, die höchste Temperatur zu wissen.
- Überlegt und markiert zunächst, welche Textteile euch Informationen für die Implementierung (Umsetzung als Computerprogramm) liefern.
- Entwickelt eine Idee und notiert diese, wie wir herausfinden können, ob die neu gemessene Temperatur höher ist als die, die wir bisher gemessen hatten.
- In dem Text steht „…wird sich dieser neu gemessene Temperaturwert als der größte Temperaturwert gemerkt.“. Überlegt und notiert euch eure Überlegungen, ob und inwiefern das „Merken“ des größten Temperaturwertes für das Programm wichtig ist. An welchen Stellen in der Beschreibung bräuchten wir den bisher gemerkten größten Temperaturwert?
Was sind Variablen?
Variablen sind grundlegende Bausteine in der Programmierung. Man kann sich eine Variable wie einen Behälter vorstellen, der Informationen speichern kann. Diese Informationen können in unserem Fall Zahlen oder Texte sein. Der Vorteil von Variablen ist, dass sie es uns ermöglichen, Daten zu speichern und später wieder darauf zuzugreifen oder sie zu ändern, ohne den gesamten Code anpassen zu müssen. Doch wie genau geht das in Open Roberta Lab?
Am Anfang muss man als Erstes eine Variable deklarieren, also anlegen. Dazu klickt man beim Start-Block auf das „+“ und dann erscheint eine neue Variable. Dieser Variablen gibt man dann einen passenden und aussagekräftigen Variablennamen. Über diesen Variablennamen kann man später auf den gespeicherten Wert zugreifen. Und nun wählt man noch den Datentyp aus, also welche Art von Werten sollen gespeichert werden? Soll eine Zahl oder eine Zeichenkette (Text) gemerkt werden? Dies entscheidet darüber, wie viel Speicherplatz für die Variable reserviert wird. Je mehr Variablen man anlegt, desto mehr Speicherplatz wird verbraucht, also sollte man hier sparsam sein, denn so wird ein Programm effizienter. Weist man nun noch nach dem roten Block eine Zahl oder eine Zeichenkette (Text) der Variable zu, dann wird die Variable mit diesem Wert initialisiert, also gestartet.


Die Blöcke, um eine Variable zu verändern oder ihr einen Wert zuzuweisen, sind, sobald die Variable deklariert (angelegt) wurde, unter dem Reiter Variablen zu finden. Es gibt einmal einen Block, um der Variablen einen neuen Wert zuzuweisen, also einen anderen Wert zu speichern. Daneben gibt es noch einen zweiten Block, mit dem man den aktuellen Wert, welcher durch die Variable gespeichert wird, nutzen kann.
Mit dem Block Schreibe Variablenname kann der entsprechenden Variablen ein neuer Variablenwert zugewiesen werden. Sie speichert also einen anderen Wert als zuvor. In dem Beispiel links wurde die Variable maxTemperatur mit dem Wert 0 initialisiert (gestartet) und nun erhält sie durch Schreibe maxTemperatur 50 den Wert 50.


Wenn ich einen Variablenwert nutzen möchte, um ihn zu vergleichen oder anzeigen zu lassen, dann verwendet man den zweiten Block unter Variablen, wo nur der entsprechende Variablenname drinsteht. Diesen kann ich, wie im Beispiel zu sehen ist, bei der Textausgabe dranhängen, um mir den Wert anzeigen zu lassen. In dem Beispiel wird dann der Wert 50 ausgegeben. Ich kann diesen Block aber auch verwenden, um den Variablenwert mit anderen Werten zu vergleichen.
Aufgaben
Im Folgenden soll es darum gehen, welchen Wert die Variable während der Programmausführung gespeichert hat. So hatten wir es in diesem Beispiel, dass der Block Zeige Text maxTemperatur den Wert 50 ausgibt.

Unten findest du drei Fragen, wähle die korrekte Antwort aus und überprüfe dein Ergebnis selbst.
Im Folgenden siehst du zwei Varianten der Einstiegsaufgabe mit dem Messen der Temperatur im Gewächshaus.


Vergleiche die beiden Varianten hinsichtlich von Unterschieden.
Begründe, welche der beiden Varianten besser lesbar ist und welche weniger Speicherplatz verbraucht.
Natürlich ist es in einem Gewächshaus auch wichtig herauszufinden, was die kälteste Temperatur ist, damit vllt. eine Heizung in der Nacht aktiviert wird.
Als Grundlage nehmen wir unser Programm aus Aufgabe 2.
Legt zunächst eine Variable an, um sich die geringste gemessene Temperatur zu merken.
Erweitere nun das Programm, indem du die gemessene Temperatur mit dem bisher kleinsten Wert vergleichst und wenn der gemessene Wert niedriger ist, als der bisher kleinste Wert, dann soll der gemessene Wert als geringster Wert gemerkt werden.
Erweitere dein Programm nun so, sodass beim Drücken des B-Knopfes die niedrigste gemessene Temperatur ausgegeben wird.
Bestimmt kennst du Zähluhren. Mit denen gehen manchmal Leute durch den Zug und zählen, wie viele Fahrgäste transportiert werden. Wir wollen auch eine solche Zähluhr machen, aber für die Anzahl unserer Tomaten im Gewächshaus.
Dazu verwenden wir unseren Calliope und den A- und B-Knopf. Beim Drücken des A-Knopfes soll zu der Variable anzahl einer hinzugezählt werden. Beim Drücken des B-Knopfes soll der aktuelle Wert der Variablen anzahl auf dem Display ausgegeben werden.
Legt zunächst die Variable anzahl mit dem passenden Datentyp und dem passenden Startwert an.
Implementiere zunächst, dass du durch das Drücken des B-Knopfes den Wert der Variablen anzahl auf dem Display anzeigen lassen kannst.
Implementiere nun, wenn der A-Knopf gedrückt wird, dass dann der Wert der Variable anzahl um eins erhöht wird. Der folgende Block, den du unter Mathematik findest, kann dir dabei helfen.

Teste deine Implementierung mithilfe der folgenden Animation. Starte die Animation und zähle mit deinem Calliope die Kreise.
Wie viele rote Kreise (Tomaten) waren vorhanden?
Unser Gewächshaus soll sicher werden. An der Tür soll ein Schloss angebracht werden, das die Buchstaben A, B, C und D als Eingaben hat und einen Knopf zur Bestätigung. Gibt der Benutzer den korrekten zweistelligen Code, bspw. DB ein und bestätigt seine Eingabe, dann wird die Tür geöffnet.
Wir wollen etwas Entsprechendes mit dem Calliope umsetzen. Die PINs benutzen wir für die Buchstaben A (PIN 0) bis D (PIN 3) und als Eingabeknopf den A-Knopf. Das richtige Codewort soll DB lauten. Der Benutzer kann zunächst über die PINs seine Eingabe machen, welche gespeichert wird und wenn der Nutzer auf den A-Knopf drückt, soll die Eingabe überprüft werden und wenn diese korrekt ist, dann soll die LED statt rot, auf grün wechseln.
Legt zunächst Variablen an, die ihr für diese Aufgabe benötigt. Als Datentyp für die Variablen hatten wir bisher nur Zahlen, überlegt ob das hier auch sinnvoll ist.
Implementiere nun, wenn der jeweilige PIN gedrückt wird, dass dann der entsprechende Buchstabe in der Variablen gespeichert wird.
Erweitere dein Programm nun so, dass beim Drücken des A-Knopfes die bisherige Eingabe mit dem richtigen Code verglichen wird und wenn diese gleich sind, dann soll die LED auf grün wechseln, bisher war sie rot.
Schleifen/Wiederholungen
Eine Lampe im Gewächshaus soll mit einer Bewegungssteuerung ausgestattet werden. Wenn eine Bewegung registriert wird, soll das Licht für 10 Sekunden angeschaltet werden. Um einen Überblick über die Beleuchtungszeit zu haben, gibt es ein Display im Gewächshaus, welches die Zeit hochzählt.
Um diese Funktionalität der Lampe umzusetzen, gibt es verschiedene Varianten. Die ausgelöste Bewegung stellen wir zunächst mit dem Drücken der Taste A dar. Die einfachste Variante ist rechts dargestellt.
- Beschreibe den Zweck der Anweisung "Warte bis Taste A gedrückt?"
- Beschreibe, was beim ersten "Zeige Text zeit"-Block angezeigt wird.
- Beschreibe den Zweck der "Warte ms 1000"-Blöcke.
- Beschreibe den Zweck der "erhöhe zeit um 1"-Blöcke.
- Beschreibe den Zweck des "Schreibe zeit 0"-Blocks.
- Beschreibe Auffälligkeiten in dem Programm.

Was sind Schleifen?
Häufig soll eine bestimmte Sequenz des Quellcodes nicht nur einmal, sondern mehrfach ausgeführt werden. Dazu werden Schleifen genutzt. In Open Roberta werden wir uns mit drei verschiedenen Schleifen beschäftigen, die in zwei Kategorien - Zählschleifen und Bedingungsschleifen - aufgeteilt werden. Du findest die Schleifenblöcke ebenfalls im Reiter „Kontrolle“.
Eine bedingte Schleife hängt, ähnlich wie eine bedingte Anweisung, von einer Bedingung ab. Dabei kann gewählt werden, ob die Schleife die eingeschlossenen Blöcke wiederholen soll, bis eine bestimmte Bedingung wahr ist oder solange sie wahr ist. Eine Variante der Bedingungsschleife ist die Endlosschleife. Diese wiederholt die eingeschlossenen Blöcke bis der Calliope mini keinen Strom mehr hat, wird also nie abgebrochen. Du hast diese Schleife wahrscheinlich in Aufgabe 1f) der Einstiegsaufgaben genutzt. Wenn du weißt, wie oft der Quelltext in der Schleife wiederholt werden soll, kann anstatt einer Bedingungsschleife auch eine Zählschleife genutzt werden. Diese wiederholt die eingeschlossenen Blöcke eine vordefinierte Anzahl mal, im Beispiel also 10-mal.

Aufgaben
Die Funktionalität des Einstiegsprogramms soll nun mit den drei verschiedenen Schleifen umgesetzt werden:



Implementiere das Programm nun mit der ausgewählten Schleife.
Beim ursprünglichen Programm muss der Calliope die drei Anweisungen "zeige Text", "Warte" und "erhöhe Zeit" zehnmal ausführen, also insgesamt 30 mal "arbeiten". Vergleicht bei den drei verschiedenen Lösungsvarianten, wie viele Anweisungen und Prüfungen der Calliope jeweils durchführen muss. Achtung: Überlegt euch genau, ob zu Beginn eines Schleifendurchlaufs etwas geprüft werden muss.
Vergleicht die verschiedenen Lösungsvarianten hinsichtlich des Programmieraufwands, Lesbarkeit und wie praktisch die Programme bei eventuellen Änderungen sind. Diese können z. B. sein:
- Die Zeitdauer der Lampe soll auf 60 Sekunden erhöht werden.
- Die Zeit soll nicht rauf- sondern runterzählen.
- Die Zeit soll nur alle 5 Sekunden angezeigt werden.
Im Folgenden sind zwei Programme dargestellt, die Schleifen verwenden. Suche dir eines der beiden Programme aus und bearbeite die Aufgaben an diesem Programm. Programm 2 ist anspruchsvoller als Programm 1.


Beschreibe, wie das Programm funktioniert und was es für einen Zweck hat.
Gib auch jeweils entsprechende Sensoren und Aktoren des Calliope an, die bei der Ausführung des Programms beteiligt sind.
Markiere, falls vorhanden, die entsprechenden Teile des Programms, die zu den folgenden Begriffen passen:
- Endlosschleife
- Bedingte Schleife
- Zählschleife
- Einfache bedingte Anweisung
- Verzweigung
- Schwellenwert
- Anweisung
- Sequenz
- Bedingung
- Logischer Operator
- Vergleichsoperator
Ein Programm soll, solange die A-Taste gedrückt wird, eine bestimmte Kombination aus Farben darstellen und solange die B-Taste gedrückt wird, eine andere Farbkombination darstellen und wird keine der Tasten gedrückt, soll die Lampe einfach nur dauerhaft weiß leuchten.
Mache dir zunächst anhand der Beschreibung Notizen, welche Kontrollstrukturen du benötigst.
Implementiere nun auf Grundlage deiner Notizen das Programm.
Die Lichttechniker haben für ihre Shows schon oft vorprogrammierte Lichtshows festgelegt. Dauerhaft ist das schwarze Partylicht an. Wenn der Lichttechniker die A-Taste drückt, wird 5 Mal eine Folge aus grünroten Lichtkombinationen wiederholt und wenn er die B-Taste drückt, wird 3 Mal eine lilablaue Farbkombination wiederholt.
Mache dir zunächst anhand der Beschreibung Notizen, welche Kontrollstrukturen du benötigst.
Implementiere nun auf Grundlage deiner Notizen das Programm.
Vielleicht kennst du das: Man geht joggen und man möchte mit etwas Licht auf sich aufmerksam machen. Das Licht soll aber nur so lange leuchten, wie man sich bewegt.
Um Bewegungen zu messen, gibt es die Anweisung gib Wert milli-g Beschleunigungssensor Stärke (s. unten). Dieser misst, wie stark sich der Calliope bewegt.
Implementiere zunächst ein Programm, um herauszufinden, welchen Beschleunigungswert der Sensor misst, wenn der Calliope ruhig auf dem Tisch liegt und notiert euch diesen. Hinweis: Bei dem Block zur Bestimmung der Beschleunigung bitte Stärke am Ende auswählen.

Solange nun also der Beschleunigungssensor einen Wert größer als diesen Ruhewert (nehmt nicht exakt den Ruhewert, sondern einen Wert etwas größer) misst, soll die Lampe weiß leuchten.
Implementiere nun das Programm, um die Jogging-Lampe zu realisieren.
Vermutlich ist dir aufgefallen, dass es Bewegungen gibt, wo der Calliope, obwohl du ihn bewegst, nicht leuchtet. Das liegt daran, dass der Calliope dann Werte misst, die geringer als der Ruhewert sind. Also müsste die Lampe leuchten, solange der Bewegungssensor einen Wert größer oder kleiner als diesen Ruhewert misst.
Ergänze deine Implementierung, um dieses Problem zu lösen.
Sicherlich weißt du, dass es Frühwarnsysteme für Erdbeben gibt. Wir werden im Folgenden ein solches Frühwarnsystem implementieren. Folge dazu den folgenden Aufgabenteilen.
Um die Beschleunigung des Calliope mini zu messen, gibt es diesen Block.

Der Calliope soll nun rot aufleuchten, wenn er sich bewegt.
Implementiere ein Programm dafür.
Da eine kurze Erschütterung eventuell nicht ausreicht, um auf ein Erdbeben hinzuweisen, integrieren wir nun noch eine Zeitmessung. Dafür musst du zwei neue Blöcke aus Open Roberta nutzen, die eine einfache Zeitmessung mit dem Calliope ermöglichen.


Verändere dein Programm so, dass die RGB-LED nur angeschaltet wird, wenn Erschütterungen für mindestens 3 Sekunden registriert wurden.
Lernstationen
Im Folgenden sind einige Lernstationen beschrieben, wo mithilfe verschiedener Sensoren und Aktoren Probleme gelöst werden müssen. Suche dir mindestens 3 Stationen aus, die du bearbeiten möchtest. Dokumentiere hier auch deinen Fortschritt.
Nun kümmern wir uns um die Temperatur im Gewächshaus. Zur Erinnerung: Der Temperatursensor ist in den Prozessor eingebaut (sieh im Abschnitt zum Calliope mini nach).
Überlegt und notiert euch, was ihr tun könnt, um die Temperatur am Sensor zu erhöhen und wieder zu senken.
Jetzt soll die Umgebungstemperatur gemessen werden.
Entwickelt und implementiert ein Programm zu Testzwecken in Open Roberta Lab, um dauerhaft die aktuelle Temperatur anzeigen zu lassen.
Entwickelt und implementiert ein Programm für den Calliope mini, das die RGB-LED in Rot leuchten lässt, wenn die Temperatur 2° über der gemessenen Raumtemperatur aus Aufgabenteil b liegt und ansonsten soll die RGB-LED blau leuchten.
Jetzt erweitern wir die Funktionalität des Programms aus Aufgabenteil c). Es gibt verschiedene optimale Boden- und Lufttemperaturen für verschiedene Pflanzen. Der Calliope soll nun unterschiedliche Temperaturbereiche durch jeweils eine Farbe anzeigen. Die Bereiche sind, in Abhängigkeit von der bereits in Aufgabenteil c) genutzten Raumtemperatur, kurz mit RT bezeichnet:
| Temperatur | Farbe |
|---|---|
| Temperatur > RT + 3 | Rot |
| RT + 2 < Temperatur ≤ RT + 3 | Orange |
| RT + 1 < Temperatur ≤ RT + 2 | Gelb |
| RT - 1 < Temperatur ≤ RT + 1 | Grün |
| Temperatur ≤ RT - 1 | Blau |
Entwickle und implementiere ein Programm für den Calliope, das bei den gemessenen Temperaturen die in der Tabelle angezeigten Farben über die RGB-LED anzeigt.
Ein Vorteil eines Gewächshauses ist, dass man bereits im Januar oder Februar Samen säen und Jungpflanzen züchten kann. Da die Intensität der Sonne und die Dauer der Sonnenstunden im Winter allerdings niedrig sind, nutzt man spezielle Lampen für Pflanzen, die häufig LED-Leuchten sind. Je nach aktueller Helligkeit sollen diese Lampen in unterschiedlicher Intensität leuchten.
Erst einmal müssen wir verstehen, wie der Helligkeitssensor funktioniert.
Entwickle und implementiere ein Programm für den Calliope, welches dir jederzeit den aktuellen Wert anzeigt, den der Helligkeitssensor misst. Probiere aus, wie sich der Wert bei verschiedener Helligkeit verändert.
Eine Lampe soll zunächst automatisch angehen, wenn es dunkel wird und ausgehen, wenn es hell ist.
Entwickle und implementiere ein Programm für den Calliope, so dass die RGB-LED angeht, sobald es dunkel wird.
Nun soll die automatische Lampensteuerung verbessert werden. Die Lampe soll nun, je nach gemessener Lichtintensität, in verschiedenen Stärken leuchten, welche durch verschiedene Farben der RGB-LED simuliert werden.
Entwickle und implementiere ein Programm für den Calliope, welches die gewünschte Funktionalität umsetzt.
Durch die Installation mehrerer Pflanzlicht-LED sollen auch größere Bereiche beleuchtet werden. Dafür ist es nun notwendig, dass der Calliope, an dem der Helligkeitssensor verbaut ist, entsprechende Signale mit seinem Funkmodul an die im Netzwerk integrierten LED sendet. Erweitere dein Programm so, dass dein Calliope je nach gewünschter Lichtstärke ein entsprechendes Signal sendet und ein zweiter Calliope dieses Signal empfängt und in Abhängigkeit von dem Signal soll das Licht entsprechend aktiviert werden.
Um die Feuchtigkeit an den Wurzeln von Pflanzen in einem optimalen Bereich zu halten werden Feuchtigkeitssensoren in der Nähe der Wurzeln im Boden angebracht. Diese messen regelmäßig einen aktuellen Wert für die Bodenfeuchtigkeit und geben diesen an einen Computer weiter. Dann kann, in Abhängigkeit des aktuellen Wertes, eine bestimmte Menge Wasser durch ein Tropfsystem an den Pflanzen verteilt werden. Durch diese Methode spart man sehr viel Wasser ein, da die Tropfen nur den Bereich um die Wurzeln herum befeuchten und kein Wasser abfließt. Außerdem lässt sich so der unterschiedliche Wasserbedarf verschiedener Pflanzenarten steuern.
Nimm dir einen Feuchtigkeitsmesser und einen Calliope und verbinde die beiden Bauteile wie in der Grafik rechts miteinander über den Grove-Stecker. Um den Feuchtigkeitsmesser verwenden zu können, muss dieser in Open Roberta eingerichtet werden, wie das geht, erfährst du in dem Video.

Lasse dir zunächst die gemessenen Werte des Feuchtigkeitssensors auf dem Display ausgeben und bestimme für dich, wann der Boden der Pflanze nicht mehr ausreichend hydriert ist. Hinweis: Nimm dir einen Topf mit Erde und bewässere verschiedene Bereiche des Topfes unterschiedlich stark.
Entwickle nun ein Programm, welches den Boden der Pflanzen misst und je nach Feuchtigkeitswert des Bodens eine unterschiedliche Menge Wasser ins Tropfsystem leitet. Die unterschiedliche Wassermenge wird durch die Anzeige einer unterschiedlichen Anzahl an Zeilen auf dem LED-Display modelliert. Es soll also sechs verschiedene Feuchtigkeitsbereiche (null Zeilen leuchten, eine Zeile leuchtet,..., fünf Zeilen leuchten) geben. Bei sehr feuchtem Boden ist auf dem Display nichts zu sehen. Mit sinkender Feuchtigkeit soll die Anzahl der Zeilen auf dem Display, die leuchten, erhöht werden.
An besonders heißen Tagen ist ein trockener Boden deutlich stressiger für Pflanzen. Deshalb soll dein Programm aus dem Aufgabenteil c) so erweitert werden, dass zusätzlich zur Bodenfeuchtigkeit auch die aktuelle Temperatur eine Rolle bei den Warnungsmeldungen spielt. Erweitere nun dein Programm aus Aufgabenteil c) so, dass in den drei Fällen mit der größten Trockenheit zusätzlich die RGB-LED rot leuchtet, wenn die aktuelle Temperatur 28° C oder mehr beträgt.
Nachts brechen immer wieder wilde Tiere in das Gewächshaus ein und stehlen das reife Obst und Gemüse. Ein Ultraschallsensor kann die Entfernung messen. Mit seiner Hilfe soll der Abstand der Tiere zu den Pflanzen ermittelt werden und entsprechend reagiert werden.
Nimm dir einen Ultraschallsensor und einen Calliope und verbinde die beiden Bauteile wie rechts auf der Grafik miteinander über den Grove-Stecker. Um den Ultraschallsensor verwenden zu können, muss dieser in Open Roberta eingerichtet werden, wie das geht, erfährst du in dem Video.

Lasse dir zunächst die gemessenen Werte des Ultraschallsensors auf dem Display ausgeben und bestimme für dich, wann ein Tier der Pflanze zu nahe kommt.
Entwickle ein Programm, das den Abstand zu einem Objekt mit dem Ultraschallsensor misst und die gemessenen Werte auf dem LED-Display des Calliope anzeigt. Setze verschiedene Schwellenwerte für den Abstand fest, um unterschiedliche Warnmeldungen zu generieren (mindestens 4 Stufen). Beispielsweise könnte bei einem Abstand von weniger als 20 cm eine rote LED blinken und eine Warnmeldung auf dem Display erscheinen. Bei einem Abstand von mehr als 50 cm könnte eine grüne LED leuchten, um anzuzeigen, dass alles in Ordnung ist.
Erweitere dein Programm aus Aufgabenteil c), indem du eine Reaktion auf den Abstand implementierst. Die Reaktion soll sein, dass der Calliope die Informationen über den Abstand und dass dort ein Tier ist, an einen anderen Calliope sendet und dieser die Informationen anzeigt. Sollte das Tier aber zu dicht an der Pflanze sein, dann soll eine helle LED aktiviert werden und ein Ton gespielt werden.
Für unsere Pflanzen sind sowohl die CO₂-Werte der Luft, als auch die Luftfeuchtigkeit relevant. Dazu gibt es spezielle Messstationen, die diese Daten aufnehmen können. In dieser Aufgabe lernst du die grundlegende Nutzung des CO₂-, Temperatur- und Luftfeuchtigkeitssensors kennen, wobei wir uns hier nur für die CO₂- und Luftfeuchtigkeitswerte interessieren. Ein Temperatursensor ist ja bereits auf dem Calliope verbaut. Dies machen wir zur Abwechslung mit einer anderen Programmiersprache. MakeCode ist ebenfalls eine grafische Programmiersprache aber für die Nutzung des Kombinationssensors, den du in dieser Station kennenlernen sollst, momentan besser geeignet als Open Roberta Lab.
Nimm dir einen CO₂-Sensor und einen Calliope und verbinde die beiden Bauteile wie rechts auf der Grafik miteinander über den Grove-Stecker. Achte darauf, dass der Sensor an A0 angeschlossen wird. Um den CO₂-Sensor verwenden zu können, muss in MakeCode unter Erweitert noch das passende Modul geladen werden, wie das geht, erfährst du in dem Video.


Um zunächst die neue Programmierumgebung und die Sensoren kennenzulernen, schreiben wir drei verschiedene Programme:
- Lass dir die aktuelle Luftfeuchtigkeit ständig auf dem Display des Calliopes ausgeben.
- Lass dir die aktuelle CO₂-Konzentration auf dem Display des Calliopes ausgeben.
- Lass dir abwechselnd beide Informationen aus (1) und (2) anzeigen.
Nun zurück zu unserem Gewächshaus.
Pflanzen nutzen CO₂ und Wasser in Verbindung mit Lichtenergie, um Biomasse aufzubauen, also zu wachsen. Bei den meisten Pflanzen gilt: Je mehr CO₂ der Pflanze zugeführt wird, desto schneller wächst die Pflanze. In Abhängigkeit des CO₂-Gehalts der Luft soll der Calliope eine jeweils andere Anzeige auf dem Display ausgeben. Die Bereiche sind: unter 200 ppm (0% der Anzeige sind an), 200-400 ppm (20% der Anzeige sind an), 400-600 ppm (40% der Anzeige sind an), 600-800 ppm (60% der Anzeige sind an), 800-1000 ppm (80% der Anzeige sind an), mehr als 1000 ppm (100% der Anzeige sind an). Mit der Anzeige ist hier das LED-Display auf dem Calliope gemeint.
Entwickle ein Programm, welches die CO₂-Werte misst und entsprechend den obigen Anforderungen eine Ausgabe erzeugt.
Erweitere dein Programm, sodass die RGB-LED in den Bereichen 0-30%, 30-50%, 50-70%, 70- 100% jeweils in einer anderen Farbe leuchtet.