Arduino Legacy [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== - Arduino Legacy ======



===== Übersicht =====

   * **Installation Arduino-IDE:** https://www.arduino.cc/en/software
   * [[informatik:arduino_programmieren|Tutorial Arduino Programmieren]]
   * Slides
   * **Arduino-Simulation:** https://wokwi.com/
   * Sprachelemente von Arduino-C\+\+: https://www.arduino.cc/reference/de/


===== Bemerkungen =====

   * Kann auch in **Visual Studio Code** Arduino programmieren, aber noch nicht ausprobiert (TODO)
   * Gibt **Alternativen** zu Arduinos, z.B. ESP32

===== Aufträge =====

==== Auftrag 0A: Warm-Up ====

In diesem Auftrag geht es darum, den Arduino und dessen Programmiersprache C\+\+ kennenzulernen.

=== Teil I ===

   1. Installiere die Arduino-IDE und verbinde den Arduino mit deinem Computer per USB.
   1. Starte dein erstes Arduino-Projekt und gebe in der Konsole der Arduino-IDE "Hello World" aus. Siehe [[informatik:arduino_programmieren#ausgabe_in_konsole|Ausgabe in Konsole]]

=== Teil II ===

Hier geht es darum, sich mit den wichtigsten Sprachelementen von C\+\+ vertraut zu machen. Verwende dazu parallel das [[informatik:arduino_programmieren|Arduino Programmieren Tutorial]].

Diese Aufgabe kann auch mit dem Simulator (https://wokwi.com/projects/294342288335700490) gelöst werden. Verwende aber besser deinen Arduino.

   1. Mache einen **Counter**, der in der Konsole im Sekundentakt beliebig weit hoch zählt: $1,2,3,4,5,\ldots$. \\ *Tipp:* [[informatik:arduino_programmieren#arduino_befehle|Arduino Befehle]]
   1. Speichere in einem int-**Array** `primes` die Primzahlen $2,3,5,7,11,13$. Gebe diese im Sekundentakt der Reihe nach aus. Ist der Code am Ende des Arrays angelangt, so soll er wieder von vorne beginnen usw. Schreibe den Code so, dass er auch funktioniert, wenn man dem Array weitere Zahlen hinzufügt.
   1. Berechne mithilfe einer **Schleife** die Summe $100+101+102+\ldots+200$ und gib das Resultat ($15150$) aus.
   1. Schreibe eine **Funktion** `rollDice` vom Typ `int`, welche kein Argument entgegennimmt und eine Zufallszahl von $1$ bis $6$ zurück gibt. Rufe nun im Sekundentakt diese Funktion auf und gebe das Resultat aus.
   1. Erweitere deinen Code von der letzten Teilaufgabe mit einer **Verzweigung**: Wenn man (nicht) eine $6$ würfelt, soll zusätzlich "Gewonnen" ("Verloren") angezeigt werden.


==== Auftrag 0B: GitHub ====

   1. Installiere [[informatik:git_github|Git]]. Auf Mac ist keine Installation nötig.
   1. Erstelle einen GitHub-Account (http://github.com). Verwende eine private Mail-Adresse, die du möglichst in 20 Jahren noch hast.
   1. Erstelle auf GitHub ein privates Repository mit Namen "ArduinoProjectsEFIF" und klone es auf deinen Computer.
   1. Gebe das Repo der Lehrperson (anschae) frei.
   1. Erstelle für jedes Projekt unten ein neues File in diesem Ordner. Adde, commite und pushe regelmässig auf GitHub. 

==== Auftrag 0C: Arduino Box ====

Arduino-Box richten:
   * Tuperware
   * Arduino
   * Batterie mit Kabel
   * LCD-Display

==== Auftrag 1: Laufschrift ====

=== Ziele ===

   * LCD-Display ansteuern können und ...
   * Laufschrift darauf anzeigen.

=== Name File ===

Benenne das Arduino-File `Laufschrift.ino`.

=== Material ===

   * LCD-Display

=== Teil I ===

Schliesse das LCD-Display an (siehe [[informatik:arduino_programmieren#lcd-display|Arduino Programmieren Tutorial]]) und gebe darauf "Hello EFIF" aus.

=== Teil II ===

Programmiere darauf eine Laufschrift.

//Tipp:// Verwende den Datentypen String. Es gibt sehr hilfreiche Befehle, um diese zu manipulieren. Siehe dazu: https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/


==== Programm 2: Disco Disco Party Party ====

=== Ziel ===

Eine LED zum Leuchten bringen und die Blink-Frequenz mit einem Potentiometer einstellen

=== Name File ===

Benenne das Arduino-File `DiscoDisco.ino`.

=== Material ===
   * LED & Widerstand
   * Potentiometer

=== Teil I ===

Bringe zuerst einmal eine LED auf dem Breadboard zum Leuchten.
Beachte:
   * Verwende unbedingt einen passenden **Vorwiderstand** (mind. 120 Ohm)! Ohne diesen geht die LED kaputt und auch der Arduino kann beschädigt werden.
   * Die längere Verbindung (Anode) der LED geht auf Plus.

=== Teil II ===

Studiere das Kapitel zur Verwendung von [[informatik:arduino_programmieren#analoge_digitale_pins|analogen und digitalen Pins.]]

Verbinde nun eine der Verbindungen der LED mit einem der digitalen Inputs/Outputs des Arduinos (Uno: Pins 2 bis 13, vermeide Pins 0 und 1). Lege nun am entsprechenden Pin HIGH an, damit die LED leuchtet. Lasse nun die LED blinken. Verwende dazu die [[informatik:arduino_programmieren#arduino_befehle|Delay-Funktion.]]

=== Teil III ===

Mit einem Potentiometer soll nun die Blink-Frequenz eingestellt werden können. Verbinde die Anschlüsse 1 & 3 des Potentiometers mit Vcc und GRN. Verbinde Anschluss 2 des Potentiometers mit einem der analogen Inputs/Outputs A0 bis A3 des Arduinos. Lese den Wert, der dort angelegt wird, nun ein. Dreht man das Potentiometer, so variiert der Wert im Bereich $0$ bis $1023$. Nutze diesen Wert, um die Frequenz festzulegen.

==== Programm 3: Helligkeit der LED ====

=== Ziel ===

Die Helligkeit einer LED mit einem Poti steuern. Die Lampe über zwei Knöpfe an und ausschalten.

=== Name File ===

Benenne das Arduino-File `HelligkeitLED.ino`.

=== Material ===

   * LED
   * Potentiometer
   * Schalter (2x)

=== Auftrag Teil 1: Helligkeit einstellen ===

Um die Helligkeit einer LED einstellen zu können, würde sich ein analoger Output-Pin anbieten, da dieser, im Gegensatz zu einem digitalen Output, auch Werte zwischen 0V und 5V annehmen kann.
Trotzdem wollen wir für diese Aufgabe die LED an einem digitalen Pin anschliessen. Um die Helligkeit einstellen zu können, so müssen wir auf einen Trick zurückgreifen: Man muss die LED blinken lassen: Schnell genug, damit man es nicht als Blinken wahrnimmt aber langsam genug, damit die LED weniger hell erscheint.
Diesen Code kann man natürlich selbst schreiben. Einfacher aber ist es, wenn man die LED an einen PWM-Pin anschliesst (digitale Pins mit Tilde-Symbol). **PWM** steht für **Pulse Width Modulation**. Der Output wechselt dabei periodisch zwischen LOW und HIGH, wobei man die Breite des Pulses mit einer Zahl zwischen 0 und 255 angeben kann: `analogWrite(PIN_NR,puls_breite);` Siehe dazu auch die Grafiken im [[https://docs.arduino.cc/learn/microcontrollers/analog-output|Manual zu PWM]].

=== Auftrag Teil 2: On/Off Schalter ===

Füge nun zwei Schalter hinzu. Schliesse diese an digitale Inputs. Mit `digitalRead` kann man abfragen, ob der Knopf gedrückt wird oder nicht. Mit einem Schalter soll die LED ein-, mit dem anderen ausgeschaltet werden können.

=== Auftrag Teil 3: nur 1 Schalter (optional) ===

Mache eine Kopie deines Codes und benenne das File `HelligkeitLED2.ino`. Entferne nun einen der Schalter. Man soll nun mit nur einem Schalter die LED ein- und ausschalten können.


==== Programm 4: Blinklichter ====

=== Ziel ===

Einfaches Testprogramm zur Vorbereitung auf den Chronometer unten.

=== Auftrag ===

   1. Mit der `delay()` Funktion kann man einfach eine LED zum Blinken bringen. Doch die Verwendung dieser Funktion bringt grosse Nachteile mit sich. Welche wären die? Bespreche mit Kolleg:in.
   1. Wie könnte man //anders// eine LED im Sekundentakt zum Blinken bringen? Mache mit Kolleg:in einen Plan.
   1. Setzt euren Plan zusammen um.
   1. Könnt ihr auch zwei (oder mehr) LEDs in beliebigen Takten (z.B: LED 1 im Sekundentakt. LED 2 im 0.7 Sekundentakt) zum Blinken bringen?

==== Programm 5: Chronometer ====

=== Ziel ===

Einen Chronometer, also eine Stoppuhr, programmieren. Die Bestzeiten sollen im EEPROM des Arduinos gespeichert werden.

=== Name File ===

Benenne das Arduino-File `Chronometer.ino`.

=== Material ===
   * Schalter (3x)

=== Teil 1: Zeitmessung ===

Verbinde die drei Schalter mit dem Arduino, von denen soll dann jeweils einer:
   * Messung Starten
   * Messung Stoppen
   * Bestzeiten verwalten

Programmiere den Arduino nun so, dass man die Zeit stoppen kann. Drückt.man auf den Startknopf, so beginnt die Zeit zu laufen. Drückt man auf den Stoppknopf, so wird die Messung gestoppt. Drückt man nun den Startknopf erneut, so startet eine neue Messung. Die Zeit wird auf dem Display in der oberen Zeile in Millisekunden ausgegeben.

<code c++>
millis(); // gibt einem die Zeit seit Programmstart in Millisekunden an.
</code>

=== Teil 2: Zeitanzeige ===

Formattiere nun die Zeitanzeige. Diese soll im Format Minuten:Sekunden:Hundertstelsekunden, also zum Beispiel 04:12:05, sein. Schreibe dazu eine eigene Funktion.


=== Teil 3: Bestzeit ===

Erzielt man eine neue Bestzeit, so soll diese im **EEPROM gespeichert** werden. Damit ist diese Zeit auch noch verfügbar, wenn man die Spannungsquelle vom Arduino trennt. Auf das EEPROM kannst du mit EEPROM.read und EEPROM.write zugreifen. Die Bestzeit soll auf der zweiten Zeile des Displays angezeigt werden. Wird der Arduino neu gestartet, so soll die bereits vorhandene Bestzeit aus dem EEPROM gelesen und angezeigt werden.

Drückt man den dritten (bisher nicht genutzten) Schalter, so soll die Bestzeit zurückgesetzt werden.

Im EEPROM des Arduino Uno kann man insgesamt 1024 Bytes speichern. Um nun eine grössere Zahl darin zu speichern, muss diese Zahl in einzelne Bytes zerlegt werden. Mit `z & 0x0000FF` extrahiert man das erste Byte des longs z. Dabei steht 0x0000FF für die Zahl 00....001111 in Hexadezimalschreibweise (deshalb das 0x). Der Operator & ist dabei die bitweise Und-Verknüpfung. Das zweite Bit extrahiert man dann mit `(z & 0x00FF00) >> 8;` Der Befehl `>> 8` verschiebt das Resultat um 8 bits nach rechts.

**ACHTUNG:** Achte darauf, dass nicht in jedem Durchgang des Loops ins EEPROM geschrieben wird/vom EEPROM gelesen wird. Ansonsten wird es beschädigt! Speichere nur dann, wenn eine neue Bestzeit erzielt wurde.

=== Teil 4: Zusätzliche Features für Schalter (optional) ===

   * Drückt man länger auf den Stoppknopf, so soll die angezeigte Zeit (nicht Bestzeit) zurückgesetzt werden.
   * Die Bestzeit soll nur dann zurückgesetzt werden, wenn die dritte Taste mind. zwei Sekunden gedrückt wird.

=== Teil 5: Mehrere Bestzeiten ===

Anstelle von nur einer Bestzeit sollen die fünf besten Zeiten sortiert im EEPROM gespeichert werden. Drückt man die dritte Taste Kurz, soll man durch dir Bestzeiten durchklicken können.

Um dies realisieren zu können, benötigst du ein **Array**, in welchem du mehrere Werte speichern kannst. Mit 
<code c++>
long arr[5];
</code>
deklarierst du ein Array namens `arr`, welches 5 longs speichern kann. Beachte, dass die Grösse eines Arrays im Nachhinein nicht mehr verändert werden kann. Die Elemente des Arrays sind durchnummeriert. Um auf ein Element eines Arrays zuzugreifen, verwenden wir eckige Klammer, z.B. `arr[2]`. Beachte, dass das erste Element den Index 0 (und nicht 1!!!) hat. Das erste Element ist also `arr[0]`, das fünfte und letzte ist `arr[4]`. 
Möchtest du auf alle Elemente eines Arrays zugreifen, kannst du eine **for-Schleife** verwenden. Möchtest du z.B. alle Elemente auf den Wert 42 setzen (warum auch nicht?), kannst du dies wie folgt machen:
<code c++>
for (int i=0; i < 5; i++)
{
  // zählt alle Zahlen durch von i=0 bis und mit i=4
  arr[i] = 42;
}
</code>

Die Bestzeiten müssen **sortiert** werden. Dafür kannst du die vordefinierte Funktion `qsort` verwenden. Besser (und interessanter) ist aber, einen eigenen Sortieralgorithmus zu schreiben. Die einfachste Möglichkeit ist der sogenannte **Select**:
Wähle das erste Element des Arrays aus. Vergleiche dieses nun mit allen Elementen rechts davon (mit höherem Index). Wann immer eines der rechten Elemente grösser ist: Vertausche die beiden. Hast du das erste Element mit allen anderen verglichen, so weist du, dass das erste Element das kleinste ist. Nun wählst du das zweite Element und vergleichst dieses mit allen Elementen rechts davon usw.

//Tipp:// Verwende zwei ineinander verschachtelte for-Schleifen.

===== Mini-Projekte =====

**Datum:** EF IF-Tag, 22.01.2023

=== Übersicht ===

Idee: Alle setzen an diesem Tag ein eigenes, kleines Arduino-Projekt um. Am späteren Nachmittag präsentieren alle den anderen ihre (hoffentlich fertigen) Projekte. Für das Projekt wird eine kurze Dokument erstellt.

=== Zeitplan ===

   * Kick-Off: 8.00
     * Info: Plan, Dokumentation
     * EFs:
       * Dokumentation beginnen: Titel, Abstract, Materialien
       * mit einer LP besprechen
     * TALITs per Teams-Chat an sca:
       * Ausgangslage: Was ist der Stand der Dinge jetzt?
       * Ziele:
         * Welche Ziele möchtest du heute unbedingt erreichen?
         * Welche sind optional?

   * Selbständiges Arbeiten bis 12.00 (TALITs: 11.45 zurück für Statusupdate)
     * dazwischen: Führung durch Informatik-Infrastruktur der KSR
   * Mittag
   * Selbständiges Arbeiten 13.00 - 15.00:
     * Dokumentation vervollständigen
   * **Präsentationsrunde: 15.00**
     * Alle demonstrieren den anderen ihr Projekt

=== Dokumentation ===

Die Dokumentation sollte 1-2 A4-Seiten lang sein und muss folgendes Beinhalten:

   - **Abstract:** Kurze Beschreibung des Projekts in wenigen Sätzen
   - **Benötigte Materialien:** Welche Komponenten werden benötigt?
   - **Fotos:**
     - des gesamten Projekts
     - Verkabelung, jedes Details (z.B. an welche Pins angeschlossen) muss ersichtlich sein 

   - **Code:** gesamter Code als Screenshot
   - **Beschreibung:**
     - Was macht dein Code? Welche Funktionalitäten hast du implementiert?
     - Bugs/Probleme: Gibt es noch Probleme? Was funktioniert (noch) nicht?
     - Ausblick: Wie könnte man das Projekt mit mehr Zeit noch erweitern?

**Abgabe: PDF im Teams-Chat an sca bis am Abend des EF-Tags.**



===== Projekte =====

Idee: Eigenes Arduino-Projekt über Zeitraum von mehreren Wochen realisieren. Wird benotet.




===== Lösungen =====

<nodisp 1>
++++Auftrag 0|
**Counter:**
<code c++>
int i = 1;

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(i);
  i++;
  delay(1000);
}
</code>

**Array Primes:**
<code c++>
int i = 0;
int primes[] = {2,3,5,7,11,13,17};

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(primes[i]);
  i = (i + 1) % (sizeof(primes) / sizeof(int));
  delay(1000);
}
</code>

**Schleife Summe:**
<code c++>
void setup() {
  Serial.begin(9600);
}

void loop() {
  int s = 0;
  int i = 100;
  while (i <= 200) {
    s += i;
    i++;
  }
  Serial.println(s);
  delay(1000);
}
</code>

**Funktion dollDice mit Verzweigung:**
<code c++>
int rollDice() {
  return random(1,7);
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  int r = rollDice();
  Serial.println(r);
  if (r == 6) {
    Serial.println("You win!");
  }
  else{
    Serial.println("You loose!");   
  }
  delay(1000);
}
</code>
++++
</nodisp>