Workshop Elektronischer Würfel

Elektronischer Würfel
Allgemeine Informationen
Klassenstufe	ab Klasse 8
Zeitumfang	4 x 2 Unterrichtsstunden
Schwierigkeitsgrad	mittel bis hoch (anpassbar)
Equipment	Microprozessoren, PC

Zurück zu den Projekten.

Die Idee

Wir bauen einen elektronischen Würfel, der zufällig Zahlen von Eins bis Sechs erzeugen und diese auf LEDs in der üblichen Form anzeigen kann. Realisiert wird dieses Projekt mit Hilfe von Mikroprozessoren vom AtTiny bis zum, ESP8266/ESP32 und die Programmierung reicht vom Assemblercode für den AtTiny über C++ in der Arduino-Umgebung bis hin zum visuellen Blockly-Script.

Am Ende verstehst du, wie man zufällige Ereignisse mit Mikroprozessoren generieren kann und welche Unterschiede es zwischen physikalischem und deterministischem Zufall gibt. Du lernst auch etwas über elektrische Grundschaltungen und - falls du dich für die AtTiny-Variante entscheidest - wie ein Mikroprozessor arbeitet. Einfache Programmiererfahrungen sind hilfreich aber keine Voraussetzung für diesen Workshop.

Die Idee aus pädagogischer Sicht

Außerhalb der Alltäglichkeit von Schule kann der Schuler im Workshop folgende Kompetenzen erlernen oder festigen:

• Bau und Test einfacher elektrische Schaltungen
  • LED als Diode, Widerstände, Reihen- und Parallelschaltungen
  • Erstellen und Lesen von Schaltplänen
• Programmierung auf unterschiedlichem Abstraktions- und Hardware-Niveaus
  • Zusammenhang von Schaltung und Programm
• Optional: Übertragung des Aufbaus der Schaltung in ein Platinen-Layout
• Notwendigkeit und Realisierung von Zufallsgeneratoren
  • physikalischer Zufall
  • Nutzung und Bewertung eingebaute Funktionen
  • eigene Versuche (AtTiny)
• Darstellung von Zahlen, Binär- und Dezimalsystem

Was kann das Fraunhofer IMWS leisten?

Neben dem technischen Wissen und dem Erfahrungsschatz unserer Mitarbeiter auch in Form von Weiterbildungen und Einführungsveranstaltungen für interessierte Pädagogen und Erfahrungen vergangener Projekte zur Programmierung von Mikroprozessoren, verfügen wir über einen Schülersatz von PCs Mikroprozessoren für erste Versuche.

Diese Materialien benötigt ihr

Technische Geräte

• einen PC (Windows/Linux/Android/MacOS) mit der Arduino-Umgebung und einem USB-Anschluss
• ein Steckboard
• ein ESP8266 oder einen vergleichbaren Microprozessor (ESP32/Arduino/Seeeduino u.s.w.) mit mindestens drei freien digitalen PINs.
• Steckbrücken und/oder Jumper-Kabel
• LEDs (mindestens 7 Stück pro )
• Widerstände
  • die Berechnung der Vorwiderstände einer LED erfolgt entweder per Hand mit den Kenndaten der LED oder mithilfe des LED-Rechners

Software

• Minimal wird die Arduino-IDE benötigt, für Android (nur sinnvoll auf Tablets) gibt es eine Portierung im Play Store (ArduinoDroid).
• Unter Windows kann die IDE auch als App für den Einzelnutzer installiert werden, was die leidige händische Updaterei durch den Administrator erspart.
• Alternativ gibt es für Programmierumgebungen Pakete, um die Arduino-IDE zu ersetzen, z.B. Plattform.io für Visual Studio Code.
• Nach der Installation müssen (anders als für die original Arduino-Boards) für den ESP8266/ESP32 die passenden Board-Bibliotheken installiert werden. Ein Anleitung findet man z.B. auf heise.de Für andere kompatible Boards liefern die Hersteller Anleitungen.

Anleitung

