====== - Arduino ======

===== - Strom, Spannung & Widerstand =====

{{ :ef_informatik:efif_arduino_01_einfuehrung_ohmsches_gesetz.pdf |Slides - Das Ohmsche Gesetz}}

==== Aufgaben A ====

Dokumentiere deine Lösungen der Aufgaben schön, entweder auf OneNote oder Papier.

=== Aufgabe A1 - Rechnungen ===

   1. Durch ein Kabel fliesst ein Strom von $130$ mA. Wie viele Elektronen pro Sekunde fliessen durch das Kabel?
   1. In einem Stromkreis, der von einer $5$ V Batterie betrieben wird und nur einen Widerstand hat, fliesse ein Strom von $250$ mA. Berechne den Widerstand des Widerstands.

++++Lösung|

   1. $8.125 \times 10^{17}$ (das sind sehr viele)
   1. $20 \, \Omega$

++++
=== Aufgabe A2 - Es werde Licht! ===

Baue einen Stromkreis mit einer Batterie, einer Lampe und einem Schalter, um die Lampe an und auszuschalten.

   1. Skizziere den zugehörigen Schaltplan.
   1. Bestimme mit einem Multimeter die Spannung der Batterie ...
   1. ... sowie den Strom im Stromkreis.
   1. Berechne daraus den Widerstand der Lampe (*).

(*) Der Widerstand der gleichen Lampe hängt von der Spannung an. Erhöht man die Spannung, so erhöht sich auch der Widerstand. Der hier berechnete Widerstand gilt also nur für die aktuell gerade angelegte Spannung.

=== Aufgabe A3 - Licht ===

Verwende ein Batteriepack und drei identische Glühbirnen. Es dürfen keine weiteren Komponenten wie Widerstände verbaut werden. Baue nun folgende Stromkreise:

   1. Alle Glühbirnen sollen nur schwach und identisch hell leuchten. Skizziere den Schaltplan.
   1. Alle Glühbirnen sollen so hell wie möglich und identisch hell leuchten. Skizziere den Schaltplan.
   1. Eine Glühbirnen soll heller und die anderen beiden weniger (aber gleich) hell leuchten. Skizziere den Schaltplan.
   1. Vergleiche die ersten beiden Stromkreise. Was ist der wesentliche Unterschied?

=== Aufgabe A4 - Widerstände in Serie ===

Baue einen einfachen Stromkreis mit zwei Widerständen in Serie. Verwende zwei unterschiedliche aber ähnlich grosse Widerstände.

   1. Skizziere den zugehörigen Schaltplan.
   1. Messe die Spannung der Batterie.
   1. Berechne den Gesamtwiderstand / Ersatzwiderstand.
   1. Berechne daraus die Stromstärke im Stromkreis.
   1. Messe nun die Stromstärke, um deine Rechnung zu überprüfen.
   1. An jedem der beiden Widerstände fällt die Spannung zu einem Teil ab. Berechne für beide Widerstände diesen Spannungsabfall mithilfe des Ohmschen Gesetz.
   1. Überprüfe deine Resultate, indem du die Spannungsabfälle misst.


=== Aufgabe A5 - Widerstände parallel ===

Verändere nun den Stromkreis aus der letzten Aufgabe so, dass die beiden Widerstände parallel geschaltet sind.

   1. Zeichne den Schaltplan.
   1. Messe die Spannung der Batterie.
   1. Berechne den Gesamtwiderstand / Ersatzwiderstand.
   1. Berechne daraus die Stromstärke im Stromkreis.
   1. Messe nun die Stromstärke, um deine Rechnung zu überprüfen.

=== Aufgabe A6 - Zusammenfassung ===

Erstelle eine **kurze aber hübsche Zusammenfassung**, welches beinhalten muss:

   1. Definition Strom
   1. Ohmsches Gesetz (mit Schaltplan)
   1. Formel Ersatzwiderstand für 2 (oder mehr) Widerstände ...
      1. in Serie (mit Schaltplan)
      1. parallel (mit Schaltplan)
   1. Erklärung: Wie misst man Strom, wie Spannung? Notiere Anweisung und Schaltplan.

=== Aufgabe A7 - Potentiometer ===

