Kompetenzorientierte Prüfung mit Arduino?

Ich hatte Anfang des Jahres mein Konzept vorgestellt, SuS Informatik zu vermitteln. Das war sehr eigenwillig, ein Versuch und überhaupt sehr viel Lernanlass für mich im letzten Jahr. Die SuS haben im zweiten Halbjahr an Projekten gearbeitet und – so die Hoffnung – ihre Programmierkenntnisse vertieft. Konkret wird an folgenden Projekten gearbeitet:

  • didaktische Aufbereitung eines komplexen Arduinocodes für Anfänger
  • ein autonomes Roboterfahrzeug
  • zwei Lightcubes, einer mit Musiksteuerung
  • ein Quizduellclone auf einem 2×40 Matrix ASCII-Display
  • ein Morsezeichendekoder

… und natürlich wird nebenbei in einem Wiki dokumentiert und Code zwischengeparkt.

Eine Klausur verlangte nun die Fachschaft (die aus zwei Lehrkräften besteht). Ich hätte bestimmt auch auf eine Ersatzleistung ausweichen können, aber ich wollte Schwarz auf Weiß sehen, was die SuS jetzt können und was sich im Vergleich zum Anfang des Jahres geändert hat. Deswegen gab es doch eine Klausur, aber eine ganz andere.

Informatikklausur Nr. 2

Material:

  1. Ein Arduinoboard (Art egal)
  2. drei Leds (ggf. verschiedene Farben)
  3. drei Vorwiderstände für die Leds (220-330 Ohm)
  4. zwei Taster
  5. zwei Widerstände für die Taster (1kOhm oder 10kOhm)
  6. ein Steckbrett
  7. Kabelverbinder

Vorbemerkungen:
Wenn du Taster an den Arduino anschließen und ihren Zustand auslesen möchtest, musst du einen zusätzlichen Widerstand verwenden, um definierte Pegel zu bekommen. Dieser Widerstand sollte einen Wert zwischen 1kOhm und 10kOhm haben.

Hier eine Beispielschaltung

<Bild von Tasterschaltung>

Aufgabe:
Du sollst ein Spiel programmieren. In diesem Spiel gibt es drei Leds (links, rechts, Erfolg) und zwei Taster (links, rechts).

Dabei gilt:
Led rechts: Pin03
Led Erfolg: Pin04
Led links: Pin05
Taster rechts: Pin06
Taster links: Pin07

Spielablauf ist folgender:

  1. Zufällig leuchtet entweder die rechte oder die linke Led auf.
  2. Der Spieler muss nun möglichst schnell eine entsprechende Taste (links oder rechts) drücken
  3. Hat er das innerhalb einer bestimmten Zeitspanne geschafft, leuchtet die Led „Erfolg“ auf, ansonsten blinken alle Leds kurz auf
  4. Die Zeitspanne wird im Laufe des Spiel immer kürzer

Für jede realisierte Stufe 1-4 gibt es bereits Punkte!

Tipp:
Suche mit Google nach „Arduino Zufall“, um herauszubekommen, wie du zufällige Werte erhältst.

Abgabe:
Du erstellst mit LibreOffice eine Datei, die deinen ausführlich kommentierten Code enthält.
Du erläuterst deinen Code.
Du beschreibst zusätzlich, welche Schwierigkeiten du während der Programmierung hattest, insbesondere dann, wenn dir etwas nicht gelungen ist.

Die Datei speicherst du unter:

<pfadangabe>

Der Dateiname muss deinen Namen enthalten, z.B. „karl_mustermann_klausur.ods“.

Du darfst:

  • Im Internet recherchieren
  • Dir selbstständig Material holen / organisieren
  • Deinen Code an einer Schaltung ausprobieren

Du darfst nicht:

  • mit deinen Kurskolleginnen und Kollegen sprechen

viel Erfolg!

 