Unser kleinstes Arduino-Würfel-Programm

 1 /* Reduziertes Würfelprogramm ohne Random-Funktion
 2 -----------------------------------------------------------------------------------------*/
 3 byte ledPin[3]  = {5, 4, 14};                       // GPIO5=D1: 1 LED, GPIO4=D2: 2 LEDs, GPIO14=D5: 4 LEDs
 4 
 5 void showDice(byte dice) {
 6   for (byte i=0; i<=2; i++)                         // für alle drei Stellen
 7     digitalWrite(ledPin[i], (dice>>i)&B1);          // schalte PIN je nach Inhalt der Stelle, B1 = binär 1 = 1 = 0000 0001
 8 }
 9 
10 void setup() {
11   for(byte i=0; i<=2; i++)                          // für alle drei Stellen
12     pinMode(ledPin[i], OUTPUT);                     // schalte PIN aus
13 }
14 
15 void loop() {
16   showDice(nanos()%6 + 1);                          // nanos(): Zeitindex in Nanosekunden, %: Rest bei Division durch 6, alternative: random(6) 
17   delay(1999);                                      // warte 1,999 Sekunden und mache weiter
18 }

Bemerkungen

Die random-Funktion erfolgt in Zeile 16 zeitgesteuert über den lokalen Zeitstempel (nanos()).

Alternativ könnte auch ein Taster verwendet werden. Warum erzeugt dies trotzdem zufällige Werte?

Der Modulo-Operator (%) entspricht dem Rest (größer Null) bei der Division mit Rest - für natürliche Zahlen wie in der Schule. Für unser Anwendung ist die Überlegung hier zu Ende, da der Zeitindex immer positiv ist.

Für ganze Zahlen (also auch negative ganze Zahlen) ergeben sich jedoch im Arduino-C++ andere Resultate:

 15 %  4 =  3
 15 % -4 =  3
-15 %  4 = -3
-15 % -4 = -3

Die Ursache liegt in der der historisch gewachsenen Implementierung der Modulo-Funktion in Programmiersprachen: $a \% b = \biggl(\frac{a}{b} - \lfloor\frac{a}{b}\rfloor\biggr)\cdot b$

Das sieht kompliziert aus, ist aber eigentlich ganz einfach:

Schritt	Formel	Anweisung	Beispiel	Ergebnis
1	$\frac{a}{b}$	dividiere a durch b	$\frac{-15}{4}$	-3,75
2	$int( \bullet)$	lass die Nachkommastellen des Ergebnisses weg	$int(-3,25)$	-3
3	$\bullet - \bullet$	bilde die Differenz	$-3,75 - -3$	-0,75
4	$\bullet \cdot b$	multipliziere das Ergebnis mit b	$-0,75 \cdot 4$	-3

Auf diese Art und Weise können auch negative Ergebnisse entstehen.

Möchte man dies nicht, muss man das Ergebnis mit Null vergleichen und falls kleiner 0 einmal |b| addieren.

Schaltung der LEDs für den Würfel

Es werden drei Pins benötigt, an denen eine (PIN 0), zwei (PIN 1) und vier (PIN 2) LEDs angeschlossen sind.

Würfelsumme und Pinbelegung

Zahl	Binärzahl (8 bit)	LEDs	zu schaltende Pins
1	0000 0001	Schaltung der Würfel-LEDS	PIN 0
2	0000 0010		PIN 1
3	0000 0011		PIN 0 und 1
4	0000 0100		PIN 2
5	0000 0101		PIN 2 und 0
6	0000 0110		Pn 2 und 1

Es werden nur drei Pins für alle sechs LEDs benötigt (0, 1, 2), denn 2³ = 8 < 6. Der Vorteil liegt in der direkten Übersetzung von Binärzahlen in die Schaltung.

Den Unterschied zum üblichen Würfel bilden die Zahlen 2 und 3, die nicht wie gewohnt diagonal sondern quer dargestellt werden.

Wie funktioniert die Übersetzung Zahl in PIN-Belegung?

Die Funktion showDice(byte dice) wird im Programm mit einer Zahl aufgerufen z.B. showDice(5).

Jetzt müssen nacheinander die letzten drei Stellen dieser Zahl im Binärcode ausgelesen werden.

Stelle 0:

dice >> 0 verschiebt den Wert der Variable dice um 0 Bit nach rechts (also gar nicht), aus 0000 0101 wird 0000 0101

Das Ergebnis wird logisch UND-verknüpft mit der Zahl B1 (= 0000 0001): 0000 0101 && 0000 0001 = 0000 0001 ( 1, PIN 0 einschalten).