Ein **Potentiometer** (kurz **Poti**) ist ein *verstellbarer elektrischer Widerstand*, der zur *Steuerung von Spannung oder Strom* in einem Stromkreis verwendet wird. Es hat drei Anschlüsse: zwei sind an den Enden des Widerstandsmaterials, und der dritte ist ein beweglicher Kontakt, der als Schleifer oder Wischer bezeichnet wird. Durch das Drehen oder Verschieben des Schleifers verändert sich der Widerstand zwischen dem Schleifer und einem der Endanschlüsse, wodurch die Spannung in einem Teil des Stromkreises variiert werden kann. Potentiometer werden oft in Lautstärkereglern (z.B. Musikanlage, E-Gitarre, Synthesizer) oder zur Kalibrierung von Geräten eingesetzt.

{{:ef_informatik:poti.jpg?100|}}

Schaltbild:

{{:ef_informatik:poti_schema.png?300|}}

Verwende nun ein Poti, um die Helligkeit einer Glühbirne zu regulieren. Skizziere den Schaltplan.

=== (Zusatzaufgabe) Aufgabe A8 - Komplexer Stromkreis ===

Baue nun einen komplexeren Stromkreis, z.B. mit zwei seriellen Widerständen, die parallel geschaltet sind zu einem Dritten.

   1. Zeichne den Schaltplan.
   1. Messe die Spannung der Batterie.
   1. Berechne nun an jedem Ort im Stromkreis den Strom.
   1. Überprüfe nun deine Rechnungen mithilfe des Multimeters.

=== (Zusatzaufgabe) Aufgabe A9 - Widerstande im Überfluss ===

Verbinde eine Glühbirne seriell mit einem 100 Ohm Widerstand und zwei in Serie geschalteten Batterie (Spannung ca. $7$ V). Achtung, ohne den Widerstand würde die Glühbirne wohl kaputt gehen!

Du wirst beobachten, dass die Glühbirne *nicht* leuchten wird. Versuche nun mithilfe der anderen Widerstände den Widerstand so zu erweitern, dass man die Glühbirne zumindest ein wenig leuchten sieht. Es dürfen nur *normale Widerstände* verwendet werden und kein Potentiometer oder variablen Widerstand.

===== - Addieren wie ein Computer =====

{{ :ef_informatik:efif_hw_addierer.pdf |Slides - Addieren wie ein Computer}}

===== - Arduino Basics =====

**{{ :ef_informatik:efif_arduino_basics.pdf |Slides Adruino Basics}}**

**Arduino & C\+\+ Tutorial: [[informatik:arduino_programmieren]]**

**Arduino-Simulation:** https://wokwi.com/projects/new/arduino-uno
==== Aufgaben B - Arduino Programmieren (ohne Komponenten) ====

Studiere zuerst das Tutorial [[informatik:arduino_programmieren]] bis und mit "Grundlagen Programmieren".

Löse alle Aufgaben hier auf dem Arduino und gib die Resultate über den Serial Monitor aus. Verwende noch keine Hardware-Komponenten.

**Erstelle für jede Aufgabe ein eigenes Arduino-Projekt.**
=== Aufgabe B1: Verzweigungen ===

Schnapps, Bier, Sirup: Speichere das Alter einer Person in einer int-Variablen age. Bestimme dann, ob die Person Schnapps, Bier oder Sirup trinken kann und gib dies aus, z.B. "Du darfst Bier trinken".

=== Aufgabe B2: Schleifen & Rechnen ===

Speichere eine natürliche Zahl in einer int-Variablen x. Bestimme die Summe aller natürlicher Zahlen bis und mit x.
Beispiel: Falls x = 100, Resultat ist $1+2+3+\ldots+98+99+100 = 5050$

=== Aufgabe B3: Funktionen ===

Wähle eine der beiden Aufgaben:

   1. (einfach) Definiere eine Funktion `pythagoras`, der man die beiden Kathetenlängen (Typ float) übergeben kann. Diese berechnet die Hypotenusenlänge und gibt sie *zurück*.
   1. (mittel) Definiere eine Funktion `isPrime`, der man eine ganze Zahl (typ int) übergeben kann. Die Funktion entscheidet, ob die Zahl eine Primzahl ist oder nicht und gibt entsprechend true oder false zurück.

=== Aufgabe B4: Arrays ===

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.

=== Aufgabe B5: Zeit ===

Mache einen **Counter**, der in der Konsole im Sekundentakt beliebig weit hoch zählt: $1,2,3,4,5,\ldots$. Löse diese Aufgabe einmal mit `delay()` und einmal mit `millis()`. Welche Option ist besser?

*Tipp:* [[informatik:arduino_programmieren|Arduino Befehle]]


++++Lösungen|

**Aufgabe 1:**

