Die vorliegenden Materialien wurden von Daniel Hoherz und André Tempel erstellt. Sollten andere Editoren die Materialien erstellt haben, werden diese explizit genannt.
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.
Vergiss nicht: Mache dir Fotos von deinen Ergebnissen und mache dir dazu Notizen.
Überlege dir mit deinem Sitznachbarn, warum man ein Gewächshaus „smart“ machen, also automatisieren, möchte.
Überlebe 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.
Vermutlich kennst du das. Du gehst im Dunkeln an ein 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, welcher Sensoren und Aktoren daran beteiligt sind.
Um unsere Anforderungen umzusetzen, nutzen wir einen Mikrocontroller, also ein sehr kleiner 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:
Vergiss nicht: Mache dir Fotos von deinen Ergebnissen und mache dir dazu Notizen.
Identifziere mit deinem Sitznachbarn Bauteile (Sensoren u. Aktoren) auf dem Calliope mini, mit denen wir die Funktionen eines smarten Gewächshauses realisieren können.
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.
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. Dieses 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.
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)
Schritt 3: Open Roberta Lab einrichten
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)
Schritt 4: Programm auf den Calliope übertragen
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)
Schritt 5: Programm simulieren
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
Schritt 6: Programm speichern
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.
Schritt 6: Programm öffnen
Menü öffnen: Klicke auf das Menü-Symbol oben links (links neben „Bearbeiten“)
Programm öffnen: Klicke auf „importiere Programme“ und wählen in den öffnen Fenster das Programm aus (ggf. musst du zu „Downloads“ navigieren). Klicke auf „Öffnen“, um das ausgewählte Programm zu öffnen.
Vergiss nicht: Mache dir Fotos von deinen Ergebnissen und mache dir dazu Notizen.
Nun versuchen wir, die Funktionsweise des 5×5 LED-Displays zu verstehen.
Erstelle ein Programm für den Calliope min in Open Roberta Lab, das deinen Namen auf der LED-Matrix ausgibt.
Erstelle ein Programm, dass auf dem LED-Displays 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, dass „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 dieses 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 Sender noch gar nicht bereit war.
Es gibt einen Block unter Nachrichten, mit dem du die Nachricht senden kannst. Füge diese 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 dieses dem Programm mitteilen, dafür gibt es unter Nachrichten einen passenden Block.
Als Empfänger solltest 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.
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.
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 Entscheidungen 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 3 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.
Hinweis: Eine Bedingung ist immer eine Ja-/Nein-Frage! Sie ist also entweder wahr oder falsch,
komplexere Situationen müssen auf eine oder mehrere Ja-/Nein-Fragen heruntergebrochen werden.
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üll ist. Folgende Vergleichsoperatoren gibt es:
Die beiden oebn genannten Beispiele mit der Temperatur und der Helligkeit sehen mit den Vergleichsoperatoren dann wie folgt aussehen:
Der Wert mit dem verglichen wird (dunkelblau) wird auch Schwellenwert genannt. Erst wenn dieser Wert erreicht wird, passiert etwas.
Im Folgenden soll mit dem Lichtsensor die Helligkeit durchgängig gemessen werden. Befolge dazu die folgende 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 und zwar so, dass wenn der Wert des Lichtsensors größer als 50% ist, dann soll die RGB-LED gelb leuchten, 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:
Setzt die aktuell gemessenen Zeit auf Null zurück.Gibt die gemessene Zeit in Millisekunden zurück. Eine Sekunde entsprechen
1000 Millisekunden.
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 eine 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.
Manchmal ist es notwendig, dass Bedingungen nicht nur eine Sache prüfen, sondern zeitlgeich mehrere Sachen. So musste in Aufgabe 3c 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 Bedingungen 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 deine 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
und rechts, „wahr“ antworten. 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:
Eine Heckenschere funktioniert nur dann, wenn zwei Knöpfe zeitgleich gedrückt werden. Das soll nun mit dem Calliope nachempfunden werden.
Implementieren Sie ein Programm, dass 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 verschiedenen 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 (goldene Kreis in dem 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.
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 es.
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.
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 Computerporgramm) liefern.
Entwickelt eine Idee und notiert diese, wie wir herauszufinden 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?
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?
Variable deklarieren und initialisieren
Am Anfang muss man als erstes eine Variablen 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? Diese entscheidet darüber, wie viel Speicherplatz für die Variable reserviert wird. Je mehr Variablen ich anlegen, 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.
Variablenblöcke finden
Die Blöcke, um einen Variablen zu verändern oder 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, als ein anderer Wert wird gespeichert. Daneben gibt es noch einen zweiten Block, mit dem man den aktuellen Wert, welcher durch die Variable gespeichert wird, nutzen kann.
Variablenwert verändern
Mit dem Block Schreibe Variablenname kann der entsprechenden 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.
Variablenwerte nutzen
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. Diese 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.
Im Folgenden soll es darum gehen, welchen Wert die Variablen 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 Temperaturausgegeben 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 anzahhl 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 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, dass die Buchstaben A, B, C und D als Eingaben hat und einen Knopf zur Bestätigung. Gibt der Benutzer den korrekte zweistelliger 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-Knopfe 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.
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 Über –
blick über die Beleuchtungszeit zu haben, gibt es ein Display im Gewächshaus, welches die Zeit
hoch zä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.
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 2d) 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.
Die Funktionalität des Einstiegsprogramms soll nun mit den drei verschiedenen Schleifen umgesetzt werden:
ZählschleifeWiederhole bisWiederhole solange
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 der Programmieraufwand, 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.
Programm 1
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 dargestellen und solange die B-Taste gedrückt wird, eine andere Farbkombination dargestellen 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 solange 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 Sätrke am Ende auswählen.
Bitte statt dem x auf Stärke wechseln.
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, trotzdessen dass 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.
Bitte statt dem x auf Stärke wechseln.
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.
Setzt die aktuell gemessenen Zeit auf Null zurück.Gibt die gemessene Zeit in Millisekunden zurück. Eine Sekunde entsprechen
1000 Millisekunden.
Verändere dein Programm so, dass die RGB-LED nur angeschaltet wird, wenn Erschütterungen für
mindestens 3 Sekunden registriert wurde.
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. Dokumentieren hier auch deinen Fortschritt.
Nun schauen kümmern wir uns um die Temperatur im Gewächshaus. Zur Erinnerung: Der Temperatursensor ist in den Prozessor eingebaut (siehe 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) genutzte 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, dass 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 Sonnenstunde 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 zweitere 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ähre 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 verbinden 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 Anzeige eines unterschiedlichen Menge 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 Tier zu den Pflanzen ermittelt werden und entsprechend reagiert werden.
Nimm dir einen Ultraschallsensor und einen Calliope und verbinden 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 dem Abstand und dass dort ein Tier ist, an einen andere 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 Luftfeuchgkeit relevant.
Dazu gibt es spezielle Messstationen, die diese Daten aufnehmen können.
In dieser Aufgabe lernst du die grundlegende Nutzung des CO₂-, Temperatur- und Luftfeuchgkeitssensors
kennen, wobei wir uns hier nur für die CO₂- und Luftfeuchgkeitswerte interessieren.
Einen 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 verbinden 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 Luftfeuchtiggkeit 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 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 andere Farbe leuchtet.