Die Zeit war für diese Aufgabe mit 90 Minuten sehr knapp bemessen, aber es gibt sogar vollständige und funktionierende Lösungen, mindestens aber immer konkrete Ansätze und was mich besonders freut: Die meisten Schaltungen sind korrekt und sauber aufgebaut. Das Prüfungsformat ist im BBS-Kontext erstmal überhaupt nicht ungewöhnlich, bei uns an der Schule jedoch schon ein Novum. Mit Google ist diese Aufgabe nur sehr eingeschränkt lösbbar, gerade auch in der gegebenen Zeit, man braucht dafür also meiner Ansicht nach auch gar nicht mal so wenig Wissen. Ich hatte erst ein wenig Angst vor der Bewertung, aber schlussendlich gibt es für Codequalität schon genug Kriterien und auch für die Beschreibungen. Spannend finde ich, dass man relativ genau sehen kann, wie jemand denkt, weil der Code im Prinzip ja ein formalisierter Plot des Denkens ist – ohne dieses Overhead-Geschwurbel in geisteswissenschaftlichen Fächern (ich darf das als Deutschlehrer sagen).

Mein Problem mit dem erfolgten Unterricht ist ein anderes: Ich komme mir so unverantwortlich vor, weil ich ja nie klassisch unterrichtet, sondern ganz viel 1:1 beraten, gelenkt, unterstützt habe und auch oft fachlich die Segel streichen musste (ich kann jetzt aber einen einstufigen Verstärker stecken). Die „Vorbereitung“ des Unterricht besteht bei dieser Unterrichtsform eher darin, ganz viel selbst lernen zu müssen, weil es um sehr individuelle Probleme geht. Nach jeder Stunde bin ich fix und foxi, weil ich immer gedanklich hin- und herswitchen und auch Anfragen priorisieren muss.

 

Wir sind die Roboter

Die Dämpfe von Lötzinn brennen einer konzentriert über den Lötkolben gebeugten Schülerin in den Augen, der Geruch von Röstzwiebeln liegt in der Luft, überall liegen elektronische und mechanische Bauteile herum. Seltsame Gefährte, die an diejenigen aus der Mad-Max-Triologie anzuknüpfen scheinen, fahren über den Flur und drehen wie von Geisterhand vor Wänden und Hindernissen um. Rechts wird geflucht über die unvermeidlichen Treiberprobleme unter Windows8, links lacht sich darüber der Nutzer eines Ubuntu-Desktops ins Fäustchen, während die Gruppe im hinteren Bereich das Scheitern des letzten Algorithmus bei einem kräftigen Biss in das selbstgebaute Hotdog und einer Partie Minecraft verarbeitet.

Die Situation entstammt nicht dem Entwicklungslabor einer nerdigen Elektronikfirma, sondern beschreibt die Atmosphäre in unserer neuen Arduino-AG auf dem letzten Regionalgruppentreffen recht genau. Da kann nach nicht einmal acht Wochen dann schon sowas herauskommen:

Die Hardware habe ich nach einem Schülerentwurf nachgebaut. Die hier zu sehenden Komponenten

  • ein Arduino UNO-Nachbau
  • ein Adafruit-Motorshield-Nachbau
  • ein HC-SR04 Ultraschallsensor
  • ein 4WD-Chassis
  • sechs Mignon-Akkus
  • ein Batteriefach
  • Kabel und anderer Kleinkram