<code c++>
void setup() {
  Serial.begin(9600);
  
  int age = 18;

  if (age < 16){
    Serial.println("Sirup!");
  } else if (age < 18) {
    Serial.println("Bier!");
  } else {
    Serial.println("Schnaps!");
  }
}

void loop() {
}
</code>

**Aufgabe 2:**

<code c++>
void setup() {
  Serial.begin(9600);
  
  int x = 100;
  int sum = 0;

  for(int i = 1; i <= x; i++) {
    sum += i;
  }

  Serial.println(sum);
}

void loop() {
}
</code>

**Aufgabe 3:**

a)
<code c++>
void setup() {
  Serial.begin(9600);
  double c = pythagoras(5.0,9.0);
  Serial.println(c);
}

void loop() {
}

double pythagoras(double a, double b){
  return sqrt(a*a + b*b);
}
</code>
b)
<code c++>
double isPrime(int n){
  if (n < 2){
    return false;
  }
  for (int i = 2; i < n; i++) {
    if (n % i == 0){
      return false;
    }
  }
  return true;
}
</code>

**Aufgabe 4:**

<code c++>
int primes[] = {2,3,5,7,11,13};

void setup() {
  Serial.begin(9600);
  Serial.println("Arrays");
}
 
void loop() {
  for (int i=0;i<sizeof(primes)/sizeof(int);i++){
    Serial.println(primes[i]);
    delay(1000);
  }
}
</code>
Alternative Lösung ohne zusätzliche Schleife im Loop:
<code c++>
int primes[] = { 2, 3, 5, 7, 11, 13 };
int nrPrimes = sizeof(primes) / sizeof(int); // number of elements in array
int i = 0; // counter

void setup() {
  Serial.begin(9600);
  Serial.println("Arrays");
}

void loop() {
  i = (i + 1) % nrPrimes; // increase counter by one and reset to 0 
  Serial.println(primes[i]);
  delay(1000);
}
</code>


**Aufgabe 5:**

**Lösung 1 mit delay:**
<code c++>
long count = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("Counter");
}
 
void loop() {
  Serial.println(count);
  delay(1000);
  count++;
}
</code>

**Lösung 2 mit millis:**
<code c++>
long count = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("Counter");
}
 
void loop() {
  if(millis() / 1000 >= count){
    Serial.println(count);
    count++;
  }
}
</code>

++++


==== Aufgaben C - Knöpfe und LED's ====

Studiere zuerst das Kapitel "5. Hardwarenahes Programmieren" im Tutorial [[informatik:arduino_programmieren]].

Verbinde nun erste einfache Komponenten mit deinem Arduino. Schreibe dann den passenden Code.

=== Aufgabe C1 - Disco Disco Party Party V1 ===

Bringe eine LED (natürlich mit passendem Vorwiderstand) zum blinken. Z.B. soll sie alle 100ms ein resp. ausschalten.

=== Aufgabe C2 - LED ein/ausschalten ===

Verbinde eine LED (Vorwiderstand) und ein Knopf mit zwei separaten Pins des Arduinos. Die LED soll genau dann leuchten, wenn man den Knopf gedrückt hält.

=== Aufgabe C3 - LED ein/ausschalten II ===

Gleiches Setup wie in vorheriger Aufgabe. Die LED soll zu Beginn nicht leuchten. Drückt man den Knopf 1x, so soll sie eingeschaltet werden. Drückt man den Knopf wieder, so wird sie ausgeschaltet usw.

=== Aufgabe C4 - Display ===

Schliesse das Display an und zeige darauf deinen Namen an.

=== Aufgabe C5 - Laufschrift ===

Zeige auf dem Display eine Laufschrift an, z.B. "Herzlich Willkommen im EF Informatik ".

<nodisp 2>

++++Lösungen C|

**Aufgabe C1**

<code c++>
/*
PIN: Digital 2 oder Analog A0 (fkt beides) -> Widerstand -> LED -> GND
*/

int DELAY_TIME = 100;
#define PIN_LED_DIGITAL 2 
#define PIN_LED_ANALOG A0 
 
void setup() {
    pinMode(2,OUTPUT);
}
 
void loop() {
  digitalWrite(PIN_LED_DIGITAL,HIGH);
  analogWrite(PIN_LED_ANALOG, 255);
  delay(DELAY_TIME);
  digitalWrite(PIN_LED_DIGITAL,LOW);
  analogWrite(PIN_LED_ANALOG, 0);
  delay(DELAY_TIME);
}
</code>

**Aufgabe C2:**

<code c++>
/*
LED: Digital 2 -> Widerstand -> LED -> GND
BUTTON: Digital 7 -> Button -> GND
*/