Alle Stellen, in denen in beiden Zahlen eine Null vorkommt, werden Null, alle Stellen, in denen in beiden zahlen eine 1 vorkommt bleiben 1.

Die Schift(Schiebe)-Operation verschiebt die interessante Stelle nach ganz rechts außen, die Zahl 0000 0001 dient als Filter und löscht alle anderen Stellen aus.

(dice >> 0) && B1 kombiniert einfach beides.

Stelle 1:

dice >> 1 verschiebt die Zahl um 1 Bit nach rechts und füllt links mit Nullen auf, aus 0000 0101 wird 0000 0010

0000 0010 && 0000 0001 = 0000 0000 (0, PIN 1 ausschalten)

Stelle 2:

dice >> 2 verschiebt die Zahl um 2 Bit nach rechts und füllt links mit Nullen auf, aus 0000 0101 wird 0000 0001

0000 0001 && 0000 0001 = 0000 0001 (1, PIN 2 einschalten)

Ergebnis:

Die PINs 0 und 2 werden auf AN geschaltet, PIN 1 auf AUS und es leuchten die entsprechenden fünf LEDs.

Tipps

Für den Schüler

• Das wichtigste zuerst (Sprüche vom Großvater mit Bart wie der von Hans Nielsen Langseth)
  • Aller Anfang ist schwer!
  • Es ist noch kein Meister vom Himmel gefallen!
• Die Lernkurve ist für denjenigen, die oder der noch nie programmiert hat, zugegebenermaßen steil. Aber da das Ganze mit realer Hardware kombiniert wird, ist mit Versuch und Irrtum schnell ein Ergebnis erzielt.

Für den Lehrer

• Die Voraussetzung im Umgang mit Computern streuen bei den Kindern sehr stark. Unterschiedliche Anspruchsniveaus können ein Gleichgewicht schaffen.
• Alle Tücken, die reale Computer bei Benutzung aufweisen können, möglichst vor dem Einsatz mit Schülern eliminieren.
  • Läuft die Arduino-Umgebung?
  • Sind Bibliotheken vorhanden und aktuell?
  • Wenn nicht: können diese problemlos heruntergeladen werden und wenn ja in welchem zeitlichen Aufwand?
  • Meckert irgendein anderes Programm sinnlos im Hintergrund (weil es Updates will, weil es dummerweise automatisch startet, weil ... )
  • Sind die Rechner auf demselben technischen Stand?

C++ oder MicroPython?

• MicroPython wirkt einfacher und angeblich ist die Lernkurve flacher.
• C++ bietet den Vorteil der Hardwarenähe.
  • Code in C++ läuft in der auf normalen ESPs zwei- bis viermal so schnell wie gleicher Code in MicroPython und benötigt weniger Speicher.
  • Besonders für kleine, sparsame Mikroprozessoren, die im Batteriebetrieb kaum Strom verbrauchen dürfen (z.B. im Einsatz als Umgebungssensoren), ist C++ die bessere Lösung.
  • Trotzdem: ein Großteil der Bibliotheken für gängige, externe Bauteile (Sensoren, Relais, Displays, etc.) sind ähnlich in beiden Sprachen erhältlich.
  • Für ESP32-Systeme gibt es mit UIFlow eine (auch dowloadbare) mehrsprachige Umgebung, die visuelle Programmierung in Blockly mit einer Ausgabe in MicroPython kombiniert. Etwas ähnliches gibt es mit dem kostenpflichtigen Projekt Visuino für die Arduino-Umgebung (C++).

Weiterführende Links

• G. Schmidt: AVR-Assembler-Tutorial. Zufallszahlen mit ATtiny13. Es wird nicht nur der AtTiny vorgestellt sondern auch kleine eine Routine, die scheinbar zufällige Zahlen durch Binäroperationen erzeugt.
• Optional: Für Schaltplan und Platinenlayout einfacher Arduino-Schaltungen eignet sich fritzing. Eine einführende Beschreibung findet sich in der Technik-Garage.
• Auf senseBox lässt sich mit einem Blockly-Editor direkt C++ für die Arduino-IDE erzeugen.
• Eine deutsche Anleitung für UIFlow findet man z.B. hier: Teach I(o)T.

LEDs

• Kennwerte von handelsüblichen LEDs
• Vorwiderstände von LEDs berechnen
• Vorwiderstandsrechner