kosten etwa 50,- Euro, wenn man etwas warten kann. Die notwendige Software gibt es kostenlos zum Download. Programmiert wird in einem C-ähnlichen Dialekt. Der Roboter aus dem Video wird von diesem Programm gesteuert:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
    #include <AFMotor.h>
 
    AF_DCMotor motor_01(1, MOTOR12_64KHZ);
    AF_DCMotor motor_02(2, MOTOR12_64KHZ);
    AF_DCMotor motor_03(3, MOTOR12_64KHZ);
    AF_DCMotor motor_04(4, MOTOR12_64KHZ);
 
    // HC-SR04
    // VCC auf 5V
    // Trig auf Trigger Pin (löst Ultraschallimpuls aus)
    // Echo auf Echo Pin (Zeit in ms bis zum Empfang des Echos)
    // GND auf GND
 
    #define echoPin 15 // Echo Pin
    #define trigPin 14 // Trigger Pin
    int turn = 1;      // Drehrichtungsänderung wenn "festgefahren"
    int count = 0;     // Anzahl der Drehausweichversuche pro Richtung
 
    long duration, distance; // Dauer um Abstand zu berechnen
 
    void setup() {
 
     motor_01.setSpeed(190);  // Wir fahren nicht volle Pulle
     motor_02.setSpeed(190);
     motor_03.setSpeed(190);
     motor_04.setSpeed(190);
 
     Serial.begin (9600);
     pinMode(trigPin, OUTPUT);
     pinMode(echoPin, INPUT);
 
    }
 
    void loop() {
 
 
     /* The following trigPin/echoPin cycle is used to determine the
     distance of the nearest object by bouncing soundwaves off of it. */ 
 
     digitalWrite(trigPin, LOW); 
     delayMicroseconds(2); 
 
     digitalWrite(trigPin, HIGH);
     delayMicroseconds(10); 
 
     digitalWrite(trigPin, LOW);
     duration = pulseIn(echoPin, HIGH);
 
     //Calculate the distance (in cm) based on the speed of sound.
     distance = duration/58.2;
 
     //Delay 50ms before next reading.
     delay(50);
 
     if (distance < 25 && turn > 0 )
 
     {
 
       motor_01.run(FORWARD);   // Motor 1 vorwärts laufen lassen
       motor_02.run(FORWARD);
       motor_03.run(FORWARD);
       motor_04.run(FORWARD); 
 
       delay(200);
 
       motor_01.run(BACKWARD);
       motor_02.run(BACKWARD);  // Motor 2 rückwärts laufen lassen
       motor_03.run(FORWARD);
       motor_04.run(FORWARD);
 
       delay(200);
 
       count++;
 
       if (count >= 3 ) {   
 
         turn = -turn;
 
       }
 
     } 
 
     else if (distance < 25 && turn < 0 )
 
     {
 
       motor_01.run(FORWARD);   // Vorwärts fahren
       motor_02.run(FORWARD);
       motor_03.run(FORWARD);
       motor_04.run(FORWARD); 
 
       delay(200);
 
       motor_01.run(FORWARD);
       motor_02.run(FORWARD);  // Motor 2 rückwärts laufen lassen
       motor_03.run(BACKWARD);
       motor_04.run(BACKWARD);
 
       delay(200);
 
          count++;
 
       if (count >= 3 ) {   
 
         turn = -turn;
 
       }
 
     }
 
     else
 
     {
       motor_01.run(BACKWARD);   // Motor 1 vorwärts laufen lassen
       motor_02.run(BACKWARD);
       motor_03.run(BACKWARD);
       motor_04.run(BACKWARD); 
 
       count = 0;
 
     }
 
    }

Beim Experimentieren mit der Arduinoplattform gibt es ganz viele verschiedene Herausforderungen:

  • Es muss zumindest in Grundzügen programmiert werden
  • Diese Programme bedürfen einer ständigen Optimierung
  • „Verdrahtet“ man mit Lötkolben und Schrauberndreher oder gleich im Programm selbst? – Im oberen Programm sind z.B. „falsch“ angeschlossene Motoren durch entsprechende Codeänderungen kompensiert worden.
  • Wie strukturiert man sein Programm so, dass man es die Woche darauf noch versteht? – Morgen werden wir uns mit Unterprogrammen und der Parameterübergabe beschäftigen.
  • Wie arbeiten die Sensoren eigentlich? (Der HC-SR04 muss z.B. so ausgerichtet werden, dass er nicht schon Unebenheiten auf dem Boden als Hindernis erfasst, mit mehreren Sensoren erhöhe ich die Messgenauigkeit usw.)
  • Wie löse ich die vielen mechanischen Probleme?
  • Die meisten Programmierbeispiele im Netz sind auf Englisch …

Ich finde es prima, dass Informatik hier erfahrbar wird und dass nicht nur virtuell vermittelte Erfahrungen und Lernanlässe vorhanden sind. Grundstrukturen zum Programmieren geben wir in der AG vor, da reines Ausprobieren schnell zu Frusterlebnissen führt, insbesondere wenn mehrere Aktoren und Sensoren dazukommen.
Die Schülerinnen und Schüler dokumentieren das im in einem DokuWiki, was sie über Aktoren und Sensoren herausfinden oder stellen auch ganz Codeschnipsel ein. Nebenbei lernen sie etwas über Syntax.