int led = false;
#define PIN_BTN 7
#define PIN_LED 2 

void setup() {
    pinMode(7,INPUT_PULLUP);
    pinMode(2,OUTPUT);
}

void loop() {
  led = digitalRead(PIN_BTN);
  digitalWrite(PIN_LED,!led);
}
</code>

**Aufgabe C3:**

<code c++>
/*
LED: Digital 2 -> Widerstand -> LED -> GND
BUTTON: Digital 7 -> Button -> GND
*/
 
int led = false;
#define PIN_BTN 7
#define PIN_LED 2 
 
void setup() {
    pinMode(7,INPUT_PULLUP);
    pinMode(2,OUTPUT);
}
 
void loop() {
  if (!digitalRead(PIN_BTN)){
    led = !led;
  }
  digitalWrite(PIN_LED,led);
  delay(200);
}
</code>

**Aufgabe C4:**

<code c++>
/*
Connect Display:
   * GND to ground
   * VCC to 3.3V
   * SCA to A4
   * SCL to A5
*/

#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
String name = "Fritz ";

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);

  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 0);
  lcd.print(name);
}

void loop() {
}
</code>


**Aufgabe C5:**

<code c++>
/*
Connect Display:
   * GND to ground
   * VCC to 3.3V
   * SCA to A4
   * SCL to A5
*/

#include <Wire.h>
#include "rgb_lcd.h"
 
rgb_lcd lcd;
String s = "HERZLICH WILLKOMMEN IM EF INFORMATIK ";

void setup(){
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2); 
}

void loop(){
    // set the cursor to column 0, line 1
    // (note: line 1 is the second row, since counting begins with 0):
    lcd.setCursor(0, 0);
    lcd.print(s);
 
    s = s + s[0];  // add first char to end of string ...
    s.remove(0,1); // ... and remove it at beginning
 
    delay(500);
}
</code>

++++

</nodisp>

==== Aufgaben D - Poti & RGB-LED ====

=== Aufgabe D1: RGB-LED ===

Eine RGB-LED ist eine spezielle LED, die drei einzelne LED beinhaltet: eine rote, grüne und blaue. 
Jede LED hat einen eigenen Eingang und einen gemeinsamen Ausgang. Damit kann jede Farbe über einen eigenen Pin gesteuert werden. Bedenke auch, dass jede dieser drei LED einen **eigenen Vorwiderstand** (also drei Stück!) benötigt!

Verbinde die RGB-LED korrekt an den Arduino an und schreibe einen Code, der alle 0.5s die Farbe ändert, es sollen mindestens drei verschiedene Farben verwendet werden, die sich dann periodisch wiederholen.

=== Aufgabe D2: Potentiometer ===

Verbinde ein Potentiometer mit dem Arduino und speichere den aktuellen Wert in einer Variablen. Nutze dann diesen Wert, um über einen anderen Pin Blinkdauer einer blinkenden LED einzustellen. Die Blinkdauer soll zwischen 0ms un d 200ms variieren.

*Tipp:* Verwende die `map(...)`-Funktion.

=== Aufgabe D3: Helligkeit regulieren mit PWM ===

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]].


<nodisp 2>

++++Lösungen D|

**Aufgabe D1:**

<code python>
</code>

**Aufgabe D2:**

<code python>
/*
POTI:
- left to LOW
- right to HIGH
- center to PIN_POTI A0

LED: PIN_LED -> LED -> Resistor 150 Ohm -> LOW
*/

#define PIN_LED 2
#define PIN_POTI A0

bool isOn = true;

void setup() {
  Serial.begin(9600);
  pinMode(PIN_LED,OUTPUT);
}

void loop() {
  int valPoti = analogRead(PIN_POTI);
  int delayTime = map(valPoti,0,1023,0,200);
  Serial.println(delayTime);
  digitalWrite(PIN_LED,isOn);
  isOn = !isOn;
  delay(delayTime);
}
</code>

++++

</nodisp>

===== - Zusatzthemen =====

Link zu Dossier von Simon Graf:

{{ :ef_informatik:transistorcpu_skript_teil_01-03.pdf | Vom Transistor zur CPU Teil 1 bis 3 }}

{{ :ef_informatik:transistorcpu_skript_teil_04-06.pdf | Vom Transistor zur CPU Teil 4 bis 6 }}

{{ :ef_informatik:transistorcpu_skript_teil_07-09.pdf | Vom Transistor zur CPU Teil 7 bis 9 }}