Informatik mit Arduino

leonardo

Ich habe in diesem Jahr einen Informatikkurs in der Klasse 10 übernommen. Den besucht man als Schülerin oder Schüler zusätzlich zu einem recht vollen Stundenplan in Klasse 10, um die Option auf eine Teilnahme an einem Informatikkurs in Klasse 11 zu bekommen. Man darf dann im Abitur zwei Kurse Naturwissenschaft durch Informatik ersetzen. Ich bin kein gelernter Informatiklehrer – ich bin einfach nur ein größenwahnsinniger Freak und wahrscheinlich schlägt die Informatikdidaktik über meine Ansätze die Hände in der Luft zusammen.  Egal – entweder man ist konventionell oder man lebt.

Stufe 1:

Wir haben Probleme in Einzelprobleme zerlegt – z.B. sollten 20 Zahlen von 20 Personen abgefragt und addiert werden. Unsere Strategien haben wir aufgeschrieben. Dabei spielteh folgende Fragen eine Rolle:

  • Wie merken wir uns die ganzen Zahlen?
  • Wenn wir sie uns aufschreiben: Wir machen wir das genau? Nebeneinander? Untereinander?
  • Addieren wir bei jeder Abfrage oder fragen wir alle Zahlen ab und addieren dann?
  • […]

Stufe 2:

Wir haben mit dem Flussdiagramm ein Verfahren kennen gelernt, dass Aufgeschriebene zu visualisieren und diese Visualisierung für weitere Probleme durchgespielt, die z.B. Fallunterscheidungen enthielten.

Stufe 3:

Mit Scratch haben wir unser Problem aus Stufe 1 ganz konkret gelöst und zwar durch Pass&Fail. Für Scratch muss man heute im Prinzip nicht einmal ein Programm installieren – das läuft auch komplett im Browser – wenn man beim MIT einen Account anlegt. Wer mochte, konnte sich auch schon am klassischen Ratespiel „rate eine Zahl zwischen 1 und 100“ versuchen oder sich eines der vielen veröffentlichten Projekte zu Scratch vornehmen. Die Lösungsansätze haben wir uns vorgestellt und teilweise diskutiert.

Stufe 4:

Anhand eines Ausdrucks eines „Scratchprogrammes“ galt es, ein Flussdiagramm zu zeichnen und einen fiesen, von mir natürlich absichtlich eingebauten Fehler zu finden. Dazu gab es noch einige Erweiterungs- und Optimierungsaufgaben.

Stufe 5:

In einem Dokuwikisystem haben die Schülerinnen und Schüler Seiten zu Programmiersprachen erstellt. Ich habe eine klare Struktur vorgegeben: Eine kurze Beschreibung zur Sprache, ein „Hello World!“- , ein „if -then – else“- und ein „while“-Codebeispiel. Dokuwiki kann das absolut prima, weil es einen leistungsfähigen Syntaxhighlighter für fast alles hat. Es braucht keine Datenbank, ist ajaxbasiert – einfach und umkompliziert. Unnötig zu erwähnen, dass dabei die Konfrontation mit dem Begriff „Syntax“ sowohl theoretisch (für die Sprache suchen) als auch praktisch (Wikisyntax) erfolgte.

Zwischenstand:

Die Schülerinnen und Schüler haben bis jetzt eigentlich schon alles erlebt, was man beim Programmieren so erleben kann:

  • „Mein Code läuft nicht!“ – „Hm. Da fehlt ’ne Klammer“ – „Oha, wenn ich da etwas einrücke, dann wird es ja viel übersichtlicher.“
  • „Sein Code läuft und meiner auch. Welcher ist denn nun richtig?“ – „Welcher gefällt dir denn warum besser?“
  • „Boah, ist das viel zu schreiben!“ – „Nunja – aber wenn sich das ständig wiederholt, könntest du ja vielleicht auch …“
  • […]

Stufe 6:

Kurzer Lehrervortrag zu Arduino. Dann ran an den Simulator – der ist absolut toll und zu empfehlen, bevor die ersten Bauteile in Rauch aufgehen.

Natürlich habe ich zunächst eine ganz einfache Beispielschaltung vorgestellt (blinkende LED).

(circuits.io klappt bisher so richtig gut nur mit Chrome oder Chromium als Browser.)

Die sollte dann um drei LEDs in einer Ampelschaltung erweitert werden. Dazu musste man schon ein Bisschen was am Breadboard verstehen. Nebenbei wurde auch etwas über die Wellenlänge des Lichts und Farbe gelernt: Im Simulator ändert man die LED-Farbe durch Eingabe von Wellenlängen in nm. Und ohne Vorwiderstand macht die LED „peng“, verpolt macht sie gar nichts. Es gab sofort das Spiel: „Wie klein darf ich den Widerstand machen, dass die LED heil bleibt?“ Nebenbei ist die Simulatorhomepage auf Englisch (Widerstand = resistor).

Stufe 7:

Es kommt etwas Theorie zur Arduino-IDE. Wir werden den Arduino Leonardo bzw. einen pinkompatiblen Nachbau  nutzen, weil der durch sein HID-Funktionen in Kombination mit Lagesensoren auch als Gamecontroller oder Mausersatz taugt. Den Arduino kaufen sich die Schülerinnen und Schüler selbst, das Zubehör stifttet unser Förderverein. Die Kosten sind aber sehr marginal im Verhältnis zu den sich bietenden Möglichkeiten. Dann können wir unsere Schaltung aus Stufe 6 real aufbauen.

Ausblick

Die Schülerinnen und Schüler sollen sich nach Möglichkeit eigene Projekte suchen, die sie mit dem Arduino realisieren. Natürlich habe ich notfalls Projekte von unterschiedlichem Schwierigkeitsgrad in der Hinterhand. Der Komplexitätsgrad der Projekte darf natürlich mit dem wachsenden Wissensbeständen steigen. Die Schule bekommt aus einem N21-Projekt für eine AG Roboter auf Arduinobasis gestellt, auf die sich dann ggf. die erwobenen Kenntnisse übertragen lassen.

Mit der steigenden Komplexität der Projekte erwarte ich ein Anwachsen der Programmcodes, das irgendwann dazu führen soll, bestimmte Funktionen auszulagern in objektorientierte Settings (Ende 2. Halbjahr). Schön wäre es, wenn der Code für einen alleine nicht mehr zu pflegen ist, sodass auch Strukturen wie SVN notwendig werden.

Erste Eindrücke

  1. Ich lerne mit den Schülerinnen und Schülern mit. Für mich ist vieles Neuland.
  2. Schülerinnen und Schüler finden Fehler im Programmcode viel schneller in Peer-Reviews als ich
  3. Dieser Ansatz schreckt auch einige ab. Man muss ja allerhand aushalten und sogar auch Elektronik- und Englischwissen ausbauen
  4. Ich musste die Beschäftigung mit der Hardware vorziehen. Ich und die Schülerinnen und Schüler können es teilweise kaum erwarten.
  5. Es wird sehr selbstständig und konzentriert gearbeitet – auf die Frage: „Kann ich das so machen?“ antworte ich oft: „Probiere es aus!“ – und mit dieser Antwort sind sie oft zufrieden.
  6. Perfektionisten sind in der Hinterhand – am effektivsten arbeiten die Experimentierfreudigen
  7. Man kann wunderbar differenzieren: Der C-Freak bekommt eben eine Bildröhre mit Composite-Eingang, auf der er ein Spiel programmiert. Das ist vom Timing her nicht trivial, da der Arduino von seiner Rechenleistung damit an eine Grenze kommt. Dem Anfänger reicht vielleicht ein Lauflicht als erstes Projekt – oder ein Thermometer (NTCs haben eine Kennlinie, muss muss mathematisiert oder mit einem anderen Thermometer kallibriert werden).
  8. Es kommen Fragen wie: „Darf ich zu Hause an meiner Schaltung im Simulator weiterarbeiten?“ „Dürfen wir unser Projekt auch mit nach Hause nehmen?“