Manual

User Manual:

Open the PDF directly: View PDF PDF.
Page Count: 154 [warning: Documents this large are best viewed by clicking the View PDF Link!]

ftDuino
ein fischertechnik-kompatibler Arduino
Bedienungsanleitung
Dr.-Ing. Till Harbaum
19. M¨
arz 2019
F¨
ur Tanja, Maya, Fabian und Ida
2017, 2018, 2019 Dr.-Ing. Till Harbaum <till@harbaum.org>
Projekt-Homepage: http://ftduino.de
Kontakt: mailto://info@ftduino.de
Forum: https://forum.ftcommunity.de/
Inhaltsverzeichnis
1 Einleitung 7
1.1 Das ftDuino-Konzept .............................................. 7
1.1.1 Das fischertechnik-Baukastensystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.2 DasArduino-System........................................... 8
1.2 Der ftDuino-Controller ............................................. 9
1.2.1 Mikrocontroller ............................................. 10
1.2.2 USB-Anschluss ............................................. 11
1.2.3 Reset-Taster............................................... 11
1.2.4 InterneLEDs .............................................. 11
1.2.5 Spannungsversorgung.......................................... 11
1.2.6 Anschl¨
usse................................................ 14
1.2.7 Variante mit internem OLED-Display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.2.8 Hinweise f¨
urArduino-erfahreneNutzer................................. 17
1.3 Probleml¨
osungen ................................................ 18
1.3.1 Die gr¨
une Leuchtdiode im ftDuino leuchtetnicht ........................... 18
1.3.2 Der ftDuino taucht am PC nicht als COM:-Portauf .......................... 18
1.3.3 Der ftDuino funktioniert, aber die Ausg¨
angenicht........................... 18
2 Installation 19
2.1 Treiber...................................................... 19
2.1.1 Windows10............................................... 19
2.1.2 Windows7undWindowsVista..................................... 19
2.1.3 Linux................................................... 21
2.2 Arduino-IDE................................................... 23
2.2.1 Installation mit dem Boardverwalter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2.2 Updates ................................................. 24
3 Erste Schritte 26
3.1 DerersteSketch................................................. 26
3.1.1 Download des Blink-Sketches auf den ftDuino ............................. 27
3.1.2 Die Funktionsweise des Sketches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.1.3 Die Funktionen setup() und loop() ................................. 28
3.1.4 AnpassungenamSketch ........................................ 28
3.2 Ansteuerung von fischertechnik-Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.1 DerSketch................................................ 29
3.2.2 Eing¨
ange................................................. 30
3.3 KommunikationmitdemPC .......................................... 31
3.3.1 DerserielleMonitor........................................... 32
3.3.2 Sketchbeschreibung ........................................... 33
3.3.3 USB-Verbindungsaufbau ........................................ 33
4 Programmierung 35
4.1 TextbasierteProgrammierung.......................................... 35
4.2 Die Programmiersprache C++ .......................................... 37
4.3 Grundlagen.................................................... 37
4.3.1 Kommentare............................................... 38
4Inhaltsverzeichnis
4.3.2 Fehlermeldungen ............................................ 39
4.3.3 Funktionen................................................ 40
4.3.4 Die Funktionen setup() und loop() ................................. 41
4.3.5 Beispiel ................................................. 42
4.4 Hilfreiche Bibliotheksfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.4.1 pinMode(pin, mode) ......................................... 43
4.4.2 digitalWrite(pin, value) ..................................... 43
4.4.3 delay(ms) ............................................... 43
4.4.4 Serial.begin(speed) ......................................... 44
4.4.5 Serial.print(val) und Serial.println(val) .......................... 44
4.4.6 ftduino.input get(),ftduino.output set() und ftduino.motor set() ........... 44
4.5 Variablen..................................................... 45
4.5.1 Datentyp int .............................................. 46
4.6 Bedingungen................................................... 47
4.6.1 if-Anweisung .............................................. 47
4.7 Schleifen..................................................... 48
4.7.1 while-Schleife.............................................. 48
4.7.2 for-Schleife............................................... 49
4.8 Beispiele ..................................................... 50
4.8.1 EinfacheAmpel ............................................. 50
4.8.2 Schranke................................................. 51
4.9 Die Warnung Wenig Arbeitsspeicher .................................... 52
4.9.1 Auswirkungen .............................................. 52
4.9.2 VorbeugendeMaßnahmen........................................ 53
4.10 Weiterf¨
uhrendeInformationen.......................................... 55
5ftDuino in der Schule 56
5.1 Grafische Programmierung mit Scratch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
5.1.1 Scratch-Versionen............................................ 57
5.1.2 Scratch1.4forArduino(S4A) ..................................... 57
5.1.3 Scratch3.0 ............................................... 58
5.2 Grafische Programmierung mit Blockly/Brickly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
5.2.1 Brickly.................................................. 61
5.2.2 Brickly-Lite ............................................... 62
5.3 Spielerische Programmierung in Minecraft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.4 Textbasierte Programmierung mit der Arduino-IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5.4.1 DieArduino-Idee ............................................ 64
5.4.2 Arduino und ftDuino .......................................... 65
5.4.3 Der ftDuino alsEinstiegs-Arduino ................................... 65
6 Experimente 66
6.1 Lampen-Zeitschaltung.............................................. 66
6.1.1 Sketch LampTimer ........................................... 66
6.2 Not-Aus ..................................................... 68
6.2.1 Sketch EmergencyStop ......................................... 68
6.3 Pulsweitenmodulation.............................................. 71
6.3.1 Sketch Pwm ............................................... 71
6.4 Schrittmotoransteuerung ............................................ 75
6.4.1 Vollschrittsteuerung........................................... 77
6.4.2 Halbschrittsteuerung .......................................... 78
6.5 Servomotoransteuerung ............................................. 80
6.5.1 Externe6-Volt-Versorgung ....................................... 81
6.6 Die Eing¨
ange des ftDuino ............................................ 83
6.6.1 Spannungsmessung ........................................... 83
6.6.2 Widerstandsmessung .......................................... 83
6.6.3 EinEingangalsAusgang ........................................ 84
6.7 Temperaturmessung............................................... 84
6.7.1 Sketch Temperature .......................................... 85
Inhaltsverzeichnis 5
6.8 Ausg¨
angean,ausodernichtsdavon?...................................... 87
6.8.1 Sketch OnOffTristate ......................................... 87
6.8.2 Leckstr¨
ome ............................................... 88
6.9 AktiveMotorbremse............................................... 88
6.10USB-Tastatur .................................................. 90
6.10.1 Sketch USB/KeyboardMessage ..................................... 90
6.11USB-GamePad.................................................. 91
6.11.1 Sketch USB/GamePad .......................................... 92
6.12Entprellen .................................................... 93
6.12.1 Sketch Debounce ............................................ 93
6.13 Nutzung des I2C-Bus .............................................. 96
6.13.1 Sketch I2C/I2cScanner ........................................ 97
6.13.2 MPU-6050-Sensor............................................ 97
6.13.3 OLED-Display.............................................. 98
6.13.4 VL53L0X LIDAR-Distanzsensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.13.5 ftDuino als I2C-Client und Kopplung zweier ftDuinos ......................... 100
6.13.6 ftDuino-I2C-Expander.......................................... 105
6.13.7 fischertechnik-Orientierungssensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.13.8 fischertechnik-Umweltsensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
6.13.9 Mini-I2C-Servo-Adapter......................................... 108
6.14 WS2812B-Vollfarb-Leuchtdioden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.14.1 Sketch WS2812FX ............................................ 110
6.15 Musik aus dem ftDuino ............................................. 111
6.15.1 Sketch Music .............................................. 112
6.15.2 Sketch MusicPwm ............................................ 112
6.16 Der ftDuino alsMIDI-Instrument........................................ 112
6.16.1 Sketch MidiInstrument ........................................ 112
6.17 Der ftDuino amAndroid-Smartphone...................................... 113
6.18 WebUSB: ftDuino viaWebbrowsersteuern................................... 114
6.18.1 Chrome-Browser............................................. 114
6.18.2 WebUSB-Sketches............................................ 115
6.18.3 Console ................................................. 115
6.18.4 Brickly-lite................................................ 116
6.18.5 Scratch3.0 ............................................... 117
7 Modelle 118
7.1 Automation Robots: Hochregallager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.2 ElectroPneumatic:Flipper............................................ 119
7.3 ROBOTICS TXT Explorer: Linienfolger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
7.4 IdasAmpel.................................................... 121
7.4.1 Zustandsautomaten........................................... 122
7.5 Klassischer2D-Plotter.............................................. 124
8 Community-Projekte 126
8.1 ftduino direct:ftDuino-Anbindung per USB an TXT und TX-Pi . . . . . . . . . . . . . . . . . . . . . 126
8.2 ftDuinIO:ftDuino-Kontroll-App f¨
urTXTundTX-Pi............................. 127
8.3 Brickly-Plugin: Grafische ftDuino-Programmierung in Brickly . . . . . . . . . . . . . . . . . . . . . . . 128
8.4 startIDE: Programmierung direkt auf dem TX-Pi oder TXT . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.5 ft-Extender: I2C-Erweiterung .......................................... 130
8.6 ScratchforArduino(S4A) ........................................... 130
8.6.1 Installation................................................ 131
8.6.2 Darstellung der Pin-Zuweisungen in S4A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
8.7 Minecraft und ftDuino: Computerspiel trifft reale Welt . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
8.7.1 Installation der ftDuino-Mod ...................................... 133
8.7.2 Vorbereitung des ftDuino ........................................ 133
8.7.3 Verwendung des ftDuino inMinecraft ................................. 134
9 Bibliotheken 135
6Inhaltsverzeichnis
9.0.1 Port-Definitionen und Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
9.1 FtduinoSimple ................................................. 136
9.1.1 VerwendungimSketch ......................................... 136
9.1.2 bool input get(uint8 t ch) .................................... 137
9.1.3 bool counter get state(uint8 t ch) ............................... 137
9.1.4 void output set(uint8 t port, uint8 t mode) ......................... 138
9.1.5 void motor set(uint8 t port, uint8 t mode) .......................... 138
9.1.6 Beispiel-Sketches ............................................ 138
9.2 Ftduino ..................................................... 138
9.2.1 Die Eing¨
ange I1 bis I8 ......................................... 139
9.2.2 void input set mode(uint8 t ch, uint8 t mode) ........................ 139
9.2.3 uint16 t input get(uint8 t ch) .................................. 139
9.2.4 Die Ausg¨
ange O1 bis O8 und M1 bis M4 ................................. 140
9.2.5 void output set(uint8 t port, uint8 t mode, uint8 t pwm) ................ 140
9.2.6 void motor set(uint8 t port, uint8 t mode, uint8 t pwm) ................. 140
9.2.7 void motor counter(uint8 t port, uint8 t mode, uint8 t pwm, uint16 t counter) . . 141
9.2.8 bool motor counter active(uint8 t port) ............................ 141
9.2.9 void motor counter set brake(uint8 t port, bool on) .................... 141
9.2.10 Die Z¨
ahlereing¨
ange C1 bis C4 ...................................... 142
9.2.11 void counter set mode(uint8 t ch, uint8 t mode) ....................... 142
9.2.12 uint16 t counter get(uint8 t ch) ................................ 142
9.2.13 void counter clear(uint8 t ch) .................................. 143
9.2.14 bool counter get state(uint8 t ch) ............................... 143
9.2.15 void ultrasonic enable(bool ena) ................................ 143
9.2.16 int16 t ultrasonic get() ...................................... 143
10 Selbstbau 144
10.1 Erste Baustufe ”Spannungsversorgung“..................................... 144
10.1.1 Bauteile-Polarit¨
at ............................................ 145
10.1.2 Kontrollmessungen ........................................... 145
10.2 Zweite Baustufe ”Mikrocontroller“ ....................................... 146
10.2.1 Funktionstest des Mikrocontrollers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
10.3 Dritte Baustufe ”Eing¨
ange“........................................... 147
10.4 Vierte Baustufe ”Ausg¨
ange“ .......................................... 148
10.4.1 Ausgangstestsmit5Volt ........................................ 148
A Schaltplan 150
B Platinenlayout 151
C Best¨
uckungsplan 152
D Maße 153
E Geh¨
ause 154
Kapitel 1
Einleitung
Elektronik- und Computermodule f¨
ur Konstruktionsbauk¨
asten gibt es seit den Anf¨
angen der privat genutzten Heimcomputer
der 80er Jahre. Diese Module verf¨
ugten ¨
uber wenig eigene Intelligenz und waren vor allem f¨
ur die Signalanpassung zwischen
dem Heimcomputer und den Motoren und Schaltern der Baukastensysteme zust¨
andig, weshalb diese Module in der Regel
als “Interfaces” bezeichnet wurden, also als Schnittstelle zwischen Computer und Modell.
¨
Uber die Jahre stieg die Leistungsf¨
ahigkeit der Heimcomputer und auch die Elektronik-Module lernten dazu. Vor allem wurden
aus “Interfaces” ¨
uber die Zeit “Controller”. Aus den weitgehend passiven Schnittstellen wurden Bausteine mit eigener
Intelligenz, die den Heimcomputer bzw. sp¨
ater den PC nur noch zur Programmierung ben¨
otigten. Einmal programmiert
konnten diese Controller das Modell auch eigenst¨
andig bedienen. Dazu wurden die auf dem PC entwickelten Programmdaten
auf den Controller geladen und dort gespeichert.
Die heutigen Controller von Lego oder fischertechnik sind selbst leistungsf¨
ahige Computer. Um deren Komplexit¨
at f¨
ur den
Endanwender benutzbar zu machen verbergen die Hersteller die Details der elektronischen Komponenten sowie der auf
den Ger¨
aten laufenden Software hinter gef¨
alligen Benutzerober߬
achen. Leider verpassen solche Systeme auf diese Weise die
Chance, Wissen ¨
uber Aufbau und Funktion derartiger Controller zu vermitteln. W¨
ahrend sich die Hersteller gegenseitig darin
¨
ubertreffen, komplexe mechanische Getriebe im Wortsinne begreifbar zu machen stellen sich die dazugeh¨
origen Controller
f¨
ur den Anwender als undurchsichtige Bausteine dar.
Parallel hat sich seit der Jahrtausendwende die sogenannte Maker-Bewegung entwickelt, die den “Selbstmach”-Gedanken in
den Bereich der Elektronikentwicklung tr¨
agt. Systeme wie der Raspberry-Pi und der Arduino laden dazu ein, alle technischen
Details dieser komplett zug¨
anglichen und dokumentierten Controller zu erforschen und eigene Entwicklungen zu betreiben.
Große Communities bieten umfangreiches Know-How und stellen Plattformen zum Wissensaustausch zur Verf¨
ugung. Im
Gegensatz zu den Controllern von fischertechnik und Lego steht hier das Innere des Controllers im Vordergrund. Allerdings
erfordert der Einsatz dieser Controller oft einiges an handwerklichem Geschick beim Aufbau der Elektronik selbst sowie
speziell bei Robotik-Projekten bei der Umsetzung von mechanischen Komponenten.
1.1 Das ftDuino-Konzept
Die Idee hinter dem ftDuino ist es, die Br¨
ucke zwischen zwei Welten zu schlagen. Auf der einen Seite integriert er sich
mechanisch und elektrisch nahtlos in die Robotics-Serie der fischertechnik-Konstruktionsbauk¨
asten. Auf der anderen Seite
f¨
ugt er sich perfekt in das Arduino-¨
Okosystem zur Software-Entwicklung von eingebetteten Systemen ein.
1.1.1 Das fischertechnik-Baukastensystem
Fischertechnik ist ein technikorientiertes Konstruktionsspielzeug. Der Schwerpunkt liegt auf Mechanik, Elektromechanik,
Elektronik und zunehmend auch Robotik und der daf¨
ur n¨
otigen Integration von informationsverarbeitenden Komponenten.
Fischertechnik selbst entwickelt und vertreibt seit den fr¨
uhen 80er Jahren Elektronik-Module, die eine Verbindung zwischen
Computer und mechanischem Modell erm¨
oglichen bzw. ¨
uber eigene Intelligenz verf¨
ugen. Die dabei zum Einsatz kommenden
Steckverbinder sowie die Sensoren (Taster, Schalter, Lichtsensoren, . . . ) und Aktoren (Lampen, Motoren, Ventile, . . . ) sind
¨
uber die Jahre zueinander kompatibel geblieben und lassen sich nach wie vor beliebig miteinander kombinieren.
8Kapitel 1. Einleitung
Abbildung 1.1: ftDuino
Die letzten zwei Controller-Generationen (fischertechnik TX- und TXT-Controller) haben eine vergleichbare mechanische
Gr¨
oße und verf¨
ugen ¨
uber eine vergleichbare Anzahl und Art von Anschl¨
ussen zur Verbindung mit dem Modell. Die Modelle
aller aktuellen Robotics-Bauk¨
asten sind auf diese Anschl¨
usse ausgelegt und untereinander kombinierbar.
(a) TX-Controller (b) TXT-Controller
Abbildung 1.2: Original-Controller von fischertechnik
Beide Original-Controller verf¨
ugen ¨
uber acht analoge Eing¨
ange, acht analoge Ausg¨
ange, vier schnelle Z¨
ahlereing¨
ange und
einen I2C-Erweiterungsanschluss.
Fischertechnik selbst vertreibt die PC-Software RoboPro zur visuellen Softwareentwicklung f¨
ur die hauseigenen Controller.
Der Einstieg in RoboPro ist relativ einfach und spricht bereits Kinder an. Die Grenzen von RoboPro sind aber schnell
erreicht, wenn es um praxisnahe und inhaltlich anspruchsvolle Projekte in weiterf¨
uhrenden Schulen, Universit¨
aten und der
Berufsausbildung geht. In diesen Bereichen haben sich Systeme wie die Arduino-Plattform etabliert.
1.1.2 Das Arduino-System
Das Arduino-¨
Okosystem hat sich in den letzten Jahren zum De-Facto-Standard f¨
ur den Einstieg und die semiprofessionelle
Entwicklung und Programmierung von eingebetteten Systemen etabliert. Eingebettete Systeme sind in der Regel mecha-
nisch kleine Computer und informationsverarbeitende Module, die innerhalb einer Maschine Steuer- und Regelaufgaben
¨
ubernehmen und immer h¨
aufiger auch mit der Außenwelt kommunizieren.
Die Arduino-IDE ist eine ¨
ubersichtliche und leicht zu bedienende Programmierober߬
ache, die sich auf Windows-, Linux-
1.2. Der ftDuino-Controller 9
(a) Arduino-Entwicklungsumgebung (IDE) (b) Arduino-Leonardo-Controller
Abbildung 1.3: Die Arduino-Entwicklungsumgebung und -Controller
und Apple-PCs nutzen l¨
asst. Die zu programmierenden Zielger¨
ate wie zum Beispiel der Arduino-Leonardo sind kleine und
kosteng¨
unstige Platinen, die per USB mit dem PC verbunden werden. Sie kommen ¨
ublicherweise ohne Geh¨
ause und stellen
¨
uber Steckverbinder eine Vielzahl von Signalleitungen zum Anschluss von Sensoren und Aktoren zur Verf¨
ugung. Typische
mit der Arduino-Plattform zu erledigende Aufgaben sind einfache Messwerterfassungen (Temperatur-logging, . . . ) und
Steueraufgaben (Jalousiesteuerungen, . . . ).
Programme, die mit der Arduino-IDE geschrieben wurden, werden in der Arduino-Welt als sogenannte “Sketches” bezeichnet.
Mit Hilfe der Arduino-IDE k¨
onnen passende Sketches f¨
ur den ftDuino geschrieben und ¨
uber das USB-Kabel direkt auf das
Ger¨
at hinuntergeladen werden.
Auch f¨
ur einfache Robotik-Experimente ist die Arduino-Plattform bestens geeignet. Schwieriger ist oft eine mechanisch
befriedigende Umsetzung selbst einfachster Robotik-Projekte. Diese L¨
ucke kann das fischertechnik-System schließen.
1.2 Der ftDuino-Controller
Der ftDuino-Controller wurde bewusst mechanisch und elektrisch an den TX- und den TXT-Controller angelehnt, um ihn
ebenfalls direkt mit den aktuellen Robotics-K¨
asten kombinieren zu k¨
onnen. Gleichzeitig wurde er softwareseitig mit dem
Arduino-System kompatibel gehalten.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
9V=
+ -
USB Rund-
stecker
LEDs
Analoge
Eingänge
I1 bis I8
Analoge
Ausgänge
O1 bis O8
(Motorausgänge
M1 bis M4)
Zählereingänge
C1 bis C4
Abbildung 1.4: Die Anschl¨
usse des ftDuino
10 Kapitel 1. Einleitung
1.2.1 Mikrocontroller
Das Herz des ftDuino ist ein Mikrocontroller des Typs ATmega32u4. Dieser Mikrocontroller wird von Microchip (ehemals
Atmel) hergestellt und findet auch im Arduino-Leonardo Verwendung. Sketches, die f¨
ur den Leonardo ¨
ubersetzt wurden,
sind oft direkt auf dem ftDuino lauff¨
ahig.
USB
I²C
SPI
2,5k
RAM
32k
Flash
1k
EEPROM
ADC Timer
AVR8
Prozessor-
kern
IO-
Ports
ATmega32u4
MC33879
MC33879
O1 - O4
O5 - O8
I²C
Pullup-
MUX
I1 - I8
C1 - C4
LED
USB
Abbildung 1.5: Blockdiagramm des ftDuino
Der ATmega32u4-Controller ist ein Mitglied der sogenannten AVR-Familie, auf der die meisten Arduino-Bords basieren. Die
AVR-Controller sind klein, g¨
unstig und ben¨
otigen zum Betrieb nur wenig weitere Bauteile. Ihr Speicher und ihre Rechenleis-
tung reicht f¨
ur den Betrieb s¨
amtlicher fischertechnik-Modelle der Roboticsreihe deutlich aus.
Der ATmega32u4 verf¨
ugt ¨
uber 32 Kilobytes nicht-߬
uchtigem Flash-Speicher, der als Sketch-Programmspeicher verwendet
wird sowie 2,5 Kilobytes internem RAM-Speicher zur Datenspeicherung. Der Prozessortakt betr¨
agt 16 Megahertz. Jeweils
ein Sketch kann im Flash-Speicher permanent gespeichert werden und bleibt auch erhalten wenn der ftDuino von der
Spannungsversorgung getrennt wird.
Der ATmega32u4 ist eines der wenigen Mitglieder der AVR-Familie, das direkte USB-Unterst¨
utzung bereits auf dem Chip
mitbringt. Auf diese Weise ist der ftDuino sehr flexibel als USB-Ger¨
at am PC einsetzbar.
Bootloader
Der ftDuino wird mit einem im ATmega32u4 vorinstallierten sogenannten Caterina-Bootloader ausgeliefert. Dieses Programm
belegt permanent vier der 32 Kilobytes Flash-Speicher des ATmega32u4 und kann nicht ohne weiteres gel¨
oscht oder ver¨
andert
werden.
Der Bootloader erm¨
oglicht die Kommunikation mit dem PC und erlaubt es, dass der PC Programmdaten in den verliebenden
28 Kilobytes Flash-Speicher ablegen bzw. austauschen kann. Der Bootloader erm¨
oglicht auf diese Weise das Hinunterladen
von Sketches in den ftDuino.
Dass der Bootloader aktiv ist und nicht etwa gerade ein Sketch ausgef¨
uhrt wird, ist am Zustand der internen LEDs erkennbar
(siehe 1.2.4).
1.2. Der ftDuino-Controller 11
1.2.2 USB-Anschluss
Die Verbindung zum PC zur Programmierung und Daten¨
ubertragung wird ¨
uber USB hergestellt. Der ftDuino verf¨
ugt ¨
uber
eine sogenannte Mini-USB-Buchse und wird ¨
uber ein handels¨
ubliches Mini-USB-Kabel mit dem PC verbunden.
Abbildung 1.6: Strom- und USB-Anschluss des ftDuino
1.2.3 Reset-Taster
Normalerweise kann die Arduino-IDE durch entsprechende Kommandos ¨
uber den USB-Anschluss den Bootloader des ftDuino
aktivieren, um einen neuen Sketch hinunterzuladen. Enth¨
alt ein hinuntergeladener Sketch aber Fehler, die eine normale
Programmausf¨
uhrung verhindern, dann kann es passieren, dass die USB-Kommunikation w¨
ahrend der normalen Program-
mausf¨
uhrung nicht funktioniert und die Arduino-IDE den ftDuino von sich aus nicht mehr ansprechen kann.
F¨
ur diesen Fall verf¨
ugt der ftDuino ¨
uber einen Reset-Taster. Wird dieser gedr¨
uckt, dann wird der Bootloader zwangsweise
aktiviert und die LEDs zeigen entsprechend den Start des Bootloaders an.
Ein mit einem fehlerhaften Sketch versehener ftDuino kann daher problemlos mit einem korrigierten Sketch versehen werden,
indem kurz vor dem Hinunterladen der Reset-Taster kurz gedr¨
uckt wird. Mehr Details dazu finden sich im Abschnitt 1.3.
1.2.4 Interne LEDs
Der ftDuino verf¨
ugt ¨
uber je eine gr¨
une und rote interne Leuchtdiode (LED). Die gr¨
une Spannungsversorungs-LED zeigt an,
dass der interne 5-Volt-Zweig mit Spannung versorgt ist und der Mikrocontroller des ftDuino versorgt wird.
Die rote LED steht f¨
ur eigene Verwendung zur Verf¨
ugung und kann vom Anwender aus eigenen Sketches heraus unter der
Bezeichnung LED BUILTIN angesprochen werden (siehe Abschnitt 3.1).
Die rote LED wird auch vom Caterina-Bootloader des ftDuino verwendet. Ist der Bootloader aktiv, so leuchtet die LED im
Sekundentakt sanft heller und dunkler (“fading”).
1.2.5 Spannungsversorgung
Der ftDuino kann auf vier Arten mit Spannung versorgt werden:
USB ¨
Uber USB wird der ftDuino immer dann versorgt, wenn keine weitere Stromversorgung angeschlossen ist. Die
USB-Versorgung reicht allerdings nicht zum Betrieb der Analogausg¨
ange. Lediglich die Eing¨
ange k¨
onnen bei USB-
Versorgung verwendet werden. Zus¨
atzlich ist die Genauigkeit einer Widerstandsmessung an den Analogeing¨
angen
deutlich herab gesetzt (siehe 1.2.6).
12 Kapitel 1. Einleitung
Abbildung 1.7: F¨
ur den ftDuino empfohlene Original-fischertechnik-Stromversorgungen
Hohlstecker Wird der ftDuino per Hohlstecker z.B. durch das fischertechnik Power Netzger¨
at 5052871oder dem Netzteil
aus dem fischertechnik Power-Set 5052832mit 9 Volt versorgt, so wird der gesamte ftDuino daraus versorgt und der
USB-Anschluss wird nicht belastet. Die Analogausg¨
ange sind in diesem Fall benutzbar und die Widerstandsmessung an
den Analogeing¨
angen erfolgt mit voller Genauigkeit. F¨
ur den Einsatz von Fremdnetzger¨
aten bietet fischertechnik unter
der Artikelnummer 1348633einen Adapter von ¨
ublichen 5mm-Hohlsteckern auf den von fischertechnik verwendeten
3,45mm-Stecker an.
9V=-Eingang Eine Versorgung des ftDuino z.B. per Batterie-Set oder mit dem Akku aus dem Akku-Set 349694entspricht
der Versorgung per Hohlstecker. Wird der ftDuino sowohl ¨
uber den 9V=-Eingang als auch per Hohlstecker versorgt,
dann erfolgt die Versorgung aus der Quelle, die die h¨
ohere Spannung liefert. Eine R¨
uckspeisung in den Akku oder eine
Ladung des Akkus findet nicht statt.
I2C¨
Uber den I2C-Anschluss versorgt der ftDuino in erster Linie andere angeschlossene Ger¨
ate wie kleine Displays oder
Sensoren. Es ist aber auch m¨
oglich, ihn selbst ¨
uber diesen Anschluss zu versorgen. Es bestehen dabei die gleichen
Beschr¨
ankungen wie bei der Versorgung ¨
uber USB. Auf diese Weise ist zum Beispiel die Versorgung zweier gekoppelter
ftDuinos aus einer einzigen Quelle m¨
oglich (siehe Abschnitt 6.13.5).
max. 3,45mm
+9V
Masse
min. 1,3mm
Abbildung 1.8: 3,45mm fischertechnik-Hohlstecker
Vorsicht ist bei der Verwendung unbekannter oder sehr alter Spannungsquellen geboten. Oftmals weichen die aufgedruckten
Nennspannungen weit von der Realit¨
at ab. Das in Abbildung 1.9 abgebildete Netzteil liefert am 6,8-Volt-Ausgang eine
Leerlaufspannung von ¨
uber 27 Volt. Ein einfaches Multimeter zeigt noch moderate 9,4 Volt an und k¨
onnte den Eindruck
erwecken, dass sich dieses Netzteil zum Betrieb des ftDuino eignet. Erst das Oszilloskop bringt den genauen Spannungsverlauf
zu Tage und zeigt, dass die Spannung kurzfristig sogar 27,2 Volt erreicht. W¨
ahrend Ein- und Ausschaltvorg¨
angen k¨
onnen
noch wesentlich h¨
ohere Spannungen auftreten und den ftDuino besch¨
adigen.
1fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=505287
2fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=505283
3fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=134863
4fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=34969
1.2. Der ftDuino-Controller 13
(a) Das Multimeter zeigt gute 9 Volt an (b) Das Oszilloskop zeigt Spitzen von ¨
uber 27 Volt
Abbildung 1.9: Vorsicht: Ein alter fischertechnik-Trafo liefert ¨
uber 27V am 6,8-Volt-Ausgang und ist f¨
ur den ftDuino unge-
eignet
Aus diesem Grund sollte man bei Einsatz solcher alten oder unbekannten Spannungsquellen sehr vorsichtig sein und im
Zweifelsfall auf den Einsatz verzichten.
Abbildung 1.10: Alte und f¨
ur den ftDuino ungeeignete Stromversorgungen
Im Zweifel sollte unbedingt eine aktuelle Spannungsversorung von fischertechnik eingesetzt werden. Das aktuelle Fischertech-
nik Power Netzger¨
at 9V 5052875ist bestens geeignet, ebenso wie der Akku aus dem Akku-Set 349696oder ein 9-Volt-Block
im Batteriehalter.
Soll es unbedingt ein Fremdger¨
at sein, so ist auf eine stabilisierte 9Volt-Spannung zu achten. Die Stromst¨
arke sollte 1,5
Ampere nicht unterschreiten, um auch kr¨
aftige Motoren betreiben zu k¨
onnen. Ein Beispiel das in Abbildung 1.11 dargestellte
Universal-Schaltnetzteil aus dem Reichelt-Onlineversand7.
5fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=505287
6fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=34969
7Reichelt MW 3R15GS https://www.reichelt.de/universal-schaltnetzteil-18-w-3-12-v-1500-ma-mw-3r15gs-p87340.html
14 Kapitel 1. Einleitung
Abbildung 1.11: F¨
ur den ftDuino geeignetes Universalnetzteil aus dem Onlineversand
1.2.6 Anschl¨
usse
Die Anschl¨
usse des ftDuino teilen sich in die fischertechnik-kompatiblen Ein- und Ausg¨
ange auf, die f¨
ur die ¨
ublichen 2,6mm-
Einzelstecker geeignet sind, sowie die ¨
ublichen Steckverbinder aus dem Computerbereich. Die fischertechnik-kompatiblen Ein-
und Ausg¨
ange sind identisch zum fischertechnik-TXT-Controller angeordnet. Verdrahtungsschemata f¨
ur den TXT k¨
onnen
daher in der Regel direkt ¨
ubernommen werden.
Analoge Eing¨
ange
Der ftDuino verf¨
ugt ¨
uber acht analoge Eing¨
ange I1 bis I8,¨
uber die Spannungen von 0 bis 10 Volt sowie Widerst¨
ande von
0 bis ¨
uber 10 Kiloohm erfasst werden k¨
onnen.
Die Eing¨
ange sind ¨
uber hochohmige Serienwiderst¨
ande gegen Kurzschl¨
usse sowie ¨
Uber- und Unterspannung abgesichert.
Jeder Eingang ist mit einem eigenen Analogeingang des ATmega32u4-Mikrocontrollers verbunden. Die Analogwerterfassung
kann mit bis zu 10 Bit Au߬
osung erfolgen (entsprechend einem Wertebereich 0 bis 1023) und wird direkt in der Hardware
des Mikrocontrollers durchgef¨
uhrt.
Ein Spannungsteiler erweitert den Eingangsspannungsbereich des Mikrocontrollers von 0 bis 5 Volt auf den bei fischertechnik
genutzten Bereich von 0 bis 10 Volt. Alle an fischertechnik-Modellen auftretenden Spannungen k¨
onnen damit erfasst werden.
Zur Widerstandsmessung kann kann jeder Eingang ftDuino-intern mit einem Widerstand gegen 5 Volt verschaltet werden.
Dieser Widerstand wirkt mit einem externen Widerstand als Spannungsteiler und aus der am Mikrocontroller gemesse-
nen Spannung kann der Wert des extern angeschlossenen Widerstands gemessen werden. Alle von fischertechnik-Modellen
¨
ublicherweise verwendeten Widerst¨
ande k¨
onnen so erfasst werden.
Die analogen Eing¨
ange sind nicht auf eine externe 9-Volt-Versorgung angewiesen, sondern funktionieren auch bei der Strom-
versorgung ¨
uber den USB-Anschluss des PC. Allerdings sinkt in diesem Fall die Genauigkeit der Widerstandsmessung signi-
fikant.
Analoge Ausg¨
ange
Der ftDuino verf¨
ugt ¨
uber acht analoge Ausg¨
ange O1 bis O8. Diese Ausg¨
ange werden ¨
uber zwei spezielle Treiberbausteine im
ftDuino angesteuert. Die Treiberbausteine k¨
onnen jeden der acht Ausg¨
ange unabh¨
angig steuern. Sie sind identisch zu denen,
1.2. Der ftDuino-Controller 15
die fischertechnik in den TX- und TXT-Controllern einsetzt. Die Ausg¨
ange sind daher kompatibel zu allen fischertechnik-
Motoren und -Aktoren, die auch am TX- und TXT-Controller betrieben werden k¨
onnen. Der maximal pro Ausgang verf¨
ugbare
Strom betr¨
agt 600mA bis 1,2A.
Die Ausg¨
ange sind bei einer reinen USB-Stromversorgung des ftDuino nicht verf¨
ugbar.
Der verwendete Treiberbaustein MC33879 ist kurzschlussfest und robust gegen ¨
Uber- und Unterspannung an den Ausg¨
angen.
Alle acht Ausg¨
ange k¨
onnen unabh¨
angig voneinander gegen Masse oder Eingangsspannung sowie hochohmig geschaltet
werden. Je zwei Einzelausg¨
ange k¨
onnen zu einem Motorausgang kombiniert werden. Die Einzelausg¨
ange O1 und O2 bilden
dabei den Motorausgang M1,O3 und O4 bilden M2 und so weiter.
Die Analogwerte an den Ausg¨
angen werden durch eine sogenannte Pulsweitenmodulation (PWM) erzeugt. Dabei werden
die Ausg¨
ange kontinuierlich schnell ein- und ausgeschaltet, so dass Motoren, Lampen und andere tr¨
age Verbraucher dem
Signal nicht folgen k¨
onnen, sondern sich entsprechend des Mittelwerts verhalten. Dieses Verfahren wird in gleicher Weise
auch im TX- und TXT-Controller angewendet.
Beide MC33879 werden vom Mikrocontroller des ftDuino intern ¨
uber dessen sogenannte SPI-Schnittstelle angeschlossen. Da
dadurch die speziellen PWM-Ausg¨
ange des Mikrocontrollers nicht zur Erzeugung der der Pulsweitenmodulation herangezogen
werden k¨
onnen muss das PWM-Signal durch den Sketch bzw. die verwendeten Software-Bibliotheken (siehe Kapitel 9) selbst
erzeugt werden. Die sogenannte PWM-Frequenz wird dabei durch den verwendeten Sketch bestimmt und kann beliebig
variiert werden.
Mehr Informationen zum Thema PWM finden sich in Abschnitt 6.3.
Z¨
ahlereing¨
ange
Der ftDuino verf¨
ugt ¨
uber vier spezielle Z¨
ahlereing¨
ange C1 bis C4. Diese Eing¨
ange k¨
onnen rein digitale Signale erfassen und
mit hoher Geschwindigkeit Ereignisse auswerten. Die maximal erfassbare Signalrate liegt je nach Sketch bei mehreren 10.000
Ereignissen pro Sekunde.
Die Z¨
ahlereing¨
ange sind kompatibel zu den Encodern der fischertechnik-Encoder-Motoren und k¨
onnen unter anderem zur
Drehwinkelauswertung sowie zur Drehzahlbestimmung herangezogen werden.
Z¨
ahlereingang C1 verf¨
ugt zus¨
atzlich ¨
uber die M¨
oglichkeit, einen fischertechnik ROBO TX Ultraschall-Distanzsensor 1330098
auszuwerten.
+9V +9V
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 1.12: Anschluss des Ultraschallsensors 133009
I2C-Anschluss
Der I2C-Anschluss ist elektrisch und mechanisch zu dem des fischertechnik-TX-Controllers kompatibel. Der dort aus dem
Ger¨
at herausgef¨
uhrte sogenannte I2C-Bus findet auch im Arduino-Umfeld h¨
aufige Verwendung und erlaubt den Anschluss
passender Elektronikkomponenten wie Sensoren, Analog-Digital-Wandler, Displays und ¨
ahnlich. Außerdem ist ¨
uber den
I2C-Bus eine Kopplung mehrerer ftDuinos m¨
oglich sowie die Kopplung des ftDuino mit dem TX-Controller und dem TXT-
Controller wie in Abschnitt 6.13 beschrieben.
8fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=133009
16 Kapitel 1. Einleitung
Masse
+5V
SDA
SCL
Masse
+5V
SDA
SCL
Abbildung 1.13: Buchsen- und Kabelbelegung des I2C-Bus am ftDuino
Die Signale auf dem I2C-Anschluss nutzen wie am TX-Controller einen 5-Volt-Pegel. Zus¨
atzlich werden aus der Spannungs-
versorgung des ftDuino 5 Volt zur Versorgung angeschlossener Komponenten bereitgestellt. Aus dem 5 Volt-Ausgang d¨
urfen
maximal 100mA entnommen werden, um die ftDuino-interne Spannungsversorgung nicht zu ¨
uberlasten
Abbildung 1.14: Entfernen der Schutzkappe vom I2C-Anschluss des ftDuino
Achtung! Der fischertechnik-TXT-Controller sowie f¨
ur den Betrieb am TXT vorgesehene Komponenten sind aufgrund dessen
3,3 Volt-Signal-Pegel nicht direkt mit dem ftDuino kompatibel. Eine direkte Verbindung zwischen TXT und ftDuino kann
den TXT besch¨
adigen. Sollen der TXT oder f¨
ur den Betrieb am TXT vorgesehene Komponenten am ftDuino verwendet
werden, so sind unbedingt passende I2C-Pegelanpassung zwischenzuschalten wie in Abschnitt 6.13.5 beschrieben.
Achtung! Die auf dem I2C-Anschluss liegenden Signale sind direkt und ungesch¨
utzt mit dem Mikrocontroller des ftDuino
bzw. mit dessen Spannungsversorgung verbunden. Werden an diesem Anschluss Kurzschl¨
usse verursacht oder Spannungen
¨
uber 5V angelegt, dann kann der ftDuino zerst¨
ort werden. Der I2C-Anschluss sollte daher nur von erfahrenen Anwendern
verwendet werden. Aus diesem Grund wird der ftDuino mit einer Schutzkappe auf dem I2C-Anschluss vertrieben. Diese
Kappe ist bei Bedarf vorsichtig mit einem flachen Schraubendreher zu entfernen.
1.2.7 Variante mit internem OLED-Display
Es gibt Varianten des ftDuino, die bereits ¨
uber ein eingebautes OLED-Display verf¨
ugen. Das Display hat eine Au߬
osung von
128 * 32 Pixel und ist intern am I2C-Bus angeschlossen.
Der OLED-ftDuino verf¨
ugt ¨
uber einen angepassten Bootloader, der direkt nach dem Einschalten das Display initialisiert und
einen ftDuino-Schriftzug einblendet. Da der Bootloader das Display aktiv anspricht bildet der OLED-ftDuino immer einen
I2C-Busmaster. Ein ftDuino mit eingebautem Display eignet sich daher nur sehr eingeschr¨
ankt daf¨
ur, selbst als I2C-Client
zu arbeiten und selbst von einem anderen I2C-Master angesprochen zu werden. Er kann jedoch selbst uneigeschr¨
ankt als
Master arbeiten und z.B. einen weiteren Display-losen ftDuino am I2C ansprechen. Zus¨
atzliche externe I2C-Ger¨
ate lassen
sich wie gehabt anschließen.
1.2. Der ftDuino-Controller 17
Abbildung 1.15: Raumschiffanimation auf dem intenen OLED des ftDuino
Abbildung 1.16: Die Adafruit-GPX-Bibliothek im Bibliotheksmanager der Arduino-IDE
Die ftDuino-Installation bringt unter Datei Beispiele Ftduino InternalOLED mehrere Beispiele mit, die jeweils
¨
uber eigene Varianten der FtduinoDisplay.cpp-Bibliothek verf¨
ugen. Alle Beispiele ben¨
otigen zus¨
atzlich die ¨
uber den
Bibliotheks-Manager der Arduino-IDE mit wenigen Klicks zu installierende “Adafruit GFX Library”.
Das Beispiel Datei Beispiele Ftduino InternalOLED Ship3D bringt eine einfache und schnelle Variante dieser
Bibliothek mit. Sie sollte immer dann verwendet werden, wenn keine weiteren I2C-Ger¨
ate am ftDuino betrieben werden und
es auf einen schnellen Bildaufbau ankommt.
Das Beispiel Datei Beispiele Ftduino InternalOLED Ship3DWire dagegen basiert auf der Arduino-Wire-
Bibliothek und der Bildaufbau ist hier deutlich langsamer. Daf¨
ur wird zum Zugriff auf den I2C-Bus die Wire-Bibliothek
verwendet und ein Betrieb zusammen mit anderen ebenfalls durch die Wire-Bibliothek angesteuerten I2C-Sensoren ist
m¨
oglich. Diese Variante der FtduinoDisplay.cpp-Bibliothek kommt auch dann zum Einsatz, wenn am OLED-ftDuino
weitere ftDuinos¨
uber I2C zur Bereitstellung zus¨
atzlicher Ein- und Ausg¨
ange angeschlossen sind.
Das interne OLED-Display belegt die Adresse 0x3C (dezimal 60) und kann daher nicht ohne weiteres parallel mit anderen
OLED-Displays unter dieser Adresse betrieben werden.
1.2.8 Hinweise f¨
ur Arduino-erfahrene Nutzer
Es gibt ein paar fundamentale Unterschiede zwischen dem klassischen Arduino und dem ftDuino. In erster Linie sind
dies die Schutz- und Treiberschaltungen, die beim ftDuino f¨
ur die fischertechnik-Kompatibilit¨
at der Anschl¨
usse sorgt.
Diese Schaltungen sind der Grund, warum man die Ein- und Ausg¨
ange des ftDuino nicht mit den Arduino-¨
ublichen
pinMode() und digitalWrite()-Funktionen ansprechend kann. Diese Funktionen sind darauf ausgelegt, direkt Anschl¨
usse
des ATmega32u4-Mikrocontrollers zu steuern und ber¨
ucksichtigen nicht, dass der ftDuino zus¨
atzliche Schaltungen beinhal-
tet.
18 Kapitel 1. Einleitung
Aus diesem Grund werden die fischertechnik-kompatiblen Ein- und Ausg¨
ange des ftDuino ¨
uber eigene Bibliotheken ange-
steuert, wie in Kapitel 9 beschrieben.
Erfahrene Nutzer k¨
onnen unter Umgehung dieser Bibliotheken nach wie vor auch direkt mit der Hardware des ftDuino
kommunizieren. Die Schaltpl¨
ane im Anhang A liefern alle daf¨
ur n¨
otige Information.
1.3 Probleml¨
osungen
1.3.1 Die gr¨
une Leuchtdiode im ftDuino leuchtet nicht
Zun¨
achst sollte der ftDuino von allen Verbindungen getrennt und ausschließlich ¨
uber den USB-Anschluss mit dem PC
verbunden werden. Die gr¨
une Leuchtdiode im ftDuino muss sofort aufleuchten. Tut sie das nicht, dann sollte ein anderer
PC bzw. ein anderer USB-Anschluss probiert werden.
Hilft das nicht, dann ist zun¨
achst das USB-Kabel zu pr¨
ufen. Funktionieren andere Ger¨
ate an diesem Kabel? Gegebenenfalls
muss das Kabel ausgetauscht werden.
1.3.2 Der ftDuino taucht am PC nicht als COM:-Port auf
Der ftDuino wird nicht mehr vom PC erkannt und es wird kein COM:-Port angelegt.
Leuchtet die gr¨
une Leuchtdiode am ftDuino? Falls nicht sollte wie unter 1.3.1 verfahren werden.
Leuchtet die gr¨
une Leuchtdiode, dann sollte ein kurzer Druck auf den Reset-Taster (siehe 1.2.3) den Bootloader des ftDuino
f¨
ur einige Sekunden aktivieren. Erkennbar ist dies am langsamen Ein- und Ausblenden der roten Leuchtdiode wie in Abschnitt
1.2.4 beschrieben. In dieser Zeit sollte der ftDuino vom PC erkannt werden. Dies wird u.a. unter Windows im Ger¨
atemanager
wie im Abschnitt 2.1.2 beschrieben angezeigt.
Wird der ftDuino nach einem Reset erkannt, aber verschwindet nach ein paar Sekunden aus der Ansicht des Ger¨
atemanagers
oder wird als unbekanntes Ger¨
at angezeigt, dann wurde wahrscheinlich ein fehlerhafter Sketch auf den ftDuino geladen und
die Arduino-IDE ist nicht in der Lage, sich eigenst¨
andig mit dem ftDuino zu verbinden. In diesem Fall sollte man das
Blink-Beispiel (siehe Abschnitt 3.1) in der Arduino-IDE ¨
offnen, den ftDuino per kurzem Druck auf den Reset-Taster in
den Bootloader-Modus versetzen und direkt danach die Download-Schalt߬
ache in der Arduino-IDE dr¨
ucken. Sobald der
funktionierende Sketch geladen wurde wird der ftDuino auch ohne manuelle Druck auf den Reset-Taster wieder von PC
erkannt und der entsprechende COM:-Port taucht wieder auf.
Der ftDuino bleibt nur wenige Sekunden im Bootloader und kehrt danach in den normalen Sketch-Betrieb zur¨
uck. Zwischen
dem Druck auf den Reset-Knopf und dem Start des Downloads aus der Arduino-IDE sollte daher m¨
oglichst wenig Zeit
vergehen.
1.3.3 Der ftDuino funktioniert, aber die Ausg¨
ange nicht
Um die Ausg¨
ange zu benutzen muss der ftDuino mit einer 9-Volt-Spannungsquelle entweder ¨
uber den Hohlstecker-Anschluss
oder ¨
uber die ¨
ublichen fischertechnik-Stecker verbunden sein. Verf¨
ugt der ftDuino ¨
uber keine ausreichende 9-Volt-Versorgung,
so k¨
onnen die Ausg¨
ange nicht betrieben werden. Da der ftDuino selbst schon mit geringerer Spannung l¨
auft ist dessen
Funktion kein sicheres Indiz daf¨
ur, dass eine ausreichende 9-Volt-Versorgung vorhanden ist.
Ist der ftDuino ¨
uber USB mit dem PC verbunden, dann versorgt er sich bei mangelhafter oder fehlender 9-Volt-Versorgung
von dort. Geht der ftDuino ganz aus, sobald man die USB-Verbindung trennt, dann ist keine 9-Volt-Versorgung gegeben
und es muss sichergestellt werden, dass Polarit¨
at und Spannung korrekt bzw. ausreichend sind. Gegebenenfalls muss die
Batterie ausgetauscht oder der verwendete Akku geladen werden.
Kapitel 2
Installation
Die Installation der Software zur Benutzung des ftDuino erfolgt in mehreren Schritten. Zu allererst muss der Computer mit
dem ftDuino bekannt gemacht werden, in dem ein passender Treiber daf¨
ur sorgt, dass der Computer erf¨
ahrt wie er mit dem
ftDuino zu kommunizieren hat.
Im zweiten Schritt wird dann die sogenannte Arduino-IDE installiert, also die eigentliche Programmierumgebung sowie die
Arduino-IDE mit dem ftDuino verbunden.
F¨
ur die Installation und auch f¨
ur die im Kapitel 3 folgenden ersten Schritte reicht es, den ftDuino per USB mit dem PC
zu verbinden. Eine zus¨
atzliche Stromversorgung per Netzteil oder Batterie ist erst n¨
otig, wenn die Ausg¨
ange des ftDuino
verwendet werden sollen.
2.1 Treiber
Unter den meisten Betriebssystemen wird der ftDuino vom Computer direkt erkannt, sobald er angesteckt wird. Das trifft
unter anderem auf Linux, MacOS X und Windows 10 zu, aber nicht f¨
ur Windows 7.
2.1.1 Windows 10
Die Verwendung des ftDuinos unter Windows 10 erfordert keine Treiberinstallation durch den Anwender.
Sobald der ftDuino an einen PC unter Windows 10 angesteckt wird werden die passenden Treiber automatisch instal-
liert. Windows 10 zeigt dies beim ersten Anschließen des ftDuino durch eine entsprechende Meldung am unteren rechten
Bildschirmrand an. Nach einigen Sekunden ist die Installation abgeschlossen und der ftDuino benutzbar.
Weiteres An- und Abstecken erzeugt keine weiteren Meldungen, allerdings ist die erfolgreiche Erkennung des ftDuino unter
Windows 10 jederzeit an der typischen Melodie zu erkennen, die ein Windows-PC beim Erkennen von Hardware ausgibt.
2.1.2 Windows 7 und Windows Vista
Windows 7 und Windows Vista bringen den passenden Treiber ebenfalls bereits mit. Allerdings muss eine passende .inf-
Datei geladen werden, um daf¨
ur zu sorgen, dass Windows diesen Treiber f¨
ur den ftDuino nutzt.
Dass kein Treiber geladen ist erkennt man u.a. daran, dass der ftDuino im Ger¨
atemanager unter “Andere Ger¨
ate” aufgef¨
uhrt
wird.
Die .inf-Datei ist unter https://harbaum.github.io/ftduino/ftduino/driver/ftduino.inf zu finden.
20 Kapitel 2. Installation
Abbildung 2.1: ftDuino ohne passenden Treiber unter Windows 7
Nach dem Download reicht ein Rechtsklick auf die Datei und die Auswahl von “Installieren” im folgenden Men¨
u.
Abbildung 2.2: Rechtsklick auf ftduino.inf
Windows bietet daraufhin an, den Treiber zu installieren.
(a) Best¨
atigungsabfrage (b) Ggf. folgende Sicherheitsabfrage
Abbildung 2.3: Installation des Treibers
Ggf. erfolgt noch eine Sicherheitsabfrage. Dieser Frage kann man getrost zustimmen, da der eigentliche Treiber bereits Teil
von Windows 7 bzw. Windows Vista ist. Die ftduino.inf-Datei fordert Windows lediglich auf, ihn zu verwenden.
Sobald die Installation erfolgreich war wird der ftDuino als sogenannter COM:-Port eingebunden.
Je nach Betriebsmodus des ftDuino und je nach installierter Anwendung auf dem ftDuino befindet er sich im Anwendungs-
modus oder im Bootloader. Windows unterscheidet zwischen beiden Zust¨
anden und weist zwei unterschiedliche COM:-Ports
zu. Das ist so gewollt und soll nicht weiter irritieren. In den meisten F¨
allen wird der Benutzer nur den Anwendungsmodus
zu sehen bekommen.
2.1. Treiber 21
(a) Anwendungsmodus (b) Bootloader
Abbildung 2.4: ftDuino mit passendem Treiber unter Windows 7
2.1.3 Linux
Der ftDuino wird von einem handels¨
ublichen Linux-PC ohne weitere manuelle Eingriffe erkannt. Da er das sogenannte “Ab-
stract Control Model” (ACM) implementiert taucht er im Linux-System unter /dev/ttyACMX auf, wobei X eine fortlaufende
Nummer ist. Sind keine weiteren ACM-Ger¨
ate verbunden, so wird der ftDuino als /dev/ttyACM0 eingebunden.
Mehr Details erf¨
ahrt man z.B. direkt nach dem Anstecken des ftDuino mit dem dmesg-Kommando:
$ dmesg
...
[15822.397956] usb 3-1: new full-speed USB device number 9 using xhci_hcd
[15822.540331] usb 3-1: New USB device found, idVendor=1c40, idProduct=0538
[15822.540334] usb 3-1: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[15822.540336] usb 3-1: Product: ftDuino
[15822.540337] usb 3-1: Manufacturer: Till Harbaum
[15822.541084] cdc_acm 3-1:1.0: ttyACM0: USB ACM device
Die genauen Meldungen variieren von System zu System, aber der generelle Inhalt wird vergleichbar sein.
Weitere Details zum erkannten USB-Ger¨
at liefert das lsusb-Kommando:
$ lsusb -vd 1c40:0538
Bus 003 Device 009: ID 1c40:0538 EZPrototypes
Device Descriptor:
bLength 18
bDescriptorType 1
bcdUSB 2.00
bDeviceClass 239 Miscellaneous Device
bDeviceSubClass 2 ?
bDeviceProtocol 1 Interface Association
bMaxPacketSize0 64
idVendor 0x1c40 EZPrototypes
idProduct 0x0538
...
Diese Ausgaben sind besonders interessant, wenn man wie in Abschnitt 6.10 oder 6.16 beschrieben die erweiterten USB-
M¨
oglichkeiten des ftDuino nutzt.
“Device or resource busy”
Auch wenn Linux bereits den eigentlichen Ger¨
atetreiber mitbringt kann es trotzdem n¨
otig sein, die Systemkonfiguration
anzupassen. Das Symptom ist, dass es beim Versuch, auf den ftDuino zuzugreifen, in der Arduino-IDE zu der folgenden
Fehlermeldung kommt.
22 Kapitel 2. Installation
Abbildung 2.5: Fehlermeldung bei installiertem ModemManager
In diesem Fall ist die wahrscheinlichste Ursache, dass der ModemManager, ein Programm zur Bedienung von Modems,
installiert ist und sich mit dem ftDuino verbunden hat. Um zu verhindern, dass der ModemManager versucht, sich mit dem
ftDuino zu verbinden, ist die Eingabe des folgenden Kommandos n¨
otig:
sudo wget -P /etc/udev/rules.d https://raw.githubusercontent.com/harbaum/ftduino/master/ftduino/driver/99-ftduino.rules
Die Datei /etc/udev/rules.d/99-ftduino.rules muss danach exakt folgenden Inhalt haben:
ATTRS{idVendor}=="1c40" ATTRS{idProduct}=="0537", ENV{ID_MM_DEVICE_IGNORE}="1"
ATTRS{idVendor}=="1c40" ATTRS{idProduct}=="0538", ENV{ID_MM_DEVICE_IGNORE}="1", MODE="0666"
Danach muss der ftDuino einmal kurz vom PC getrennt und wieder angesteckt werden und sollte in der Folge ohne Probleme
zu verwenden sein.
Das Kommando legt eine Datei namens /etc/udev/rules.d/99-ftduino.rules an. Diese Datei enth¨
alt Regeln, wie
der Linux-Kernel mit bestimmten Ereignissen umgehen soll. In diesem Fall soll beim Einstecken eines USB-Ger¨
ates mit der
Hersteller-Identifikation 1c40 und den Ger¨
ateidentifikationen 0537 und 0538 dieses vom ModemManager ignoriert werden.
Zus¨
atzlich werden die Zugriffsrechte auf das USB-Ger¨
at etwas ausgeweitet, so dass der in Abschnitt 6.18.1 beschriebene
Zugriff aus dem Web-Browser funktioniert.
2.2. Arduino-IDE 23
2.2 Arduino-IDE
Die integrierte Entwicklungsumgebung (IDE) f¨
ur den Arduino bekommt man kostenlos f¨
ur die g¨
angigsten Betriebssysteme
unter https://www.arduino.cc/en/Main/Software. Die Windows-Version mit eigenem Installer ist dort z.B. direkt unter dem
Link https://www.arduino.cc/download handler.php erreichbar. Diese Arduino-IDE wird zun¨
achst installiert.
Um den ftDuino unter der Arduino-IDE nutzen zu k¨
onnen muss eine entsprechende Konfiguration vorgenommen werden.
Die Arduino-IDE erlaubt es, diesen Vorgang weitgehend zu automatisieren.
2.2.1 Installation mit dem Boardverwalter
F¨
ur die einfache Installation zus¨
atzlicher Boards bringt die Arduino-IDE den sogenannten Boardverwalter mit. Zun¨
achst
muss dem Boardverwalter in den Arduino-Voreinstellungen mitgeteilt werden, wo die ftDuino-Konfiguration zu finden ist.
Dazu tr¨
agt man https://harbaum.github.io/ftduino/package ftduino index.json in den Voreinstellungen wie folgt ein. Beim
Eintragen der entsprechende Zeile ist darauf zu achten, dass die URL Unterstriche ( ) enth¨
alt, die ggf. beim Kopieren (Copy’n
Paste) der URL aus diesem PDF-Dokument verloren gehen. In diesem Fall sollte die URL manuell eingegeben werden.
Abbildung 2.6: URL der ftDuino-Konfiguration in den Arduino-Voreinstellungen
Den eigentlichen Boardverwalter erreicht man danach direkt ¨
uber das Men¨
u der IDE unter Werkzeuge Board: ...
Boardverwalter... .
Abbildung 2.7: Den Boardverwalter startet man aus dem Men¨
u
Nachdem die JSON-Datei in den Voreinstellungen eingetragen wurde bietet der Boardverwalter automatisch die ftDuino-
Konfiguration an.
Durch Klick auf Installieren... werden alle f¨
ur den ftDuino n¨
otigen Dateien automatisch heruntergeladen und installiert.
24 Kapitel 2. Installation
Abbildung 2.8: Im Boardverwalter kann das ftDuino-Board installiert werden
Nach erfolgreicher Installation kann der ftDuino unter den Boards ausgew¨
ahlt werden.
Abbildung 2.9: Auswahl des ftDuino-Boards unter Windows
Ist bereits ein ftDuino angeschlossen und wurde der n¨
otige Treiber installiert, so l¨
asst sich der ftDuino nun unter Port
ausw¨
ahlen.
Abbildung 2.10: Auswahl des Ports unter MacOS
Die Installation ist damit abgeschlossen. W¨
ahrend der Installation wurden bereits einige Beispielprogramme installiert. Diese
finden sich im Men¨
u unter Datei Beispiele Examples for ftDuino .
Diese Beispiele k¨
onnen direkt geladen und auf den ftDuino hinuntergeladen werden.
2.2.2 Updates
Die Arduino-IDE benachrichtigt automatisch ¨
uber Softwareupdates der ftDuino-Konfiguration. Mit wenig Aufwand bleibt
man so immer auf dem aktuellen Stand.
2.2. Arduino-IDE 25
Abbildung 2.11: Beispiele zum ftDuino-Board
Kapitel 3
Erste Schritte
In diesem Kapitel geht es darum, erste Erfahrungen mit dem ftDuino und der Arduino-IDE zu sammeln. Voraussetzung ist,
dass der ftDuino von einem passenden Treiber auf dem PC unterst¨
utzt wird und dass die Arduino-IDE wie in Kapitel 2
beschrieben installiert und f¨
ur die Verwendung des ftDuinos vorbereitet wurde.
Zus¨
atzlich zum ftDuino wird ein handels¨
ubliches Mini-USB-Kabel ben¨
otigt, wie es z.B. auch mit den fischertechnik TX und
TXT verwendet wird.
3.1 Der erste Sketch
F¨
ur die ersten Versuche ben¨
otigt der ftDuino keine separate Stromversorgung. Es gen¨
ugt, wenn er per USB vom PC versorgt
wird. Die fischertechnik-Ein- und Ausg¨
ange bleiben zun¨
achst unbenutzt.
Als erstes kann man den folgenden Sketch direkt in der Arduino-IDE eingeben. Das Beispiel muss aber nicht zwingend
manuell eingetippt werden, denn es findet sich als fertig mitgeliefertes Beispiel im Datei -Men¨
u der Arduino-IDE unter
Datei Beispiele FtduinoSimple Blink .
Abbildung 3.1: Die ftDuino-Beispiele in der Arduino-IDE
Alle vorinstallierten Beispiele k¨
onnen mit einem Klick geladen werden und es ¨
offnet sich ein neues Fenster mit dem aus-
gew¨
ahlten Beispiel.
1/*
2Blink
3
4Schalte t die in te rne rote LED des ft Du ino f¨u r eine Se ku nde ein
5und f ¨ur eine Seku nde aus und wieder holt die s en dlos .
6
7Origina l :
8ht tp : // w ww . a rd uin o . cc / en / T ut ori al / Bl ink
9*/
3.1. Der erste Sketch 27
10
11 // die setup - Funktion wird ein ma l beim Start aufgerufen
12 void setup () {
13 // Konfig ur ie re den Pin , an den die int erne LED a ng esc hl os sen ist , als A us gang
14 pinMode(LED_BUILTIN ,OUTPUT);
15 }
16
17 // die loop - Fun kt ion wird immer wied er a uf ge ru fe n
18 void loop() {
19 digitalWrite(LED_BUILTIN ,HIGH); // scha lt e die LED ein ( HIGH ist der hohe Spa nn un gsp eg el )
20 delay (1000); // war te 1000 M ill is eku nde n ( eine S eku nd e )
21 digitalWrite(LED_BUILTIN ,LOW); // sc halte die LED aus , i nde m die Sp annun g auf
22 // n ie dri gen P eg el ( LOW ) ge sch alt et wir d
23 delay (1000); // warte eine Se kunde
24 }
3.1.1 Download des Blink-Sketches auf den ftDuino
Der Blink-Sketch sollte nun ge¨
offnet sein. Der ftDuino sollte an den PC angeschlossen sein und im Men¨
u unter Werkzeuge
Board der ftDuino ausgew¨
ahlt sowie der richtige COM:-Port unter Werkzeuge Port ausgew¨
ahlt sein.
Abbildung 3.2: Auswahl des Ports in der Arduino-IDE unter Windows
Dies zeigt die Arduino-IDE auch ganz unten rechts in der Statusleiste an.
(a) Linux (b) Windows
Abbildung 3.3: Der ausgew¨
ahlte ftDuino wird in der Statusleiste angezeigt
Der Download des Sketches auf den ftDuino erfordert nur noch einen Klick auf die Download-Pfeil-Schalt߬
ache in der
Arduino-IDE oben links.
Abbildung 3.4: Download-Schalt߬
ache der Arduino-IDE
Der Sketch wird von der IDE zun¨
achst in Maschinencode ¨
ubersetzt. Wenn die ¨
Ubersetzung erfolgreich war wird der Ma-
schinencode ¨
uber die USB-Verbindung auf den ftDuino ¨
ubertragen und dort im Flash-Speicher abgelegt.
W¨
ahrend des Downloads zeigt die interne rote Leuchtdiode des ftDuino wie in Abschnitt 1.2.4 beschrieben an, dass der
Bootloader aktiviert wird und dass der Download stattfindet.
Nach erfolgreichem Download startet der Sketch sofort und die interne rote Leuchtdiode blinkt langsam.
28 Kapitel 3. Erste Schritte
Abbildung 3.5: Blinkende interne rote Leuchtdiode im ftDuino
3.1.2 Die Funktionsweise des Sketches
Der Sketch-Code besteht zum ¨
uberwiegenden Teil aus erkl¨
arenden Kommentaren, die f¨
ur die Funktion des Sketches v¨
ollig
unbedeutend sind und lediglich dem Verst¨
andnis durch einen menschlichen Leser dienen. Kommentarzeilen beginnen mit
einem doppelten Schr¨
agstrich (//). Mehrzeilige Kommentare werden durch /* und */ eingeschlossen. In diesem Dokument
sowie in der Arduino-IDE sind Kommentare an ihrer hellgrauen F¨
arbung leicht zu erkennen. Tats¨
achlicher Code befindet
sich lediglich in den Zeilen 12 bis 15 sowie den Zeilen 18 bis 24.
3.1.3 Die Funktionen setup() und loop()
Jeder Arduino-Sketch enth¨
alt mindestens die beiden Funktionen setup() (englisch f¨
ur Einrichtung) und loop() (englisch
f¨
ur Schleife). Zwischen den beiden geschweiften Klammern ({und }) befinden sich jeweils durch Semikolon abgetrennt die
eigentlichen durch den ftDuino auszuf¨
uhrenden Befehle. Die Befehle in der Funktion setup() werden einmal bei Sketch-
Start ausgef¨
uhrt. Sie werden ¨
ublicherweise verwendet, um initiale Einstellungen vorzunehmen oder Ein- und Ausg¨
ange zu
parametrieren. Die Befehle der loop()-Funktion werden hingegen immer wieder ausgef¨
uhrt solange der ftDuino eingeschaltet
bleibt oder bis er neu programmiert wird. Hier findet die eigentliche Sketch-Funktion statt und hier wird auf Sensoren reagiert
und Aktoren werden angesteuert.
Auch das Blink-Beispiel arbeitet so. In der setup()-Funktion wird in Zeile 14 der mit der roten Leuchtdiode verbundene
interne Anschluss im ftDuino zum Ausgang erkl¨
art.
In der loop()-Funktion wird dann in Zeile 19 der interne Anschluss der roten Leuchtdiode eingeschaltet (Spannungspegel
hoch, HIGH) und in Zeile 21 wird er ausgeschaltet (Spannungspegel niedrig, LOW). Zwischendurch wird jeweils in den Zeilen
20 und 23 1000 Millisekunden bzw. eine Sekunde gewartet. Die Leuchtdiode wird also eingeschaltet, es wird eine Sekunde
gewartet, sie wird ausgeschaltet und es wird eine weitere Sekunde gewartet. Dies passiert immer und immer wieder, so dass
die Leuchtdiode mit einer Frequenz von 0,5 Hertz blinkt.
3.1.4 Anpassungen am Sketch
F¨
ur den Einstieg ist es oft sinnvoll, mit einem vorgefertigten Sketch zu starten und dann eigene ¨
Anderungen vorzunehmen.
Die Beispiele der Arduino-IDE stehen aber allen Benutzern eines PCs zur Verf¨
ugung und k¨
onnen daher zun¨
achst nicht
ver¨
andert werden. Nimmt man an einem Beispiel-Sketch ¨
Anderungen vor und versucht sie zu speichern, dann weist einen
die Arduino-IDE darauf hin, dass man eine eigene Kopie anlegen soll. Dazu ¨
offnet die Arduino-IDE einen Dateidialog und
man hat die M¨
oglichkeit, den Sketch vor dem Speichern umzubenennen z.B. in SchnellBlink.
Abbildung 3.6: Die Arduino-IDE fordert zum Speichern einer eigenen Kopie auf
3.2. Ansteuerung von fischertechnik-Komponenten 29
Sobald man auf diese Weise eine eigene Kopie angelegt hat kann man sie beliebig ver¨
andern. Die eigene Kopie wird im
Men¨
u der Arduino-IDE unter Datei Sketchbook eingef¨
ugt und kann von dort sp¨
ater jederzeit wieder geladen werden.
Abbildung 3.7: Kopie SchnellBlink im Sketchbook der Arduino-IDE
Im Sketch kann man nun beispielsweise aus den 1000 Millisekunden in den Zeilen 20 und 23 jeweils 500 Millisekunden
machen.
18 void loop() {
19 digitalWrite(LED_BUILTIN ,HIGH); // scha lt e die LED ein ( HIGH ist der hohe Spa nn un gsp eg el )
20 delay (500) ; // w ar te 5 00 M ill ise ku nde n ( eine h al be Se kun de )
21 digitalWrite(LED_BUILTIN ,LOW); // sc halte die LED aus , i nde m die Sp annun g auf
22 // n ie dri gen P eg el ( LOW ) ge sch alt et wir d
23 delay (500) ; // warte eine ha lbe S ekunde
24 }
Nach erfolgreichem Download wird die Leuchtdiode dann jeweils f¨
ur 0,5 Sekunden ein- und ausgeschaltet und die Blinkfre-
quenz verdoppelt sich auf ein Hertz.
3.2 Ansteuerung von fischertechnik-Komponenten
Um die interne Leuchtdiode des ftDuino blinken zu lassen h¨
atten wir keinen ftDuino ben¨
otigt. Alle Arduinos verf¨
ugen ¨
uber
eine solche interne Leuchtdiode und h¨
atten f¨
ur unser erstes Beispiel verwendet werden k¨
onnen.
Seine speziellen F¨
ahigkeiten spielt der ftDuino aus, wenn es darum geht mit den ¨
ublichen fischertechnik-Sensoren und -
Aktoren umzugehen. Der Blink-Sketch soll daher so erweitert werden, dass zus¨
atzlich zu Leuchtdiode eine am Ausgang O1
angeschlossene Lampe blinkt.
Angeschlossen wird dazu eine normale fischertechnik-Lampe mit einem Stecker an den Ausgang O1 des ftDuino und mit dem
zweiten Stecker an einen der Masseanschl¨
usse des ftDuino. Masseanschl¨
usse sind die 12 Anschl¨
usse, die in der Abbildung
3.8 mit einem Massesymbol ⊥verbunden sind.
Da nun die mit 9 Volt betriebenen fischertechnik-Ausg¨
ange verwendet werden muss der ftDuino zus¨
atzlich mit 9 Volt versorgt
werden. Das kann z.B. ¨
uber ein ¨
ubliches fischertechnik-Netzteil erfolgen oder ¨
uber einen Batteriehalter. Beide Anschl¨
usse
sind verpolungsgesch¨
utzt, speziell beim Anschluss der Batterie kann man also keinen Schaden anrichten.
3.2.1 Der Sketch
Der folgende Beispiel-Sketch BlinkO1 findet sich auch im Datei -Men¨
u der Arduino-IDE unter Datei Beispiele
FtduinoSimple BlinkO1 .
1// B lin kO1 . i no
2//
3// Bli nken ei ner L amoe an A us gang O1
4//
5// ( c ) 2 01 8 b y Ti ll H a rb au m < t i ll @h ar ba um . or g >
6
30 Kapitel 3. Erste Schritte
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 3.8: Blinkende fischertechnik-Lampe am ftDuino
7#include < F t du in oS imp le .h >
8
9void setup () {
10 // LED initialisieren
11 pinMode(LED_BUILTIN ,OUTPUT);
12 }
13
14 void loop() {
15 // schalt e die in te rne LED und den A us gang O1 ein ( HIGH bzw . HI )
16 digitalWrite(LED_BUILTIN ,HIGH);
17 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
18
19 delay (1000); // war te 1000 M ill is eku nde n ( eine S eku nd e )
20
21 // schalt e die in te rne LED und den A us gang O1 aus ( LOW bzw . LO )
22 digitalWrite(LED_BUILTIN ,LOW);
23 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: LO );
24
25 delay (1000); // warte eine Se kunde
26 }
Der Sketch unterscheidet sich nur in wenigen Details vom urspr¨
unglichen Blink-Sketch. Neu hinzugekommen sind die Zeilen
7, 17 und 23. In Zeile 7 wird eine Bibliothek eingebunden, die speziell f¨
ur den ftDuino mitgeliefert wird und den Zugriff
auf die Ein- und Ausg¨
ange des ftDuino vereinfacht. In den Zeilen 17 und 23 wird der Ausgang O1 eingeschaltet (HI) bzw.
ausgeschaltet (LO). Weitere Details zu dieser Bibliothek finden sich in Kapitel 9.
Die Kommandos zum Ein- und Ausschalten der internen Leuchtdiode sind nach wie vor vorhanden, so dass die interne
Leuchtdiode nun parallel zur extern angeschlossenen Lampe blinkt.
Weitere einfache Beispiele und Erkl¨
arungen zur Benutzung der Ein- und Ausg¨
ange in eigenen Sketches finden sich in
Abschnitt 9.1.1.
3.2.2 Eing¨
ange
Zum Anschluss an ¨
ubliche fischertechnik-Taster, -Fototransistoren und ¨
ahnlich verf¨
ugt der ftDuino ¨
uber die acht Eing¨
ange
I1 bis I8 und die Z¨
ahlereing¨
ange C1 bis C4.
Der Zugriff auf diese Eing¨
ange erfolgt ¨
uber passende Bibliotheken wie in Abschnitt 9 dargestellt. ¨
Uber die FtduinoSimple-
Bibliothek kann der Schaltzustand eines Tasters abgefragt werden:
1#include < F t du in oS imp le .h >
3.3. Kommunikation mit dem PC 31
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
Abbildung 3.9: Taster am Eingang I1 des ftDuino
2
3void setup () {
4// kein e Ini ti ali si er ung no etig
5}
6
7void loop() {
8// lies den Z ustan d einer Tas te an Einga ng I1
9if (ftduino.input_get(Ftduino:: I1 ) ) {
10 /* ... tue etwas ... */
11 }
12 }
Um Analogwerte wie Spannungen und Widerst¨
ande einzulesen ist der erweiterte Funktionsumfang der Ftduino-Bibliothek
n¨
otig. Bei ihrer Verwendung muss zun¨
achst der Messmodus des Eingangs eingestellt werden, bevor Widerstands-Werte
gelesen werden k¨
onnen:
1#include <Ftduino.h>
2
3void setup () {
4// Init ia lis ier ung der Ftduino - Bi bliothek
5ftduino.init() ;
6
7// Ein gang I1 zur W id ers ta n ds mes su ng v orbereite n
8ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: RESISTANCE ) ;
9}
10
11 void loop() {
12 // Auswer tu ng des W id er stands an Ein gang I1
13 uint16_ t w id er st an d =ftduino.i nput _get (Ftduino:: I 1 );
14 /* ... tue etwas ... */
15 }
In den Experimenten in Kapitel 6 finden sich diverse Beispiel, in denen die Eing¨
ange des ftDuino ausgewertet werden inklusive
spezieller Sensoren wie dem Temperatursensor in Abschnitt 6.7.
3.3 Kommunikation mit dem PC
Der ftDuino ist prim¨
ar daf¨
ur gedacht, ein Modell autonom zu steuern und w¨
ahrend des Betriebs nicht auf die Hilfe eines
PC angewiesen zu sein. Trotzdem gibt es Gr¨
unde, warum auch im laufenden Betrieb ein Datenaustausch mit einem PC
erw¨
unscht sein kann.
Vor allem w¨
ahrend der Sketch-Entwicklung und bei der Fehlersuche hilft es oft sehr, wenn man sich z.B. bestimmte Werte
am PC anzeigen lassen kann oder wenn man Fehlermeldungen im Klartext an den PC senden kann. Aber auch die Ausgabe
z.B. von Messwerten an den PC zur weiteren Auswertung oder Speicherung ist oft hilfreich.
Ein Sketch kann dazu den COM:-Port zwischen ftDuino und PC f¨
ur den Datenaustausch nutzen. Der ftDuino-Beispiel-Sketch
ComPort zum Beispiel verwendet den COM:-Port, um ein paar einfache Textausgaben am PC zu erzeugen. Das ComPort-
32 Kapitel 3. Erste Schritte
Beispiel findet sich im Datei -Men¨
u der Arduino-IDE unter Datei Beispiele FtduinoSimple USB ComPort .
Auch der ComPort-Sketch verwendet keinen der Ausg¨
ange und ben¨
otigt daher neben der USB-Verbindung keinerlei weitere
Spannungsversorgung.
1/*
2ComPo rt - Ko mm un ika ti on mit dem PC ¨u ber den COM : - Port
3
4*/
5
6int zaehler = 0;
7
8void setup () {
9// Port ini ti ali si ere n und auf USB - Verbindung wart en
10 Serial.begin (9600);
11 while (! Serial) ; // wart e auf USB - Ver bindung
12
13 Serial.println(" ft Duin o COM : - Port tes t ");
14 }
15
16 void loop() {
17 Serial.print (" Z¨a hler : " ); // gib "Z ¨a hler :" aus
18 Serial.println(zaehler ,DEC ); // gib za ehler als De zi ma lz ahl aus
19
20 zaehler =zaehler+1; // zaehl er um eins hochz ¨a hlen
21
22 delay (1000); // war te 1 Sek unde (1 000 Mil li se kun de n )
23 }
3.3.1 Der serielle Monitor
Man kann ein beliebiges sogenanntes Terminalprogramm auf dem PC nutzen, um Textausgaben des ftDuino via COM:-Port
zu empfangen. Die Arduino-IDE bringt praktischerweise selbst ein solches Terminal mit. Es findet sich im Men¨
u unter
Werkzeuge Serieller Monitor .
Abbildung 3.10: Der serielle Monitor findet sich im Werkzeuge -Men¨
u
Man muss den COM:-Port nicht separat einstellen, sondern es wird der COM:-Port ¨
ubernommen, der bereits f¨
ur den Sketch-
Download eingestellt wurde.
Nach der Auswahl im Men¨
u¨
offnet der serielle Monitor ein eigenes zus¨
atzliches Fenster auf dem PC. Wurde der ComPort-
Sketch bereits auf den ftDuino geladen, dann erscheinen sofort entsprechende Ausgaben, sobald der serielle Monitor ge¨
offnet
wurde.
Zeilenenden
Der serielle Monitor hat am unteren Fensterrand eine recht unscheinbare Option, das Zeilenende zu markieren. F¨
ur einfache
Textausgaben vom ftDuino zum PC ist diese Option bedeutungslos. Aber sobald Eingaben vom PC erwartet werden wie
3.3. Kommunikation mit dem PC 33
Abbildung 3.11: Der serielle Monitor
zum Beispiel im Modell des Hochregallagers in Abschnitt 7.1 kommt dieser Option eine Bedeutung zu. Die Option muss
auf Neue Zeile oder Zeilenumbruch (CR) stehen, damit die Befehlseingabe klappt.
Abbildung 3.12: Einstellung des Zeilenendes
Die Nutzung des COM:-Ports wird automatisch zwischen Sketch-Download und seriellem Monitor geteilt. Man kann also
jederzeit bei ge¨
offnetem seriellen Monitor den Sketch-Editor in den Vordergrund holen und einen Download starten. Der
seriellem Monitor wird dann automatisch f¨
ur die Zeit des Downloads deaktiviert.
Eine Besonderheit des USB-COM:-Ports die der ftDuino vom Arduino Leonardo erbt ist, dass die sogenannte Bitrate (oft
auch Baudrate genannt) keine Bedeutung hat. Im ComPort-Beispiel wird in Zeile 10 eine Bitrate von 9600 Bit pro Sekunde
eingestellt, in Abbildung 3.11 ist aber unten rechts eine Bitrate von 115200 Bit pro Sekunde eingestellt. Die USB-Verbindung
ignoriert diese Einstellungen und kommuniziert trotzdem fehlerfrei. Einige andere Mitglieder der Arduino-Familie wie der
Arduino-Uno ben¨
otigen hier aber ¨
ubereinstimmende Einstellungen.
3.3.2 Sketchbeschreibung
Der Sketch besteht aus wenig mehr als den eigentlich Aufrufen zur Bedienung des COM:-Ports. Da der COM:-Port auch oft
“serieller Port”, englisch “Serial” genannt wird fangen die entsprechenden Funktionsaufrufe alle mit Serial. an.
In Zeile 10 der sofort bei Sketchstart aufgerufenen setup()-Funktion wird zun¨
achst der COM:-Port f¨
ur die Kommunikation
ge¨
offnet. In Zeile 11 dann wird gewartet, bis der COM:-Port auf PC-Seite verf¨
ugbar ist und die erste Kommunikation
stattfinden kann. In Zeile 13 wird danach eine erste Startmeldung an den PC geschickt.
Innerhalb der wiederholt durchlaufenen loop()-Funktion wird dann in den Zeilen 17 und 18 zun¨
achst der Text “Z¨
ahler: “
ausgegeben, gefolgt von dem Inhalt der Variablen zaehler in Dezimaldarstellung. Die println()-Funktion f¨
uhrt nach der
Ausgabe einen Zeilenvorschub aus. Die folgende Ausgabe erfolgt daher am Beginn der n¨
achsten Bildschirmzeile.
Schließlich wird in Zeile 20 die zaehler-Variable um eins erh¨
oht und eine Sekunde (1000 Millisekunden) gewartet.
3.3.3 USB-Verbindungsaufbau
Bei Ger¨
aten wie dem Arduino Uno, die einen separaten USB-Kommunikationsbaustein f¨
ur die USB-Kommunikation nutzen,
besteht die USB-Verbindung durchg¨
angig, sobald das Ger¨
at mit dem PC verbunden ist. Beim ftDuino sowie beim Arduino
Leonardo ¨
ubernimmt der Mikrocontroller wichtige Aspekte der USB-Kommunikation selbst. Das bedeutet, dass die logische
USB-Verbindung jedes Mal getrennt und neu aufgebaut wird, wenn ein neuer Sketch auf den Mikrocontroller ¨
ubertragen
wird.
34 Kapitel 3. Erste Schritte
Beginnt der ftDuino direkt nach dem Download mit der Textausgabe auf dem COM:-Port, so gehen die ersten Nachrichten
verloren, da die USB-Verbindung noch nicht wieder aufgebaut ist. Daher wartet der Sketch in Zeile 11 darauf, dass die
Kommunikationsverbindung zwischen ftDuino und PC wieder besteht, bevor die ersten Ausgaben erfolgen.
Man kann testweise diese Zeile einmal l¨
oschen oder auskommentieren (Programmcode, der per // in einen Kommentar
verwandelt wurde, wird nicht ausgef¨
uhrt).
8void setup () {
9// Port ini ti ali si ere n und auf USB - Verbindung wart en
10 Serial.begin (9600);
11 // while (! Serial ) ; // warte auf USB - V erbi ndu ng
12
13 Serial.println(" ft Duin o COM : - Port tes t ");
14 }
L¨
adt man diesen Sketch nun auf den ftDuino, so beginnt die Textausgabe im seriellen Monitor erst ab der Zeile Z¨ahler: 2.
Die beiden vorhergehenden Zeilen werden vom ftDuino an den PC gesendet, bevor die USB-Verbindung wieder steht und
gehen daher verloren. Dieses Verhalten kann trotzdem gew¨
unscht sein, wenn die Ausgabe ¨
uber USB nur zus¨
atzlich erfolgen
soll und der ftDuino auch ohne angeschlossenen PC arbeiten soll.
Kapitel 4
Programmierung
Dieses Kapitel erkl¨
art die Programmierung eigener Programme bzw. Sketches f¨
ur den ftDuino. Wer zun¨
achst keine eigenen
Programme schreiben m¨
ochte und erst einmal die vorgefertigten Beispiele und Experimente ausf¨
uhren m¨
ochte ohne deren
Programmcode zu verstehen kann direkt mit Kapitel 6 weitermachen.
Der ftDuino wird mit einer st¨
andig wachsenden Anzahl vorgefertigter Beispiel-Sketches ausgeliefert. F¨
ur viele Modelle und
Versuche reicht es daher, wie in den vorhergehenden Kapiteln beschrieben diese Beispiele auf den ftDuino zu laden. Aber
wie der Spaß beim Bauen mit fischertechnik gerade dort beginnt, wo man die vorgegebenen Pfade der Bauanleitungen hinter
sich l¨
asst, so besteht auch beim ftDuino der eigentliche Nutzen darin, dass man ihn mit eigenen Sketches programmieren
kann. Zusammen mit einem selbst entworfenen Modell ergeben sich so beeindruckende M¨
oglichkeiten. Und ganz nebenbei
lernt man nicht nur die mechanische Grundlagen kennen, sondern erh¨
alt zus¨
atzlich einen realistischen Einblick in die Welt
der Mikrocontroller-Programmierung.
Dieses Kapitel soll einen ersten Einblick in die Programmierung des ftDuino geben. Es werden die wesentlichen Sprach-
konstrukte der auf dem ftDuino verwendeten Programmiersprache soweit erkl¨
art, wie sie zum Verst¨
andnis der Programme
der nachfolgenden Kapitel ben¨
otigt werden. Die Beschreibung beschr¨
ankt sich bewusst auf das allern¨
otigste. Trotzdem sind
Ende dieses recht kurzen Kapitels alle n¨
otigen Grundlagen f¨
ur erste eigene Sketches vorhanden.
4.1 Textbasierte Programmierung
Im Gegensatz zu den meisten Programmierumgebungen aus der Welt der Konstruktionsspielzeuge wird der Arduino nicht
grafisch sondern textbasiert programmiert. W¨
ahrend die grafischen Umgebungen wie fischertechniks RoboPro oder Legos
EV3-Programmier-App auf leichte Erlernbarkeit ausgelegt sind steht in der Arduino-IDE der Praxisbezug im Vordergrund.
Arduino zu programmieren bedeutet auf die gleiche Art Programme zu schreiben, wie es auch professionelle Entwickler
kommerzieller Produkte machen.
(a) grafisch (b) textbasiert
Abbildung 4.1: Blinken einer Lampe an Ausgang O1
36 Kapitel 4. Programmierung
Tats¨
achlich hat die textuelle Darstellung einige signifikante Vorteile. Vor allem bei großen Projekten ist eine ansprechend
formatierte textuelle Darstellung daher wesentlich verst¨
andlicher als eine grafische.
(a) in der Arduino-IDE (b) auf Github
Abbildung 4.2: Darstellung des gleichen Arduino-Sketches
Ein textbasiertes Programm besteht aus unformatiertem Text. Einige Programmierumgebungen wie die Arduino-IDE lassen
dennoch farbige Hervorhebungen oder unterschiedliche Schriftgr¨
oßen zu oder zeigen im Programmtext Zeilennummern an.
Im Gegensatz zu Texten aus einer Textverarbeitung sind diese Formatierungen aber nicht Teil des erstellten Programms.
Stattdessen sind sie Teil der Programmierumgebung selbst und die Formatierung geht z.B. bei der Weitergabe des Pro-
grammcodes verloren. Der gleiche Programmcode kann daher in einer anderen Umgebung vollkommen anders aussehen. F¨
ur
die Funktion des Programms ist das bedeutungslos. Es kommt nicht darauf an wie der Programmtext dargestellt wird. F¨
ur
die eigentliche Programmfunktion ist ausschließlich der Inhalt des dargestellten Texts verantwortlich, nicht sein Aussehen.
Wie in Abbildung 4.2 zu sehen unterscheidet sich die Darstellung des identischen Programmcodes zwischen der Arduino-IDE
und z.B. dem Web-Dienst Github deutlich.
Auch dieses Handbuch verwendet eine eigene Darstellung und stellt zum Beispiel manchmal Zeilennummern dar. Diese
Zeilennummern dienen nur der leichteren Bezugnahme auf einzelne Zeilen und d¨
urfen nicht als Teil des Programms explizit
eingegeben werden:
1// B lin kO1 . i no
2//
3// Bli nken ei ner L ampe an A us gang O1
4//
5// ( c ) 2 01 8 b y Ti ll H a rb au m < t i ll @h ar ba um . or g >
6
7#include < F t du in oS imp le .h >
8
9void setup () {
10 // LED initialisieren
11 pinMode(LED_BUILTIN ,OUTPUT);
12 }
13
14 void loop() {
15 // schalt e die in te rne LED und den A us gang O1 ein ( HIGH bzw . HI )
16 digitalWrite(LED_BUILTIN ,HIGH);
17 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
18
19 delay (1000); // war te 1000 M ill is eku nde n ( eine S eku nd e )
20
21 // schalt e die in te rne LED und den A us gang O1 aus ( LOW bzw . LO )
22 digitalWrite(LED_BUILTIN ,LOW);
23 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: LO );
24
25 delay (1000); // warte eine Se kunde
26 }
4.2. Die Programmiersprache C++ 37
Wer auch in der Arduino-IDE Zeilennummern dargestellt bekommen m¨
ochte kann sie in den Voreinstellungen der Arduino-
IDE wie in Abbildung 4.3 dargestellt aktivieren.
Abbildung 4.3: Aktivierung von Zeilennummern in der Arduino-IDE
4.2 Die Programmiersprache C++
Arduinos und der ftDuino werden in der Programmiersprache C++, genauer dem Standard C++11 programmiert. Ein Arduino-
Sketch unterscheidet sich in einigen wenigen fundamentalen Dingen von klassischen C++-Programmen, davon abgesehen
entspricht die Programmierung dem Standard. Die Programmiersprache C++ ist in der professionellen Softwareentwicklung
weit verbreitet. Große Teile aller g¨
angigen Betriebssysteme wie Windows, Linux oder MacOS sind in C++ bzw. einer eng mit
C++ verwandten Programmiersprache geschrieben. Die Arduino-Programmierung liefert dadurch einen realistischen Einblick
in den professionellen Bereich.
Die Sketches genannten C++-Programme der Arduino-Welt werden durch ein Compiler genanntes Programm in sogenannten
Maschinen- oder Bin¨
arcode ¨
ubersetzt, der vom Mikrocontroller des Arduino bzw. ftDuino verstanden wird. Dieser Bin¨
arcode
kann dann auf den ftDuino per Download ¨
ubertragen werden.
Der Compiler, der von der Arduino-IDE verwendet wird ist der sogenannte GCC1. Dieser Compiler findet auch in der Industrie
Verwendung und wird unter anderem zur ¨
Ubersetzung des Linux-Kernels verwendet, wie er auf jedem Android-Smartphone
zum Einsatz kommt. Es handelt sich bei der Arduino-IDE und deren intern verwendeten Werkzeugen also keinesfalls um
reine Hobby-Technik. Unter der anf¨
angertauglichen Ober߬
ache verbergen sich im Gegenteil leistungsf¨
ahige und professionelle
Komponenten.
4.3 Grundlagen
Ein Arduino-Sketch besteht aus einer textuellen Beschreibung. Der minimale Text, der einen g¨
ultigen Sketch bildet sieht
folgendermaßen aus:
void setup () {
}
void loop() {
}
1GNU-Compiler-Collection GCC: https://gcc.gnu.org/
38 Kapitel 4. Programmierung
Um diesen Sketch einzugeben ¨
offnet man zun¨
achst die Arduino-IDE und w¨
ahlt dann im Men¨
uDatei Neu . Es ¨
offnet sich
ein neues Fenster, das genau die vorher abgebildeten Zeilen bereits enth¨
alt. Zus¨
atzlich sind noch zwei mit // beginnende
Zeile vorhanden. Diese k¨
onnen entfernt werden, sodass der Text am Ende exakt dem obigen Beispiel entspricht.
(a) ¨
Ubersetzung (b) Download
Abbildung 4.4: Schalt߬
achen der Arduino-IDE
Dieser minimale Sketch l¨
asst sich in der Arduino-IDE erfolgreich ¨
ubersetzen und auf den ftDuino laden. Dazu gibt es in der
Arduino-IDE die beiden in Abbildung 4.4 dargestellten Schalt߬
achen. Eine Fl¨
ache startet die ¨
Ubersetzung in Maschinencode.
Diese Funktion ben¨
otigt keinen angeschlossenen ftDuino und mit ihr l¨
asst sich schnell feststellen, ob ein Sketch keine
fundamentalen Fehler enth¨
alt, die bereits die ¨
Ubersetzung verhindern. Die zweite Schalt߬
ache startet den Download auf
den ftDuino. Sollte der Sketch noch nicht ¨
ubersetzt sein, so wird bei Klick auf die Download-Schalt߬
ache vorher noch
automatisch die ¨
Ubersetzung gestartet. Nur wenn diese ¨
Ubersetzung erfolgreich ist wird der Download begonnen.
Hat man den Sketch per Datei Neu frisch angelegt, so wird einen die Arduino-IDE nun ggf. fragen, ob man den Sketch
speichern m¨
ochte. Wenn man dem Speichern zustimmt kann man an dem Sketch sp¨
ater jederzeit weiter arbeiten.
Nach dem erfolgreichen Download wird der ftDuino keine sichtbare Reaktion zeigen. Der Sketch besteht aus zwei sogenannten
Funktionen, eine mit dem Namen setup() und eine mit dem Namen loop(). Diese Funktionen bilden das Skelett eines
jeden Arduino-Sketches. Sie enthalten jeweils in ein Paar geschweifter Klammern {und }eingebettete Anweisungen, die
die eigentliche Funktionalit¨
at des Sketches beschreiben. Aufeinanderfolgende Anweisungen werden dabei per Semikolon (;)
getrennt.
Befinden sich aber wie in diesem einfachen Beispiel ¨
uberhaupt keine Anweisungen zwischen den Klammern, so l¨
ost der
Sketch folgerichtig auch keine erkennbare Reaktion auf dem ftDuino aus.
4.3.1 Kommentare
Die beiden zun¨
achst entfernten mit // beginnenden Zeilen f¨
ugen dem Sketch ebenfalls keine Funktionalit¨
at zu. Um das zu
¨
uberpr¨
ufen kann man noch einmal Datei Neu ausw¨
ahlen und den Sketch diesmal unver¨
andert lassen:
void setup () {
// put your setup code here , to run onc e :
}
void loop() {
// put your ma in code here , to run re pe at ed ly :
}
Ein erneuter Klick auf den Download-Button wird auch diesen Sketch ¨
ubersetzen und auf den ftDuino laden. Wieder erfolgt
am ftDuino keine erkennbare Funktion. Das liegt daran, dass die beiden zus¨
atzlichen Zeilen reine Kommentarzeilen sind. Sie
sind dazu gedacht, einem menschlichen Leser zus¨
atzliche Erkl¨
arungen zu geben. F¨
ur die ¨
Ubersetzung in Maschinencode sind
diese Zeilen bedeutungslos. Alles, was in einer Zeile hinter den doppelten Schr¨
agstrichen // steht wird bei der Erzeugung
des Maschinencodes ignoriert.
Zus¨
atzlich kann man Kommentare in /* und */ einschließen. Die Erzeugung von Maschinencode beginnt erst wieder hinter
dem schließenden Element */. Außerdem d¨
urfen Kommentare dieser Art ¨
uber mehrere Zeilen gehen.
void setup () {
/* mehrzeilige Kommentare
sind au ch m ¨o g li ch */
}
4.3. Grundlagen 39
Einen Hinweis auf Kommentare gibt in der Arduino-IDE die Farbgebung. Kommentare sind immer hellgrau dargestellt und
damit leicht vom eigentlichen Programmcode zu unterscheiden.
4.3.2 Fehlermeldungen
Als n¨
achstes sollen zwei Programmanweisungen zwischen den geschweiften Klammern der setup()-Funktion eingef¨
ugt
werden:
1void setup () {
2pinnMod e (LED_BUILTIN ,OUTPUT) ;
3digitalWrite(LED_BUILTIN ,HIGH);
4}
5
6void loop() {
7}
Was diese beiden kryptischen Zeilen genau bedeuten wird sp¨
ater erkl¨
art werden. Zun¨
achst soll der Sketch lediglich wieder
¨
ubersetzt und auf den ftDuino geladen werden. Ist das Programm fehlerfrei ¨
ubersetzbar, so wird es erneut auf den ftDuino
¨
ubertragen.
Leider ist es in diesem Fall aber nicht fehlerfrei. Wurde das Programm exakt wie abgebildet eingegeben, so sollte die
¨
Ubersetzung des Programms mit der in Abbildung 4.5 zu sehenden Fehlermeldung abbrechen.
Abbildung 4.5: Anzeige eines ¨
Ubersetzungsfehlers
im oberen Teil des Bildschirms wird die fehlerhafte Codezeile hervorgehoben. Im unteren Teil des Fensters sind die Ausgaben
des GCC-Compilers zu sehen. Die eigentliche Fehlermeldung lautet ’pinnMode’ was not declared in this scope.
Damit teilt der Compiler mit, dass er mit dem Begriff pinnMode nichts anfangen kann. Schon bei der Eingabe des Sketches
gab es einen Hinweis auf dieses Problem, denn die Anweisung pinnMode wurde bei der Eingabe in der IDE lediglich schwarz
dargestellt w¨
ahrend z.B. in der zweiten Zeile das Wort digitalWrite orange hervorgehoben wurde. Die Arduino-IDE f¨
arbt
die meisten ihr bekannten Anweisungen ein und ein nicht-gef¨
arbter Teil kann einen Hinweis auf einen Fehler sein.
Tats¨
achlich hat sich hier ein Fehler eingeschlichen und statt pinnMode h¨
atte es pinMode heißen m¨
ussen. ¨
Andert man das
Wort entsprechend, so f¨
arbt die IDE es erwartungsgem¨
aß orange ein, die ¨
Ubersetzung gelingt und ein Download ist m¨
oglich.
Der korrigierte Sketch sollte nun wie folgt aussehen.
1void setup () {
2pinMode(LED_BUILTIN ,OUTPUT);
3digitalWrite(LED_BUILTIN ,HIGH);
4}
5
6void loop() {
7}
40 Kapitel 4. Programmierung
Nach dem Download wird die rote Leuchtdiode im ftDuino leuchten, denn genau das bewirken die zwei kryptischen Zeilen,
die im folgenden Abschnitt genauer erkl¨
art werden.
4.3.3 Funktionen
Das im Rahmen der Arduino-Programmierung wichtigste C++-Sprachelement sind die sogenannten Funktionen. Mit ihnen
lassen sich bereits sinnvolle einfache Programm-Sketches schreiben.
Funktionsdefinitionen fassen Anweisungen zusammen. Das folgende Programmfragment zeigt die Definition einer Funktion
namens name, die in ihrem Funktionsk¨
orper die beiden Anweisungen anweisung1 und anweisung2 enth¨
alt. Anweisungen
werden durch das Semikolon ;voneinander getrennt.
void name() {
an we is un g1 ;
an we is un g2 ;
}
Eine Funktion wird in der Regel genutzt, um alle f¨
ur eine komplexe Aufgabe ben¨
otigten Anweisungen zusammenzufassen
und einen passenden Namen zu geben. Die Anweisungen im K¨
orper einer Funktion werden nacheinander von oben nach
unten ausgef¨
uhrt. In diesem Fall wird also erst anweisung1 ausgef¨
uhrt und dann anweisung2.
Da die Ausf¨
uhrung der einzelnen Anweisungen je nach Komplexit¨
at nur wenige Mikrosekunden dauert entsteht oft der
Eindruck, als w¨
urden Dinge gleichzeitig passieren. Tats¨
achlich werden alle Anweisungen aber der Reihe nach ausgef¨
uhrt.
Dementsprechend k¨
onnen auch widerspr¨
uchliche Anweisungen konfliktfrei untereinander stehen und beispielsweise eine Lam-
pe ein- und unverz¨
uglich danach wieder ausgeschaltet werden. Diese Ereignisse passieren so kurz nacheinander, dass der
Anwender nicht erkennen kann, dass z.B. eine Leuchtdiode f¨
ur wenige Mikrosekunden eingeschaltet war.
Die Ausf¨
uhrung der Anweisungen kann direkt etwas bewirken und z.B. eine Leuchtdiode am ftDuino aufleuchten lassen.
Eine Funktion, die alle Anweisungen zum Einschalten der Leuchtdiode zusammenfasst k¨
onnte z.B. wie folgt aussehen.
void SchalteLeuchtdiodeEin() {
pinMode(LED_BUILTIN ,OUTPUT); // schalte Pin auf Ausgang
digitalWrite(LED_BUILTIN ,HIGH); / / s et ze A u sg an gsp in a uf ’ hig h ’
}
Eine Funktion in der Sprache C++ ist sehr nah an mathematische Funktionen angelehnt und kann wie diese ein Ergebnis
liefern. Ob und was f¨
ur ein Ergebnis die Funktion zur¨
uck liefert steht vor dem Funktionsnamen. Im vorliegenden Fall soll kein
Ergebnis geliefert werden, daher steht vor dem Funktionsnamen void, englisch f¨
ur “nichts”. Außerdem kann eine Funktion
einen oder mehrere zu verarbeitende Eingabewerte erhalten, die zwischen den runden Klammern (()) angegeben werden.
Die vorliegende Funktion ben¨
otigt keine Eingabewerte, die Klammern bleiben also leer.
void name() {
anweisung1;
anweisung2;
}
Funktionsname
Ergebnistyp
Parameter
Funktionskörper
Abbildung 4.6: Funktionsdefinition
Die Definition einer Funktion bewirkt, dass der Compiler die entsprechenden Anweisungen ¨
ubersetzt und die n¨
otigen Maschi-
nenbefehle hintereinander im Maschinencode ablegt. Damit ist aber noch nichts dar¨
uber gesagt, wann diese Anweisungen
tats¨
achlich ausgef¨
uhrt werden.
Ausgef¨
uhrt werden die Anweisungen der Funktion, sobald die Funktion aufgerufen wird. Dazu muss lediglich der Funktions-
name mit den Parametern als Anweisung eingegeben werden. Da die Funktion SchalteLeuchtdiodeEin keine Parameter
erwartet bleibt der Bereich zwischen den runden Klammern beim Aufruf leer. Der Funktionsaufruf muss dabei selbst wieder
im Funktionsk¨
orper einer Funktionsdefinition stehen.
void setup () {
SchalteLeuchtdiodeEin() ;
}
4.3. Grundlagen 41
Damit wird klar, dass die Anweisungen pinMode(LED BUILTIN, OUTPUT); und digitalWrite(LED BUILTIN, HIGH);
ebenfalls Funktionsaufrufe waren. Beide Funktionen bekamen jeweils zwei durch Kommata getrennte Parameter mitgegeben.
4.3.4 Die Funktionen setup() und loop()
https://www.arduino.cc/reference/en/language/structure/sketch/setup/
https://www.arduino.cc/reference/en/language/structure/sketch/loop/
Wenn Funktionen selbst immer nur aus anderen Funktionen aufgerufen werden d¨
urfen ergibt sich ein Henne-Ei-Problem bei
der Frage, von wo aus denn der erste Funktionsaufruf erfolgt.
void setup(){
}
void loop() {
}
Abbildung 4.7: Ablauf eines Sketches
An dieser Stelle kommen die beiden Funktionsdefinitionen setup() und loop() ins Spiel, ¨
uber die jeder Sketch mindestens
verf¨
ugen muss. Fehlt eine oder beide Definitionen, so bricht die Arduino-IDE die ¨
Ubersetzung mit einer Fehlermeldung ab.
Beiden Funktionen m¨
ussen nicht explizit aufgerufen werden. Stattdessen wird ihr Aufruf von der Arduino-IDE w¨
ahrend
der ¨
Ubersetzung des Sketches automatisch in den erzeugte Maschinencode eingef¨
ugt. Die Funktion setup() wird dabei
einmal bei Sketch-Start aufgerufen und die Funktion loop() wird in Folge immer wieder aufgerufen wie in Abbildung 4.7
dargestellt.
Mit Sketch-Start ist im Falle des ftDuino eine von drei Situationen gemeint:
1. Direkt nach dem Download eines ¨
ubersetzten Sketches wird dessen Code gestartet.
2. Nach dem Anlegen der Stromversorgung an den ftDuino wird ein vorher per Download installierter Sketch-Code
gestartet.
3. Wurde der Bootloader des ftDuino durch Druck auf den Reset-Taster gestartet, so bleibt dieser f¨
ur acht Sekunden
aktiviert. Wird der Bootloader in dieser Zeit nicht vom PC aus angesprochen, so beendet sich der Bootloader und der
zuletzt heruntergeladene Sketch-Code wird stattdessen gestartet.
Hinweis f¨
ur erfahrene Nutzer
Wer schon einmal mit C++ auf einem PC oder ¨
ahnlich zu tun hatte wird an dieser Stelle ggf. ¨
uberrascht sein.
In jenem Fall gab es die speziellen Funktionen setup() und loop() nicht. Stattdessen gab es eine Funktion
namens main(), die bei Programmstart automatisch aufgerufen wurde.
Die Entwickler der Arduino-IDE haben sich entschieden, an dieser Stelle vom ¨
ublichen Standard abzuweichen, da
das Konzept der main()-Funktion eher f¨
ur nur zeitweilig auf einem komplexen Computer laufende Programme
entwickelt wurde und sich nur bedingt in die Welt der Hardware-Programmierung einf¨
ugt.
Bibliotheksfunktionen
Wie im Falle der name()-Funktion geschehen kann man eigene Funktionen schreiben. Die Arduino-IDE bringt aber bereits
eigene Funktionssammlungen mit. Die Sammlungen bestehen in erster Linie aus h¨
aufig ben¨
otigten universellen Funktionen.
42 Kapitel 4. Programmierung
Sie sind dem System von vornherein mit Namen bekannt und man kann sie in eigenen Programmen einfach aufrufen, ohne
sie selbst definieren zu m¨
ussen.
Die Funktionen pinMode() und digitalWrite() sind solche Bibliotheksfunktionen. W¨
ahrend die Sprache C++ universell
ist und sich bei der Verwendungen auf einem PC oder einem Arduino nicht unterscheidet sind die Bibliotheksfunktionen in
der Regel plattformspezifisch. Die Funktion pinMode() steht dem Programmierer nur auf dem Arduino zur Verf¨
ugung und
bei der Entwicklung eines Programms f¨
ur einen Windows-PC w¨
urde der Aufruf dieser Funktion zu einem ¨
Ubersetzungsfehler
f¨
uhren.
Dies ist auch der Grund, warum sich viele C++-Beispiele und Tutorials aus dem Internet nicht direkt auf den Arduino
¨
ubertragen lassen. Handelt es sich bei diesen Programmen nicht zuf¨
allig bereits um Arduino- sondern um PC-Programme,
dann werden dort Funktions-Bibliotheken verwendet, die wiederum auf dem Arduino nicht vorhanden sind. Das liegt in erster
Linie an der deutlich unterschiedlichen Hardware der verschiedenen Plattformen. W¨
ahrend ein PC-Programm in erster Linie
Fenster auf dem Bildschirm ¨
offnet und mit Benutzereingaben umgeht wird ein Arduino-Programm eher Hardware-Eing¨
ange
auswerten und Ausg¨
ange schalten.
Hinweis f¨
ur erfahrene Nutzer
Auch bei der Verwendung von Bibliotheken gibt es einen Unterschied zu ¨
ublicher C++-Programmierung auf PCs.
Die Arduino-IDE macht die grundlegenden Arduino-spezifischen Bibliotheken automatisch im Sketch bekannt,
so dass sich Funktionen wie pinMode() direkt nutzen lassen.
G¨
angige C++-Compiler binden von sich aus keine Bibliotheken ein. Sie m¨
ussen durch sogenannte #include-
Anweisungen explizit bekannt gemacht werden. Dies ist auf dem Arduino zumindest f¨
ur die meisten mitgelieferten
Bibliotheken nicht n¨
otig.
4.3.5 Beispiel
Damit sind die wesentlichen Grundlagen erkl¨
art und das folgende Beispiel verst¨
andlich.
1/* Funktion zum Einsch al te n der LED */
2void SchalteLedEin() {
3pinMode(LED_BUILTIN ,OUTPUT);
4digitalWrite(LED_BUILTIN ,HIGH);
5}
6
7void setup () {
8SchalteLedEin() ;
9}
10
11 void loop() {
12 }
Bei Systemstart wird zun¨
achst die setup()-Funktion aufgerufen. Die Funktion setup() enth¨
alt eine einzelne Anweisung in
Form eines Aufrufs der Funktion SchalteLedEin. Diese Funktion ist wiederum in den Zeilen 2 bis 5 des Sketches definiert
und besteht ihrerseits aus dem Aufruf zweier Bibliotheksfunktionen, die die eingebaute Leuchtdiode des ftDuino aufleuchten
lassen.
Die loop()-Funktion wird nach Systemstart permanent immer wieder aufgerufen. Sie ist aber leer, ¨
uber das Einschalten
der Leuchtdiode direkt bei Systemstart zeigt der Sketch also keine weitergehende Funktion.
Der Kommentar in Zeile eins dient lediglich der Erkl¨
arung und hat keinen Einfluss auf die ¨
Ubersetzung des Sketches oder
seine Funktion.
4.4 Hilfreiche Bibliotheksfunktionen
Wie in den vorigen Abschnitten angedeutet bringt die Arduino-IDE einige Bibliotheken mit, die Funktionen zur Verwendung
spezieller Eigenschaften des Arduino bieten. Zus¨
atzlich bringt die ftDuino Installation eigene Bibliotheken mit, um auf die
fischertechnik-Ein- und -Ausg¨
ange des ftDuino zuzugreifen.
4.4. Hilfreiche Bibliotheksfunktionen 43
Im folgenden werden sieben der am h¨
aufigsten ben¨
otigten Funktionen beschrieben. Mit ihnen lassen sich bereits vielf¨
altige
Sketches schreiben.
Eine Beschreibung weiterer Funktionen der Arduino-IDE findet man online in der Arduino-Language-Reference unter htt-
ps://www.arduino.cc/reference/en/#functions w¨
ahrend weitere ftDuino-spezifische Funktionen im Kapitel 9 beschrieben
sind.
4.4.1 pinMode(pin, mode)
https://www.arduino.cc/reference/en/language/functions/digital-io/pinMode/
Diese Funktion konfiguriert einen Pin des ATmega32u4-Mikrocontrollers als Ein- (mode =INPUT) oder Ausgang (mode =
OUTPUT). Diese Funktion wird auf Arduinos sehr h¨
aufig verwendet, da dort direkt mit den Anschl¨
ussen des Mikrocontrol-
lers gearbeitet wird. Auf dem ftDuino befinden sich an den meisten Anschl¨
ussen Zusatzschaltungen zur Verbindung mit
fischertechnik-Komponenten, die die direkte Verwendung der pinMode()-Funktion unn¨
otig machen. Stattdessen bringen
die ftDuino-Bibliotheken alle Funktionen mit, um die Ein- und Ausg¨
ange fischertechnik-konform zu bedienen.
Die wesentliche Ausnahme bildet der Anschluss der internen roten Leuchtdiode. F¨
ur pin muss in dem Fall LED BUILTIN
verwendet werden.
// internen Ans ch lusspin der L eu ch tdiode zum Ausga ng erkl ¨a ren
pinMode(LED_BUILTIN ,OUTPUT);
4.4.2 digitalWrite(pin, value)
https://www.arduino.cc/reference/en/language/functions/digital-io/digitalwrite/
Die Funktion digitalWrite() steuert einen durch die Funktion pinMode() zum Ausgang erkl¨
arten Pin. Sie wird daher
im ftDuino in der Regel f¨
ur die Leuchtdiode verwendet und in seltenen F¨
allen zur Steuerung der beiden am I2C-Anschluss
verf¨
ugbaren Signale.
F¨
ur pin gelten die gleichen Werte wie bei pinMode()-Funktion. Der Wert f¨
ur value kann HIGH oder LOW sein, was den
entsprechenden Pin ein- oder ausschaltet.
// internen Ans ch lusspin der L eu ch tdiode zum Ausga ng erkl ¨a ren
pinMode(LED_BUILTIN ,OUTPUT);
// Leuc ht di od e e in sc ha lten
digitalWrite(LED_BUILTIN ,HIGH);
4.4.3 delay(ms)
https://www.arduino.cc/reference/en/language/functions/time/delay/
Die meisten Aufgaben erledigt auch ein so einfacher Mikrocontroller wie der ATmega32u4 schneller als f¨
ur Menschen
wahrnehmbar. Um Abl¨
aufe auf ein passendes Maß zu senken ist die delay()-Funktion hilfreich. Sie erwartet als Parameter
eine Wartezeit in Millisekunden.
Wie in Abschnitt 4.3.4 beschrieben wird die Funktion setup() nur einmal aufgerufen, die Function loop() aber daraufhin
immer wieder. Der folgende Sketch l¨
asst die Leuchtdiode daher kontinuierlich blinken.
void setup () {
// internen Ans ch lusspin der L eu ch tdiode zum Ausga ng erkl ¨a ren
pinMode(LED_BUILTIN ,OUTPUT);
}
void loop() {
// Leuchtdiode einschalten
digitalWrite(LED_BUILTIN ,HIGH);
// 1 Seku nde warten
delay (1000);
// Leuchtdiode ausschalten
digitalWrite(LED_BUILTIN ,LOW);
// 1 Seku nde warten
44 Kapitel 4. Programmierung
delay (1000);
}
4.4.4 Serial.begin(speed)
https://www.arduino.cc/reference/en/language/functions/communication/serial/begin/
Die Kommunikationsm¨
oglichkeiten des ftDuino beschr¨
anken sich direkt am Ger¨
at im Wesentlichen auf die fischertechnik
Ein- und Ausg¨
ange. Bei komplexeren Projekten wird es schwierig, nur am Verhalten des ftDuino den Programmfluss zu
verfolgen. Ein einfacher Weg, aus dem Sketch heraus Informationen an den Benutzer auszugeben ist die Verwendung der
Serial-Bibliothek.
Auf PC-Seite werden die Ausgaben dieser Bibliothek ¨
uber den sogenannten seriellen Monitor angezeigt. Dessen Benutzung
wurde in Abschnitt 3.3.1 genauer beschrieben. Die Funktion Serial.begin() bereitet den Sketch auf die Verwendung des
seriellen Monitors vor. Sie sollte daher am Beginn des Sketches bzw. in der setup()-Funktion aufgerufen werden.
Die Funktion Serial.begin() erwartet einen Parameter namens speed. Dieser Wert ist f¨
ur die USB-Verbindung des
ftDuino belanglos und sollte z.B. auf einen Wert von 115200 gesetzt werden.
void setup () {
// Vorb er ei te n der s er ie ll en Verbindung
Serial.begin ( 115200 ) ;
}
void loop() {
}
4.4.5 Serial.print(val) und Serial.println(val)
https://www.arduino.cc/reference/en/language/functions/communication/serial/print/
https://www.arduino.cc/reference/en/language/functions/communication/serial/println/
Ist eine serielle Verbindung per Serial.begin() eingerichtet, so k¨
onnen die Funktionen Serial.print() und
Serial.println() zur Ausgabe von Nachrichten an den seriellen Monitor verwendet werden. Der Unterschied zwischen
Serial.print() und Serial.println() liegt darin, dass nach der Ausgabe per Serial.println() eine neue Ausgabe-
zeile begonnen wird, w¨
ahrend weitere Ausgaben nach Serial.print() direkt in der gleichen Zeile erfolgen. Die Funktion
Serial.println() wird daher oft genutzt, um komplexere Ausgaben abzuschließen.
F¨
ur val k¨
onnen unter anderem Zeichenketten und Zahlen verwendet werden. Zeichenketten m¨
ussen in doppelte
Anf¨
uhrungszeichen (“) eingeschlossen werden.
void setup () {
// Vorber ei te n der s er ie ll en Verbindung
Serial.begin ( 115200 ) ;
// 2 Sekund en Verz ¨o gerung , um dem PC Zeit zu geben ,
// die V er bi nd un g e ntgegen zu nehm en
delay (2000);
// ein paar A us ga ben
Serial.print (" D ie A ntw or t la ut et : " );
Serial.println(42);
}
void loop() {
}
4.4.6 ftduino.input get(),ftduino.output set() und ftduino.motor set()
Ein Controller f¨
ur ein fischertechnik-Modell muss nat¨
urlich Eingaben aus dem Modell empfangen und Reaktionen im Modell
ausl¨
osen k¨
onnen. Die ftDuino-Bibliotheken sind in allem Detailgrad in Kapitel 9 beschrieben. In diesem Absatz wird daher
nur das absolute Minimum beschrieben.
4.5. Variablen 45
Es wurde in Abschnitt 4.3.4 erkl¨
art, dass es eine Besonderheit ist, dass Bibliotheksfunktionen ohne weitere Vorbedingungen
zur Verf¨
ugung stehen und im Sketch verwendet werden k¨
onnen. Dies trifft aber nur auf die Arduino-eigenen Bibliotheken zu
wie sie in den bisherigen Beispielen verwendet wurden. Die ftDuino-Bibliotheken stehen nicht automatisch zur Verf¨
ugung
sondern m¨
ussen am Anfang des Sketches mit einer #include-Anweisung bekannt gemacht werden.
#include < F t du in oS imp le .h >
void setup () {
}
void loop() {
}
Erst dann sind die Funktionen aus dieser Bibliothek im Sketch nutzbar.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 4.8: Lampe an Ausgang O1
Die wichtigsten Funktionen daf¨
ur sind ftduino.input get(port) zum Abfragen eines Eingangs und
ftduino.output set(port, mode) zum Schalten eines Ausgangs. Bei ftduino.input get(port) sind f¨
ur
port Werte von Ftduino::I1 bis Ftduino::I8 erlaubt. Zum Schalten eines Ausgangs gibt es die Funktion
ftduino.output set(port, mode), wobei port Werte von Ftduino::O1 bis Ftduino::O8 annehmen darf und
mode auf Ftduino::HI gesetzt wird, wenn der Ausgang eingeschaltet werden soll und auf Ftduino::OFF gesetzt wird,
um den Ausgang auszuschalten.
Die Funktion ftduino.motor set(port, mode) ist ftduino.output set(port, mode) sehr ¨
ahnlich, nur dass hier ein
Motorausgang M1 bis M4 geschaltet werden kann. Der Wert for mode kann dann Ftduino::LEFT,Ftduino::RIGHT oder
Ftduino::OFF sein, je nachdem, ob sich der Motor linksherum, rechtsherum oder gar nicht drehen soll.
#include < F t du in oS imp le .h >
void setup () {
// Ein gang I1 les en
ftduino.input_get(Ftduino:: I 1 );
// Aus gang O1 einsc ha lt en
ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
}
void loop() {
}
Dieser Sketch w¨
urde eine wie in Abbildung 4.8 angeschlossene Lampe zum Leuchten bringen. Achtung: Dazu muss der
ftDuino mit 9 Volt versorgt sein.
4.5 Variablen
https://www.arduino.cc/reference/en/#variables
Oft besteht der Bedarf in einem Sketch etwas zu “merken” bzw. zu speichern. Wenn etwas beispielsweise mit einer bestimm-
ten H¨
aufigkeit passieren soll, dann muss w¨
ahrenddessen irgendwo vermerkt werden, wie oft es schon passiert ist bzw. wie oft
46 Kapitel 4. Programmierung
es noch zu passieren hat. Ein anderes Beispiel sind einmalige Ereignisse wie “der Benutzer hat einen Taster gedr¨
uckt”. Auch
wenn dieses Ereignis vor¨
ubergeht und der Benutzer den Taster losgelassen hat soll die Aktion ggf. weitergef¨
uhrt werden.
Dazu muss irgendwo vermerkt werden, dass der Taster vor kurzem noch gedr¨
uckt war.
F¨
ur diesen Zweck gibt es sogenannte Variablen. Mit ihnen weist man den Compiler an, Platz im Speicher des ftDuino
f¨
ur etwas “gemerktes” zu reservieren. W¨
ahrend der Sketch im sogenannten Flash-Speicher des ftDuino abgelegt wird und
daher auch ¨
uber das Ausschalten des ftDuino hinaus erhalten bleibt. Wird der Speicherplatz f¨
ur Variablen im ߬
uchtigen
RAM-Speicher des ftDuino abgelegt. Der gespeicherte Wert einer Variablen geht also beim Ausschalten des ftDuino verloren.
Eine Variable wird wie eine Funktion im Sketch definiert. Dazu erh¨
alt sie wie eine Funktion einen Namen. Außerdem muss
angeben werden, welcher Art die in der Variablen abzulegenden Daten sind. Im folgenden Beispiel wird eine Variable namens
variablenName f¨
ur Daten vom Typ int angelegt.
int variablenName;
void setup () {
}
void loop() {
}
4.5.1 Datentyp int
https://www.arduino.cc/reference/en/language/variables/data-types/int/
Der Datentyp int ist der Standard-Datentyp. Beim ftDuino erlaubt dieser Datentyp das Ablegen ganzzahliger Werte im
Bereich von -32768 bis +32767. F¨
ur die meisten Verwendungen ist das ausreichend.
Eine Variable wird genutzt, um Daten in ihr abzulegen und sp¨
ater wieder abzurufen. Das Ablegen von Werte geschieht, indem
der Variablen ein Wert mit dem Gleichheitszeichen (=) zugewiesen wird. Die Ausdr¨
ucke auf der rechten Seite der Zuweisung
k¨
onnen komplexe mathematische Funktionen beinhalten und sogar Funktionsaufrufe, um beispielsweise den Zustand eines
Eingangs des ftDuino zu speichern.
// eine e infache Zuweisung
variablenName = 42;
// ein k om pl ex er Ausd ru ck
variablenName = (4*8*8+38) /7;
// Zus tand des E in gangs I1
variablenName =ftduino.input_ge t (Ftduino:: I1 );
Außerdem k¨
onnen in den Ausdr¨
ucken wiederum Variablen enthalten sein. Dabei kann auch die auf der linken Seite stehende
Variable auch auf der rechten Seite auftauchen, was dem mathematischen Verst¨
andnis einer Gleichung etwas widerspricht.
// Wert aus einer ander en Variabl e ¨u bernehmen
variablenName =andererVariablenName;
// Wert der Variablen ver ¨a nd ern und wied er der Variable n z uw eisen
variablenName =variablenName + 1;
Man darf diese Art der Zuweisung nicht als mathematischen Vergleich lesen, auch wenn die Darstellung das nahelegt.
Stattdessen wird zun¨
achst der Ausdruck auf der rechten Seite berechnet und das Ergebnis wird danach der Variablen auf
der linken Seite zugewiesen. Dieser zeitliche Ablauf f¨
uhrt dazu, dass eine Zuweisung wie
variablenName =variablenName + 1;
einen Sinn ergibt.
Variablen k¨
onnen auch als Parameter bei Funktionsaufrufen verwendet werden.
int variablenName;
void setup () {
Serial.begin ( 115200 ) ;
variablenName = 192/4;
Serial.print (" V ari abl en inh al t : ") ;
Serial.println(variablenName) ;
}
4.6. Bedingungen 47
void loop() {
}
Wichtig ist hier die korrekte Verwendung der Anf¨
uhrungszeichen (“). Ein Wort oder Text in Anf¨
uhrungszeichen steht f¨
ur
den Text selbst und wird nicht weiter interpretiert. Ein Wort ohne Anf¨
uhrungszeichen kann u.a. f¨
ur eine Anweisung, einen
Funktionsnamen oder einen Variablennamen stehen und der Compiler versucht diesem Wort eine Bedeutung zuzuweisen.
// gib das W ort v ar iable nN am e aus
Serial.println("variablenName");
// gib den Inha lt der V ar ia bl en n amens var ia bl enNam e aus
Serial.println(variablenName) ;
4.6 Bedingungen
Bisher haben alle Beispiele aus Anweisungen in einer festen Reihenfolge bestanden. Alle Anweisung wurden immer auf die
gleiche Weise ausgef¨
uhrt und z.B. Leuchtdioden haben geblinkt oder Meldungen wurden ausgegeben. Es ist aber zu keiner
Zeit etwas abh¨
angig von irgendeinem anderen Ereignis passiert.
Es ist aber bei der Robotersteuerung und auch generell in der Programmierung oft n¨
otig, dass ein Programm auf Ereignisse
reagiert. Der C++-Mechanismus daf¨
ur sind Anweisungen, die auf Bedingungen reagieren k¨
onnen.
4.6.1 if-Anweisung
https://www.arduino.cc/reference/en/language/structure/control-structure/if/
if(Bedingung){
Anweisung1;
Anweisung2;
}
Bedingung
Bedingungskörper
Abbildung 4.9: if-Anweisung
Die if-Anweisungen ist solch eine Anweisung. Sie erwartet eine Bedingung in runden Klammern und die auf die if-Anweisung
folgende Anweisung im Bedingungsk¨
orper wird nur dann ausgef¨
uhrt, wenn die Bedingung sich als “wahr” herausstellt.
if (12 > 5+3)
Serial.println(" z woe lf ist g ro esser als die Summe aus fu enf und drei ") ;
In der Bedingung k¨
onnen unterschiedliche Vergleichsoperatoren verwendet werden. Die wichtigsten sind:
C++-Schreibweise Vergleichsoperation
>gr¨
oßer als
<kleiner als
== gleich
!= ungleich
Die Bedingung kann auch Funktionsaufrufe enthalten. Im Falle der ftduino.input get()-Funktion ist das Ergebnis des
Funktionsaufrufs bereits ein Wahrheitswert (wahr oder unwahr) und der Funktionsaufruf kann direkt verwendet werden. Soll
mehr als eine Anweisung von der if-Anweisung betroffen sein, so kann man sie durch geschweifte Klammern ({und })
zusammenfassen.
#include < F t du in oS imp le .h >
void setup () {
// Vorb er ei te n der s er ie ll en Verbindung
Serial.begin ( 115200 ) ;
}
void loop() {
48 Kapitel 4. Programmierung
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
Abbildung 4.10: Taster an Eingang I1
// testen , on die Ta ste an I1 gedr ¨u ckt ist
if (ftduino.input_get(Ftduino:: I1 ) ) {
Serial.print (" D er T aste r ist g edr uec kt " );
// eine vier te l Se kunde warten
delay (250) ;
}
}
4.7 Schleifen
Programmschleifen sind ebenfalls ein sehr fundamentales Konzept. Erst durch sie wird es m¨
oglich, Teile eines Programms
mehrfach auszuf¨
uhren. Ohne sie w¨
urden alle Anweisungen eines Programms einmal der Reihe nach abgearbeitet.
Allerdings gab es in den bisherigen Beispielen bereits das ein oder andere Programm, das etwas mehrfach getan hat. Das liegt
an der Arduino-spezifischen loop()-Funktion. Sie wird automatisch w¨
ahrend des Programmablaufs immer wieder aufgerufen
wie in Abbildung 4.7 abgebildet. Dadurch lassen sich in Arduino-Sketches auch ohne den Einsatz von entsprechenden C++-
Anweisungen Programmteile wiederholen.
Dennoch ist es hilfreich, auch auf die C++-eigenen Mechanismen f¨
ur Schleifen zur¨
uckgreifen zu k¨
onnen. Im Folgenden werden
zwei davon beschrieben.
4.7.1 while-Schleife
https://www.arduino.cc/reference/en/language/structure/control-structure/while/
while(Bedingung){
Anweisung1;
Anweisung2;
}
Schleifen-Bedingung
Schleifenkörper
Abbildung 4.11: while-Schleife
Die while-Schleife erlaubt es, den folgenden Befehl im sogenannten Schleifenk¨
orper solange zu wiederholen, wie die Bedin-
gung zwischen ihren runden Klammern erf¨
ullt ist. Wie schon bei der if-Anweisung k¨
onnen mehrere folgenden Anweisungen
durch geschweifte Klammern zusammengefasst werden. Die while-Schleife gilt dann f¨
ur den gesamten Anweisungsblock.
Ist die Bedingung von vornherein nicht erf¨
ullt, so wird der Schleifenk¨
orper nicht ausgef¨
uhrt.
whi le (variablenName < 12) {
Serial.println(" V ar iab le ist k lei ner 12 " );
variablenName =variablenName + 1;
}
4.7. Schleifen 49
Die Bedingung gleicht ebenfalls der der if-Anweisung und kann die gleichen Operatoren enthalten. Das folgende Beispiel
erweitert das Beispiel aus dem Abschnitt der if-Anweisung so, dass auf das Loslassen der Taste gewartet wird.
#include < F t du in oS imp le .h >
void setup () {
// Vorb er ei te n der s er ie ll en Verbindung
Serial.begin ( 115200 ) ;
}
void loop() {
// testen , on die Ta ste an I1 gedr ¨u ckt ist
if (ftduino.input_get(Ftduino:: I1 ) ) {
Serial.print (" D er T aste r ist g edr uec kt " );
// eine vier te l Se kunde warten
delay (250) ;
// warten , bis die T aste wie der lo sg el assen wird
whi le (ftduino.input_get(Ftduino:: I1 )) {
// der Raum z wi sc hen den ge sc hw ei ften Kl am me rn kann
// auch ganz leer bleiben , wenn w¨a hrend der
// Wied er ho lung keine w ei teren A nw ei su ng en aus
// gef ¨u hrt wer den s olle n
}
}
}
4.7.2 for-Schleife
https://www.arduino.cc/reference/en/language/structure/control-structure/for/
Etwas komplexer als die while-Schleife ist die for-Schleife. Sie enth¨
alt zwischen ihren Runden Klammern gleich drei
durch Semikolon getrennte Anweisungen. Die erste wird vor Schleifenbeginn einmal ausgef¨
uhrt, die zweite wird w¨
ahrend der
Ausf¨
uhrung der Schleife ausgewertet und bestimmt, wie die Bedingung der while-Schleife wie h¨
aufig die Schleife ausgef¨
uhrt
wird. Die dritte Anweisung wird schließlich nach jeder Ausf¨
uhrung des Schleifenk¨
orpers ausgef¨
uhrt. Ist die Bedingung von
vornherein nicht erf¨
ullt, so wird der Schleifenk¨
orper nicht ausgef¨
uhrt. Die Vor-Anweisung wird in jedem Fall ausgef¨
uhrt.
for(Anweisung;Bedingung;Anweisung){
Anweisung1;
Anweisung2;
}
Schleifen-Bedingung
Schleifenkörper
Schleifen-Widerholungs-Anweisung
Schleifen-Vor-Anweisung
Abbildung 4.12: for-Schleife
Was recht aufwendig klingt wird verst¨
andlich, wenn man sich die ¨
ubliche Anwendung der for-Schleife ansieht: Das Wieder-
holung eines Befehls mit einer bestimmten H¨
aufigkeit.
for (variablenName = 0 ; variablenName < 12; variableName =variableName + 1)
Serial.println(" Die ser Text wi rd 12 mal a usgegeben " );
Die drei Anweisungen bzw. Bedingungen innerhalb der runden Klammern lauten:
variablenName = 0;
variablenName < 12;
variableName =variableName + 1;
Die erste Anweisung wird nur einmal zu Beginn der Schleife ausgef¨
uhrt. In diesem Fall schreibt sie den Wert 0 in die Variable
variablenName die zweite Anweisung ist die Bedingung, die bestimmt wie oft die Schleife ausgef¨
uhrt wird. In diesem Fall
solange der Inhalt der Variable variablenName kleiner als 12 ist. Und die dritte Anweisung wird schließlich am Ende jedes
Durchlaufs der for-Schleife ausgef¨
uhrt. In diesem Fall wird dort der Inhalt der Variablen variablenName um eins erh¨
oht.
In diesem Beispiel passiert also:
1. Der Inhalt der Variablen variablenName wird auf 0 gesetzt
50 Kapitel 4. Programmierung
2. Solange der Inhalt der Variablen variablenName kleiner als 12 ist ...
(a) ... werden die Anweisungen im Schleifenk¨
orper ausgef¨
uhrt ...
(b) ... und danach der Inhalt der Variablen variablenName um eins erh¨
oht
Der Schleifenk¨
orper wird also genau 12 mal ausgef¨
uhrt.
4.8 Beispiele
Die in diesem Kapitel vorgestellten C++-Sprachkonstrukte sowie die ausgew¨
ahlten Funktionen der Arduino- und der ftDuino-
Bibliotheken bilden zwar nur einen geringen Teil ab. Aber schon diese wenigen Informationen reichen, um einige interessante
Sketches selbst zu schreiben.
4.8.1 Einfache Ampel
Dieses Beispiel stellt eine eine einfache Bedarfs-Ampel dar. Nach dem Einschalten zeigt sie zun¨
achst rot. Sobald der Taster
gedr¨
uckt wird springt sie f¨
ur 10 Sekunde auf gr¨
un und wechselt dann zur¨
uck in den Anfangszustand.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
I1
O1
O2
Abbildung 4.13: Einfache Ampel
Der dazugeh¨
orige Sketch ist sehr einfach. In der setup()-Funktion wird in Zeile 5 die rote Lampe eingeschaltet.
In der loop()-Funktion wird in Zeile 10 permanent getestet, ob der Taster gedr¨
uckt ist. Ist er gedr¨
uckt, so wird der gesamte
Bedingungsk¨
orper in den Zeilen 11 bis 20 ausgef¨
uhrt.
Dort wird in Zeile 12 die rote Lampe aus- und in Zeile 14 die gr¨
une Lampe eingeschaltet. In Zeile 16 wird 10000 Millisekunden,
also 10 Sekunden gewartet, bevor in den Zeilen 18 und 20 die gr¨
une Lampe zun¨
achst aus- und die rote dann eingeschaltet
wird.
Dies ist ein Beispiel f¨
ur Dinge, die aufgrund der Geschwindigkeit des Mikroprozessors als gleichzeitig wahrgenommen werden.
Obwohl die Lampen in den Zeilen 12 und 14 bzw. 18 und 20 jeweils nacheinander ein- bzw. ausgeschaltet werden ist keine
zeitliche Differenz erkennbar. Der Abstand von wenigen Mikrosekunden ist nicht erkennbar.
1#include < F t du in oS imp le .h >
2
3void setup () {
4// beim Start der A mpel le uc ht et die rote La mpe
5ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
6}
7
8void loop() {
9// testen , on die Ta ste an I1 gedr ¨u ckt ist
10 if (ftduino.input_get(Ftduino:: I1 ) ) {
11 // rote La mpe ausschalt en
12 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: OFF ) ;
13 // gr ¨u n e La mpe e in sc hal te n
14 ftduino.o ut pu t_ set (Ftduino:: O2 ,Ftduino:: HI );
15 // zehn S ekunden warten
16 delay (10000);
4.8. Beispiele 51
17 // gr ¨u n e La mpe a us sc hal te n
18 ftduino.o ut pu t_ set (Ftduino:: O2 ,Ftduino:: OFF ) ;
19 // rote La mpe einschalt en
20 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
21 }
22 }
4.8.2 Schranke
Das Schrankenbeispiel ist etwas komplexer. Es besteht aus einer motorisierten Schranke mit jeweils zwei Endtastern. Der
Taster an I2 wird bet¨
atigt, wenn sich die Schranke komplett ge¨
offnet hat, der an I3 wird bet¨
atigt, wenn die Schranke
vollst¨
andig geschlossen ist.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
3
2
1
3
2
1
I1
I2
I3
M1
O3
3
2
1
3
2
1
M1
I3
I2
Abbildung 4.14: Schranke
Achtung: Taster I2 und I3 sind so verdrahtet, dass der Kontakt im unbet¨
atigten Zustand geschlossen ist. Er ¨
offnet sich,
sobald die Taster bet¨
atigt werden, die Schranke also ganz ge¨
offnet oder geschlossen ist.
Bei Sketchstart wird zun¨
achst der Motor in Zeile 10 so lange linksherum gedreht, solange der Kontakt des Tasters an I2
in Zeile 15 als geschlossen erkannt wird, also solange die Schranke nicht vollst¨
andig ge¨
offnet ist. Sobald der Taster bet¨
atigt
wird wird der Motor in Zeile 18 gestoppt.
Sobald die Taste an I1 in Zeile 23 gedr¨
uckt wird wird der Motor in Zeile 26 diesmal rechtsherum gestartet bis der Taster
an I3 bet¨
atigt wird. In Zeile 28 wird der Motor dann gestoppt.
In den Zeilen 31 bis 40 wird die Lampe an O3 insgesamt f¨
unfmal mit einer Pause von jeweils 500 Millisekunden ein- und
wieder ausgeschaltet.
Danach wird die Schranke schließlich in den Zeilen 43 bis 45 wieder geschlossen.
1#include < F t du in oS imp le .h >
2
3// Z ¨a hl erv ar iable zum Blin ke n
4int zaehler;
5
6void setup () {
7// Beim Sta rt f¨a hrt die Sc hranke auf
8
9// moto r l in ks he rum dreh en
10 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: LEFT);
11
12 // Wart en bis S ch ranke gesch lo ss en offen ist . Da der Taster als
13 // ¨
O ff ner v erd rah te t ist l ¨a u ft der Mo tor , s ola nge der Ta ster
14 // geschl os se n ist
15 whi le (ftduino.input_get(Ftduino:: I2 )) { }
16
17 // Sob ald der Tast er ni cht mehr g eschlos se n ist M oto r stop pe n
18 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: OF F );
19 }
20
21 void loop() {
52 Kapitel 4. Programmierung
22 // testen , on die Ta ste an I1 gedr ¨u ckt ist
23 if (ftduino.input_get(Ftduino:: I1 ) ) {
24
25 // M oto r r e ch tsh er um drehe n , b is T ast er I 3 ge ¨o ff net ist
26 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: RI GHT );
27 whi le (ftduino.input_get(Ftduino:: I3 )) { }
28 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: OF F );
29
30 // f ¨u nfmal mit der Lampe bl inken
31 for (zaehler=0;zaehler <5; zaehler=zaehler+1) {
32 // Lamp e an
33 ftduino.o ut pu t_ set (Ftduino:: O3 ,Ftduino:: HI );
34 // 500 ms war ten
35 delay (500) ;
36 // Lamp e aus
37 ftduino.o ut pu t_ set (Ftduino:: O3 ,Ftduino:: OFF ) ;
38 // 500 ms war ten
39 delay (500) ;
40 }
41
42 // M oto r l i nks he ru m d re he n , b is T as ter I2 ge ¨o f fne t ist
43 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: LEFT);
44 whi le (ftduino.input_get(Ftduino:: I2 )) { }
45 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: OF F );
46 }
47 }
4.9 Die Warnung Wenig Arbeitsspeicher
Bei der Programmierung gr¨
oßerer Projekte und speziell bei der großz¨
ugigen Verwendung von Bibliotheken kann es leicht zu
der in Abbildung 4.15 dargestellten Warnmeldung kommen.
Abbildung 4.15: Warnung der Arduino-IDE ¨
uber geringen Arbeitsspeicher
Da der ftDuino lediglich ¨
uber 2560 Bytes dynamischen Speicher (RAM-Speicher) verf¨
ugt ist der Umgang mit dieser knappen
Resource oft nicht einfach.
Die Warnung ¨
uber den geringen Arbeitsspeicher bezieht ausschließlich auf den dynamischen RAM-Speicher und nicht auf den
ebenfalls in der Meldung erw¨
ahnten Programmspeicherplatz (oft auch als Flash-Speicher bezeichnet). Der Programmspeicher
kann bedenkenlos zu 100% gef¨
ullt werden.
4.9.1 Auswirkungen
Im Flash-Speicher des ftDuino sind zu jeder Zeit zwei Programme gespeichert:
Bootloader Der Bootloader (siehe Abschnitt 1.2.1) ist in einem gesch¨
utzten Teil des Flashspeichers abgelegt. Er wird
genutzt, um Sketches aus der Arduino-IDE ¨
uber USB in den ¨
ubrigen Flash-Speicher zu laden.
Sketch Der Sketch wird vom Anwender mit Hilfe der Arduino-IDE und des Bootloaders installiert und kann s¨
amtlichen
Flash-Speicher nutzen, der nicht durch den Bootloader belegt wird. Im ftDuino stehen neben dem vom Bootloader
belegten Bereich noch 28672 Bytes des Flash-Speichers f¨
ur eigene Sketche zur Verf¨
ugung.
F¨
ur beide Programme hat die Meldung eine (unterschiedliche) Bedeutung.
4.9. Die Warnung Wenig Arbeitsspeicher 53
Auswirkungen auf den Sketch
Die genauen Auswirkungen von RAM-Mangel auf den Sketch sind kaum vorhersagbar. Problematisch wird der Mangel
an dynamischem Speicher dadurch, dass w¨
ahrend der Sketchausf¨
uhrung immer mal wieder zus¨
atzlicher dynamischer Spei-
cher ben¨
otigt wird um beispielsweise Zwischenergebnisse von Rechnungen zu speichern oder zu speichern, wo die Sket-
chausf¨
uhrung nach dem Aufruf von Unterfunktionen fortgesetzt werden muss. Durch den Speichermangel werden dann
Zwischenergebnisse oder Fortsetzungspunkte verf¨
alscht. Die gesamte Programmausf¨
uhrung kann dann zu v¨
ollig unerwarte-
ten und unsinnigen Reaktionen f¨
uhren.
Ein solcher defekter Sketch kann jederzeit durch einen korrigierten Sketch ersetzt werden, um eine korrekte Programm-
ausf¨
uhrung wieder herzustellen.
Im Zweifelsfall sollte man zun¨
achst einen einfachen und bekanntermaßen funktionsf¨
ahigen Sketch installieren. Der Blink-
Sketch unter Datei Beispiele 01. Basics Blink bietet sich daf¨
ur an.
Auswirkungen auf den Bootloader
Der Bootloader selbst ist ein eigenst¨
andiges Programm im Flash. Er ist von Engp¨
assen beim dynamischen Speicher nicht
betroffen, da er sich diesen Speicher nicht mit dem Sketch teilen muss. Allerdings gibt es einen kleinen zum Bootloader
geh¨
origen Funktionsblock innerhalb eines jeden Sketches, der von der Arduino-IDE f¨
ur den Anwender unsichtbar in den Code
des Sketches integriert wird.
Dieser Teil realisiert die USB-Kommunikation mit dem PC w¨
ahrend der Sketchausf¨
uhrung wird. Vor allem reagiert dieser
Teil auf den von der Arduino-IDE gesendeten Befehl, den Bootloader in Vorbereitung eines Sketch-Uploads zu starten.
Stellt dieser Teil des laufenden Sketches fest, dass die Arduino-IDE einen neuen Sketch ¨
ubertragen will, so aktiviert sie den
Bootloader. Der Bootloader wiederum handhabt in Folge den eigentlichen Empfang des neuen Sketches.
Bei dynamischem Speichermangel kann es passieren, dass dieser verborgene Teil des Sketches nicht korrekt funktioniert.
Die Arduino-IDE kann dadurch selbst nicht mehr den Start des Bootloaders veranlassen und Upload-Versuche durch die
Arduino-IDE scheitern. Unter Umst¨
anden ist die USB-Kommunikation zum PC so sehr beeintr¨
achtigt, dass der ftDuino
w¨
ahrend der Sketch-Ausf¨
uhrung vom PC nicht korrekt oder ggf. sogar ¨
uberhaupt nicht erkannt wird.
F¨
ur diesen Fall verf¨
ugt der ftDuino ¨
uber einen Reset-Taster (siehe Abschnitt 1.2.3). Ist die Arduino-IDE durch Speichermangel
im Sketch nicht mehr in der Lage, den ftDuino ¨
uber USB anzusprechen und zur Aktivierung des Bootloaders zu veranlassen,
so ist es mit dem Reset-Taster manuell immer noch m¨
oglich, den Bootloader im passenden manuell zu aktivieren wie in
Abschnitt 1.3.2 beschrieben. Die Funktion des Reset-Tasters ist immer vorhanden und sie kann nicht durch einen fehlerhaften
Sketch beeinflusst werden. Mit seiner Hilfe ist es immer m¨
oglich, einen neuen Sketch auf den ftDuino zu laden.
4.9.2 Vorbeugende Maßnahmen
Taucht die o.g. Warnung auf, so sollte man im Zweifelsfall davon Abstand nehmen, den Sketch auf den ftDuino zu laden.
Auch wenn es mit Hilfe des Reset-Tasters immer m¨
oglich ist, den fehlerhaften Sketch zu ersetzen, so erfordert dieses
Vorgehen ein gutes Timing und es kann einige Versuche erfordern, bis der st¨
orrische Sketch erfolgreich ersetzt ist.
Verwendung von Flash-Speicher f¨
ur konstante Daten
In vielen Sketchen werden Textausgaben gemacht, entweder ¨
uber den seriellen Monitor oder z.B. auf ein kleines Display.
¨
Ublicherweise enth¨
alt ein Sketch daher Zeilen wie die folgende.
Serial.println(" Hal lo W el t !" );
Dabei ist nicht offensichtlich, dass hier 12 Bytes des kostbaren dynamischen RAM-Speichers unn¨
otigerweise belegt werden.
Das l¨
asst sich leicht in einem minimalen Sketch testen:
1void setup () {
2Serial.begin (9600);
3}
4void loop() {
5Serial.println(" Hal lo W el t !" );
6delay (1000);
7}
54 Kapitel 4. Programmierung
Dieser Sketch belegt laut Arduino-IDE 163 Bytes bzw. 6% des dynamischen Speichers (der genaue Wert kann je nach
Version der Arduino-IDE etwas schwanken). Kommentiert man Zeile 5 durch vorangestellte // aus, so reduziert sich der
Speicherverbrauch auf 149 Bytes, es werden also ganze 14 Bytes des dynamischen Speichers gespart.
Der Grund liegt darin, dass die Arduino-IDE davon ausgeht, dass die Zeichenkette “Hallo Welt!” weiter verarbeitet werden
soll. Daher legt die Arduino-IDE die Zeichenkette “Hallo Welt!” im dynamischen Speicher ab, wo sie vom Sketch ver¨
andert
werden k¨
onnte. Da wir aber nicht vor haben, diese Zeichenkette jemals w¨
ahrend der Sketch ausgef¨
uhrt wird zu ver¨
andern
k¨
onnte man sie auch im Flash-Speicher belassen. Genau daf¨
ur gibt es Hilfsfunktionen in der Arduino-IDE. Ein schlichtes
F(...) um die Zeichenkette herum erledigt genau das. Dazu ersetzt man die bisherige “Hallo-Welt”-Ausgabe durch das
folgende Konstrukt.
Serial.println(F(" Hal lo W el t !" ));
Dieser Sketch verh¨
alt sich identisch zur vorherigen Version, er belegt aber nur 151 statt 163 Bytes. Die Differenz entspricht
genau der L¨
ange der Zeichenkette “Hallo Welt!” zuz¨
uglich eines weiteren Bytes, das die Zeichenkette beendet. In vielen
Sketches l¨
asst sich auf diese Weise bereits signifikant dynamischer Speicher sparen.
Der Umgang mit dem Flash-Speicher ist allerdings nicht ganz einfach. Das folgende Beispiel nutzt einen weiteren Hilfs-
mechanismus namens PROGMEM um eine Zeichenkette im Flash abzulegen. Leider l¨
asst sich diese dann nicht einfach per
println() ausgeben.
// das folg en de kla ppt nicht , denn der ftDui no w eiss nicht , ob er RAM
// oder Fla sh le sen soll
sta tic const char str[] PROGMEM =" Hal lo Welt ! ";
Serial.println(str );
Das Problem ist, dass println() nicht erkennen kann, ob str auf Flash- oder RAM-Speicher verweist. Eine m¨
ogliche
L¨
osung ist, die Zeichen einzeln aus dem Flash-Speicher mit Hilfe spezieller Funktionen auszulesen und auszugeben wie im
folgenden Beispiel:
sta tic const char str[] PROGMEM =" H all o W el t !\ n " ;
for (char c= 0; c<strlen_P (str ) ; c++)
Serial.print (( char)pgm_read_byte_near(str +c) ) ;
Die Dokumentation der Arduino-IDE h¨
alt viele weitere Beispiel zur Nutzung des Flash-Speichers bereit. Unter dem Stichwort
PROGMEM finden sich weiterf¨
uhrende Informationen unter anderem unter
https://www.arduino.cc/reference/en/language/variables/utilities/progmem/
und
http://playground.arduino.cc/Main/PROGMEM.
Diese Technik l¨
asst sich nicht nur auf Zeichenketten anwenden, sondern auf alle Arten statischer Daten wie T¨
one, Werte-
Tabellen usw.
Verwendung von alternativen Bibliotheken
Bibliotheken sind eine praktische Sache, keine Frage. Und bei funktionsreichen Bibliotheken ist die Wahrscheinlichkeit umso
h¨
oher, dass man alles findet, das man f¨
ur sein konkretes Problem ben¨
otigt.
Oft sind es aber gerade die besonders umfangreichen Bibliotheken, die besonders ressourcenhungrig sind und eine große
Menge Speicher belegen. Bei Verwendung des OLED-Displays aus Abschnitt 6.13.3 am ftDuino sind es zum Beispiel die
Grafikbibliotheken von Adafruit, die alle Funktionen f¨
ur aufw¨
andige Grafiken mitbringen, aber gleichzeitig einen hohen
Speicherverbrauch haben.
Mit wenigen Zeile Code bringt das folgende Beispiel die Nachricht “Hallo Welt!” auf den OLED-Bildschirm.
1#include <Adafruit_GFX.h>
2#include <Adafruit_SSD1306.h>
3Adafruit_SSD1306 display( -1) ;
4
5void setup () {
6display.begin (S SD 13 06 _S WITCHCAPVCC , 0 x 3C ) ;
7display.clearDisplay() ;
8display.setTextColor(WHITE );
4.10. Weiterf¨
uhrende Informationen 55
9display.println(" Hal lo W el t !" );
10 display.display() ;
11 }
12
13 void loop() { }
Schon dieses einfache Beispiel belegt 1504 Bytes bzw 58% des dynamischen Speichers. Das ist vor allem der Tatsache
geschuldet, dass die Bibliothek f¨
ur komplexe Zeichenoperationen eine Kopie des Bildschirminhalts im dynamischen Speicher
vorh¨
alt. Bei 128 x 64 Pixel sind das bereits 128∗64
/8= 1024 Bytes.
Ist man auf Grafikf¨
ahigkeiten aber gar nicht angewiesen, sondern kann mit einer Darstellung von 16 x 8 Zeichen auskommen,
dann bieten sich sparsame Alternativen an.
Eine davon ist die U8g2-Bibliothek und dort speziell die mitgelieferte U8x8-Bibliothek. Sie l¨
asst sich direkt im Bibliotheks-
manager der Arduino-IDE installieren. Das “Hallo Welt!”-Beispiel sieht in diesem Fall wie folgt aus.
1#include <U8x8lib.h>
2U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(U8X8_PIN_NONE) ;
3
4void set up (void)
5{
6u8x8.begin ( ) ;
7u8x8.setPowerSave( 0) ;
8u8x8.setFont(u8x8_font_chroma48medium8_r) ;
9u8x8.d ra wS tr in g (0 ,0 , " Ha llo Welt ! ") ;
10 }
11
12 void loop() { }
Hier werden nur 578 Bytes entsprechend 22% des dynamischen Speichers belegt und es bleibt wesentlich mehr f¨
ur andere
Bibliotheken und eigenen Code ¨
ubrig.
Bei vielen Bibliotheken ist es ¨
ahnlich und es kann sich lohnen, genau zu schauen, welche Anspr¨
uche man hat und welche
Bibliothek diese Anspr¨
uche mit minimalem Aufwand und Ressourceneinsatz erf¨
ullen kann. Oft lassen sich mit nur kleinen
Einschr¨
ankungen bereits große Gewinne erzielen.
4.10 Weiterf¨
uhrende Informationen
Es gibt im Internet viele Tutorials sowohl zur C++-Programmierung2als auch zur Arduino-Programmierung3.
Diese und ¨
ahnliche Tutorials erkl¨
aren viele weitere Sprachkonstrukte und Bibliotheksfunktionen. Solche Tutorials sind nicht
auf den ftDuino zugeschnitten. Aber dieses Kapitel hat die n¨
otigen Grundlagen geliefert, um auch mit anderen Tutorials
weiterarbeiten zu k¨
onnen. Nicht alles aus der Welt der PC-Programmierung oder der Arduino-Programmierung l¨
asst sich auf
den ftDuino ¨
ubertragen. Zusammen mit den Experimenten und Modellen der folgenden Kapitel sowie den fertig mitgelieferten
Beispielprogrammen ist der tiefere Einstieg in die professionelle C++-Programmierung aber m¨
oglich.
2C++-Tutorial http://www.online-tutorials.net/c-c++-c/c++-tutorial-teil-1/tutorials-t-1-58.html
3Arduino-Tutorial http://www.arduino-tutorial.de
Kapitel 5
ftDuino in der Schule
Der ftDuino wurde wie alle Mitglieder der Arduino-Familie in erster Linie zur Programmierung in der Sprache C++ entworfen
wie in Kapitel 4 beschrieben. Wird der ftDuino im Vorfeld mit einem entsprechende Sketch versehen, so kann er mit
wesentlich geringerem Anspruch aber auch ohne Programmierwissen verwendet werden. Der ftDuino l¨
asst sich so sehr
flexibel in unterschiedlichen Klassenstufen einsetzen.
Scratch Blockly Arduino
Schwierigkeitsgrad
Minecraft
Abbildung 5.1: ftDuino-Programmierumgebungen mit unterschiedlichem Schwierigkeitsgrad
In allen F¨
allen bedient sich der ftDuino dabei etablierten Projekten (Scratch, Blockly, . . . ). Dadurch bildet der ftDuino keine
Insell¨
osung sondern kann neben anderen z.B. Arduino-basierten Projekten gleichberechtigt eingesetzt werden. Wissen und
Werkzeuge aus dem Arduino-Einsatz k¨
onnen auf den ftDuino ¨
ubertragen werden und umgekehrt. Oft erlaubt der ftDuino
so einen leichten Einstieg mit Hilfe eines fischertechnik-Modells und erst sp¨
ater folgt dann der elektrisch und mechanisch
anspruchsvollere Aufbau auf Basis eines klassischen Arduinos.
5.1 Grafische Programmierung mit Scratch
Wikipedia schreibt zur Programmiersprache Scratch:
Zielsetzung
Ihr Ziel ist es, Neueinsteiger – besonders Kinder und Jugendliche – mit den Grundkonzepten der Programmie-
rung vertraut zu machen. Unter dem Motto imagine, program, share (”Ausdenken, Entwickeln, Teilen“) wird
die kreative und explorative Erstellung eigener Spiele und Multimedia-Anwendungen, verbunden mit dem ge-
genseitigen Austausch dar¨
uber, als Motivation genutzt. Kostenlos und werbefrei k¨
onnen die Ergebnisse in einer
internationalen Online-Community mit dem Scratch-Player abgespielt, diskutiert und weiterentwickelt werden.
Außerdem gibt es einige Beispiele, die Anregungen f¨
ur Einsteiger schaffen und das Prinzip des Programmierens
n¨
aher bringen.
https://de.wikipedia.org/wiki/Scratch (Programmiersprache)
5.1. Grafische Programmierung mit Scratch 57
Scratch wurde im Original als reine Simulationsumgebung ausgelegt. Die Programmierung erfolgt grafisch mit der Maus am
PC. Die Programmausf¨
uhrung sowie die Darstellung von Ergebnissen ¨
ubernimmt ebenfalls der PC. Scratch sieht zun¨
achst
nicht vor, reale Hardware wie den ftDuino in die Programmentwicklung einzubinden.
Abbildung 5.2: Die Scratch-2.0-Programmierumgebung
Scratch stammt aus dem englischsprachigen Umfeld und ist im Original unter https://scratch.mit.edu/ zu finden. Es gibt
aber auch deutschsprachige Portale wie das DACH-Scratch-Wiki unter https://scratch-dach.info und INF-Schule unter
https://www.inf-schule.de/programmierung/scratch, die sich speziell an Lehrer und Sch¨
uler aus dem deutschen Sprachraum
richten und einen Scratch-Einstieg in der Schule unterst¨
utzen.
5.1.1 Scratch-Versionen
Scratch ist inzwischen in drei unabh¨
angigen Versionen erschienen.
Scratch 1.x wurde 2007 ver¨
offentlicht und kam als eigenst¨
andiges PC-Programm. Auf der letzten Version 1.4 dieser Reihe
basiert Scratch-for-Arduino (S4A), das sich auch mit dem ftDuino verwenden l¨
asst wie in Abschnitt 5.1.2 beschrieben.
Scratch 1 wird seit 2009 nicht mehr weiterentwickelt.
Scratch 2.0 erschien 2013 und war eine komplette Neuentwicklung. Scratch 2.0 ist Browser-basiert und nutzt das so-
genannte Flash-Framework. Vor allem aus Sicherheitsgr¨
unden wird Flash in vielen modernen Browsers nicht mehr
unterst¨
utzt. Die Nutzung von Scratch 2.0 gestaltet sich damit zunehmend schwieriger. Zur Nutzung externer Ger¨
ate
wurde von Scratch 2.0 die Variante ScratchX (siehe https://scratchx.org/) abgeleitet. Eine ftDuino-Anbindung wurde
f¨
ur Scratch 2.0 bzw. ScratchX (bisher) nicht entwickelt.
Scratch 3.0 wurde 2019 ver¨
offentlicht und ist wiederum eine komplette Neuentwicklung. Scratch 3.0 ist ebenfalls Browser-
basiert, verzichtet aber auf Flash und verwendet stattdessen HTML5. Es ist daher in jedem modernen Browser nutzbar.
Eine ftDuino-Anbindung ist in Abschnitt 5.1.3 beschrieben.
F¨
ur neue Projekte sollte Scratch 3.0 verwendet werden. Die Nutzung von Scratch for Arduino (S4A) ist nur dann sinnvoll,
wenn auf eine bestehende S4A-Installtion aufgebaut werden soll. S4A ist in vielen Schulen mit regul¨
aren Arduinos im Einsatz
und kann ohne ¨
Anderungen direkt auch auf den ftDuino angewendet werden.
Scratch 3.0 ist dagegen in aktiver Entwicklung und auch die ftDuino-Anbindung wird aktiv weiterentwickelt.
5.1.2 Scratch 1.4 for Arduino (S4A)
Das Projekt Scratch for Arduino, kurz S4A baut auf Scratch 1.4 auf und hat sich zum Ziel gesetzt, eine Interaktion
zwischen virtueller Scratch-Welt auf dem PC und physischer an den PC angeschlossener Hardware herzustellen. Das S4A-
58 Kapitel 5. ftDuino in der Schule
Projekt greift dazu auf Arduinos zur¨
uck und integriert diese in die virtuelle Scratch-Umgebung. Das Scratch-Programm am
PC kann dadurch auf Sensoreingaben (z.B. Tastendr¨
ucke) des angeschlossenen Arduino reagieren bzw. Aktionen an Aktoren
(z.B. Lampen) am Arduino ausl¨
osen.
S4A ist mit den meisten g¨
angigen Arduinos kompatibel. Diese m¨
ussen im Vorfeld mit einem entsprechenden Sketch versehen
und per USB an den PC angeschlossen werden. Der entsprechende Sketch ist unter http://s4a.cat/ erh¨
altlich.
Im Gegensatz zu Scratch l¨
auft S4A nicht im Browser sondern erfordert die Installation eines separaten Programms auf dem
PC. Entsprechende Downloads finden sich unter http://s4a.cat/.
S4A stammt aus dem spanischsprachigen Raum und ist im Original unter http://s4a.cat/ erh¨
altlich. Deutschsprachige
Informationen finden sich z.B. unter https://scratch-dach.info/wiki/S4A.
Scratch for ftDuino
Die Anpassung von S4A an den ftDuino betrifft nur den ftDuino selbst und den dort zu installierenden Sketch. PC-seitig
besteht kein Unterschied zwischen S4A und dessen Verwendung mit dem ftDuino. Es k¨
onnen problemlos Arduinos und
ftDuino gemeinsam genutzt werden.
Da Arduino und ftDuino unterschiedliche Anschl¨
usse haben muss der Benutzer wissen, unter welcher Bezeichnung die
Anschl¨
usse des ftDuino unter S4A angesprochen werden k¨
onnen. Das folgende Bild zeigt die entsprechende Zuordnung.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Analog0
S4A-Sensor
Analog5
Digital2
Digital3
Analog1
Analog2
Analog3
Analog4
digital 13
analog5
analog6
analog9
digital10
digital11
digital12
S4A-Ausgang
motor 4
motor 7
motor 8
Abbildung 5.3: Zuordnung der ftDuino-Pins an S4A
Weiterf¨
uhrende Informationen zu Einsatz von S4A mit dem ftDuino finden sich in Abschnitt 8.6.
5.1.3 Scratch 3.0
Scratch 3.0 ist eine Online-Anwendung und kann direkt mit jedem g¨
angigen Browser auf https://scratch.mit.edu ge¨
offnet
werden.
Scratch 3.0 lehnt sich trotz der kompletten Neuentwicklung und der v¨
ollig unterschiedlichen darunterliegenden Technologie
sehr stark an Scratch 2.0 an und der Umstieg ist ggf. recht unproblematisch.
Die Verbreitung von Scratch in Schulen auch außerhalb des Einsatzes mit fischertechnik oder ¨
ahnlichen Systemen sorgt
in der Regel f¨
ur einen leichten und schnellen Start. Die Sch¨
uler k¨
onnen zun¨
achst ohne zus¨
atzliche Hardware direkt in der
Scratch-Umgebung Erfahrungen sammeln und sich mit dem prinzipiellen Umgang vertraut machen. Der Einsatz des ftDuino
kann dann fließend erfolgen und es ist kein Wechsel der Softwareumgebung n¨
otig, wenn der Einsatz von realer Hardware in
Scratch gewechselt werden soll.
Einsatz des ftDuino unter Scratch 3.0
F¨
ur den Einsatz des ftDuino sind zwei zus¨
atzliche Dinge n¨
otig. Zum einen muss auf dem ftDuino der passende Sketch
installiert sein. Zum zweiten muss die verwendete Scratch-3.0-Variante eine passende sogenannte Extension beinhalten.
5.1. Grafische Programmierung mit Scratch 59
Abbildung 5.4: Der Hauptbildschirm vom Scratch3 mit ftDuino-Extension
Zur Nutzung von Scratch 3.0 sind folgende Schritte n¨
otig:
Installation des Datei Beispiele WebUSB IoServer -Sketches auf dem ftDuino.
Anschluss des ftDuino per USB an den PC oder das Smartphone
¨
Offnen der Scratch-Webseite https://harbaum.github.io/ftduino/webusb/scratch3/ im Chrome-Browser
Weitere Informationen zu WebUSB und zur Installation des passenden Sketches finden sich in Abschnitt 6.18.
Nach dem Start sind zun¨
achst keine Extensions eingebunden. Die Extensions erreicht man ¨
uber den Auswahlbildschirm.
Abbildung 5.5: Button zur Extension-Auswahl in Scratch 3.0
Abbildung 5.6: Die ftDuino-Extension im Auswahlbildschirm
Ein Klick auf die Extension installiert diese in Scratch. Der Zustand des angeschlossenen ftDuino wird durch ein drittes
60 Kapitel 5. ftDuino in der Schule
Symbol neben der gr¨
unen Start-Flagge und dem roten Stop-Symbol angezeigt.
Das Symbol untscheidet drei Zust¨
ande. Das rote Kreuz zeigt an, dass ein generelles Problem mit der USB-Anbindung
vorliegt. Das orange “nicht verbunden”-Symbol zeigt an, dass ein ftDuino ausgew¨
ahlt werden kann. Ein Klick dieses Symbol
¨
offnet eine Liste der angeschlossenen Ger¨
ate, in diesem Fall dem ftDuino. Wird der ftDuino ausgew¨
ahlt, so ¨
andert sich das
Symbol zu dem gr¨
unen Verbunden-Symbol und der ftDuino kann verwendet werden.
(a) Kein
WebUSB
(b) Nicht ver-
bunden
(c) Verbunden
Abbildung 5.7: Das ftDuino-Status-Symbol neben den Start-Stop-Symbolen
Die Auswahl ist in der Regel nur einmal notwendig. Der ftDuino kann w¨
ahrend der Benutzung an- und abgesteckt werden
und sollte in der Folge automatisch eingebunden werden.
Offline-Nutzung von Scratch 3.0
Die Offline-Nutzung ist zur Zeit in Entwicklung ...
5.2 Grafische Programmierung mit Blockly/Brickly
Google hat sowohl das Potenzial der Scratch-Idee erkannt als auch die technischen Beschr¨
ankungen, denen es inzwischen
unterworfen ist.
Blockly ist Googles Versuch, die Scratch-Philosophie auf eine moderne technische Basis zu heben. Blockly basiert auf HTML5
und ist damit auf absehbare Zeit in allen g¨
angigen Webbrowsern und auf allen g¨
angigen Plattformen (u.a. Windows, Apple
MacOS, Linux, Android und IOS) lauff¨
ahig.
Abbildung 5.8: Die Blockly-Benutzerober߬
ache
Scratch bildet eine komplette Umgebung und beinhaltet neben der grafischen Code-Darstellung auch gleich die M¨
oglichkeit,
die erstellten Programme auszuf¨
uhren und deren Ergebnisse darzustellen. Blockly selbst ist dagegen ein reiner Code-Editor.
Der mit Blockly erzeugte Code kann von Blockly selbst daher nicht ausgef¨
uhrt werden und Blockly bringt auch keine
5.2. Grafische Programmierung mit Blockly/Brickly 61
Mechanismen mit, um Programmausgaben darzustellen. Beides muss von einem Softwareentwickler erst hinzugef¨
ugt werden,
um eine f¨
ur den Endbenutzer verwendbare Umgebung zu schaffen.
Brickly (siehe Abschnitt 8.3) und Brickly-Lite (siehe Abschnitt 6.18.4) sind zwei auf Blockly basierende komplette Umgebun-
gen, die speziell f¨
ur den fischertechnik-TXT-Controller bzw. den ftDuino entwickelt wurden. Auch wenn beide Umgebungen
bewusst ¨
ahnlich gehalten wurden und sich f¨
ur den Anwender sehr ¨
ahnlich darstellen ist die technische Funktion sehr unter-
schiedlich.
5.2.1 Brickly
Im Falle von Brickly wird Blockly genutzt, um Code f¨
ur den TXT-Controller zu entwickeln. Brickly ist erzeugt im Browser
sogenannten Python-Code, der auf den TXT ¨
ubertragen und dort ausgef¨
uhrt wird. Einmal erstellte Brickly-Programme
befinden sich dauerhaft auf dem TXT und k¨
onnen zu jedem sp¨
ateren Zeitpunkt auch direkt am TXT manuell gestartet
werden. Ein Web-Browser wird nur ben¨
otigt, um neue Programme zu erstellen. W¨
ahrend der Programmausf¨
uhrung auf
dem TXT k¨
onnen Ausgaben auf dem Bildschirm des TXT erfolgen. Ist der Benutzer mit dem Web-Browser mit dem TXT
verbunden, so werden diese Ausgaben vom TXT zus¨
atzlich zur¨
uck an den Browser gesendet und dort ausgegeben.
Abbildung 5.9: Die Brickly-Benutzerober߬
ache
S¨
amtliche im Browser dargestellten Informationen werden vom TXT an den Browser ¨
ubertragen. Es werden keine Daten
mit dem ¨
ubrigen Internet ausgetauscht.
Brickly wurde prim¨
ar dazu entwickelt, die Ein- und Ausg¨
ange des TXT zu bedienen. Bricklys auf Blockly basierender grafi-
scher Editor wurde daher um Bl¨
ocke erweitert, die sich zur Bedienung der Anschl¨
usse des TXT eignen. Durch zus¨
atzliche In-
stallation eines sogenannten Brickly-Plugins auf dem TXT (siehe https://github.com/harbaum/brickly-plugins) kann Brickly
erweitert werden. Ein solches Plugin erlaubt es, einen ftDuino per USB mit dem TXT zu koppeln und aus dem Brickly-
Programm heraus neben dem TXT selbst auch die Anschl¨
usse des angeschlossenen ftDuino zu bedienen.
Brickly ist auch von jungen Sch¨
ulern leicht zu bedienen und verf¨
ugt gegen¨
uber Scratch ¨
uber eine einfachere und leich-
ter zu nutzenden Benutzerober߬
ache. Die Nutzung von Brickly erfordert aber zuvor die Installation der Brickly-Software
auf dem TXT, was wiederum die Nutzung der sogenannten Community-Firmware auf dem TXT voraussetzt (siehe
https://cfw.ftcommunity.de/ftcommunity-TXT/de/). F¨
ur die Nutzung des ftDuino am TXT ist zus¨
atzlich die Installati-
on des ftDuino-Plugins n¨
otig. Sehr erfahrene Nutzer k¨
onnen statt des TXT-Controllers auch den wesentlich g¨
unstigeren
Raspberry-Pi nutzen. F¨
ur den Endanwender ergibt sich kein Unterschied, auch dieses Setup ist von Sch¨
ulern leicht zu
bedienen.
62 Kapitel 5. ftDuino in der Schule
Zur sp¨
ateren Nutzung von Brickly sind folgende vorbereitende Schritte n¨
otig:
Installation des Community-Firmware auf dem TXT (alternativ auf dem Raspberry-Pi, siehe
https://github.com/harbaum/tx-pi)
Installation von Brickly auf dem TXT (siehe https://cfw.ftcommunity.de/ftcommunity-
TXT/de/programming/brickly/)
Zugriff auf den TXT per beliebigem Browser
Soll zus¨
atzlich der ftDuino von TXT aus angesprochen werden sind weiterhin folgende Schritte n¨
otig:
Installation des ftduino direct-Sketches auf dem ftDuino (siehe https://github.com/PeterDHabermehl/ftduino direct)
Installation des ftduino-Brickly-Plugins (siehe https://github.com/harbaum/brickly-plugins)
5.2.2 Brickly-Lite
Wesentlich geringer als bei Brickly ist der administrative Aufwand bei der Nutzung von Brickly-Lite. Aus Sch¨
ulersicht ist
der Unterschied zwischen Brickly und Brickly-Lite minimal. Brickly-Lite bietet eine nochmal vereinfachte Darstellung.
Abbildung 5.10: Die Brickly-Lite-Benutzerober߬
ache
Im Gegensatz zu Brickly bezieht Brickly-Lite alle Daten aus dem Internet. F¨
ur die Benutzung von Brickly-Lite ist daher eine
Internet-Verbindung Voraussetzung. Und w¨
ahrend bei Brickly der Browser lediglich zur Code-Eingabe und zur Ergebnis-
ausgabe verwendet wird ¨
ubernimmt er bei Brickly-Lite fast alle Aufgaben inklusive der eigentlichen Programmausf¨
uhrung.
Der ftDuino stellt daher bei Brickly-Lite dem Browser seine Ein- und Ausg¨
ange zur Verf¨
ugung, f¨
uhrt aber das eigentliche
Brickly-Programm nicht aus. Aus diesem Grund ist zur sp¨
ateren Programmausf¨
uhrung der Browser immer n¨
otig. Ein mit
Brickly-Lite erstelltes Programm kann ohne Browser nicht ausgef¨
uhrt werden.
Der Sch¨
uler merkt von diesen Unterschieden nichts. F¨
ur den Lehrer ist aber der Vorbereitungsaufwand gegen¨
uber Brickly
sehr viel geringer, da neben ftDuino und Browser keine weiteren Komponenten ben¨
otigt werden. Gr¨
oßte Einschr¨
ankung ist
die Festlegung auf den Chrome-Browser (siehe https://www.google.com/intl/de ALL/chrome/). Dieser wird ben¨
otigt, da
nur dieser Browser-Typ mit lokal per USB abgeschlossenen Ger¨
aten wie in diesem Fall dem ftDuino kommunizieren kann.
Zur Nutzung von Brickly-Lite sind folgende Schritte n¨
otig:
Installation des Datei Beispiele WebUSB IoServer -Sketches auf dem ftDuino.
Anschluss des ftDuino per USB an den PC oder das Smartphone
¨
Offnen der Brickly-Lite-Webseite https://harbaum.github.io/ftduino/webusb/brickly-lite/ im Chrome-Browser
5.3. Spielerische Programmierung in Minecraft 63
5.3 Spielerische Programmierung in Minecraft
Minecraft ist ein extrem popul¨
ares Aufbauspiel. Es beinhaltet unter anderem eine Art elektrischer Schaltungssimulation in
Form des sogenannten Redstone. Mit diesem leitf¨
ahigen virtuellen Material lassen sich entsprechende Bl¨
ocke im Spiel verbin-
den und es lassen sich Spiel-interne Sensoren wie Taster und Schalter mit Aktoren wie Lampen und Druckzylindern verbinden.
Zus¨
atzliche Logikelemente wie die Redstone-Fackel (Inverter, Negierer), ein Vergleicher oder ein Verz¨
ogerungselement er-
lauben komplexe Schaltungen.
Mit dem ftDuino l¨
asst sich Minecraft mit der physischen Welt verbinden und virtuelle Sensoren in Minecraft k¨
onnen physische
fischertechnik-Aktoren ausl¨
osen und umgekehrt.
Abbildung 5.11: Minecraft mit ftDuino-Schnittstelle
Die Vorbereitungszeit auf Lehrerseite beschr¨
ankt sich auf das Ausspielen des passenden Sketches auf den ftDuino sowie die
Installation der entsprechenden ftDuino-Mod in eine bestehende Minecraft-Installation wie in Abschnitt 8.7 beschrieben.
Minecraft ist eine kommerzielle Software und ben¨
otigt eine seperat zu erwerbende Lizenz. Die Modifikation des Spiels durch
Erweiterungen wie der ftDuino-Mod wurde vom Hersteller explizit vorgesehen und verletzt keine Lizenzbedingungen.
Auf Sch¨
ulerseite ist die Einarbeitung theoretisch recht aufw¨
andig. In der Praxis ist ein großer Teil der Sch¨
uler mit den
Konzepten von Minecraft bis ins kleinste Detail vertraut und versteht die Logik der zus¨
atzlichen ftDuino-Bl¨
ocke sofort.
In der Regel sind Minecraft-erfahrene Sch¨
uler in wenigen Minuten in der Lage einfache Schaltungen wie Lauflichter zu
realisieren und mit dem physischen Modell zu verbinden.
Der Einsatz von Minecraft eignet sich vor allem zur Motivation bereits Minecraft-affiner Sch¨
uler. Als Lehrer hat man hier
besonders mit Sch¨
ulern zu rechnen, die ein extrem großes Fachwissen und erstaunliche F¨
ahigkeiten mitbringen. Minecraft
l¨
adt geradezu dazu ein, unorthodoxe L¨
osungen zu erstellen und z.B. virtuelle Lebewesen oder Fahrzeuge (Loren) in die
Signbalverarbeitung einzubinden.
Zur Nutzung von Minecraft sind folgende im Abschnitt 8.7 im Detail beschriebenen Schritte n¨
otig:
Installation einer lizensierten Minecraft-Version 1.12.2
Installation des Forge-Mod-Systems
Installation der ftDuino-Mod
Installation des Datei Beispiele WebUSB IoServer -Sketches auf dem ftDuino.
Anschluss des ftDuino per USB an den PC
64 Kapitel 5. ftDuino in der Schule
5.4 Textbasierte Programmierung mit der Arduino-IDE
Scratch und Brickly sind selbst komplexe Konstrukte. Sie werden als Programm auf dem PC oder als aktive Webseite im
Browser z.B. eines Mobilger¨
ats ausgef¨
uhrt. Der ftDuino fungiert in beiden F¨
allen nur als relativ passiver Schnittstellenbau-
stein. Er nimmt Befehle ¨
uber seinen USB-Anschluss vom PC entgegen und sendet Ergebnisse zur¨
uck.
F¨
ur den Anwender bleibt damit – wie bei der Benutzung von PCs ¨
ublich – der gr¨
oßte Teil der Technik in den Programmen
verborgen. W¨
ahrend sich so die Grundlagen der Programmierung verstehen lassen ist es einem Anf¨
anger kaum m¨
oglich, alle
zugrundeliegenden Komponenten und Verfahren zu verstehen.
5.4.1 Die Arduino-Idee
Das urspr¨
ungliche Konzept der Arduinos zielt darauf ab, ein fundamentales Verst¨
andnis zu vermitteln. Der Arduino und
der davon abgeleitete ftDuino geh¨
oren zu den technisch einfachsten programmierbaren Ger¨
aten. Die Technik auf der sie
basieren entspricht derjenigen, die auch in vielen allt¨
aglichen Ger¨
aten wie Computerm¨
ausen, Kaffeemaschinen oder Ge-
tr¨
ankeautomaten nahezu unsichtbar und unbemerkt eingesetzt wird.
Die Zahl und Komplexit¨
at der auf einem Arduino verwendeten Bauteile ist so gering wie m¨
oglich gehalten, so dass das
gesamte Ger¨
at auch von interessierten Laien weitgehend durchschaut werden kann. Trotzdem liegen die f¨
ur diese Art der
Verwendung n¨
otigen F¨
ahigkeiten deutlich ¨
uber denen zur Benutzung von Scratch oder Brickly. Der direkte Umgang mit
dem Arduino erfordert gr¨
oßeres Know-How bei Sch¨
uler und Lehrer und ist ungef¨
ahr ab Klasse 7 bis 8 sinnvoll m¨
oglich.
Abbildung 5.12: Die Arduino-IDE
Arduino in der Schule
Arduinos werden bereits in breitem Maße in der Schule eingesetzt. Speziell der geringe Preis und die Verbreitung in Privat-
haushalten f¨
uhrt zu einer geringen Einstiegsh¨
urde.
Allerdings ist die Lernkurve relativ steil und das erforderliche Know-How steigt mit der Komplexit¨
at der Aufgabenstellungen
schnell an. Arduinos werden als unverkleidete Platinen vertrieben und ihre Elektronik und Anschl¨
usse sind gegen ¨
außere
Ein߬
usse weitgehend ungesch¨
utzt. Vor allem der geringe Preis relativiert diese Nachteile, da sich versehentlich zerst¨
orte
Teile mit geringen Kosten ersetzen lassen. Die einfachsten Arduinos sind f¨
ur unter drei Euro erh¨
altlich, weitere Kosten fallen
zun¨
achst nicht an.
Die Programmierumgebung Arduino-IDE ist als kostenloser Download unter https://www.arduino.cc/en/Main/Software f¨
ur
alle g¨
angigen PC-Betriebssysteme verf¨
ugbar. Viele Dokumentationen und Beispiele sind im Internet frei verf¨
ugbar. Arduino-
Soft- und Hardware ist unter g¨
angigen Open-Source-Lizenzen verf¨
ugbar und darf lizenzfrei geteilt werden. Der Einsatz in der
Schule ist damit bedenkenlos m¨
oglich und der freie Austausch der meisten Unterlagen unterliegt keinen im Schul-Umfeld
relevanten Beschr¨
ankungen.
5.4. Textbasierte Programmierung mit der Arduino-IDE 65
5.4.2 Arduino und ftDuino
Der ftDuino ist eine Erweiterung des Arduino-Konzepts in Richtung fischertechnik. Der ftDuino wird programmiert wie
ein Arduino, nutzt aber elektrische und mechanische fischertechnik-Komponenten, um den Aufbau komplexer Modell zu
erm¨
oglichen.
Dabei bietet der ftDuino gegen¨
uber einem Arduino einige Vereinfachungen, die die Einstiegsh¨
urde senkt. Der ftDuino ist
aus Anwendersicht nicht zwangsl¨
aufig als Fortf¨
uhrung des Arduino-Gedankens zu verstehen. Er er¨
offnet vielmehr einen
einfacheren Einstieg in die Arduino-Welt.
Der ftDuino lehnt sich nah an den Arduino Leonardo an. Er erweitert den Leonardo um folgende Eigenschaften:
Robustheit Der ftDuino ist robust. Seine Anschl¨
usse sind entgegen denen des Arduino kurzschlussfest und die Elektronik
wird durch ein geschlossenes Geh¨
ause gesch¨
utzt.
Versorgungsspannung Der ftDuino wird mit fischertechnik-¨
ublichen 9 Volt betrieben und kann diese Spannungen auch an
allen Ein- und Ausg¨
angen nutzen w¨
ahrend der Arduino f¨
ur maximal 5 Volt ausgelegt ist und mit vielen fischertechnik-
Elementen nicht direkt verbunden werden darf.
Eing¨
ange Der ftDuino verf¨
ugt ¨
uber 8 dedizierte Analogeing¨
ange I1 bis I8 und 4 Z¨
ahlereing¨
ange C1 bis C4, die bereits
f¨
ur die Spannungs-, Widerstands- bzw. Ereignismessung vorbereitet sind. Der Arduino verf¨
ugt dagegen ¨
uber universell
verwendbare Ein- und Ausg¨
ange, die jedoch durch entsprechende zus¨
atzliche Beschaltung an die konkrete Verwendung
angepasst werden k¨
onnen.
Ausg¨
ange Der ftDuino verf¨
ugt ¨
uber 8 dedizierte Analogausg¨
ange O1 bis O8, die leistungsstark genug zur Ansteuerung von
Lampen und Motoren sind. Die universellen Ein- und Ausg¨
ange ben¨
otigen zus¨
atzliche Beschaltung, um leistungsstarke
Verbraucher ansteuern zu k¨
onnen.
5.4.3 Der ftDuino als Einstiegs-Arduino
Der ftDuino erlaubt den einfachen und unproblematischen Einstieg in den Arduino-Einsatz in der Schule. Er ist robust genug
f¨
ur den Schulalltag und erfordert zusammen mit dem fischertechnik-System keine weiteren elektrischen, elektronischen
oder mechanischen Voraussetzungen. Alle mechanischen und elektrischen Verbindungen werden gesteckt und es wird kein
Werkzeug ben¨
otigt. Viele direkt mitgelieferte Beispiele u.a. in dieser Anleitung erlauben einen einfachen und sicheren Start.
Der ftDuino kann dabei den Einsatz des klassischen Arduino vorbereiten. Der Aufbau eines Prototypen aus ftDuino und
Arduino bietet einen sicheren Start. Eine sp¨
atere Umsetzung mit klassischen Arduinos, zus¨
atzlicher Elektronik und speziell
aufgebauter Mechanik erfolgt dann auf Basis der mit dem ftDuino gewonnenen Erkenntnissen.
Kapitel 6
Experimente
Die Experimente dieses Kapitels konzentrieren sich auf einzelne Aspekte des ftDuino. Sie veranschaulichen einen Effekt oder
ein Konzept und verwenden daf¨
ur nur minimale externe Komponenten. Die Experimente stellen an sich keine vollst¨
andigen
Modelle dar, k¨
onnen aber oft als Basis daf¨
ur dienen.
Beispiele f¨
ur komplexe Modelle finden sich im Kapitel 7.
6.1 Lampen-Zeitschaltung
Schwierigkeitsgrad:
Dieses sehr einfache Modell besteht nur aus einem Taster und einer Lampe und bildet die Funktion einer typischen Treppen-
hausbeleuchtung nach. Um Energie zu sparen wird hier nicht einfach ein Kippschalter genommen, um das Licht zu schalten.
Stattdessen wird ein Taster verwendet und jeder Druck auf den Taster schaltet das Licht nur f¨
ur z.B. zehn Sekunden ein.
Wird w¨
ahrend dieser Zeit der Taster erneut gedr¨
uckt, so verl¨
angert sich die verbleibende Zeit wieder auf volle zehn Sekunden.
Nach Ablauf der zehn Sekunden verlischt das Licht und das Spiel beginnt von vorn.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
Abbildung 6.1: Lampen-Zeitschaltung
6.1.1 Sketch LampTimer
Der folgende Sketch findet sich bei installierter ftDuino-Unterst¨
utzung im Men¨
u der Arduino-IDE unter Datei
Beispiele FtduinoSimple LampTimer .
1/*
2LampTimer - Lampen - Z eitsc ha ltu hr
3
4(c ) 2017 by Till Ha rbaum < til l@har ba um . org >
5
6.1. Lampen-Zeitschaltung 67
6Schalte t ei ne La mpe an Ausg ang O1 f ¨ur 10 Se ku nden ein ,
7sob ald ein Tas ter an Eing ang I1 gedr ¨u ckt wird .
8*/
9
10 #include < F t du in oS imp le .h >
11
12 uint32_ t s tartzeit = 0;
13
14 // Die Setup - Funktion w ird einmal ausg ef ¨u hrt , wenn Reset gedr ¨u ckt oder
15 // das Bo ar d ges tar tet wi rd .
16 void setup () { }
17
18 // Die Loop - F un ktion wird en dlos immer und imm er wi eder au sge f ¨u hrt
19 void loop() {
20 // Teste , ob der Tas ter an I1 ge dr ¨u c kt ist
21 if (ftduino.input_get(Ftduino:: I1 ) ) {
22 // merk e S ta rt ze it
23 startzeit =millis() ;
24
25 // sch alte La mpe ein ( A usgan g HI )
26 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
27 }
28
29 // g ¨u ltige S ta rt ze it und seit de m mehr als 10 Sek un den
30 // ( 10 .000 Mi lli sekun de n ) v erstr ic hen ?
31 if (( sta rt ze it != 0) &&
32 (millis() > startzeit + 10000)) {
33 // ver giss S ta rt ze it
34 startzeit = 0;
35 // s cha lte L am pe aus ( A usga ng OFF )
36 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: OFF ) ;
37 }
38 }
Sketchbeschreibung
Die f¨
ur die Lampen-Zeitschaltung n¨
otigen Funktionen des ftDuino sind sehr einfach und die Anwendung l¨
asst sich mit der
einfachen FtduinoSimple-Bibliothek (siehe Abschnitt 9.1) abdecken.
Der Arduino-Sketch enth¨
alt eine leere setup()-Funktion, da keine Initialisierung n¨
otig ist. S¨
amtliche Funktionalit¨
at steckt
in der loop()-Funktion.
Die Taste an I1 wird ¨
uber input get() permanent abgefragt. Ist sie gedr¨
uckt, so wird die aktuelle Zeit seit Ger¨
atestart
in Millisekunden mit der Funktion millis() abgefragt und in der Variablen startzeit gespeichert und die Lampe wird
eingeschaltet. War die Lampe bereits an, dann bewirkt dieses zus¨
atzliche Einschalten nichts, aber der bereits gesetzte
Zeitwert in startzeit wird durch den aktuellen ersetzt.
Unabh¨
angig davon wird permanent getestet, ob startzeit einen g¨
ultigen Wert enth¨
alt und ob die aktuelle Systemzeit
bereits mehr als zehn Sekunden (10.000 Millisekunden) nach dem dort gespeicherten Wert liegt. Ist das der Fall, dann
sind seit dem letzten Tastendruck mehr als zehn Sekunden vergangen und die Lampe wird ausgeschaltet sowie der Wert in
startzeit auf Null gesetzt, um ihn als ung¨
ultig zu markieren.
Aufgabe 1: 20 Sekunden
Sorge daf¨
ur, dass die Lampe nach jedem Tastendruck 20 Sekunden lang an bleibt.
L¨
osung 1:
In Zeile 32 muss der Wert 10000 durch den Wert 20000 ersetzt werden, damit die Lampe 20000 Millisekunden, also 20
Sekunden eingeschaltet bleibt.
31 if (( sta rt ze it != 0) &&
32 (millis() > startzeit + 20000)) {
68 Kapitel 6. Experimente
Aufgabe 2: Keine Verl¨
angerung
Sorge daf¨
ur, dass ein weiterer Druck auf den Taster, w¨
ahrend die Lampe bereits leuchtet, die verbleibende Zeit nicht wieder
auf 10 Sekunden verl¨
angert.
L¨
osung 2:
Vor der Zuweisung in Zeile 23 muss eine zus¨
atzliche Abfrage eingef¨
ugt werden, die nur dann einen neue Wert setzt, wenn
bisher keiner gesetzt war. Beide Zeilen zusammen sehen dann so aus:
23 if (startzeit == 0)
24 startzeit =millis() ;
Expertenaufgabe:
Schließt Du statt der Lampe eine Leuchtdiode an (der rote Anschluss der Leuchtdiode muss an Ausgang O1), dann wirst Du
etwas merkw¨
urdiges bemerken, wenn das Licht eigentlich aus sein sollte: Die Leuchtdiode leuchtet trotzdem ganz schwach,
obwohl der Ausgang doch OFF ist. Wie kommt das?
Erkl¨
arung
Durch eine Lampe oder Leuchtdiode fließt ein Strom, wenn zwischen den beiden Anschl¨
ussen ein Spannungsunterschied
besteht. Den einen Anschluss haben wir fest mit Masse bzw. 0 Volt verbunden, der andere ist offen und wird von den Bauteilen
im ftDuino nicht mit Spannung versorgt. Anders als bei einem mechanischem Schalter ist diese Trennung bei dem im ftDuino
als sogenannter Ausgangstreiber verwendeten Halbleiterbaustein aber nicht perfekt. Ein ganz kleiner sogenannter Leckstrom
fließt trotzdem zur 9V-Versorgungsspannung. Dieser kleine Strom reicht nicht, die Lampe zum Leuchten zu bringen. Aber
er reicht, die wesentlich effizientere Leuchtdiode ganz leicht aufleuchten zu lassen.
L¨
asst sich daran etwas ¨
andern? Ja! Statt den Ausgang komplett unbeschaltet zu lassen k¨
onnen wir dem Ausgangstreiber im
ftDuino sagen, dass er den Ausgang fest auf Masse (0 Volt) schalten soll. Beide Anschl¨
usse der Leuchtdiode liegen dann
fest auf Masse und die Ein߬
usse irgendwelcher Leckstr¨
ome treten nicht mehr in Erscheinung. Dazu muss in der Zeile 36 die
Konstante OFF durch LO ersetzt werden. LO steht f¨
ur low, englisch niedrig und meint in diesem Fall 0 Volt. Die Leuchtdiode
erlischt nun komplett nach Ablauf der Zeit.
36 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: LO );
Direkt nach dem Einschalten des ftDuino leuchtet die Leuchtdiode aber nach wie vor. Vielleicht findest Du selbst heraus,
wie sich das ¨
andern l¨
asst. Tipp: Die bisher unbenutzte setup()-Funktion k¨
onnte helfen.
Mehr dazu gibt es im Abschnitt 6.8.
6.2 Not-Aus
Schwierigkeitsgrad:
Ein Not-Aus-Schalter kann Leben retten und scheint eine einfache Sache zu sein: Man dr¨
uckt einen Taster und die betreffende
Maschine schaltet sich sofort ab. Im Modell stellt ein XS-Motor mit Ventilator an Ausgang M1 die Maschine dar. Ein Taster
an Eingang I1 bildet den Not-Aus-Taster.
6.2.1 Sketch EmergencyStop
1/*
2Em er gen cy Sto p - Not - Aus
3
4(c ) 2017 by Till Ha rbaum < til l@har ba um . org >
5
6Schalte t einen V en ti la to r aus , s oba ld der Not - Aus - Tast er
6.2. Not-Aus 69
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
Abbildung 6.2: Not-Aus
7bet ¨a t ig t wi rd .
8*/
9
10 #include < F t du in oS imp le .h >
11
12 // Die Setup - Fu nkt ion wi rd e inm al b ei St ar t de s S yste ms au sgef ¨u hr t
13 void setup () {
14 // Ventilator bei Star t des Syst ems ein sc ha lt en
15 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: LEFT);
16
17 // Aus gang der i nt ernen roten LED ak ti vi er en
18 pinMode(LED_BUILTIN ,OUTPUT);
19 // und LED aus sc ha lt en
20 digitalWrite(LED_BUILTIN ,LOW);
21 }
22
23 // Die Loop - F un ktion wird en dlos immer und imm er wi eder au sge f ¨u hrt
24 void loop() {
25 // Teste , ob der Tas ter an I1 ge dr ¨u c kt ist
26 if (ftduino.input_get(Ftduino:: I1 ) ) {
27 // Moto r b remse n
28 ftduino.motor_set(Ftduino: : M1 ,Ftduino:: BR AKE );
29 // inte rn e rote LED e in sc ha lt en
30 digitalWrite(LED_BUILTIN ,HIGH);
31 }
32 }
Sketchbeschreibung
Der Sketch ist sehr kurz und einfach. In der setup()-Funktion wird in Zeile 15 bei Sketchstart der Motor gestartet. Zus¨
atzlich
wird in den Zeilen 18 bis 20 die rote interne Leuchtdiode des ftDuino f¨
ur die sp¨
atere Verwendung aktiviert, aber zun¨
achst
ausgeschaltet gelassen.
In der loop()-Funktion wird in Zeile 26 permanent abgefragt, ob der Not-Aus-Taster geschlossen wurde. Ist das der Fall,
dann wird der Motor in Zeile 28 sofort gestoppt und in Zeile 30 die rote Leuchtdiode eingeschaltet. Der Motor wird bewusst
per BRAKE gestoppt statt OFF. Auf diese Weise wird der Motor kurzgeschlossen und aktiv gebremst, w¨
ahrend er andernfalls
langsam auslaufen w¨
urde, was im Notfall eine Gefahr darstellen w¨
urde.
Aufgabe 1: Kabelbruch
Not-Taster sind zwar an vielen Maschinen vorhanden. Gl¨
ucklicherweise werden sie aber nur sehr selten wirklich ben¨
otigt.
Das hat den Nachteil, dass kaum jemand bemerken wird, wenn mit dem Not-Aus-Taster etwas nicht stimmt. Anf¨
alliger als
der Taster selbst sind oft die Kabel und es kann im Arbeitsalltag leicht passieren, dass ein Kabel besch¨
adigt wird. Oft sieht
man das dem Kabel nicht an, wenn z.B. die Ummantlung unbesch¨
adigt aussieht, durch zu starke Belastung aber dennoch
die Kupferleiter im Inneren unterbrochen sind. Der Resultat ist ein sogenannter Kabelbruch.
70 Kapitel 6. Experimente
Du musst kein Kabel durchreissen. Es reicht, wenn Du einen der Stecker am Kabel, das den Taster mit dem ftDuino
verbindet, heraus ziehst. Der Not-Aus-Taster funktioniert dann nicht mehr und die Maschine l¨
asst sich nicht stoppen. Eine
gef¨
ahrliche Situation.
L¨
osung 1:
Die L¨
osung f¨
ur das Problem ist ¨
uberraschend einfach. Wir haben unseren Not-Aus-Taster als Schließer angeschlossen. Das
bedeutet, dass der Kontakt geschlossen wird, wenn der Taster bet¨
atigt wird. Man kann den fischertechnik-Taster aber auch
als ¨
Offner verwenden. Der Kontakt ist dann im Ruhezustand geschlossen und wird bei Druck auf den Taster ge¨
offnet.
3
2
1
3
2
1
Abbildung 6.3: Kabelbruch-sicherer Not-Aus- ¨
Offner
Mit dem aktuellen Sketch geht die Maschine bei einem Kabelbruch sofort in den Notzustand, da der Taster ja sofort als
geschlossen erkannt wird. Also muss auch im Sketch die Logik herum gedreht werden. Das passiert durch folgende ¨
Anderung
in Zeile 26:
26 if (! ftduino.input_get(Ftduino:: I1 ) ) {
Man muss genau hinschauen, um den Unterschied zu sehen. Hinter der ¨
offnenden Klammer steht nun aus Ausrufezeichen, das
in der Programmiersprache C f¨
ur die logische Negation eines Ausdrucks steht. Die Bedingung wird nun also ausgef¨
uhrt, wenn
der Taster nicht geschlossen ist. Nach dieser ¨
Anderung sollte sich die Maschine wieder genau wie urspr¨
unglich verhalten.
Mit einer kleinen ¨
Anderung: Zieht man nun einen der Stecker am Not-Aus-Taster heraus, so stoppt die Maschine sofort.
Bei einem Kabelbruch w¨
urde das ebenfalls passieren.
So eine Schaltung nennt man auf englisch “Fail-Safe”: Wenn etwas kaputt geht, dann wechselt die Schaltung in einen
sicheren Zustand. Der fischertechnik-3D-Drucker verwendet diese Schaltung zum Beispiel f¨
ur die Endlagentaster. Ist hier ein
Kabel abgerissen, dann f¨
ahrt der Drucker seine Motoren nicht gewaltsam gegen die Endanschl¨
age der Achsen. Stattdessen
verweigert der Drucker die Arbeit komplett, sobald die Verbindung zu einem Endlagentaster unterbrochen ist.
Expertenaufgabe:
Ein Kabel kann nicht nur unterbrochen werden. Es kann auch passieren, dass ein Kabel z.B. so stark gequetscht wird, dass
die inneren Leiter Kontakt miteinander bekommen. Das passiert wesentlich seltener, stellt aber ebenfalls eine realistische
Gefahr dar.
Vor diesem Fall w¨
urde unsere verbesserte Notschaltung nicht sch¨
utzen und der Not-Aus-Taster w¨
urde in dem Fall wieder
nicht funktionieren. Wir brauchen also eine Variante, bei der weder der geschlossene noch der offene Zustand der Verbindung
als “gut” erkannt wird.
L¨
osung:
Die L¨
osung ist in diesem Fall etwas aufw¨
andiger. Es m¨
ussen nun mindestens drei Zust¨
ande unterschieden werden: “normal”,
“unterbrochen” und “kurzgeschlossen”. Reine Schalteing¨
ange k¨
onnen aber nur die beiden Zust¨
ande “geschlossen” und
“offen” unterscheiden.
Die L¨
osung ist, die analogen F¨
ahigkeiten der Eing¨
ange zu nutzen. Dazu kann man z.B. direkt am Taster einen 100 Ω-
Widerstand in die Leitung integrieren.
Im Normalfall ist der Taster geschlossen und der am Eingang I1 zu messende Widerstand betr¨
agt 100 Ω. Ist die Leitung
unterbrochen, dann ist der Widerstand unendlich hoch. Und ist die Leitung kurzgeschlossen, dann ist der Widerstand nahe
0Ω. Die Maschine darf also nur dann laufen, wenn der Widerstand nahe an 100 Ωist. Etwas Toleranz ist n¨
otig, da der
genau Wert des verwendeten Widerstands Fertigungstoleranzen unterworfen ist und auch der geschlossene Taster sowie sein
Anschlusskabel ¨
uber einen eigenen sehr geringen Widerstand verf¨
ugen, der den gemessenen Gesamtwiderstand beeinflusst.
6.3. Pulsweitenmodulation 71
3
2
1
Abbildung 6.4: Gegen Kabelbruch und Kurzschluss sicherer Not-Aus
Warum muss der Widerstand nahe am Taster angebracht werden? Was passiert, wenn er nahe am ftDuino eingesetzt wird
und dann ein Kurzschluss im Kabel zwischen Widerstand und Taster auftritt?
6.3 Pulsweitenmodulation
Schwierigkeitsgrad:
Wenn man eine Lampe mit variierender Helligkeit leuchten lassen m¨
ochte oder einen Motor mit regelbarer Geschwindigkeit
laufen lassen will, dann ben¨
otigt man eine M¨
oglichkeit, die Energieaufnahme der Lampe oder des Motors zu beeinflussen.
Am einfachsten klappt das mit einer einstellbaren Spannungsquelle. Bei h¨
oherer Spannung steigt auch die Energieaufnahme
der Lampe und sie leuchtet heller und der Motor dreht sich schneller, bei niedrigerer Spannung wird die Lampe dunkler und
der Motor dreht sich langsamer. F¨
ur die Analogausg¨
ange des ftDuino bedeutet das, dass sie eine zwischen 0 und 9 Volt
kontinuierlich (analog) einstellbare Spannung ausgeben k¨
onnen sollen, um Lampen und Motoren von v¨
olliger Dunkelheit
bzw. Stillstand bis zu maximaler Helligkeit bzw. Drehzahl betreiben zu k¨
onnen.
Der Erzeugung variabler Spannungen ist technisch relativ aufw¨
andig. Es gibt allerdings einen einfachen Weg, ein vergleich-
bares Ergebnis zu erzielen. Statt die Spannung zu senken schaltet man die Spannung periodisch nur f¨
ur sehr kurze Momente
ein. Schaltet man die Spannung z.B. nur 50% der Zeit ein und 50% der Zeit aus, so wird ¨
uber die Gesamtzeit gesehen nur die
H¨
alfte der Energie ¨
ubertragen. Ob man das Ergebnis als Blinken der Lampe oder als Stottern des Motors wahrnimmt oder
ob die Lampe einfach mit halber Helligkeit leuchtet und der Motor mit halber Drehzahl dreht ist von der Geschwindigkeit
abh¨
angig, mit der man die Spannung ein- und ausschaltet.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
3
2
1
Abbildung 6.5: Pulsweitenmodulation
6.3.1 Sketch Pwm
1/*
2Pwm - Pulsweitenmodulation
3
4(c ) 2017 by Till Ha rbaum < til l@har ba um . org >
5*/
6
7#include < F t du in oS imp le .h >
8
9uint16_ t s ch al tz ei t = 819 2; // 8192 e nt sp richt je 1/2 S ekund e an und aus
10
11 // Die Setup - Funktion w ird einmal ausg ef ¨u hrt , wenn Reset gedr ¨u ckt oder
12 // das Bo ar d ges tar tet wi rd .
72 Kapitel 6. Experimente
13 void setup () { }
14
15 // w ar te d ie a nge geb ene Ze it . De r " zei t "- Wert 81 92 so ll d ab ei eine r h albe n S eku nde
16 // e nt spr ech en . Es mu ss al so " zeit " mal 5 000 00/ 819 2 Mi kr ose kun den ge war tet w er den
17 void war te (u int 16_t zeit ) {
18 whi le (zeit - -)
19 _delay_us( 50 0000/ 81 92) ;
20 }
21
22 // Die Loop - F un ktion wird en dlos immer und imm er wi eder au sge f ¨u hrt
23 void loop() {
24 static uint8 _t a n_a us =false ;/ / d er ak tue ll e A us gang - an / aus - Z ust and
25 static uint8_t i1=false ,i2 =fal se ;// le tzter Zustand der Tast en an I1 und I2
26
27 // ist die Tas te an I1 gedr ¨u ckt ?
28 if (ftduino.input_get(Ftduino:: I1 ) ) {
29 // und war die Taste v orh er nicht gedr ¨u ckt und ist die
30 // akt ue ll e S ch al tz ei t kleine r 81 92?
31 if (! i1 && ( schaltzeit < 8 19 2) ) {
32 // dann v er do pp le die S ch al tz ei t
33 sc ha lt ze it *= 2;
34 // warte eine Mill isekunde , fa lls die Tast e nachpre ll t
35 _delay_ms(1) ;
36 }
37 // merke , dass die Ta ste an I1 zur Zeit gedr ¨u ckt ist
38 i1 =true;
39 }else
40 // merke , dass die Ta ste an I1 zur Zeit nicht gedr ¨u ckt ist
41 i1 =false ;
42
43 // ist die Tas te an I2 gedr ¨u ckt ?
44 if (ftduino.input_get(Ftduino:: I2 ) ) {
45 // und war die Taste v orh er nicht gedr ¨u ckt und ist die
46 // a kt ue lle S c hal tz ei t gr ¨o ß er 1?
47 if (! i2 && ( schaltzeit > 1) ) {
48 // dann h albiere die Schaltzeit
49 sc ha lt ze it /= 2;
50 // warte eine Mill isekunde , fa lls die Tast e nachpre ll t
51 _delay_ms(1) ;
52 }
53 // merke , dass die Ta ste an I2 zur Zeit gedr ¨u ckt ist
54 i2 =true;
55 }else
56 // merke , dass die Ta ste an I2 zur Zeit nicht gedr ¨u ckt ist
57 i2 =false ;
58
59 // schalt e den Au sg and O2 je nach Zusta nd der an_aus - V ar iable an oder aus
60 if (an_aus)
61 // wenn der ak tu elle an_aus - Zust and wahr ist , d ann schalt e den Au sgang ein
62 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
63 else
64 // wenn der ak tu elle an_aus - Zust and un wah r ist , dann scha lt e den Au sgang aus
65 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: OFF ) ;
66
67 // wart e die aktu el le Sc ha lt ze it
68 war te (s chaltzeit ) ;
69
70 // w echs el den an_aus - Zus tand
71 an_aus = ! an_aus;
72 }
Sketchbeschreibung
Der Sketch schaltet den Ausgang O1 in der loop()-Funktion in den Zeilen 60 bis 71 kontinuierlich ein und aus. Je nach
Wert der Variable an aus wird der Ausgang in Zeile 62 auf 9 Volt (HI) geschaltet oder in Zeile 65 ausgeschaltet (von der
Spannungsversorgung getrennt). In Zeile 71 wird in jedem Durchlauf der loop()-Funktion der Zustand der Variable an aus
gewechselt, so dass der Ausgang im in jedem Durchlauf im Wechsel ein- und ausgeschaltet wird.
Nach jeden An/Aus-Wechsel wird in Zeile 68 etwas gewartet. Wie lange gewartet wird steht in der Variablen schaltzeit
Sie gibt die Wartezeit in 1
/8192 halben Sekunden an. Dazu wird in der Funktion wait() in Zeile 19 so oft 500000
/8192
6.3. Pulsweitenmodulation 73
Mikrosekunden gewartet wie in der Variablen schaltzeit angegeben. Warum halbe Sekunden? Weil zweimal pro Zyklus
gewartet wird, einmal wenn der Ausgang eingeschaltet ist und einmal wenn er ausgeschaltet ist. Wird jeweils eine halbe
Sekunde gewartet, so dauert der gesamte Zyklus eine Sekunde und der Ausgang wird einmal pro Sekunde f¨
ur eine halbe
Sekunde eingeschaltet. Der Ausgang wechselt also mit einer Frequenz von 1
/Sek. oder einem Hertz.
Durch einen Druck auf den Taster an I1 (Zeile 28) kann der Werte der Variablen schaltzeit verdoppelt (Zeile 33) und
mit einem Druck auf den Taster an I2 (Zeile 44) halbiert (Zeile 49) werden. Dabei wird der Wert von Schaltzeit auf den
Bereich von 1 (Zeile 47) und 8192 (Zeile 31) begrenzt. Nun wird auch klar, warum dieser merkw¨
urdig “krumme” Wert 8192
gew¨
ahlt wurde: Da 8192 eine Zweierpotenz (213) ist l¨
asst der Wert sich ohne Rundungsfehler bis auf 1 hinunterteilen und
wieder hochmultiplizieren.
Da die Tasten nur beim Wechsel zwischen an und aus abgefragt werden muss man den Taster bei niedrigen Frequenzen
einen Moment gedr¨
uckt halten, bis sich die Blinkfrequenz ver¨
andert.
Wenn der Sketch startet leuchtet die Lampe einmal pro Sekunde f¨
ur eine halbe Sekunde auf. Ein (langer) Druck auf
den Taster an I2 halbiert die Wartezeit und die Lampe blinkt zweimal pro Sekunde. Nach einem zweiten Druck auf den
Taster blinkt sie viermal usw. Nach dem sechsten Druck blinkt sie 32 mal pro Sekunde, was nur noch als leichtes Flackern
wahrnehmbar ist und nach dem siebten Druck gar 64 mal. Frequenzen oberhalb circa 50 Hertz kann das menschliche Auge
nicht mehr au߬
osen und die Lampe scheint mit halber Helligkeit zu leuchten. Die Frequenz weiter zu erh¨
ohen hat dann
keinen erkennbaren Effekt mehr.
Aufgabe 1: Die tr¨
age Lampe
Es ist in diesem Aufbau nicht nur das menschliche Auge, das tr¨
age ist. Die Lampe ist ebenfalls tr¨
age. Es dauert eine Zeit,
bis sich ihr Gl¨
uhfaden aufheizt und die Lampe leuchtet und es dauert auch eine Zeit, bis sich der Gl¨
uhfaden wieder so weit
abk¨
uhlt, dass die Lampe nicht mehr leuchtet.
Wesentlich schneller als Gl¨
uhlampen sind Leuchtdioden. In ihnen muss sich nichts aufheizen oder abk¨
uhlen, sondern das
Licht entsteht direkt durch optoelektrische Effekte im Halbleitermaterial der Leuchtdiode. Schließt man statt der Lampe
eine Leuchtdiode an (rot markierter Anschluss an Ausgang O1), dann sieht das Verhalten zun¨
achst ¨
ahnlich aus und wieder
scheint ab einer Frequenz von 64 Hertz die Leuchtdiode gleichm¨
aßig mit halber Helligkeit zu leuchten. Viele Menschen
nehmen 64 Hz allerdings noch als leichtes Flimmern wahr und erst ab 100Hz redet man von einer wirklich flimmerfreien
Darstellung.
Man kann das Flimmern der Leuchtdiode aber auch bei diesen Frequenzen noch beobachten, wenn sich die Leuchtdiode
bewegt. Nutzt man ein etwas l¨
angeres Kabel, so dass die Leuchtdiode sich frei bewegen l¨
asst und bewegt sie dann in einer
etwas abgedunkelten Umgebung schnell hin- und her, so wird der Eindruck einer Reihe von unterbrochenen Leuchtstreifen
entstehen.
Abbildung 6.6: Muster bei schneller Bewegung der flackernden Leuchtdiode
Je h¨
oher die PWM-Frequenz ist, desto k¨
urzer sind die sichtbaren Leuchtstreifen.
Dieses Experiment kann man auch mit der Lampe wiederholen. Durch die Tr¨
agheit der Lampe sieht man nur einen durch-
gehenden Leuchtstreifen. Allerdings sollte man nicht allzu wild vorgehen, da der empfindliche Gl¨
uhfaden einer leuchtenden
Lampe bei Ersch¨
utterung leicht kaputt geht. Leuchtdioden sind auch in dieser Beziehung robust und lassen sich selbst von
starken Ersch¨
utterungen nicht beeindrucken.
74 Kapitel 6. Experimente
Aufgabe 2: T¨
one aus dem Motor
Ein Motor ist ebenfalls tr¨
age und nicht in der Lage, beliebig schnellen An-/Aus-Signalen zu folgen. Schon bei recht niedrigen
PWM-Frequenzen dreht sich der Motor kontinuierlich mit halber Drehzahl. Das dabei vornehmlich zu vernehmende Ger¨
ausch
ist das Laufger¨
ausch des Motors.
Wenn man den Motor aber mechanisch blockiert, indem man ihn z.B. mit der Hand festh¨
alt, dann wird das Laufger¨
ausch
unterdr¨
uckt und ein anderer Effekt wird h¨
orbar: Die Spulen im Motor wirken wie ein Lautsprecher und man kann die PWM-
Frequenz bei blockiertem Motor als Ton h¨
oren. Eine Ver¨
anderung der PWM-Frequenz hat dabei einen deutlich h¨
orbaren
Unterschied der Tonh¨
ohe zur Folge.
Je h¨
oher die PWM-Frequenz, desto h¨
oher der am blockierten Motor h¨
orbare Ton.
Aufgabe 3: Nachteil hoher PWM-Frequenzen
Im Fall der Lampe scheint eine h¨
ohere PWM-Frequenz ein reiner Vorteil zu sein, da das Flimmern mit h¨
oherer Frequenz
abnimmt. Am Motor kann aber ein negativer Effekt beobachtet werden.
L¨
auft der Motor frei, so h¨
angt die geh¨
orte Tonh¨
ohe des Motor-Laufger¨
auschs mit seiner Drehgeschwindigkeit zusammen,
w¨
ahrend das PWM-Ger¨
ausch der vorigen Aufgabe in den Hintergrund tritt. Je schneller der Motor dreht, desto h¨
oher die
Frequenz des Laufger¨
auschs und umgekehrt.
Erh¨
oht man nun die PWM-Frequenz, dann sinkt die Frequenz der T¨
one, die der Motor abgibt leicht. Er wird offensichtlich
mit steigender PWM-Frequenz langsamer. Dieser Effekt ist damit zu erkl¨
aren, dass der Motor eine sogenannte induktive Last
darstellt. Er besteht im Wesentlichen aus Spulen, sogenannten Induktoren. Der Widerstand einer induktiven Last ist abh¨
angig
von der Frequenz einer angelegten Wechselspannung. Und nichts anderes ist das durch die PWM erzeugte An-/Aus-Signal.
Je h¨
oher die Frequenz, desto h¨
oher der Widerstand der Spule und es fließt weniger Strom durch die Spule.
Es ist technisch m¨
oglich, die Ausgangsspannung zu gl¨
atten und diesen Effekt zu mildern. Diese Auslegung so einer Gl¨
attung
ist allerdings von der verwendeten PWM-Frequenz und der Stromaufnahme des Motors abh¨
angig. Außerdem beeinflusst sie
das generelle Schaltverhalten des Ausgangs. Der Einsatz einer entsprechenden Gl¨
attung im ftDuino kommt daher nicht in
Frage, da die universelle Verwendbarkeit der Ausg¨
ange dadurch eingeschr¨
ankt w¨
urde.
Ziel bei der Auswahl der PWM-Frequenz ist also eine Frequenz, die hoch genug ist, um Lampenflackern oder Motorstottern zu
verhindern, die aber dennoch m¨
oglichst gering ist, um induktive Widerst¨
ande in den Wicklungen der Motoren zu minimieren.
Eine PWM-Frequenz von 100-200Hz erf¨
ullt diese Bedingungen.
Motordrehzahl in Abh¨
angigkeit des PWM-Verh¨
altnisses
Die Motordrehzahl l¨
asst sich durch das Verh¨
altnis der An- und Ausphasen w¨
ahrend der Pulsweitenmodulation beeinflussen.
In den bisherigen Versuchen waren die An- und Ausphase jeweils gleich lang. Ver¨
andert man das Verh¨
altnis der beiden
Phasen, dann l¨
asst sich die Helligkeit einer Lampe oder die Drehzahl eines Motors steuern. Die PWM-Frequenz kann dabei
konstant bleiben.
0%
25%
50%
75%
100%
Abbildung 6.7: Ausgew¨
ahlte PWM-Verh¨
altnisse von 0 bis 100%
Je l¨
anger die eingeschaltete Phase gegen¨
uber der ausgeschalteten, desto heller leuchtet die Lampe und desto schneller
dreht der Motor. Der genaue Zusammenhang zwischen Lampenhelligkeit und PWM-Verh¨
altnis ist mangels entsprechender
Messm¨
oglichkeit nicht einfach festzustellen. Die sogenannten Encoder-Motoren haben aber eine eingebaute M¨
oglichkeit zur
Geschwindigkeitsmessung. Im Fall der TXT-Encodermotoren erzeugen diese Encoder 63 Signalimpulse pro Umdrehung der
6.4. Schrittmotoransteuerung 75
Achse. Man kann also durch Auswertung der Encodersignale an den Z¨
ahlereing¨
angen des ftDuino die Drehzahl des Motors
feststellen.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 6.8: Anschluss des TXT-Encoder-Motors zur PWM-abh¨
angigen Drehzahlmessung
Das Beispiel Datei Beispiele Ftduino PwmSpeed regelt das An-/Ausverh¨
altnis der PWM langsam von 0 auf
100% hoch und misst dabei kontinuierlich f¨
ur jeweils eine Sekunde die am Eingang C1 anliegenden Impulse. Diese werden in
Umdrehungen pro Minute umgerechnet und ausgegeben. Dabei kommt die vollst¨
andige Bibliothek Ftduino zum Einsatz,
die die eigentliche Erzeugung der PWM-Signale bereits mitbringt. Die Erzeugung des PWM-Signals passiert vollst¨
andig im
Hintergrund, so dass der Sketch selbst lediglich den Motor startet und dann eine Sekunde wartet.
Speist man die so gewonnenen Daten in den sogenannten “seriellen Plotter”, der sich im Men¨
u der Arduino-IDE unter
Werkzeuge Serieller Plotter befindet, so kann man die Messergebnisse anschaulich visualisieren.
Abbildung 6.9: Leerlaufdrehzahl des TXT-Encoder-Motors in Abh¨
angigkeit des PWM-Verh¨
altnisses
Auf der horizontalen Achse ist das PWM-Verh¨
altnis aufgetragen, beginnend mit “dauerhaft aus” ganz links bis “dauerhaft
an” ganz rechts. Auf der vertikalen Achse ist die gemessene Drehzahl in Umdrehungen pro Minute dargestellt. Man sieht,
dass der Zusammenhang im Leerlauf nicht linear ist. Bereits bei nur circa 25% der Zeit eingeschaltetem Signal wird 90%
der maximalen Motordrehzahl erreicht.
Man kann z.B. indem man den Motor eine konstante Last anheben l¨
asst nachpr¨
ufen, wie sich diese Kurve und Last ver¨
andert.
6.4 Schrittmotoransteuerung
Schwierigkeitsgrad:
G¨
angige Elektromotoren, wie sie ¨
ublicherweise in Spielzeug eingesetzt werden sind sogenannte Asynchronmotoren. Diese in
der Regel mit Gleichspannung versorgten Motoren zeichnen sich dadurch aus, dass sie beim Anlegen einer Spannung sofort
76 Kapitel 6. Experimente
anfangen, sich zu drehen. Die Drehzahl richtet sich dabei nur indirekt nach ¨
außeren Einfl¨
ussen und der Motor dreht letztlich
so schnell es ihm m¨
oglich ist. F¨
ur viele Anwendungen ist diese Art Motor sehr gut geeignet. Modellautos lassen sich ohne
weitere Steuerung motorisieren und fahren auf mit diesen Motoren so schnell wie gerade m¨
oglich. Auch fischertechnik setzt
diese Motoren in den meisten F¨
allen ein und der ftDuino erlaubt es, sie direkt an jeweils einen Motorausgang M1 bis M4
anzuschließen.
Aber es gibt Anwendungen, in denen diese Motorfamilie sehr große Schw¨
achen zeigt. So ist es sehr schwierig, mit einfachen
Asynchronmotoren eine exakte Drehzahl zu erreichen bzw. eine exakte Position anzufahren. Die Encoder-Motoren von
fischertechnik versuchen dies durch zus¨
atzliche Hardware zu erm¨
oglichen. Aber auch diesem Vorgehen sind Grenzen gesetzt,
speziell bei den fischertechnik-Encoder-Motoren, die nicht in der Lage sind, die Drehrichtung zu erfassen.
Abbildung 6.10: 17HS13-Schrittmotor am ftDuino
F¨
ur Aufgaben, bei denen es auf exaktes reproduzierbares Verhalten des Motors ankommt, gibt synchron arbeitende Motoren
wie die sogenannten Schrittmotoren. G¨
angige Anwendungen daf¨
ur sind heutzutage Scanner und 3D-Drucker, aber auch die
fr¨
uher verwendeten Diskettenlaufwerke und fr¨
uhe Festplatten verwendeten Schrittmotoren. Erkennbar ist die Nutzung von
Schrittmotoren auch am charakteristischen Betriebsger¨
ausch, das findige T¨
uftler sogar nutzen, um mit solchen Motoren
Musik zu erzeugen1.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
3
2
1
Abbildung 6.11: Anschluss des Schrittmotors an den ftDuino
G¨
angige Schrittmotoren bestehen aus einem drehbar gelagerten Anker aus Permanentmagneten, der von Elektromagneten
umgeben ist. Der Permanentmagnet richtet sich entsprechend den ihm umgebenden Magnetfeldern aus. Im Spannungslosen
1Im Internet leicht zu finden unter dem Stichwort “Floppymusik”
6.4. Schrittmotoransteuerung 77
Zustand l¨
asst sich die Achse des Motors vergleichsweise leicht drehen. Der dabei sp¨
urbare Widerstand resultiert daraus, dass
der Permanentmagnet von den Eisenkernen der Elektromagnete auch im spannungslosen Zustand angezogen wird.
Abbildung 6.12: Vereinfachtes Schema eines Schrittmotors
Der in der Abbildung dargestellte vereinfachte Schrittmotor verf¨
ugt ¨
uber einen Permanentmagneten und zwei Elektromagne-
te. Reale Schrittmotoren haben in der Regel mehr als zwei Spulen und der Anker bildet auch mehr als nur zwei magnetische
Pole ab. Auf das Funktionsprinzip hat diese Vereinfachung keine Auswirkungen.
¨
Ubliche sogenannte bipolare Schrittmotoren verf¨
ugen ¨
uber vier Anschl¨
usse, jeweils zwei f¨
ur jeden der beiden Elektromagneten.
Durch Anlegen einer Spannung werden die Elektromagnete magnetisiert. In der Folge richtet sich der Anker entsprechend
aus. Die Polarit¨
at der angelegten Spannung bestimmt die Richtung des Magnetfelds der Elektromagneten.
6.4.1 Vollschrittsteuerung
Sind immer beide Spulen unter Spannung, so gibt es vier verschiedene Ausrichtungen der beiden Elektromagnetfelder und
der Anker nimmt jeweils vier unterschiedliche Positionen ein. Wird eine entsprechende sich wiederholende Signalfolge an
die Elektromagneten angelegt, so folgt der Anker den Signalen und dreht sich. Er folgt dabei exakt den sich wechselnden
Magnetfeldern und dreht sich synchron zum angelegt Signalmuster. Geschwindigkeit und Position des Motors sind auf diese
Weise exakt vorhersagbar. Sind immer alle Spulen unter Spannung und durchl¨
auft der Zyklus daher genau vier Zust¨
ande,
so spricht man von einer Vollschrittsteuerung.
L1
L2
L1
L2
L1
L2
L1
L2
L1.A
L1.B
L2.A
L2.B
A
B
A B
A
B
A B
A
B
A B
A
B
A B
Abbildung 6.13: Vollschrittsteuerung eines Schrittmotors
Ein Sketch, der kontinuierlich das entsprechende Signalmuster erzeugt sieht folgendermaßen aus:
while (1) {
ftduino.motor_set(Ftduino: : M1 ,Ftduino:: LEFT);
delay (5) ;
ftduino.motor_set(Ftduino: : M2 ,Ftduino:: LEFT);
delay (5) ;
ftduino.motor_set(Ftduino: : M1 ,Ftduino:: RI GHT );
delay (5) ;
ftduino.motor_set(Ftduino: : M2 ,Ftduino:: RI GHT );
78 Kapitel 6. Experimente
delay (5) ;
}
Ein vollst¨
andiges Beispiel findet sich in der Arduino-IDE unter Datei Beispiele FtduinoSimple StepperMotor .
W¨
ahrend sich der dargestellte vereinfachte Schrittmotor pro Signal¨
anderung um 90 dreht und daher nach vier Schritten
eine volle Umdrehung absolviert hat haben reale Schrittmotoren eine h¨
ohere Au߬
osung. G¨
angig ist ein Schrittwinkel von
1,8 . Erst nach 200 Schritten hat sich so ein Motor einmal komplett gedreht. Da im abgebildeten Listing nach jedem Schritt
5ms gewartet wird werden genau 200 Schritte pro Sekunde erzeugt. Ein g¨
angiger 1,8 -Motor w¨
urde sich genau einmal pro
Sekunden drehen.
F¨
ur die Experimente am ftDuino muss ein Motor gew¨
ahlt werden, der mit den 9V-Ausg¨
angen des ftDuino kompatibel ist.
Der hier verwendete 17HS13 ist f¨
ur eine Betriebsspannung von 12V ausgelegt, arbeitet aber auch mit den fischertechnik-
¨
ublichen 9 Volt zuverl¨
assig. Die Motoren des fischertechnik-Plotters 305712von 1985 waren f¨
ur 6 Volt ausgelegt. Sollen
diese Motoren am ftDuino betrieben werden, so ist dieser mit 6 statt den ¨
ublichen 9 Volt zu versorgen.
Die Abbildungen der Abl¨
aufe beinhalten in der unteren H¨
alfte jeweils die Signalverl¨
aufe an den vier Anschl¨
ussen des Motors.
Die Signalverl¨
aufe sind farblich entsprechend der sich ergebenden Megnetfeldrichtung hinterlegt. Man sieht, wie die beiden
Anschl¨
usse eines Magneten immer genau gegenteilig angesteuert werden und sich das Magnetfeld beim Wechsel der Signale
¨
andert. Die abgebildete Farbe entspricht jeweils der Polarit¨
at der dem Anker zugewandten Seite des Elektromagneten.
6.4.2 Halbschrittsteuerung
Eine h¨
ohere Winkel-Au߬
osung erreicht man, wenn man den Schrittmotor im sogenannten Halbschrittbetrieb ansteuert. Der
Signalzyklus besteht in dem Fall nicht mehr aus vier sondern aus acht Schritten. In jedem zweiten Schritt wird einer der
beiden Elektromagneten abgeschaltet, so dass sich der Anker nur nach dem verbliebenen Magneten ausrichtet. Die sich
dadurch ergebenden vier Zwischenzust¨
ande sind von den resultierenden Winkel genau zwischen den vier Zust¨
anden der
Vollschrittsteuerung angeordnet. Der Motor kann also die doppelt so viele Winkel ansteuern und entsprechend genauer
positioniert werden.
L1
L2
L1
L2
L1
L2
L1
L2
L1.A
L1.B
L2.A
L2.B
A
B
A B
A
B
A B
A
B
A B
A
B
A B
L1
L2
L1
L2
L1
L2
L1
L2
A
B
A B
A
B
A B
A
B
A B
A
B
A B
Abbildung 6.14: Halbschrittsteuerung eines Schrittmotors
In der Abbildung ist sichtbar, dass sich die beiden Signale zur Ansteuerung eines Elektromagneten nicht mehr gleichzeitig
¨
andern, sondern dass es einen Versatz gibt, w¨
ahrenddessen beide Signale auf gleichem Pegel liegen. Der Magnet steht zu
dieser Zeit nicht unter Spannung und hat kein Magnetfeld. Die Signalverl¨
aufe sind zu dieser Zeit daher nicht farbig hinterlegt.
Der Nachteil der Halbschrittsteuerung liegt darin, dass in den Zeiten, in denen nur ein Elektromagnet aktiv ist die Kraft des
Motors reduziert ist.
Timer-Interrupt betriebener Schrittmotor
Der im vorhergehenden Abschnitt verwendete Sketch zur Schrittmotoransteuerung hat vor allem einen großen Vorteil: Er
ist anschaulich. Das Problem ist aber, dass die Ansteuerung Motors permanente Signalwechsel ben¨
otigt und daher die
Motorfunktionen im Sketch permanent aktiv sein m¨
ussen, damit der Motor sich dreht. Der Sketch verbringt praktisch
die ganze Zeit damit in den diversen delay()-Funktionsaufrufen, auf den n¨
achsten Signalwechsel zu warten. Der gr¨
oßte
2fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=30571
6.4. Schrittmotoransteuerung 79
Nachteil: W¨
ahrend der Sketch einen Motor bedient kann er kaum etwas anderes tun. Einen zweiten Motor gleichzeitig mit
gegebenenfalls sogar unterschiedlicher Drehzahl laufen zu lassen ist mit diesem einfachen Sketch kaum zu realisieren.
Das gleiche Problem stellte sich w¨
ahrend der Entwicklung des ftDuino bereits mit den ¨
ubrigen Komponenten des ftDuino
auch die Auswertung der Analogeing¨
ange, die PWM-Drehzahlregelung der Motorausg¨
ange und die Auswertung der Z¨
ahler
beanspruchen permanent eine aktive Mitarbeit des Mikrocontrollers. Trotzdem muss der Anwender daf¨
ur in seinem Sketch
keine Funktion vorsehen. All diese Dinge passieren weitgehend unbemerkt im Hintergrund. Solch eine Hintergrundfunktion
w¨
are auch f¨
ur den Betrieb des Schrittmotors w¨
unschenswert.
Mikrocontroller wie der ATmega32u4 des ftDuino bestehen aus einem Mikroprozessor (der eigentlichen Recheneinheit)
und diversen zus¨
atzlichen Hardwarekomponenten wie z.B. USB-Schnittstellenfunktionen. Unter anderem verf¨
ugt der AT-
mega32u4 ¨
uber einige sogenannte Timer. Einen Timer kann man sich wie eine unabh¨
angig vom eigentlichen Prozessor
arbeitende Uhr vorstellen. Man kann per Software festlegen, wie schnell die Uhr laufen soll und ob zu bestimmten Zeitpunk-
ten gegebenenfalls bestimmte Dinge passieren sollen, aber das eigentliche Fortschreiten der Uhrzeit geschieht automatisch
und ohne weiteres Zutun eines auf dem Prozessor ausgef¨
uhrten Sketches. Eines der Dinge, die von so einem Timer regelm¨
aßig
ausgel¨
ost werden k¨
onnen ist eine sogenannte Unterbrechungsanforderung (englisch Interrupt). Sie veranlasst den Prozessor,
zu unterbrechen, was auch immer er gerade tut und sich f¨
ur kurze Zeit einer anderen Aufgabe zu widmen.
Diese Art von Unterbrechung ist ideal, um z.B. einen Schrittmotor zu steuern. Soll der Schrittmotor z.B. 200 Schritte pro
Sekunde bewegt werden, so kann ein Timer so programmiert werden, dass der Prozessor alle 5 Millisekunden unterbrochen
wird. In dieser Unterbrechung muss der Prozessor dann das Magnetfeld des Motors einen Schritt weiter drehen und sich
dann wieder seiner normalen Aufgabe widmen.
Das folgende Code-Segment programmiert den Timer 1 des ATmega32u4 so, dass die sogenannte Interrupt-Service-Routine
exakt alle 5 Millisekunden ausgef¨
uhrt wird. Der Motor ließe sich so durch passenden Programmcode innerhalb dieser Routine
v¨
ollig unabh¨
angig vom Hauptprogramm des Sketches betreiben.
1#include < F t du in oS imp le .h >
2
3// die s oge na nnt e I nterr up t - Servi ce - Ro uti ne ( ISR ) w ir d
4// nicht vom Ske tch selbst zur Ausf ¨u hrung gebracht , sonder n
5// die H ar dware des A Tm eg a3 2u l¨o st die Ausf ¨u hrung auf Basis
6// eines Timer - Ereigniss es aus
7ISR (TIMER1_COMPA_vect) {
8// D iese F unk tio n w ir d a ll e 5 ms aus gef ¨u hrt .
9// Das W ei te rdrehen des Schr itt motor - M agnet fe ld es
10 // k¨o nnte z . B . hier g es ch eh en .
11 // ...
12 }
13
14 void setup () {
15 // K onf ig ur ation des Ti mer 1 des ATmega32u4 , die genaue
16 // Be sc hr ei bun g der R eg is ter findet si ch in Kap itel 14
17 // des Dat en bl at t :
18 // http :// ww1 . microc hip . com / dow nloads /en / De viceDoc / Atmel -7766 -8 - bit -AVR - ATmega16 U4 -32
U4_Datasheet.pdf
19
20 // Timer 1 soll im s og enannte n CTC - Modus s ch al ten mit OCR1A
21 // als obere Grenz e . Der Timer l¨a uft mit 1/2 56 CPU - Takt . Dieser
22 // w ie de ru m b et r ¨a gt 16 MHz , de r Ti me r l ¨a uf t als o mit 6 2 ,5 kHz .
23 // Um den Motor 200 S ch ri tte pro S ekunde zu dr ehe n muss der
24 // Motor i mmer dann einen Schri tt machen , wenn der Ti mer 312
25 // ( 62 500 /2 00) s ein er Z ¨a h lsc hri tt e du rch lau fe n hat .
26 TCCR1A = 0;
27 TCCR1B = (1 < < WGM1 2 ) | (1 < < CS12); // Sta rte T ime r 1 mit 1/256 F _CPU = 62.5 kHz
28 TCCR1C = 0;
29
30 // E re ig ni s a us l ¨o sen wen n 6 240 0/2 00 Z ¨a h ler sc hri tt e e rr eich t sind
31 TCNT1 = 0;
32 OCR1A = 62 50 0/ 20 0;
33
34 // Erei gn i se rz eug un g bei E rr ei ch en der Z ielsc hr it te ausl ¨osen
35 TIMSK1 = (1 < < OCIE1A) ;
36 }
37
38 void loop() {
39 // die H auptr ou ti ne kann b el ie big ge nutzt wer den und
40 // de r T im er 1 - I nt er rup t wird u nabh ¨a n gi g re ge lm ¨a ß ig
41 // a usg ef ¨u hr t
80 Kapitel 6. Experimente
42 }
Das vollst¨
andige Beispiel findet sich unter Datei Beispiele FtduinoSimple StepperMotorSrv . Es entspricht
weitgehend der vorgeschlagenen Nutzung von Timer 1. Ein zweiter Motor ließe sich z.B. ebenfalls im Hintergrund und
unabh¨
angig vom bereits vorhandenen Motor und auch unabh¨
angig vom Hauptprogramm des Sketches durch Timer 3
steuern. Mit zwei Schrittmotoren ist so recht elegant z.B. ein sogenannter Plotter zu realisieren wie in Abschnitt 7.5 gezeigt.
6.5 Servomotoransteuerung
Schwierigkeitsgrad:
Neben den normalen Gleichspannungsmotoren und den Schrittmotoren aus Abschnitt 6.4 gibt es eine dritte vor allem im
Modellbau verbreitete Art von Motoren, die sogenannten Servos. fischertechnik vertreibt einen Servo unter der Artikelnummer
1322923.
Technisch bestehen Servos aus einfachen Gleichstrommotoren und einer einfachen Elektronik. Eine Messmechanik meldet
dieser Elektronik st¨
andig den aktuellen Stellwert (Winkel) des Servos. Die Elektronik vergleicht diesen mit einem externen
Sollwert und regelt den Motor bei Bedarf nach. Das Servo folgt also mit seinem Drehwinkel einem externen Sollwert.
Servos haben daher ein drei-adriges Anschlusskabel. Zwei Adern werden zur Spannungsversorgung (rot = 6 Volt, braun =
Masse) verwendet, die dritte Ader (orange) ¨
ubertr¨
agt den Sollwert. Es lassen sich handels¨
ubliche Servos verwenden, aber
auch der fischertechnik-Servo 1322924aus dem 5405855-PLUS Bluetooth Control Set. Auch der fischertechnik RC-Servo
302756von 1983 m¨
usste auf diese Weise verwendbar sein. Das wurde jedoch bisher nicht ¨
uberpr¨
uft.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O 2
O3 O 4
O5 O 6
O7 O 8
C1
C2
C3
C4
I²C
(a) Versorgung durch den ftDuino
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O 2
O3 O 4
O5 O 6
O7 O 8
C1
C2
C3
C4
I²C
7806
(b) Versorgung mit 7806-Regler
Abbildung 6.15: Anschluss des Servos an den ftDuino
Da Servos f¨
ur eine Betriebsspannung von 6 Volt ausgelegt sind und oft auch bei 5 Volt noch funktionieren ist eine Ver-
sorgung aus den internen 5 Volt des ftDuino ¨
uber den I2C-Anschluss m¨
oglich wie in Abbildung 6.15(a) dargestellt. Bei
dieser Versorgung ist Vorsicht geboten, da die Stromaufnahme des Servos 100mA nicht ¨
uberschreiten darf, um die interne
Stromversorgung des ftDuino nicht zu ¨
uberlasten. Die meisten Servos ¨
uberschreiten diesen Wert deutlich und sollten daher
nicht direkt aus dem ftDuino versorgt werden.
3fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=132292
4fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=132292
5fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=540585
6fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=30275
6.5. Servomotoransteuerung 81
6.5.1 Externe 6-Volt-Versorgung
Wesentlich robuster und kaum aufw¨
andiger ist die Versorgung ¨
uber einen externen Spannungsregler z.B. vom Typ 7806,
der unter dieser Bezeichnung leicht im Online-Handel zu finden ist. Dieser sogenannte L¨
angsregler kann direkt an einen
der 9-Volt-Ausg¨
ange des ftDuino angeschlossen werden und stellt an seinem Ausgang eine auf 6 Volt reduzierte Spannung
bereit.
Ben¨
otigte Teile:
1x Spannungsregler 7806
1x Servo-Verl¨
angerungskabel JR-Stecker
2x roter ft-Stecker
1x gr¨
uner ft-Stecker
1x rote ft-Buchse
Der 7806 kann mit fischertechnik-¨
ublichen Steckern versehen und dann direkt in den ftDuino eingesteckt werden. Der
Steuersignal-Anschluss muss mit dem SDA-Anschluss des I2C-Steckers verbunden werden. Die zus¨
atzliche Nutzung des
SCL-Anschlusses erm¨
oglicht den Anschluss eines zweiten Servos. Trennt man das rote Kabel direkt am Stecker des Servos
auf und versieht es mit einem fischertechnik-Stecker wie in Abbildung 6.15(b) dargestellt, so l¨
asst sich der Stecker des
Servos mit den zwei verbliebenen Adern direkt auf den I2C-Anschluss stecken. Will man das Anschlusskabel des Servos
nicht zerschneiden, dann kann man auch ein handels¨
ubliche JR-Servo-Verl¨
angerungskabel zerschneiden wie in Abbildung
6.5.1 dargestellt. Der aufgetrennte mittlere rote Anschluss wird dann mit dem fischertechnik-Stecker an den ebenfalls mit
fischertechnik-H¨
ulsen versehenen 7806 gesteckt.
(a) Servo an Regler und Adapterkabel (b) Spannungsregler und Adapterkabel
Abbildung 6.16: Servo-Motor am ftDuino
Das Steuersignal eines Servos entspricht nicht dem I2C-Standard. Stattdessen verwenden Servos ein einfaches Pulsweitensi-
gnal, das alle 20 Millisekunden wiederholt wird. Der Puls selbst ist zwischen einer und zwei Millisekunden lang und bestimmt
den Winkel, den das Servo einnehmen soll. Eine Millisekunde steht dabei f¨
ur den minimalen Wert und zwei Millisekunden
f¨
ur den maximalen. Soll der Servomotor in Mittelstellung fahren, so ist dementsprechend ein Puls von 1,5 Millisekunden
L¨
ange n¨
otig.
Das Servo verf¨
ugt ¨
uber keine weitere Intelligenz und es werden die vorgegebenen Steuersignale nicht ¨
uberpr¨
uft. Pulsl¨
angen
kleiner einer Millisekunde oder gr¨
oßer zwei Millisekunden versucht das Servo ebenfalls in entsprechende Winkel umzusetzen.
Dabei ist zu beachten, dass der Bewegung des Servos mechanische Grenzen gesetzt sind und das Servo Schaden nehmen
kann, wenn es Positionen außerhalb seines normalen Arbeitsbereichs anzufahren versucht. Es ist daher nicht ratsam, den
Bereich von ein bis zwei Millisekunden zu verlassen.
Um das n¨
otige Puls-Signal auf den eigentlich f¨
ur I2C-Signale vorgesehenen Pins zu erzeugen muss auf Software
zur¨
uckgegriffen werden. Ein Programmfragment, das den Servo in die Mittelposition bewegt k¨
onnte z.B. folgendermaßen
aussehen:
1void setup () {
82 Kapitel 6. Experimente
1ms 20ms 1,5ms 20ms 2ms 20ms
Abbildung 6.17: Servo-Winkel in Abh¨
angigkeit vom Stellsignal
2// P ort D . 1 ( SD A - A n sc hl us s ) a uf A us ga ng s ch al ten
3bitSet(DDRD , 1) ;
4}
5
6void loop() {
7// P ort D .1 a uf Hi gh - P eg el (5 V ) l ege n
8bitSet(PORTD , 1) ;
9
10 // 1500 us (1.5 ms ) warten
11 _delay_us(1500);
12
13 // P or t D .1 au f Low - P eg el ( GND ) l egen
14 bitClea r (PORTD , 1) ;
15
16 // 18500 us (18.5 ms ) w arten
17 _delay_us(20000-1500);
18 }
Hier wird der SDA-Anschluss am I2C zun¨
achst in der setup()-Funktion zu einem unabh¨
angig verwendbaren Ausgang
konfiguriert. In der Folge kann in der loop()-Funktion der Ausgang auf Hi (5 Volt) oder Masse (GND) geschaltet werden,
indem das entsprechende Bit im Register PORTD gesetzt oder gel¨
oscht wird. Nach dem Einschalten des Ausgangs wird
1500 Mikrosekunden (1,5 Millisekunden) gewartet, nach dem Ausschalten 18,5 Millisekunden, so dass die Zykluszeit von
insgesamt 20 Millisekunden erreicht wird.
Wie schon beim Schrittmotor ergibt sich das Problem, dass der Prozessor des ftDuino bei dieser einfachen Art der Program-
mierung permanent mit der Signalerzeugung ausgelastet wird und nebenbei keine anderen Aufgaben erledigen kann.
Die L¨
osung besteht wie beim Schrittmotor darin, die Signalerzeugung im Hintergrund durch einen Hardwaretimer zu veranlas-
sen. Das Beispiel Datei Beispiele FtduinoSimple ServoDemo bringt eine einfache Klasse zur Servoansteuerung
mit. Das eigentliche Hauptprogramm sieht dann folgendermaßen aus:
1//
2// S ervo . i no
3//
4
5#include " Servo . h"
6
7void setup () {
8ser vo .b egin () ;
9}
10
11 void loop() {
12 static uint8 _t value =Serv o :: VALUE_MAX/2;
13
14 if (value <Ser vo :: VALUE_MAX)value ++;
15 else value = 0;
16 ser vo .set(val ue ) ;
17
18 delay (10 ) ;
19 }
Die Ansteuerung des Servos beschr¨
ankt sich auf den Aufruf der servo.begin()-Funktion, die die n¨
otigen Ti-
mer im Hintergrund einrichtet. Der Winkel des Servos kann dann mit der servo.set()-Funktion von 0 (mini-
maler Winkel) bis Servo::VALUE MAX (maximaler Winkel) eingestellt werden. Die Mittelposition wird z.B. durch
servo.set(Servo::VALUE MAX/2) angefahren.
6.6. Die Eing¨
ange des ftDuino 83
6.6 Die Eing¨
ange des ftDuino
Schwierigkeitsgrad:
Wer sich schon einmal mit einem Arduino besch¨
aftigt hat weiss, dass man dort relativ frei bestimmen kann, welche Anschl¨
usse
man als Ein- oder Ausg¨
ange verwenden m¨
ochte, da s¨
amtliche Pins am Mikrocontroller in der Richtung umgeschaltet werden
k¨
onnen. Beim ftDuino konnte diese F¨
ahigkeit nicht erhalten werden, da an den Eing¨
angen zus¨
atzliche Schutzschaltungen
gegen ¨
Uberspannung und Kurzschl¨
usse eingesetzt werden und die Signale Ausg¨
ange verst¨
arkt werden, um fischertechnik-
Lampen und -Motoren betreiben zu k¨
onnen.
Abbildung 6.18: Interne Beschaltung der Eing¨
ange I1 bis I8 des ftDuino
Jeder der acht Eing¨
ange I1 bis I8 des ftDuino f¨
uhrt auf einen eigenen Analogeingang des ATmega32u4-Mikrocontrollers
und kann von diesem unabh¨
angig ausgewertet werden. Dazu kann der Mikrocontroller die Spannung des entsprechenden
Eingangs messen.
6.6.1 Spannungsmessung
Bevor das Eingangssignal den Mikrocontroller erreicht wird es ¨
uber einen Spannungsteiler aus zwei 47-Kiloohm-Widerst¨
anden
gef¨
uhrt. Diese Widerst¨
ande erf¨
ullen zwei Aufgaben. Erstens halbieren sie die Spannung eines angelegten Signals bevor es den
Mikrocontroller erreicht. Da der Mikrocontroller ftDuino-intern mit 5 Volt betrieben wird und auch nur Signale im Bereich
von 0 bis 5 Volt verarbeiten kann. Die Spannungshalbierung erweitert den messbaren Eingangsspannungsbereich auf 0 bis
10 Volt, wodurch sich die fischertechnik-¨
ublichen Spannungen bis maximal 9 Volt verarbeiten lassen. Zum zweiten sch¨
utzen
diese Widerst¨
ande im Zusammenspiel mit den Mikrocontroller-internen Schutzdioden den Mikrocontroller vor Spannungen,
die außerhalb des f¨
ur ihn vertr¨
aglichen 0 bis 5 Volt-Spannungsbereichs liegen. Spannungen bis zu 47 Volt an einem Eingang
besch¨
adigen den Mikrocontroller daher nicht.
6.6.2 Widerstandsmessung
Die 1 kΩ- und 2.2 kΩ-Widerst¨
ande sowie der Schalter haben keine Bedeutung, solange der Schalter offen ist. Acht dieser
Schalter, je einer f¨
ur jeden Eingang, befinden sich im ftDuino im Baustein mit der Bezeichnung CD4051 (IC1) wie im
Schaltplan in Anhang A ersichtlich. Der Mikrocontroller kann genau einen der acht Schalter zu jeder Zeit schließen und auf
diese Weise einen Widerstand von insgesamt 3.2 kΩ(1 kΩplus 2.2 kΩ) vom jeweiligen Eingang gegen 5 Volt aktivieren.
Der Schalter wird geschlossen und die Widerst¨
ande werden aktiviert, wenn eine Widerstandsmessung erfolgen soll. Der 3.2 kΩ-
Widerstand bildet dann mit einem zwischen Eingang und Masse angeschlossenen externen Widerstand einen Spannungsteiler.
Aus der gemessenen Spannung kann dann der unbekannte externe Widerstand bestimmt werden.
84 Kapitel 6. Experimente
Die Widerstandsmessung wird von der Ftduino-Bibliothek im Hintergrund ausgef¨
uhrt. Dabei findet auch eine automatische
Umschaltung der Widerstandsmessung auf all jene Eing¨
ange statt, die im Sketch zur Zeit zur Widerstandsmessung genutzt
werden. Der Programmierer muss sich also um keine Details k¨
ummern und kann jederzeit Widerstandswerte mit Hilfe der
Funktion ftduino.input get() (siehe 9.2.2) abfragen.
6.6.3 Ein Eingang als Ausgang
Die Tatsache, dass im Falle einer Widerstandsmessung ein Widerstand gegen 5 Volt geschaltet wird bedeutet, dass ¨
uber
den zu messenden extern angeschlossenen Widerstand ein Stromkreis geschlossen wird. Der Strom durch diesen Stromkreis
ist relativ gering. Wenn der Eingang direkt mit Masse verbunden ist betr¨
agt der Gesamtwiderstand 3.2 kΩund es fließt ein
Strom von I= 5V/3.2 kΩ=1,5625mA.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 6.19: Anschluss einer LED an Eingang I1 des ftDuino
Dieser Strom reicht zwar nicht, um eine Lampe oder gar einen Motor zu betreiben. Aber eine Leuchtdiode kann man damit
schwach zum Leuchten bringen. Schließt man eine Leuchtdiode direkt zwischen einem Eingang und Masse an und schaltet
den Eingang auf Widerstandsmessung, so wird die LED ganz leicht leuchten.
Der tats¨
achliche Strom wird noch deutlich unter den vorausgesagten 1,5mA liegen, da zum einen direkt an der Leuchtdiode
die sogenannte Vorw¨
artsspannung von circa 0,7V abf¨
allt und ¨
uber den Widerst¨
anden daher nur eine Spannung von etwas
¨
uber vier Volt anliegt.
Zum anderen fragt die Ftduino-Bibliothek im Hintergrund alle acht Eing¨
ange ab und aktiviert jeden Eingang dabei nur 1
/8
der Zeit. Es fließt im Mittel daher auch nur 1
/8des Stroms.
Die FtduinoSimple-Bibliothek schaltet ebenfalls die Widerst¨
ande ein und zwar f¨
ur den jeweils zuletzt aktivierten Eingang.
Dieser Widerstand ist dann dauerhaft aktiviert, bis ein anderer Eingang angefragt wird. Das folgenden Code-Fragment l¨
asst
eine LED an Eingang I1 im Sekundentakt blinken.
1#include < F t du in oS imp le .h >
2
3void loop() {
4// lies Wert von Ei ng ang I1 , aktiviert Wi de rs ta nd auf I1
5ftduino.input_get(Ftduino:: I 1 );
6delay (1000);
7// lies Wert von Eing an g I2 , deaktiv ie rt Wi de rs tand auf I1
8// ( und aktiviert ihn auf I2 )
9ftduino.input_get(Ftduino:: I 2 );
10 delay (1000);
11 }
6.7 Temperaturmessung
Schwierigkeitsgrad:
6.7. Temperaturmessung 85
Fischertechnik vertreibt unter der Artikelnummer 364377einen sogenannten NTC. Dieses unscheinbare Bauteil liegt einigen
Robotics-Bauk¨
asten bei.
Ein NTC ist ein elektrischer Widerstand, der seinen Wert abh¨
angig von der Umgebungstemperatur ¨
andert. Er eignet sich
daher zur Temperaturmessung. NTC steht dabei f¨
ur “Negativer-Temperatur-Coeffizient”, was bedeutet, dass der ohmsche
Widerstand mit steigender Temperatur sinkt. NTCs werden im Deutschen auch als Heißleiter bezeichnet, da ihre Leitf¨
ahigkeit
mit der Temperatur steigt.
Der Nennwiderstand RNeines NTCs wird in der Regel bei einer Temperatur von 25 C (298,15 K) angegeben. Der f¨
ur den
fischertechnik-Sensor angegebene Wert ist 1.5 kΩ. Der ohmsche Widerstand betr¨
agt bei 25 C also 1.5 kΩ.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 6.20: Anschluss des Temperatursensors an Eingang I1
6.7.1 Sketch Temperature
Der folgende Sketch findet sich bei installierter ftDuino-Unterst¨
utzung im Men¨
u der Arduino-IDE unter Datei
Beispiele Ftduino Temperature .
1//
2// T em per aur e . ino
3//
4// Abf rage ei nes fi sch er te chn ik Temperatur - Widers ta nd s an Einga ng I1
5//
6// ( c ) 2 01 8 b y Ti ll H a rb au m < t i ll @h ar ba um . or g >
7//
8
9#include <Ftduino.h>
10 #include < m ath . h > // F ¨ur Fliesspunkt - Arithmetik
11
12 #define K2C 273.15 // Off set Kel vin nach Grad C el sius
13 #define B 3900.0 // s og . B - W ert des Se ns or s
14 #define R_N 1500.0 // Widerstand bei 25 Grad Ce ls ius Ref er enz te mpe ra t ur
15 #define T_N ( K2C + 25.0) // Re fer en z te mpe ra tur in Kelvin
16
17 float r2 de g (uint 16 _t r ) {
18 if (r== 0) return NAN ;// ein Widerstand von 0 Ohm ergi bt ke ine si nnvolle Te mperatur
19
20 // Widerstand in Kelvi n umrechnen
21 float t=T_N *B/ ( B+T_N *log (r/R_N)) ;
22
23 // Kel vin in Grad C elsiu s umrech ne n
24 return t-K2C ;
25
26 // a ltern at iv : Kelvin in Grad Fahrenheit umre chnen
27 // ret urn t * 9 / 5 - 4 59.67 ;
28 }
29
30 void setup () {
31 // LED initialisieren
32 pinMode(LED_BUILTIN ,OUTPUT);
7fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=36437
86 Kapitel 6. Experimente
33 digitalWrite(LED_BUILTIN ,LOW);
34
35 Serial.begin ( 115200 ) ;
36 while (! Serial) ;
37
38 ftduino.init() ;
39
40 // Die T emp er a tu rme ss ung e rf olgt mit e ine m
41 ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: RESISTANCE ) ;
42 }
43
44 void loop() {
45 uint16_ t r =ftduino.input_get (Ftduino:: I 1 );
46
47 Serial.print (" I 1 : " );
48 Serial.print (r 2d eg (r)) ;
49 Serial.println(" Grad C elsi us ") ;
50
51 delay (1000);
52 }
Sketchbeschreibung
Der Temperatur-Sketch verwendet an einigen Stellen sogenannte Fließkommazahlen, um Temperaturen zu speichern. So
wird die in der Computertechnik verwendete interne Darstellung von nicht-ganzzahligen Werten (Dezimalbr¨
uchen) genannt.
Der Sketch bindet daf¨
ur in Zeile 10 die Datei math.h ein, um dem Sketch Zugriff auf Fließkommafunktionen zu geben. Zur
Speicherung der Fließkommazahlen wird der Datentyp float z.B. in Zeile 21 verwendet.
Da der zur Temperaturmessung verwendete Sensor ein Widerstand ist wird in der setup()-Funktion in Zeile 41 der Eingang
I1 des ftDuino auf Widerstandsmessung eingestellt.
Der eigentlich Widerstandswert wird in Zeile 45 von Eingang I1 ausgelesen und in der ganzzahligen Variablen rabgelegt.
W¨
ahrend der Ausgabe des Wertes in Zeile 48 wird die Funktion r2deg() aufgerufen. Diese Funktion befindet sich in den
Zeilen 17 bis 28. Sie nimmt einen ganzzahligen Widerstandswert in Ohm entgegen und liefert eine Temperatur in Grad
Celsius als Fließkommawert zur¨
uck.
Zun¨
achst erfolgt in Zeile 21 die Umrechnung des Widerstands in Kelvin. Dazu wird neben dem Widerstand RNbei 25 C
auch der sogenannte B-Wert des Sensors ben¨
otigt. Dieser Wert beschreibt das Verhalten des Sensors außerhalb des 25 C-
Punkts und wie stark dabei der Widerstand auf Temperatur¨
anderungen reagiert. Dieser Wert liegt bei dem von fischertechnik
vertriebenen Sensor bei 3900.
F¨
ur NTCs gilt n¨
aherungsweise8:
1
T=1
TN+1
Bln( RT
RN)⇔T=TN∗B
B+TN∗ln( RT
RN)
mit
T. . . aktuelle Temperatur
TN. . . Nenntemperatur (¨
ublicherweise 25 C)
B. . . B-Wert
RT. . . Widerstand bei aktueller Temperatur
RN. . . Widerstand bei Nenntemperatur
Nach der Umrechnung liegt die Temperatur in Kelvin vor. Zur Umrechnung in Grad Celsius muss Zeile 24 lediglich eine
Konstante abgezogen werden. Eine Umrechnung in Grad Fahrenheit w¨
are etwas komplexer und ist beispielhaft in Zeile 27
dargestellt.
Die Genauigkeit der Temperaturmessung ist direkt von der Genauigkeit der Widerstandsmessung abh¨
angig und diese ist wie
in Abschnitt 1.2.5 erkl¨
art von der Spannungsversorgung abh¨
angig. Zur Temperaturmessung sollte der ftDuino daher aus
einer 9v-Quelle mit Spannung versorgt werden. Eine Versorgung nur ¨
uber die USB-Schnittstelle ist nicht ausreichend.
8https://de.wikipedia.org/wiki/Hei%C3%9Fleiter
6.8. Ausg¨
ange an, aus oder nichts davon? 87
6.8 Ausg¨
ange an, aus oder nichts davon?
Schwierigkeitsgrad:
Einen Ausgang kann man ein- oder ausschalten, das ist die g¨
angige Sichtweise. Dass es aber noch einen weiteren Zustand
gibt ist auf den ersten Blick vielleicht nicht offensichtlich.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 6.21: Zwei Lampen an Ausgang O1
Die Ausg¨
ange des ftDuino lassen sich in drei Zust¨
ande schalten: Ftduino::HI,Ftduino::LO und Ftduino::OFF.
Am offensichtlichsten ist der Zustand Ftduino::HI. In diesem Zustand wird der entsprechende Ausgang ftDuino-intern mit
der 9-Volt-Versorgungsspannung verbunden. Ist an diesem Ausgang eine Lampe oder ein Motor so angeschlossen, dass der
zweite Anschluss an Masse liegt, so fließt ein Strom von der 9V-Quelle ¨
uber den Ausgang durch Lampe oder Motor zur
Masse. Der Motor dreht sich und die Lampe leuchtet. Im abgebildeten Beispiel leuchtet die rote Lampe.
Im Zustand Ftduino::LO ist der entsprechende Ausgang mit Masse verbunden. Eine wieder mit dem zweiten Anschluss
an Masse angeschlossene Lampe wird nun nicht mehr leuchten, da beide Anschl¨
usse der Lampe auf Masse liegen und die
Spannung zwischen beiden Anschl¨
ussen daher 0 Volt betr¨
agt. Schließt man den zweiten Anschluss der Lampe aber an 9
Volt an, so leuchtet sie nun. Der Strom fließt von der Spannungsversorgung des ftDuino ¨
uber den 9-V-Anschluss, durch die
Lampe und schließlich ¨
uber den auf Masse liegenden Ausgang. Im abgebildeten Beispiel leuchtet nun die blaue Lampe.
Der dritte Zustand ist schließlich der Zustand Ftduino::OFF. In diesem Fall ist der Ausgang komplett offen. Er ist weder
mit Masse noch mit 9 Volt verbunden und es fließt kein Strom ¨
uber ihn. Als Resultat leuchten beiden Lampen mit halber
Helligkeit, da der Strom nun vom Ausgang v¨
ollig unbeeinflusst durch beide Lampen fließt. Dieser Zustand wird oft auch mit
dem englischen Begriff “tristate” bezeichnet und entsprechende Ausg¨
ange an Halbleitern als “tristate-f¨
ahig”. Im Deutschen
beschreibt der Begriff “hochohmig” diesen dritten Zustand recht gut.
Der folgende Sketch wechselt im Sekundentakt zwischen den drei Zust¨
anden. Man kann diesen Effekt zum Beispiel ausnutzen,
um zwei Motoren oder Lampen an einem Ausgang unabh¨
angig zu steuern, um Ausg¨
ange zu sparen. Allerdings lassen sich
bei dieser Verschaltung niemals beide Lampen gleichzeitig ausschalten
6.8.1 Sketch OnOffTristate
1/*
2On Of fTris ta te - der drit te Zust an d
3*/
4
5#include < F t du in oS imp le .h >
6
7void setup () { }
8
9// Die Loop - F un ktion wird en dlos immer und imm er wi eder au sge f ¨u hrt
10 void loop() {
11 // Aus gang O1 auf 9V sch alten
12 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
13 delay (1000);
14 // Aus gang O1 auf Masse s chalten
15 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: LO );
88 Kapitel 6. Experimente
16 delay (1000);
17 // Aus gang O1 unb es ch al tet l ass en
18 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: OFF ) ;
19 delay (1000);
20 }
6.8.2 Leckstr¨
ome
Ganz korrekt ist die Aussage, dass im hochohmigen bzw. Tristate-Zustand kein Strom fließt nicht. ¨
Uber die Leistungsend-
stufen und deren interne Schutzschaltungen fließt oft trotzdem ein geringer Strom. In einigen F¨
allen wird dies sogar bewusst
getan, um z.B. mit Hilfe dieses geringen Stromflusses das Vorhandensein eines angeschlossenen Verbrauchers feststellen zu
k¨
onnen. Diese sogenannten Leckstr¨
ome wurden in Abschnitt 6.1.1 bereits beobachtet.
Ersetzt man die zwei Lampen im aktuellen Modell durch zwei Leuchtdioden, so wird man feststellen, dass die vom Ausgang
nach Masse angeschlossene LED immer dann leicht glimmt, wenn der entsprechende Ausgang hochohmig geschaltet ist.
Nur wenn der Ausgang auf Masse geschaltet ist leuchtet die LED nicht. Man kann also direkt an der LED die drei Zust¨
ande
unterscheiden.
6.9 Aktive Motorbremse
Schwierigkeitsgrad:
Das Abschalten eines Motors scheint rein elektrisch trivial zu sein. Sobald der Motor von der Spannungsversorgung getrennt
wird bleibt er stehen. Im Wesentlichen stimmt das auch so.
Physikalisch bedeutet die Trennung von der Spannungsversorgung lediglich, dass dem Motor keine weitere Energie zugef¨
uhrt
wird. Dass das letztlich dazu f¨
uhrt, dass der Motor anh¨
alt liegt daran, dass die in der Rotation des Motors gespeicherte
Energie langsam durch Reibung z.B. in den Lagern der Motorwelle verloren geht. Wie lange es dauert, bis der Motor auf
diese Weise zum Stillstand kommt h¨
angt wesentlich vom Aufbau des Motors und der Qualit¨
at seiner Lager ab.
Zus¨
atzlich wirken viele Gleichstrom-Elektromotoren, wie sie auch fischertechnik einsetzt, als Generator. Werden sie gedreht,
so wird in ihren internen Elektromagneten eine Spannung induziert.
Abbildung 6.22: Der TXT-Encoder-Motor als Generator
Dieser Effekt l¨
asst sich mit einer Leuchtdiode leicht nachvollziehen. Schließt man die Leuchtdiode direkt an den Motor an
und dreht dann manuell die Motorachse, so leuchtet die Leuchtdiode auf, wenn man den Motor in die richtige Richtung
dreht und damit eine Spannung mit der f¨
ur die Leuchtdiode passenden Polarit¨
at erzeugt. Man kann f¨
ur diesen Versuch
auch eine Gl¨
uhlampe oder gar einen zweiten Motor nehmen. Deren gegen¨
uber einer Leuchtdiode h¨
ohere Energieaufnahme
erfordert aber gegebenenfalls ein etwas kr¨
aftigeres Drehen.
Je mehr Last ein Generator versorgen soll und je mehr Energie im entnommen werden soll, desto gr¨
oßer ist die mechanische
Kraft, die n¨
otig ist, um den Generator zu drehen. H¨
ohere Last bedeutet in diesem Fall ein geringerer elektrischer Widerstand.
Die Leuchtdiode mit ihrer vergleichsweise geringen Last besitzt einen hohen elektrischen Widerstand, die Gl¨
uhlampe und
noch mehr der Motor besitzen einen geringen elektrischen Widerstand und belasten bzw. bremsen den Generator damit
st¨
arker. Die gr¨
oßte denkbare Last ist in diesem Fall der Kurzschluss. Er hat einen minimalen elektrischen Widerstand und
sorgt f¨
ur maximalen Stromfluss und damit maximale elektrische Last am Generator. Auch die Bremswirkung ist dabei
maximal.
Dieser Effekt l¨
asst sich nutzen, um einen Elektromotor zu bremsen. Wende beide Anschl¨
usse eines Motors miteinander
verbunden, so fließt ein Strom, der eine Bremswirkung entwickelt. Das wurde bereits beim Not-Aus-Modell aus Abschnitt
6.2 genutzt, um den Motor im Notfall schnell zu stoppen. Ist dagegen z.B. einer der Anschl¨
usse des Motors offen, so ist
6.9. Aktive Motorbremse 89
MM
gebremst ungebremst
Abbildung 6.23: Elektrisch gebremster und ungebremster Elektromotor
kein geschlossener Stromkreis vorhanden und es fließt kein Strom und es tritt keine Bremswirkung auf. Wie groß ist dieser
Effekt aber?
Der fischertechnik-Encoder-Motor enth¨
alt eine M¨
oglichkeit zur Drehzahlmessung wie schon im PWM-Experiment in Ab-
schnitt 6.3 genutzt. Das Bremsverhalten dieses Motors l¨
asst sich daher experimentell gut verfolgen.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 6.24: Anschluss des TXT-Encoder-Motors an die Anschl¨
usse M1 und C1
Das Beispiel Datei Beispiele Ftduino MotorBrake l¨
asst den Motor an Ausgang M1 alle f¨
unf Sekunden f¨
ur drei
Umdrehungen laufen und misst dann f¨
ur eine weitere Sekunde, wie viele weitere Impulse der Encoder an Eingang C1 liefert,
nachdem er die drei Umdrehungen vollendet hat und abgeschaltet wurde.
Die Funktion motor counter set brake() (siehe Abschnitt 9.2.9) wird dabei im Wechsel so aufgerufen, dass der Motor
frei ausl¨
auft bzw. dass er aktiv gebremst wird.
Abbildung 6.25: Ausgabe bei Verwendung des TXT-Encoder-Motors
Wie in Abbildung 6.25 zu sehen macht die aktive Bremse einen deutlichen Unterschied. W¨
ahrend der Encoder-Motor
ungebremst noch f¨
ur weitere 90 Impulse weiter dreht, also fast 1,5 volle Umdrehungen, kommt er bei aktiver Bremse bereits
nach f¨
unf weiteren Impulse zum Stillstand. Das entspricht lediglich knapp 1
/13 Umdrehung.
90 Kapitel 6. Experimente
6.10 USB-Tastatur
Schwierigkeitsgrad:
Der ftDuino ist nicht vom klassischen Arduino Uno abgeleitet, sondern vom Arduino Leonardo. Der wesentliche techni-
sche Unterschied zwischen beiden Arduinos liegt in der Tatsache, dass der Arduino Uno einen separaten Chip f¨
ur die
USB-Kommunikation mit dem PC verwendet, w¨
ahrend diese Aufgabe beim Arduino Leonardo allein dem ATmega32u4-
Mikrocontroller zuf¨
allt.
In den meisten F¨
allen macht das keinen Unterschied und die meisten Sketches laufen auf beiden Arduinos gleichermaßen. Es
gibt allerdings sehr große Unterschiede in den M¨
oglichkeiten, die sich mit beiden Arduinos bei der USB-Anbindung bieten.
W¨
ahrend der USB-Chip im Uno auf das Anlegen eines COM:-Ports beschr¨
ankt ist zeigt sich der Leonardo und damit auch
der ftDuino sehr viel flexibler und der ftDuino kann sich unter anderem gegen¨
uber einem PC als USB-Tastatur ausgeben.
Da die Ausg¨
ange des ftDuino bei diesem Modell nicht verwendet werden reicht die Stromversorgung ¨
uber USB und es ist
keine weitere Versorgung ¨
uber Batterie oder Netzteil n¨
otig.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
Abbildung 6.26: Tastatur-Nachricht
6.10.1 Sketch USB/KeyboardMessage
1/*
2Ke ybo ard Mes sag e - USB - T asta tur
3
4Der ft Du ino gi bt sic h als USB - T ast at ur aus und " ti pp t " ei ne Na ch ri ch t , s obal d
5ein Tas ter an E inga ng I1 f ¨u r mi nde ste ns 10 M ill ise ku nde n g ed r ¨u ckt wird .
6
7Ba sier end auf dem Sketch :
8ht tp : // w ww . a rd uin o . cc / en / T ut ori al / K ey bo ar dM es sa ge
9
10 Die ser B eis pielc ode ist Public - Do main .
11 */
12
13 #include < F t du in oS imp le .h >
14 #include < K ey bo ard .h >
15
16 unsigne d long lastButtonEvent = 0;
17 uint16_t previousButtonState =Ftduino:: OFF ;// for c he cking the state of a pushButton
18
19 void setup () {
20 // i nit iali ze co ntro l over the key board :
21 Keyboar d .begin ( ) ;
22 }
23
24 void loop() {
25 // Tast e an Einga ng I1 a us lesen
26 uint16_ t b ut to nS ta te =ftduino.inpu t_get (Ftduino:: I1 );
27
28 // Hat s ich der Zust and der Ta ste ge ¨a ndert ?
29 if (buttonState != previousButtonState) {
30 // ja , Zeit des W echsels merken
6.11. USB-GamePad 91
31 lastButtonEvent =millis() ;
32 // und den neuen Z us tand merken , dami t wir weite re
33 // ¨
A nd eru nge n erk enn en k ¨o nne n
34 previousButtonState =buttonState;
35 }
36
37 // Gibt es ein u nb ea rbe it et es Ereg nis und hat sich der Zust and der Taste seit dem
38 // f ¨ur m eh r a ls 10 M i ll is eku nd en n ich t ge ¨a nd ert ?
39 if (lastButtonEvent && (( millis() - lastButtonEvent) > 10) ) {
40 // Zeit dies es E re ig ni sses ve rg es se n
41 lastButtonEvent = 0;
42
43 // T aste w ur de gedr ¨u ckt
44 if (buttonState) {
45 // N ach rich t " tip pen "
46 Keyboar d .println(" H allo vom ft Duin o !" );
47 }
48 }
49 }
Sketchbeschreibung
Die Arduino-IDE bringt bereits Bibliotheken mit, um USB-Ger¨
ate wie M¨
ause und Tastaturen umzusetzen. Der eigentliche
Sketch bleibt so sehr einfach und die komplizierten USB-Detail bleiben in den Bibliotheken verborgen. Entsprechend kurz
ist auch dieser Sketch.
In der setup()-Funktion muss lediglich die Methode Keyboard.begin() aufgerufen werden, um beim Start des ftDuino
alle USB-seitigen Vorkehrungen zu treffen, so dass der ftDuino vom PC als USB-Tastatur erkannt wird. Allerdings verf¨
ugt
diese Tastatur zun¨
achst ¨
uber keine Tasten, so dass man kaum merkt, dass der PC nun ¨
uber eine zus¨
atzliche Tastatur zu
verf¨
ugen meint.
Um die Tastatur mit Leben zu f¨
ullen muss in der loop()-Funktion bei Bedarf ein entsprechendes Tastensignal erzeugt und
an den PC gesendet werden. In den Zeilen 25 bis 35 des Sketches wird ein Taster an Eingang I1 abgefragt und sichergestellt,
dass nur Tastendr¨
ucke ¨
uber 10ms L¨
ange als solche erkannt werden (mehr Details zu diesem sogenannten Entprellen findet
sich in Abschnitt 6.12).
Immer wenn die Taste an I1 gedr¨
uckt wurde, werden die Sketchzeilen 45 und folgende ausgef¨
uhrt. Hier wird die Funktion
Keyboard.println() aus der Arduino-Keyboard-Bibliothek aufgerufen und ein Text an den PC gesendet. F¨
ur den PC sieht
es so aus, als w¨
urde der Text vom Anwender auf der Tastatur getippt 9.
Die M¨
oglichkeit, Nachrichten direkt als Tastatureingaben zu senden kann sehr praktisch sein, erlaubt sie doch ohne weitere
Programmierung auf dem PC, die automatische Eingabe z.B. vom Messwerten in eine Tabelle oder ¨
ahnlich. Nat¨
urlich l¨
asst
sich diese F¨
ahigkeit aber auch f¨
ur allerlei Schabernack nutzen, indem der ftDuino zeitgesteuert oder auf andere Ereignisse
reagierend den ¨
uberraschten Anwender mit unerwarteten Texteingaben irritiert. Bei solchen Sp¨
aßen sollte man immer eine
ordentliche Portion Vorsicht walten lassen, da der falsche Tastendruck zur falschen Zeit leicht einen Datenverlust zur Folge
haben kann.
6.11 USB-GamePad
Schwierigkeitsgrad:
Aus der PC-Sicht ist der Unterschied zwischen einer USB-Tastatur und einen USB-Joystick oder -Gamepad minimal. Beide
nutzen das sogenannte USB-HID-Protokoll (HID = Human Interface Device, also ein Schnittstellenger¨
at f¨
ur Menschen).
Arduino-seitig gibt es aber den fundamentalen Unterschied, dass die Arduino-Umgebung zwar vorgefertigte Bibliotheksfunk-
tionen f¨
ur Tastaturen mitbringt, f¨
ur Gamepads und Joysticks aber nicht. Um trotzdem ein USB-Gamepad zu implementieren
ist daher im Sketch sehr viel mehr Aufwand zu treiben.
9Weitere Informationen und tiefergehenden Erkl¨
arungen zu den Arduino-Bibliotheken zur Maus- und Tastaturnachbildung finden sich unter
https://www.arduino.cc/en/Reference/MouseKeyboard
92 Kapitel 6. Experimente
3
2
1
3
2
1
3
2
1
3
2
1
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
3
2
1
Abbildung 6.27: GamePad mit vier Richtungstasten und zwei Feuerkn¨
opfen
6.11.1 Sketch USB/GamePad
Das entsprechende Beispiel findet sich unter Datei Beispiele FtduinoSimple USB GamePad . Dieser Sketch be-
steht aus drei Dateien. W¨
ahrend GamePad.ino den eigentlichen Sketch enth¨
alt implementieren HidGamePad.cpp und
HidGamePad.h denjenigen Teil der Gamepad-Unterst¨
utzung, die die Arduino-IDE nicht bietet. Interessant ist vor allem die
hidReportDescriptor-Struktur in der Datei HidGamePad.cpp.
9sta tic cons t uint8_t _hidReportDescriptor[] PROGMEM = {
10 0x05 , 0 x01 ,// USAGE_PAGE ( Ge neri c D eskt op )
11 0x09 , 0 x05 ,// USA GE ( Gam epad )
12 0x85 ,REPORT_ID ,// RE PORT_ID (3)
13 0xa1 , 0 x01 ,// COLLECTION ( Appli ca ti on )
14 0x09 , 0 x01 ,// USAGE ( P oint er )
15 0xa1 , 0 x00 ,// COL LECT ION ( Phy sica l )
16 0x09 , 0 x30 ,// USAGE ( X)
17 0x09 , 0 x31 ,// USAGE ( Y)
18 0x15 , 0 x00 ,// LOG IC AL_MI NI MUM (0)
19 0x26 , 0 xff , 0 x00 ,// LO GIC AL _M AXI MU M (255)
20 0x35 , 0 x00 ,// PHYSICAL_MINIMUM(0)
21 0x46 , 0 xff , 0 x00 ,// PHYSICAL_MAXIMUM(255)
22 0x75 , 0 x08 ,// RE PORT_SIZE (8)
23 0x95 , 0 x02 ,// REPORT_COUNT(2)
24 0x81 , 0 x02 ,// INP UT ( Da ta ,Var , Abs )
25 0xc0 ,// END_COLLECTION
26 0x05 , 0 x09 ,// U SAGE_PAGE ( Bu tton )
27 0x19 , 0 x01 ,// U SAG E_M INI MUM ( But to n 1)
28 0x29 , 0 x02 ,// U SAG E_M AXI MUM ( But to n 2)
29 0x15 , 0 x00 ,// L OG ICA L_ MI NIM UM (0)
30 0x25 , 0 x01 ,// L OG ICA L_ MA XIM UM (1)
31 0x95 , 0 x02 ,// REPORT_COUNT(2)
32 0x75 , 0 x01 ,// R EP OR T_ SI ZE (1)
33 0x81 , 0 x02 ,// IN PUT ( Data , Var , A bs )
34 0x95 , 0 x06 ,// REPORT_COUNT(6)
35 0x81 , 0 x03 ,// IN PUT ( Const , Var , Ab s )
36 0xc0 // END_COLLECTION
37 };
Diese vergleichsweise kryptische Struktur beschreibt die F¨
ahigkeiten eines USB-HID-Ger¨
ats10. Sie beschreibt, um welche Art
Ger¨
at es sich handelt und im Falle eines Joysticks ¨
uber was f¨
ur Achsen und Tasten er verf¨
ugt.
In diesem Fall meldet das Ger¨
at, dass es ¨
uber zwei Achsen X und Y verf¨
ugt, die jede einen Wertebereich von 0 bis 255
abdecken. Weiterhin gibt es zwei Buttons, die jeweils nur den Zustand an und aus kennen. F¨
ur einen einfachen Joystick
reicht diese Beschreibung. Es ist aber leicht m¨
oglich, die Beschreibung zu erweitern und zus¨
atzliche Achsen und Tasten
vorzusehen. Mit den insgesamt acht analogen und den vier digitalen Eing¨
angen verf¨
ugt der ftDuino ¨
uber ausreichend
Verbindungsm¨
oglichkeiten f¨
ur komplexe Eingabeger¨
ate.
¨
Ubliche HID-Ger¨
ate sind Tastaturen, M¨
ause und Joysticks bzw. Gamepads. Aber die Spezifikation der sogenannten HID-
10Mehr Info unter http://www.usb.org/developers/hidpage/
6.12. Entprellen 93
Usage-Tabellen11 sieht wesentlich originellere Eingabeger¨
ate f¨
ur diverse Sport-, VR-, Simulations- und Medizinger¨
ate und
vieles mehr vor. Und nat¨
urlich ist mit den Ausg¨
angen des ftDuino auch die Implementierung von R¨
uckmeldungen ¨
uber
Lampen oder Motoren in Form von z.B. Force-Feedback m¨
oglich.
6.12 Entprellen
Schwierigkeitsgrad:
In einigen der vorherigen Sketches wurde unerwartet viel Aufwand betrieben, um Taster abzufragen. Im Pwm-Sketch aus
Abschnitt 6.3.1 wurde in den Zeilen 35 und 51 eine Verz¨
ogerung von einer Millisekunde eingebaut und im KeyboardMessage-
Sketch in Abschnitt 6.10 wurde in den Zeilen 31 und 39-41 ebenfalls die Zeit erfasst und in die Auswertung des Tastendrucks
eingef¨
ugt. Die Frage, warum das n¨
otig ist soll etwas n¨
aher betrachtet werden.
Der Grund f¨
ur diese Verwendung von Zeiten bei der Auswertung von einzelnen Tastendr¨
ucken ist das sogenannte “Prellen”.
Mechanische Taster bestehen aus zwei Metallkontakten, die entweder getrennt sind oder sich ber¨
uhren. In Ruhe sind die
Kontakte getrennt und wenn der Taster bet¨
atigt wird, dann sorgt eine Mechanik daf¨
ur, dass die beiden Metallkontakte in
Ber¨
uhrung kommen und der Kontakt geschlossen wird.
Folgender Sketch fragt kontinuierlich einen Taster an Eingang I1 ab und gibt auf dem COM:-Port eine Meldung aus, wenn
sich der Zustand ¨
andert. Zus¨
atzlich z¨
ahlt er mit, wie oft sich der Zustand insgesamt bereits ge¨
andert hat.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
Abbildung 6.28: Entprellen
6.12.1 Sketch Debounce
1/*
2Debounc e
3
4Demonstriert Tastenprellen
5*/
6
7#include < F t du in oS imp le .h >
8
9// die setup - Funktion wird e inm al beim Start a ufgerufen
10 void setup () {
11 Serial.begin (9600);
12
13 while (! Serial) ; // wart e auf USB - Ver bindung
14
15 Serial.println(" ftD uino Tas te np re ll - Be ispi el ") ;
16 }
17
18 uint8 _t le tzt er _z ust an d =false ;
19 uint8_t wechselzaehler = 0;
20
21 // die loop - Fun kt ion wird immer wied er a uf ge ru fe n
11http://www.usb.org/developers/hidpage/Hut1 12v2.pdf
94 Kapitel 6. Experimente
22 void loop() {
23 uint8_t zustand =ftduino.input_get(Ftduino:: I1 ) ; // Tas ter ausles en
24
25 if (zustand != letzter_zustand) { // Hat der Zu stan d si ch ge ¨a nde rt ?
26 wechselzaehler =wechselzaehler + 1; // Ja , Z ¨a hle r rum ein s erh ¨o he n
27
28 Serial.print (" I 1 " ); // und e ine Meld ung au sg eben
29 Serial.print (wechselzaehler);
30 Serial.println(" mal ge ¨a n de rt ") ;
31 letzter_zustand =zustand;// neuen Zustan d als letz ten merk en
32 }
33 }
Sketchbeschreibung
In den Zeilen 10 bis 16 wird wie schon beim ComPort-Beispiel aus Abschnitt 3.3 die Ausgabe an den PC vorbereitet und
f¨
ur den seriellen Monitor eine Nachricht ausgegeben.
In Zeile 23 wird kontinuierlich der Eingang I1 abgefragt. Hat sich sein Zustand gegen¨
uber dem in der Varia-
blen letzter zustand gespeicherten ge¨
andert, so wird dies in Zeile 25 festgestellt. In der Folge wird die Variable
wechselzaehler erh¨
oht und der neue Wert in den Zeilen 28 bis 30 ausgegeben.
Aufgabe 1: Es z¨
ahlt zu viel
Etwas merkw¨
urdiges passiert, wenn man den Sketch auf den ftDuino l¨
adt und ausprobiert: Sobald die Taste gedr¨
uckt wird
erscheinen gleich mehrere Meldungen ¨
uber Zustands¨
anderungen des Eingangs und auch der Z¨
ahler z¨
ahlt wesentlich weiter
als erwartet. Was passiert hier?
Das Problem ist, dass im Moment des Schaltens der Kontakt nicht sofort perfekt schließt. Stattdessen ber¨
uhren sich die
Metall߬
achen kurz, federn dann f¨
ur ein paar Mikrosekunden zur¨
uck und ¨
offnen sich wieder f¨
ur einen sehr kurzen Moment.
Erst nach mehreren Federvorg¨
angen kommen die Kontakte zur Ruhe und sind dauerhaft geschlossen.
L¨
osung 1:
Die einfachste L¨
osung des Problems liegt darin, ein klein wenig zu warten, bevor man nach einem Schaltereignis ein weiteres
akzeptiert. Das erreicht man zum Beispiel, indem man nach Zeile 31 zus¨
atzlich etwas wartet, wie es auch im Pwm-Sketch
aus Abschnitt 6.3.1 getan wurde.
31 letzter_zustand =zustand;// neuen Zustan d als letz ten merk en
32 delay (10 ) ; // warte zehn M illis ek un den
33 }
Nach dieser ¨
Anderung z¨
ahlt der Sketch tats¨
achlich nur noch einzelne Tastendr¨
ucke. Diese einfache L¨
osung hat aber einen
Nachteil: Die Ausf¨
uhrung des gesamten Sketches wird bei jeden Tastendruck f¨
ur zehn Millisekunden pausiert. Hat der Sketch
noch andere Aufgaben zu erledigen, dann wird die Verarbeitung dieser Aufgaben ebenfalls f¨
ur diese zehn Millisekunden
unterbrochen. Je nach verwendetem Taster l¨
asst sich die Zeit auf unter eine Millisekunde verk¨
urzen. Aber bei zu kurzer
Wartezeit werden wieder falsche Ereignisse erkannt.
Eleganter ist es daher, bei jedem Ereignis mit der Funktion millis() einen Zeitstempel aus dem Systemzeitz¨
ahler zu
nehmen und erst dann ein Ereignis als g¨
ultig zu erkennen, wenn das letzte Ereignis l¨
anger als 10 Millisekunden zur¨
uck liegt.
Der KeyboardMessage-Sketch aus Abschnitt 6.10 l¨
ost das Problem auf genau diese Weise.
Aufgabe 2: Was passiert denn nun genau?
Wie lange der Taster prellt und wie er sich genau verh¨
alt konnte wir bisher nur vermuten. L¨
asst sich der ftDuino nutzen,
um etwas genauer auf das Schaltverhalten des Tasters zu schauen?
6.12. Entprellen 95
L¨
osung 2:
Um Signalverl¨
aufe zu veranschaulichen verf¨
ugt die Arduino-IDE ¨
uber ein sehr einfaches aber interessantes Werkzeug: Den
sogenannten “seriellen Plotter” er findet sich im Men¨
u unter Werkzeuge Serieller Plotter und ¨
offnet wie der serielle
Monitor ein eigenes Fenstern. Aber statt einen per COM:-Port empfangenen Text direkt anzuzeigen interpretiert der serielle
Plotter die eingehenden Daten Zeile f¨
ur Zeile als Werte, die grafisch in einer Kurve dargestellt (geplottet) werden.
Das folgende Beispiel ist unter Datei Beispiele FtduinoSimple BounceVisu zu finden.
1/*
2Bo un ce Vi su
3
4visualisiert Tastenprellen
5*/
6
7#include < F t du in oS imp le .h >
8
9#define E VE NT _T IM E 480 // 480 us
10 ui nt 8_t ev ent [EV EN T_ TI ME ];
11
12 // die setup - Funktion wird e inm al beim Start a ufgerufen
13 void setup () {
14 Serial.begin (9600);
15 while (! Serial) ; // wart e auf USB - Ver bindung
16 }
17
18 // die loop - Fun kt ion wird immer wied er a uf ge ru fe n
19 void loop() {
20
21 // W arte bis Ta ster g ed r ¨u ckt
22 if (ftduino.input_get(Ftduino:: I1 ) ) {
23
24 // hole 480 M ik ro sekun de n lang im MiK ro sek un den ta kt je einen E ingangs we rt
25 for (ui nt1 6_t i =0;i<E VENT_TIME ;i++) {
26 eve nt [i] = ftduino.input_ge t (Ftduino:: I1 );
27 _delay_us(1) ;
28 }
29
30 // gib zun ¨a chst 20 N ul len aus
31 for (ui nt1 6_t i =0;i< 20 ; i++)
32 Serial.println( 0) ;
33
34 // gib die e in geles en en 480 W ert e aus
35 for (ui nt1 6_t i =0;i<E VENT_TIME ;i++)
36 Serial.println(event [i]) ;
37
38 // Wart e eine Sekund e
39 delay (1000);
40 }
41 }
Der Sketch wartet in Zeile 22 darauf, dass die Taste an Eingang I1 gedr¨
uckt wird. Daraufhin zeichnet er f¨
ur eine kurze Weile
den Zustand des Eingang I1 auf. In Zeile 9 ist festgelegt, dass 480 Werte aufgezeichnet werden. Zwischen zwei Aufzeich-
nungen wird in Zeile 27 jeweils eine Mikrosekunde gewartet, so dass insgesamt ¨
uber 480 Mikrosekunden aufgezeichnet wird.
Ist die Aufzeichnung vollst¨
andig, dann werden zun¨
achst 20 Zeilen Nullen ausgegeben und danach die vorher aufgezeichneten
480 Werte, so dass insgesamt 500 Werte ausgegeben werden. Die ersten 20 Werte repr¨
asentieren den Zustand vor der
Aufzeichnung, als der Taster noch nicht gedr¨
uckt wurde.
Die insgesamt 500 Werte stellt der serielle Plotter als Kurve dar. Der Wert ist null, wenn der Kontakt als offen erkannt wird
und eins, sobald der Kontakt geschlossen ist. Man sieht in der Grafik, wie der Taster zun¨
achst circa 40 Mikrosekunden lang
mehrfach ¨
offnet und schließt, dann liegt das Signal ¨
uber 100 Mikrosekunden stabil an, bevor der Kontakt noch ein paar mal
¨
offnet, um schließlich nach insgesamt 200 Mikrosekunden stabil geschlossen zu bleiben. Die in L¨
osung 1 eingesetzte Pause
kann also auf gute 200 Mikrosekunden reduziert werden, ohne dass das Prellen Auswirkungen h¨
atte.
Es ist n¨
otig, die Werte vor der Ausgabe komplett zu erfassen und zu speichern, da die ¨
Ubermittlung der Zeichen an den
PC vergleichsweise viel Zeit in Anspruch nimmt. W¨
urden die Werte sofort an den PC ¨
ubermittelt, dann w¨
are die Au߬
osung
von einer Mikrosekunde nicht zu erreichen, da die Daten¨
ubermittlung selbst schon l¨
anger dauert. Tats¨
achlich dauert auch
96 Kapitel 6. Experimente
Abbildung 6.29: Verlauf des Prellens im seriellen Plotter
das Auslesen des Eingangs I1 etwas Zeit und das Zeitverhalten unser Messung ist nicht sehr genau. Es gen¨
ugt aber, um die
prinzipiellen Abl¨
aufe darzustellen.
6.13 Nutzung des I2C-Bus
Schwierigkeitsgrad:
Wie in Abschnitt 1.2.6 beschrieben verf¨
ugt der ftDuino ¨
uber einen I2C-Anschluss. In der Arduino-Welt ist der I2C-Bus
¨
außerst beliebt, denn er erlaubt den einfach Anschluss einer Vielzahl von preisg¨
unstigen Erweiterungsbausteinen.
Der ftDuino wird mit einer Schutzkappe auf dem I2C-Anschluss ausgeliefert wie in Abschnitt 1.2.6 abgebildet. Diese Kappe
muss vor Benutzung des I2C-Anschlusses entfernt werden.
Mit wenig Aufwand lassen sich die meisten Sensoren mit einem passenden Anschlusskabel f¨
ur den ftDuino versehen. In
Abbildung 6.30 ist beispielhaft die Verkabelung einer typischen im Online-Handel g¨
unstig erh¨
altlichen MPU6050-Sensor-
Platine dargestellt. Der Sensor ist damit direkt an den ftDuino anschließbar.
V C C
G N D
SCL
S D A
X D A
X C L
ADO
I N T
MPU-6050 ITG/MPU
(a) Verdrahtungsschema (b) fertiger Sensor
Abbildung 6.30: MPU6050-Sensor mit Anschlusskabel f¨
ur den ftDuino
Um den jeweiligen Sensor in eigenen Projekten zu verwenden sind in der Regel zus¨
atzliche Code-Routinen oder Bibliotheken
n¨
otig. Die große Verbreitung der Arduino-Plattform f¨
uhrt dazu, dass man zu praktisch jedem g¨
angigen Sensor mit wenig
Suche passende Beispiele und Code-Bibliotheken findet12.
12Eine große Sammlung von Sensorbibliotheken findet sich unter https://github.com/ControlEverythingCommunity.
6.13. Nutzung des I2C-Bus 97
Abbildung 6.31: Diverse I2C-Sensoren mit passendem Anschlusskabel an den ftDuino
6.13.1 Sketch I2C/I2cScanner
F¨
ur einen schnellen Test, ob die elektrische Verbindung zum Sensor korrekt ist reicht aber in der Regel ein einfacher Test
der I2C-Kommunikation aus. Unter Datei Beispiele FtduinoSimple I2C I2cScanner findet sich ein einfaches
I2C-Testprogramm, das am I2C-Bus nach angeschlossenen Sensoren sucht und deren Adresse ausgibt. Die jeweilige Adresse
eines Sensors wird in der Regel vom Sensorhersteller fest vergeben. Im Falle des MPU-6050 ist dies die Adresse 0x68. Diese
Adresse wird bei korrektem Anschluss des Sensors angezeigt.
Abbildung 6.32: Ausgabe von I2cScanner bei angeschlossenem MPU-6050
6.13.2 MPU-6050-Sensor
F¨
ur den MPU6050 liefert die ftDuino-Umgebung ein eigenes Beispiel mit. Der Beispiel-Sketch unter Datei Beispiele
FtduinoSimple I2C MPU6050Test liest die Beschelunigungswerte aus dem MPU-6050 aus und gibt sie auf dem
seriellen Monitor aus.
Abbildung 6.33: Ausgabe von MPU6050Test
98 Kapitel 6. Experimente
6.13.3 OLED-Display
Eine weitere naheliegenden Anwendung des I2C-Anschlusses ist der Anschluss eines kleinen Displays, mit dem z.B. direkt
am ftDuino Messwerte ausgegeben werden k¨
onnen.
F¨
ur wenig Geld gibt es im Online-Handel OLED-Displays mit 0,96 Zoll Bilddiagonale. Mit einer Gr¨
oße von etwas unter
3∗3cm2eignen sich diese Displays auch sehr gut f¨
ur den Einbau in ein entsprechendes fischertechnik-kompatibles Geh¨
ause
13.
VCC GND S C L SDA
128x6 4 OLE D
(a) Vorderseite
VCC
GNDSCL
SDA
Ad d re s s Se l e ct
0x7A
0x7B
0
(b) R¨
uckseite
(c) im Geh¨
ause
Abbildung 6.34: OLED-Display mit Anschlusskabel f¨
ur den ftDuino
Beim Anl¨
oten des Kabels muss man sich unbedingt am Aufdruck auf der Display-Platine und nicht an den Skizzen hier
orientieren, da es in der Anschlussbelegung Unterschiede zwischen den ansonsten baugleichen Displays gibt.
Dieses Display verwendet als Display-Controller-Baustein den SSD130614 von Solomon Systech. Diese Display-Sorte ist im
Arduino-Umfeld sehr beliebt und passende Bibliotheken gibt es im Internet1516.
Wichtig: Wie viele andere I2C-Sensoren auch ist das OLED-Display nicht ftDuino-spezifisch, sondern wird auch in anderen
Arduino-Projekten eingesetzt. Daher ist dessen Unterst¨
utzung kein Teil der ftDuino-Installation, sondern es m¨
ussen die o.g.
Adafruit-Bibliotheken unbedingt separat installiert werden. Andernfalls wird die ¨
Ubersetzung des Sketches mit einer Meldung
der Art “fatal error: Adafruit GFX.h: No such file or directory” oder ¨
ahnlich abgebrochen.
Zum Displaytest bringt die Adafruit SSD1306-Bibliothek unter Datei Beispiele Adafruit SSD1306
ssd1306 128x64 i2c ein Beispiel. Erscheint vor dem Download die Meldung “Height incorrect, please fix
Adafruit SSD1306.h!”, dann muss in der Datei Adafruit SSD1306.h folgende ¨
Anderung vorgenommen werden, um
die Unterst¨
utzung des 128x64-Displays zu aktivieren:
72 /* - - -- -- - -- -- - -- - -- -- - -- -- - -- -- - -- - -- -- - -- -- - -- - -- -- - -- -- - -- -- - -- - -- -- - -- -- */
73 #define SSD1306_128_64
74 // # def ine S SD1 306 _12 8_3 2
75 // # def ine S SD1 306 _96 _16
76 /*=========================================================================*/
13https://www.thingiverse.com/thing:2542260
14Datenblatt des SSD1306: https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf
15Adafruit-SSD1306-Bibliothek: https://github.com/adafruit/Adafruit SSD1306
16Adafruit-GFX-Bibliothek: https://github.com/adafruit/Adafruit-GFX-Library
6.13. Nutzung des I2C-Bus 99
Zus¨
atzlich muss im Sketch selbst die I2C-Adresse von 0x3D nach 0x3C angepasst werden:
60 // by default , we ’ll g en erate the high vo ltage from the 3.3 v line i nt ernally ! ( neat !)
61 display.begin (S SD 13 06 _S WITCHCAPVCC , 0 x 3C ) ; // initialize with the I2C addr 0 x3D ( for the
128 x64 )
62 // init done
Die ftDuino-Installation selbst bringt ebenfalls ein Beispiel mit, das dieses Display verwendet. Das Shootduino-Spiel findet
sich unter Datei Beispiele FtduinoSimple Shootduino . Das Spiel erwartet drei Taster an den Eing¨
angen I1,
I2 und I3 zur Steuerung des Raumschiffs und gegebenenfalls eine Lampe an O1.
6.13.4 VL53L0X LIDAR-Distanzsensor
Fischertechnik liefert einen Ultraschallsensor zur Distanzmessung, der wie in Abschnitt 1.2.6 gezeigt auch am ftDuino
betrieben werden kann. Dieser Ultraschallsensor sendet einen Ultraschallimpuls aus und misst die Laufzeit, bis die Schallwelle
ein Hindernis erreicht und zum Sensor zur¨
uck reflektiert. Aus der Laufzeit und der bekannten Schallgeschwindigkeit l¨
asst
sich so die Distanz bestimmen.
In der Arduino-Welt gibt es eine interessante Alternative in Form des VL53L0X-Laser-Distanzsensors. Das Funktionsprinzip
gleicht dem des Ultraschallsensors, allerdings kommt kein Schall, sondern Laserlicht zu Einsatz. Der VL53L0X l¨
asst sich
recht leicht ¨
uber I2C mit dem ftDuino verbinden.
VIN
SCL
SDA
GPIO01
XSHUT
GND
GYVL53L0XV2
Abbildung 6.35: Anschlussschema des VL53L0X an den ftDuino
Ein passendes Geh¨
ause zum selbst-drucken findet sich im ftDuino-Repository17.
Abbildung 6.36: VL53L0X in 3D-gedrucktem Geh¨
ause
Wie f¨
ur fast alle ¨
ublichen I2C-Sensoren findet man auch beim VL53L0X bereits fertige Arduino-Bibliotheken und -Sketches
im Internet18.
17VL53L0X-Geh¨
ause: https://github.com/harbaum/ftduino/tree/master/addons/vl53l0x
18Adafruit-Bibliothek f¨
ur den VL53L0X: https://github.com/adafruit/Adafruit VL53L0X
100 Kapitel 6. Experimente
6.13.5 ftDuino als I2C-Client und Kopplung zweier ftDuinos
Der ftDuino kann nicht nur andere Ger¨
ate ¨
uber den I2C-Bus ansprechen, er kann sich selbst auch als passives Ger¨
at am Bus
ausgeben, um von einem anderen Ger¨
at angesprochen zu werden.
Am einfachsten l¨
asst sich diese M¨
oglichkeit nutzen, wenn zwei ftDuinos direkt ¨
uber I2C gekoppelt werden.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
9 Volt-Versorgung für beide Geräte
I²C-Master I²C-Slave
Abbildung 6.37: Kopplung zweier ftDuinos¨
uber I2C
Es wird dazu eine 1:1-Verbindung zwischen den beiden I2C-Anschl¨
ussen der beteiligten Controller hergestellt. Ein Con-
troller muss in diesem Aufbau als Master konfiguriert werden, einer als Slave. Entsprechende Beispiel-Sketches finden sich
unter Datei Beispiele FtduinoSimple I2C I2cMaster und Datei Beispiele FtduinoSimple I2C
I2cSlave .
Der Master fragt kontinuierlich einen an Eingang I1 angeschlossenen Taster ab und sendet den Zustand des Tasters ¨
uber
I2C an den zweiten, als Slave konfigurierten ftDuino. Dieser schaltet dann eine Lampe an Ausgang O1 entsprechend ein oder
aus.
Die Spannungsversorgung des Masters kann dabei ¨
uber die I2C-Verbindung erfolgen. Lediglich der Slave muss direkt mit 9
Volt versorgt sein, um die Lampe am Ausgang steuern zu k¨
onnen. Die Versorgung ¨
uber I2C entspricht der Versorgung ¨
uber
USB mit den bekannten Einschr¨
ankungen wie in Abschnitt 1.2.5 beschrieben.
Erweiterter I2cSlave
Neben dem einfachen Beispiel Datei Beispiele FtduinoSimple I2C I2cSlave , das auf der funktionsreduzier-
ten FtduinoSimple-Bibliothek aufbaut befindet sich unter Datei Beispiele Ftduino I2C I2cSlave ein auf der
vollwertigen Bibliothek aufbauendes Beispiel, das die meisten Ein- und Ausgabef¨
ahigkeiten des ftDuino ¨
uber I2C verf¨
ugbar
macht.
Dieser erweiterte Sketch eignet sich als Basis f¨
ur komplexe Modelle. Das hier abgebildete Beispiel verwendet drei ftDuinos
zur Erweiterung des Master-ftDuino um weitere 24 Aus- und 36 Eing¨
ange.
Der erste ftDuino im Bild ganz links bildet den Master, gefolgt von den drei Slaves. Auf dem ersten Slave l¨
auft das un-
ver¨
anderte Beispiel aus Datei Beispiele Ftduino I2C I2cSlave . F¨
ur die weiteren Slaves muss die I2C-Adresse
im Sketch jeweils angepasst werden. Das geschieht, indem in Zeile 16 im I2cSlave-Sketch die Adresse 43 ersetzt wird
durch 44 bzw 45 f¨
ur die beiden weiteren Slaves.
13 void setup () {
14 pinMode(LED_BUILTIN ,OUTPUT); // LED initialisieren
15
16 Wire.begin (43); // t ritt I2C - Bus an Adr esse #43 als " S lave " bei
17 Wire.onReceive (receiveEvent); // Auf Schreib - E reignisse r egi strie re n
18 Wire.onRequest (requestEvent); // Auf Lese - Ereigniss e r eg is tr ie ren
19
20 ftduino.init() ;
21
6.13. Nutzung des I2C-Bus 101
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
9 Volt-Versorgung für alle Geräte I²C-Master I²C-Slave #44
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
I²C-Slave #43 I²C-Slave #45
Abbildung 6.38: Kopplung von vier ftDuinos¨
uber I2C
22 // a ll e Au sg ¨a nge sind h oc hoh mig
23 memset(output_mode , 0 , sizeof(output_mode) ) ;
24 }
Der Master enth¨
alt in diesem Fall die gesamte eigentliche Programmlogik und die Slaves nehmen fundamentale Steuerbefehle
¨
uber I2C entgegen. Der Master-Sketch findet sich unter Datei Beispiele Ftduino I2C I2cMaster . In Zeile 12
sind dort die Adressen 43, 44 und 45 der drei Slaves bereits eingestellt. Sollen mehr oder weniger Slaves verwendet werden,
so ist die Zeile 12 entsprechend anzupassen.
9// L iste der a nzu st eu ern de n I2c - Clients , be gin nen d m it 0 ( d er M as ter s elb st )
10 // und -1 als End em ar kie ru ng . In diesem Fall sind drei Clien ts unter den Adr es sen
11 // 43 , 44 und 45 anges ch lo ssen
12 sta tic cons t int8_t clien ts [] = { 0 , 43 , 44 , 45 , -1 };
Die Stromversorgung aller vier ftDuinos kann aus einem fischertechnik-Netzteil erfolgen, das an den Master angeschlossen
wird. Die Slaves werden dann vom 9-Volt-Ausgang des Masters ¨
uber zweipolige fischertechnik-Kabel versorgt.
Abbildung 6.39: Vier ftDuinos¨
uber I2Cgekoppelt
Das Beispiel Datei Beispiele Ftduino I2C I2cMaster eignet sich als Vorlage f¨
ur komplexe Modelle. Je nach
Modell kann es aber praktischer sein, auch die Slaves zu ver¨
andern und zu erweitern. Ger¨
ate bei Modellen mit weitgehend
eigenst¨
andigen Untereinheiten (z.B. Taktstraße) kann es einfacher sein, die einzelnen Stationen jeweils von einem ftDuino
weitgehend autonom steuern zu lassen und die I2C-Kommunikation auf das n¨
otigste zu reduzieren, um z.B. die Ankunft
eines neuen Bauteils in der Station anzuk¨
undigen.
Die folgenden Tabelle listete die I2C-Register, wie sie vom I2cSlave.ino f¨
ur den ftDuino implementiert werden. Werte mit
vorangestelltem 0xsind in Hexadezimalschreibweise dargestellt.
102 Kapitel 6. Experimente
Registerbelegungen f¨
ur Ausg¨
ange O1 bis O8 bzw. M1 bis M4
0x00 Ausgangs-Modus O1/M1
0x0x- Betrieb als Einzelausgang
0x00 - Einzelausgang offen/hochohmig (tristate)
0x01 - Einzelausgang gegen +9V geschaltet (High)
0x02 - Einzelausgang gegen Masse geschaltet (Low)
0x1x- Ausgang mit O2 zum Motorausgang M1 gekoppelt
0x10 - Motorausgang ungebremst aus (off)
0x11 - Motorausgang gebremst aus (brake)
0x12 - Motorausgang links drehend an
0x13 - Motorausgang rechts drehend an
0x01 Ausgangswert (PWM) O1/M1 von 0 (aus) bis 255 (100% an)
Der Zustand des Hardwareausgangs wird beim Schreiben
dieses Registers aktualisiert
0x02 Ausgangs-Modus O2
Der Inhalt dieses Registers wird ignoriert, wenn Ausgangs-Modus O1/M1
(Register 0x00) den Wert 0x1xenth¨
alt
0x00 - Einzelausgang offen/hochohmig (tristate)
0x01 - Einzelausgang gegen +9V geschaltet (High)
0x02 - Einzelausgang gegen Masse geschaltet (Low)
0x03 Ausgangswert (PWM) O2 von 0 (aus) bis 255 (100% an)
Der Inhalt dieses Registers wird ignoriert, wenn Ausgangs-Modus O1/M1
(Register 0x00) den Wert 0x1xenth¨
alt
Der Zustand des Hardwareausgangs wird beim Schreiben
dieses Registers aktualisiert
0x04 Ausgangs-Modus O3/M2, siehe Ausgang-Modus O1 (Register 0x00)
0x05 Ausgangswert O3/M2, siehe Ausgangswert O1 (Register 0x01)
0x06 Ausgangs-Modus O4, siehe Ausgang-Modus O2 (Register 0x02)
0x07 Ausgangswert O4, siehe Ausgangswert O2 (Register 0x03)
0x08 Ausgangs-Modus O5/M3, siehe Ausgang-Modus O1 (Register 0x00)
0x09 Ausgangswert O5/M3, siehe Ausgangswert O1 (Register 0x01)
0x0aAusgangs-Modus O6, siehe Ausgang-Modus O2 (Register 0x02)
0x0bAusgangswert O6, siehe Ausgangswert O2 (Register 0x03)
0x0cAusgangs-Modus O7/M4, siehe Ausgang-Modus O1 (Register 0x00)
0x0dAusgangswert O7/M4, siehe Ausgangswert O1 (Register 0x01)
0x0eAusgangs-Modus O8, siehe Ausgang-Modus O2 (Register 0x02)
0x0fAusgangswert O8, siehe Ausgangswert O2 (Register 0x03)
Registerbelegungen f¨
ur Eing¨
ange I1 bis I8
Es k¨
onnen maximal die beiden Bytes eines Eingangs in einem gemeinsamen I2C-Transfer gelesen werden. Jeder Eingang
muss einzeln gelesen werden.
6.13. Nutzung des I2C-Bus 103
0x10 schreiben: Eingangs-Modus I1
0x00 - Spannung
0x01 - Widerstand
0x02 - Schalter
lesen: Eingangswert I1, Low-Byte (LSB)
0x11 lesen: Eingangswert I1, High-Byte (MSB)
0x12 Eingangs-Modus/Eingangswert I2, siehe Eingangs-Modus I1 (Register 0x10)
0x13 Eingangswert I2, siehe Eingangswert I1 (Register 0x11)
0x14 Eingangs-Modus/Eingangswert I3, siehe Eingangs-Modus I1 (Register 0x10)
0x15 Eingangswert I3, siehe Eingangswert I1 (Register 0x11)
0x16 Eingangs-Modus/Eingangswert I4, siehe Eingangs-Modus I1 (Register 0x10)
0x17 Eingangswert I4, siehe Eingangswert I1 (Register 0x11)
0x18 Eingangs-Modus/Eingangswert I5, siehe Eingangs-Modus I1 (Register 0x10)
0x19 Eingangswert I5, siehe Eingangswert I1 (Register 0x11)
0x1aEingangs-Modus/Eingangswert I6, siehe Eingangs-Modus I1 (Register 0x10)
0x1bEingangswert I6, siehe Eingangswert I1 (Register 0x11)
0x1cEingangs-Modus/Eingangswert I7, siehe Eingangs-Modus I1 (Register 0x10)
0x1dEingangswert I7, siehe Eingangswert I1 (Register 0x11)
0x1eEingangs-Modus/Eingangswert I8, siehe Eingangs-Modus I1 (Register 0x10)
0x1fEingangswert I8, siehe Eingangswert I1 (Register 0x11)
Registerbelegungen f¨
ur Z¨
ahlereing¨
ange C1 bis C4
0x20 schreiben: Z¨
ahler-Modus C1
0x00 - aus
0x01 - steigende Flanke
0x02 - fallende Flanke
0x03 - beide Flanken
0x04 - Ultraschallsensor aktivieren
lesen: Eingangszustand C1
0x21 schreiben: Z¨
ahler C1
0x00 - Z¨
ahler unver¨
andert lassen
sonst - Z¨
ahler l¨
oschen
lesen: Z¨
ahlerstand C1/Ultraschall-Distanz, Low-Byte (LSB)
0x22 Z¨
ahlerstand C1/Ultraschall-Distanz, High-Byte (MSB)
0x24 schreiben: Z¨
ahler-Modus C2
0x00 - aus
0x01 - steigende Flanke
0x02 - fallende Flanke
0x03 - beide Flanken
lesen: Eingangszustand C2
0x25 schreiben: Z¨
ahler C2
0x00 - Z¨
ahler unver¨
andert lassen
sonst - Z¨
ahler l¨
oschen
lesen: Z¨
ahlerstand C2, Low-Byte (LSB)
0x26 Z¨
ahlerstand C2, High-Byte (MSB)
0x28 Z¨
ahler-Modus C3, siehe Z¨
ahler-Modus C2 (Register 0x24)
0x29 Z¨
ahlerstand C3, Low-Byte (LSB), siehe Z¨
ahlerstand C2 (Register 0x25)
0x2aZ¨
ahlerstand C3, High-Byte (MSB), siehe Z¨
ahlerstand C2 (Register 0x26)
0x2cZ¨
ahler-Modus C4, siehe Z¨
ahler-Modus C2 (Register 0x24)
0x2dZ¨
ahlerstand C4, Low-Byte (LSB), siehe Z¨
ahlerstand C2 (Register 0x25)
0x2eZ¨
ahlerstand C4, High-Byte (MSB), siehe Z¨
ahlerstand C2 (Register 0x26)
104 Kapitel 6. Experimente
ftDuino als I2C-Slave am PC
Nat¨
urlich l¨
asst sich der ftDuino als I2C-Slave nicht nur an anderen ftDuinos betreiben, sondern auch an PCs und anderen
Ger¨
aten, wenn sie mit einer entsprechenden I2C-Schnittstelle ausger¨
ustet sind. Im Fall eines PCs l¨
asst sich die n¨
otige I2C-
Schnittstelle auch mit Hilfe eines einfachen Adapters ¨
uber USB nachr¨
usten. Ein solcher Adapter ist der i2c tiny usb19.
P0
GND
P1 P2 P3 P4 P5
5V VIN
(a) Verdrahtungsschema (b) fertiger Adapter
Abbildung 6.40: Digispark/i2c tiny usb zum Anschluss an den I2C des ftDuino
Auf einem Linux PC20 kann das Programm i2c detect verwendet werden. Mit dem Parameter -l kann man sich zun¨
achst
eine Liste aller im PC installierten I2C-Busse ausgeben lassen.
$ i2cdetect -l
i2c-3 unknown i915 gmbus dpc N/A
i2c-1 unknown i915 gmbus vga N/A
i2c-8 i2c em2860 #0 I2C adapter
i2c-6 unknown DPDDC-B N/A
i2c-4 unknown i915 gmbus dpb N/A
i2c-2 unknown i915 gmbus panel N/A
i2c-0 unknown i915 gmbus ssc N/A
i2c-9 i2c i2c-tiny-usb at bus 001 device 023 I2C adapter
i2c-7 unknown DPDDC-C N/A
i2c-5 unknown i915 gmbus dpd N/A
Der Digispark/i2c tiny usb erscheint in diesem Fall als i2c-9. Unter dieser Bus-Nummer l¨
asst sich der I2C-Bus des
i2c tiny usb nach Ger¨
aten absuchen.
$ i2cdetect -y 9
0123456789abcdef
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- 2a -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
In diesem Fall wurde unter Adresse 2a (dezimal 42) der auf der FtduinoSimple-Bibliothek basierende einfache I2cSlave
des ftDuino erkannt.
Im Repository21 findet sich ein Python-Beispiel, mit dem vom PC aus auf den ftDuino zugegriffen werden kann. F¨
ur die
umfangreichere auf der Ftduino-Bibliothek basierende Variante gibt es ebenfalls ein Python-Beispiel im Repository22.
ftDuino als I2C-Slave am TXT
Wie im Abschnitt 6.13 erw¨
ahnt ist mit 3,3 Volt betriebene I2C-Anschluss des fischertechnik-TXT-Controllers nicht elektrisch
kompatibel zum mit 5 Volt betriebenen I2C-Anschluss des ftDuino.
19Weitere Infos zum i2c tiny usb finden sich unter https://github.com/harbaum/I2C-Tiny-USB
20Auch der Raspberry-Pi oder der fischertechnik TXT sind Linux-PCs
21 https://harbaum.github.io/ftduino/ftduino/libraries/FtduinoSimple/examples/I2C/I2cSlave/master.py
22 https://harbaum.github.io/ftduino/ftduino/libraries/Ftduino/examples/I2C/I2cSlave/master.py
6.13. Nutzung des I2C-Bus 105
Einfacher Levelshifter
Mit Hilfe eines passenden Pegel-Wandlers kann man aber leicht die n¨
otige Signalanpassung vornehmen. Die Elektronik dazu
ist preisg¨
unstig im Online-Handel erh¨
altlich. Man sollte darauf achten, dass die Elektronik die Spannungsversorgung der
3,3-Volt-Seite selbst aus der Versorgung der 5-Volt-Seite erzeugt, da der TXT selbst keine 3,3 Volt zur Verf¨
ugung stellt.
AV CC
ASCL
ASDA
AG N D
BVC C
BSCL
BG N D
BSDA
TXT
ftDuino
(a) Kabelschema (b) Anschluss an den TXT
Abbildung 6.41: Levelshifter zur Verbindung von TXT und ftDuino
6.13.6 ftDuino-I2C-Expander
Die Funktion eines Levelshifters erf¨
ullt auch der sogenannte I2C-Expander23. Dieses Ger¨
at wurde zum Einsatz am ftDuino
entworfen, kann aber auch am TXT oder TX betrieben werden.
(a) fertiges Ger¨
at (b) Einzelteile
Abbildung 6.42: I2C-Expander f¨
ur den ftDuino
Der I2C-Expander stellt einen TXT-kompatiblen 10-poligen I2C-Anschluss bereit und vier 6-polige TX- bzw. ftDuino-
kompatible. Die vier ftDuino-kompatiblen Anschl¨
usse sind 1-zu-1 verbunden und k¨
onnen zum Anschluss mehrerer I2C-Ger¨
ate
an den ftDuino verwendet werden. Zus¨
atzlich ist eine Levelshifter enthalten, der einen Anschluss an den TXT bzw. an dessen
Sensoren erlaubt. Die Spannungsversorgung des Levelshifters erfolgt vom ftDuino.
Eine passende App f¨
ur die Community-Firmware des fischertechnik-TXT-Controllers findet sich im cfw-apps-Repository24.
Da I2C-Ger¨
ate am TXT auch unter RoboPro und der Originalfirmware angesteuert werden k¨
onnen l¨
asst sich der ftDuino
auf diese Weise auch unter RoboPro als Erweiterung des TXT nutzen.
6.13.7 fischertechnik-Orientierungssensor
Das Kabel zum Anschluss des ftDuino an den TXT und der I2C-Expander sind nicht auf eines feste Richtung festgelegt. Sie
k¨
onnen daher auch dazu verwendet werden, f¨
ur den TXT entworfene Sensoren an den ftDuino anzuschließen.
23Der ftDuino-I2C-Expander: https://github.com/harbaum/ftduino/tree/master/addons/i2c-expander
24 https://github.com/harbaum/cfw-apps/tree/master/packages/ftDuinoI2C
106 Kapitel 6. Experimente
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 6.43: Anschluss eines fischertechnik-Sensors via I2C-Expander
Getestet wurde dies z.B. mit dem “Kombisensor 15840225 3-in-1 Orientierungssensor”26 basierend auf dem Bosch BMX055,
f¨
ur den es auch fertige Arduino-Sketches gibt27. Der Anschluss der 9-Volt-Versorgungsspannung erfolgt dabei exakt wie
beim TXT an einem der 9-Volt-Ausg¨
ange des ftDuino.
(a) am Levelshifter (b) am I2C-Expander
Abbildung 6.44: Orientierungssensor von fischertechnik am ftDuino
6.13.8 fischertechnik-Umweltsensor
Der Umweltsensor aus dem “ROBOTICS TXT Smart Home”-Baukasten 54462428 basiert auf dem BME68029 von Bosch
Sensortec. Er beinhaltet Sensoren f¨
ur Temperatur, Luftdruck, Luftfeuchtigkeit und Luftqualit¨
at.
Auch f¨
ur diesen Sensor gibt es im Arduino-Umfeld diverse Bibliotheken, die ¨
uber den Bibliotheks-Manager der Arduino-IDE
leicht zu installieren sind, wie in Abbildung 6.45 zu sehen. F¨
ur erste Experimente empfielt sich die Bibliothek von Adafruit.
Die I2C-Adresse des BME680 ist durch entsprechende Verdrahtung verstellbar. Fischertechnik stellt die Adresse auf 0x76
ein w¨
ahrend die Adafruit-Bibliothek den Sensor standardm¨
aßig unter der Adresse 0x77 erwartet. In den Beispielen unter
Datei Beispiele Adafruit BME680 Library muss daher jeweils die von fischertechnik verwendete Adresse explizit
angegeben werden. Der Aufruf der Funktion bme.begin() ist in den Beispielen wie folgt zu ¨
andern:
if (! bme .begin (0 x76 )) {
Serial.println(" Could not find a valid BME68 0 sensor , check wi ring !" );
while (1) ;
25fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=158402
26https://content.ugfischer.com/cbfiles/fischer/Zulassungen/ft/158402-Kombisensor-Kurzanleitung-BMX055-2017-06-09.pdf
27https://github.com/ControlEverythingCommunity/BMX055
28fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=544624
29Bosch BME680: https://www.bosch-sensortec.com/bst/products/all products/bme680
6.13. Nutzung des I2C-Bus 107
Abbildung 6.45: Arduino-Bibliotheken f¨
ur den BME680
}
Der Sensor l¨
asst sich mit dem Levelshifter als auch mit dem I2C-Expander betreiben sowie mit dem ft-Extender (siehe
Abschnitt 8.5).
(a) Anschluss per Levelshifter (b) Ausgabe von Datei .Beispiele .Adafruit BME680 Library .
bme680test
Abbildung 6.46: fischertechnik-Umweltsensor am ftDuino
Die Luftqualit¨
at wertet der BME680 durch Erhitzen und Widerstandsmessung aus. Die Adafruit-Bibliothek liefert hier
lediglich den wenig aussagekr¨
aftigen Widerstandswert. Bosch selbst liefert eine Closed-Source-Bibliothek, um den Wert in
den ACQ-Qualit¨
atswert umzurechnen, den auch fischertechnik selbst in seinen Bauk¨
asten nutzt. Diese Bibliothek ist auch
f¨
ur den Arduino erh¨
altlich, allerdings ist die Bibliothek zu groß f¨
ur den Flash-Speicher des ftDuino.
Eine alternative Berechnung eines abstrakten “Air-Quality”-Wertes airq sieht wie folgt aus.
gas_baseline = 20 0000.0;
hum_baseline = 40.0;
hum_weighting = 0.25;
ga s_ of fs et =gas_baseline -gas_resistance;
hu m_ of fs et =h umidity -hum_baseline;
hum_score = (100 - hum_baseline -hu m_offset ) /
(100 - hum_baseline) * ( hum_weighting * 10 0) ;
gas_score = ( gas_resistance /gas_baseline) * (100 - ( hum_weighting * 10 0) ) ;
airq =hum_score +gas_score;
108 Kapitel 6. Experimente
6.13.9 Mini-I2C-Servo-Adapter
Speziell f¨
ur den ftDuino wurde der Mini-I2C-Servo-Adapter entworfen. Er vereint trotz seiner geringen Gr¨
oße eine Span-
nungsversorgung und eine Servosteuerung in einem Geh¨
ause.
Abbildung 6.47: Der Mini-I2C-Adapter am ftDuino
Anschluss und Inbetriebnahme
Zur Erstinbetriebnahme sollte nur die I2C-Verbindung zwischen ftDuino und Mini-I2C-Adapter hergestellt werden. Generell
ist es ratsam, den ftDuino von der Spannungs- und USB-Versorgung zu trennen, w¨
ahrend die I2C-Verbindungen hergestellt
und getrennt werden. Sobald die Verbindung hergestellt ist kann der ftDuino eingeschaltet werden. Die Leuchtdiode im
Mini-I2C-Adapter sollte f¨
ur ca. eine Sekunde aufleuchten und dann verl¨
oschen.
Auf dem ftDuino sollte f¨
ur den ersten Test der Datei Beispiele FtduinoSimple I2C I2cScanner -Sketch in-
stalliert werden. Weder 9 Volt noch der Servoanschluss werden f¨
ur erste Tests ben¨
otigt. Der I2cScanner-Sketch sollte nun
unter Adresse 0x11 den Adapter finden:
I2C Scanner
Scanning...
I2C device found at address 0x11 !
done
Jedesmal wenn der Adapter vom ftDuino angesprochen wird sollte die Leuchtdiode im Adapter kurz aufleuchten. Sollte
dieser Test nicht klappen sollte das I2C-Kabel ¨
uberpr¨
uft werden (sind beiden Stecker korrekt orientiert?). Funktionieren
andere Ger¨
at am I2C-Anschluss des ftDuino?
War dieser Test erfolgreich, dann k¨
onnen Servo und 9-Volt-Versorgung angeschlossen werden wie in Abbildung 6.48 zu
sehen. Auch hier sollte der ftDuino w¨
ahrend der Umverkabelung von der Strom- und USB-Versorgung getrennt werden.
Der Mini-I2C-Adapter wird zwischen den I2C-Ausgang des ftDuino und den Anschluss des Servos gesteckt. Zus¨
atzlich wird
eine 9-Volt-Verbindung zur Spannungsversorgung des Servos ben¨
otigt. Der Mini-I2C-Adapter reduziert die fischertechnik-
¨
ublichen 9 Volt auf Servo-vertr¨
agliche 5 Volt.
Sind alle Verbdidungen hergesellt kann z.B. der Sketch unter Datei Beispiele FtduinoSimple I2C
MiniServoAdapter verwendet werden. Er steuert kontiniertlich beide Servoausg¨
ange gegenl¨
aufg an.
Programmierung
Die Programmierung des Mini-I2C-Servo-Adapters ist recht einfach, ein simples Beispiel findet sich unter Datei
Beispiele FtduinoSimple I2C MiniServoAdapter . Das Setzen eines Ausgangs auf einen Wert ben¨
otigt lefig-
lich folgenden Code:
6.14. WS2812B-Vollfarb-Leuchtdioden 109
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Servo
9V
I²C
1
2
Abbildung 6.48: Anschluss des Mini-I2C-Adapters an den ftDuino
Wire.beginTransmission(ADDRESS) ;
Wire.write (0 x00); // 0 = se rvo 1 , 1 = s ervo 2
Wire.write (94); // Mitte , 63 ( ganz lin ks ) bis 125 ( ganz re chts )
Wire.endTransmission() ;
Registerbelegung
Die Standard-Adresse des Mini-I2C-Servo-Adapters ist hex 0x11 bzw. dezimal 17. Diese Adresse kann permanent ge¨
andert
werden (s.u.). Sollte man die Adresse vergessen haben, dann hilft der Datei Beispiele FtduinoSimple I2C
I2cScanner -Sketch, die Adresse des Adapters zu bestimmen.
Register Beschreibung
0x00/0x01 Setzen der Pulsweite der Servoausg¨
ange 1 oder 2 in Schritten von 16 s. In der Standardeinstellung
werden nur Werte im f¨
ur Servos geeigneten Bereich von 63 (1ms) bis 125 (2ms) akzeptiert. Werte
außerhalb dieses Bereiches werden gekappt. Die Grenzen k¨
onnen ver¨
andert werden (s.u.).
0x02/0x03 Setzen der unteren Grenze der Pulsweise von Servo 1 bzw. Servo 2 in 16 s-Schritten. Standard-
wert ist 63. Werte gr¨
oßer als diese Grenze, die in die Register 0x00 und 0x01 geschrieben werden
werden auf diese untere Grenze beschr¨
ankt.
0x04/0x05 Setzen der oberen Grenze der Pulsweise von Servo 1 bzw. Servo 2 in 16 s-Schritten. Standardwert
ist 125. Werte kleiner als diese Grenze, die in die Register 0x00 und 0x01 geschrieben werden
werden auf diese obere Grenze beschr¨
ankt.
0x06/0x07 Das Schreiben dieses Registers setzt einen Offset f¨
ur Servo 1 oder 2. Der Standardwert ist 0.
Der Offset wird zu der durch Register 0x00 oder 0x01 gesetzen Pulsweise addiert nachdem die
Grenzen ¨
uberpr¨
uft wurden. Auf diese Weise l¨
asst sich z.B. die Mittelstellung an die individuallen
Eigenschaften eines Servos anpassen.
0x08 Setzen der I2C-Adresese. Die neue Adresse muss im Bereich von 0x03 bis 0x77 liegen mit
Ausnahme von 0x3c(diese Adresse wird vom internen OLED-Display entsprechender ftDuinos
verwendet).
0x09 Das Schreiben von 0xa5in Register 0x09 ¨
ubertr¨
agt speichert die ¨
uber Register 0x02 bis 0x08
gemachten Einstellungen permanent im EEPROM. Ab diesem Zeitpunkt bleiben die Einstellungen
auch ¨
uber einen Neustart und Stromlosigkeit erhalten.
0x00 lesen Das Lesen von Register 0x00 liefert die Firmwareversion in BCD-Kodierung zur¨
uck. Also bei-
spielsweise 0x10 f¨
ur Version 1.0
0x01+ lesen Alle anderen Register liefern beim Lesen 0x5a
6.14 WS2812B-Vollfarb-Leuchtdioden
Schwierigkeitsgrad:
110 Kapitel 6. Experimente
Die Nutzung von WS2812B-Leuchtdioden am ftDuino erfordert etwas L¨
otarbeit sowie die Installation von Hilfs-Bibliotheken.
Dieses Projekt wird daher nur einem fortgeschrittenen Nutzer empfohlen.
Der I2C-Anschluss des ftDuino ist zwar prim¨
ar zum Anschluss von I2C-Ger¨
aten gedacht. Da die dort angeschlossenen
Signale SDA und SCL aber auf frei benutzbaren Anschl¨
usse des ATmega32u4-Mikrocontrollers liegen k¨
onnen sie auch f¨
ur
andere Signalarten zweckentfremdet werden. Ein solches Signal ist der serielle synchrone Datenstrom, wie ihn die WS2812B-
Leuchtdioden verwenden. Diese Leuchtdioden gibt es f¨
ur kleines Geld als Meterware bei diversen Online-Anbietern.
Um die interne Stromversorgung des ftDuino nicht zu ¨
uberlasten sollten maximal zwei WS2812B-Leuchtdioden an der 5-
Volt-Versorgung des I2C-Anschlusses des ftDuino betrieben werden. Sollen mehr Leuchtdioden verwendet werden, so ist eine
separate externe 5-Volt-Versorgung vorzusehen.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
+5V
DO
DI
GNDGND
+5V +5V
DO
DI
GNDGND
+5V
Abbildung 6.49: Anschluss von zwei WS2812B-Vollfarb-Leuchtdioden
Jeder WS2812B-Leuchtdiodenstreifen verf¨
ugt ¨
uber drei Eingangssignale: Masse,+5V und DI. Versorgungssignale Masse und
+5V werden direkt mit ihren Gegenst¨
ucken am I2C-Anschluss verbunden. Das Signal DI steht f¨
ur “Data In” und ist der
Datensignaleingang der Leuchtdioden. Der ebenfalls am anderen Ende des Leuchtdiodenstreifens vorhandene Datenausgang
(DO) darf nicht verwendet werden. Er leitet das ¨
uber DI empfangene Signal gegebenenfalls an zus¨
atzliche Leuchtdioden
weiter. Das DI-Signal kann wahlweise mit dem SCL oder SDA-Pin des I2C-Anschluss verbunden werden. Der entsprechende
Signalname muss sp¨
ater im Sketch eingetragen werden.
Die Leuchtdioden sollten mit Vorsicht angeschlossen werden. Kurzschl¨
usse oder falsche Verbindungen k¨
onnen die Leuchtdi-
oden und den ftDuino besch¨
adigen.
6.14.1 Sketch WS2812FX
Das Beispiel zu Ansteuern der WS2812B-Leuchtdioden sowie die n¨
otige Code-Bibliothek k¨
onnen beispielsweise der
WS2812BFX-Bibliothek30 entnommen werden. Andere Bibliotheken zur Ansteuerung der WS2812B-Leuchtdioden d¨
urften
gleichermaßen zu nutzen sein.
Die Installation der Bibliothek erfordert etwas Erfahrung mit der Arduino-IDE. Wurde die Bibliothek korrekt installiert, dann
finden sich diverse Beispiele unter Datei Beispiele WS2812FX . Das Beispiel auto mode cycle ist gut geeignet, die
Funktion der Leuchtdioden zu ¨
uberpr¨
ufen.
Am Beginn des Sketches sind lediglich zwei kleine ¨
Anderungen vorzunehmen, um die Zahl und den verwendeten Anschluss
der Leuchtdioden anzupassen.
1#include < W S2 81 2FX .h >
2
3#define L ED_COUNT 2
4#define LED_ PI N SCL
5
6#define TIMER_ MS 5000
30https://github.com/kitesurfer1404/WS2812FX
6.15. Musik aus dem ftDuino 111
6.15 Musik aus dem ftDuino
Schwierigkeitsgrad:
Der ftDuino verf¨
ugt ¨
uber keinen eingebauten Lautsprecher und kann daher ohne Hilfe keine T¨
one ausgeben. Es ist aber
problemlos m¨
oglich, einen Lautsprecher an einen der Ausg¨
ange des ftDuino anzuschließen. Dazu eignet sich nat¨
urlich
besonders gut die fischertechnik Lautsprecherkassette 36936.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 6.50: Anschluss der Lautsprecherkassette an den ftDuino
Wichtig ist, dass ein Vorwiderstand von mindestens 100 Ωzwischen den Lautsprecher und den ftDuino geschaltet wird.
Werden die 9 Volt des ftDuino direkt auf den Lautsprecher gelegt, dann kann der Lautsprecher sehr leicht Schaden nehmen
und erzeugte T¨
one w¨
aren extrem laut. Der Vorwiderstand begrenzt den maximal fließenden Strom und sch¨
utzt Lautsprecher
und Geh¨
or.
Schaltet man nun den Ausgang O2 mit 50% PWM-Verh¨
altnis ein, so kann man das PWM-Signal direkt h¨
oren.
ftduino.o ut pu t_ set (Ftduino:: O2 ,Ftduino:: HI ,Ftduino:: MAX /2 ) ;
Durch das 50% PWM-Signal wird der Ausgang permanent zwischen HI und OFF umgeschaltet (siehe auch Abschnitt 6.3).
Nur wenn der Ausgang HI ist fließt ein Strom vom Ausgang ¨
uber den Lautsprecher zum Masse-Anschluss. Da die PWM-
Frequenz der Ftduino-Bibliothek circa 200 Hertz betr¨
agt h¨
ort man dann einen Ton in dieser Frequenz.
Die PWM-Erzeugung wird wie im Abschnitt 6.3 beschrieben nicht ¨
uber daf¨
ur vorgesehene PWM-Ausg¨
ange des ATmega32u4-
Mikrocontrollers erzeugt sondern durch Signale, die der Mikrocontroller kontinuierlich ¨
uber seinen SPI-Bus an die Ausgangs-
treiber sendet. Dieses Vorgehen ist sehr flexibel und erlaubt es, alle acht Ausg¨
ange mit unabh¨
angigen Signalen zu steuern,
es erfordert aber ein konstantes Mitarbeiten des Mikrocontrollers und nimmt einen gewissen Prozentsatz seiner Rechen-
zeit permanent in Anspruch. Je h¨
oher die PWM-Frequenz, desto h¨
aufiger muss der Mikrocontroller die Signale ¨
andern
und desto h¨
oher ist der Bedarf an Rechenzeit, die nicht im eigentlichen Sketch zur Verf¨
ugung steht. Bei 200 Hertz ist
dieser Effekt zu vernachl¨
assigen. F¨
ur eine Tonerzeugung sind aber Frequenzen im Kilohertzbereich n¨
otig. Sollen nicht nur
digitale an/aus-Rechtecksignale sondern z.B. auch analoge Sinussignale erzeugt werden, dann sind sogar PWM-Signale im
Megahertz-Bereich n¨
otig. Das kann der ATmega32u4 ¨
uber den SPI-Bus nicht leisten.
Die MC33879-Ausgangstreiber haben jeweils zwei Eing¨
ange31, die am SPI-Bus vorbei direkt angesteuert werden k¨
onnen.
Im ftDuino liegen die meisten dieser Eing¨
ange auf Masse, aber der f¨
ur den Ausgang O2 zust¨
andige Eingang EN6 des
Ausgangstreibers U3 ist mit dem Pin PB7 des ATmega32u4 verbunden. Damit l¨
asst sich einer der Ausgangstransistoren des
Ausgangstreibers ¨
uber diesen Pin am ATmega32u4 direkt schalten. In der Arduino-Welt hat dieser Pin die Nummer 11 und
l¨
asst sich mit den ¨
ublichen Arduino-Funktionen schalten.
// Highside - Tre iber von Ausg an g O2 f¨ur eine Se ku nde ak ti vieren
pinMode(11 , OUTPUT) ;
digitalWrite(11 , HIGH) ;
delay (1000);
digitalWrite(11 , LOW );
Um den Effekt am Ausgang zu sehen muss die FtduinoSimple-Bibliothek in den Sketch eingebunden sein, da die nach wie
vor n¨
otige Initialisierung der Ausgangstreiber durch die Bibliothek erfolgt.
31EN5 und EN6, siehe http://cache.freescale.com/files/analog/doc/data sheet/MC33879.pdf
112 Kapitel 6. Experimente
6.15.1 Sketch Music
Schwierigkeitsgrad:
Alternativ k¨
onnen auf diesen Pin auch die Arduino-Befehle zur Ton-Erzeugung angewendet werden. Der Beispielsketch unter
Datei Beispiele FtduinoSimple Music nutzt dies.
// K am me rt on A f¨ur eine Seku nde spiel en
tone(11 , 440 , 100 0) ;
6.15.2 Sketch MusicPwm
Schwierigkeitsgrad:
Der verwendete Pin PB7 ist Teil des ATmega32u4-internen Timer 1. Das bedeutet, dass spezielle Hardware des ATmega32u4
zur Signalerzeugung herangezogen werden kann. Damit k¨
onnen Signale hoher Frequenz ganz ohne Einsatz von Rechenleistung
erzeugt werden.
Der Beispiel-Sketch Datei Beispiele FtduinoSimple MusicPwm nutzt das, um die exakt gleiche Melodie wie der
vorige Sketch zu erzeugen. Der Code ist deutlich kryptischer und sieht komplizierter aus. W¨
ahrend die Arduino-tone()-
Funktion aber im Hintergrund in einem sogenannten Timer-Interrupt Rechenleistung ben¨
otigt, um den Ton zu erzeugen
werden die T¨
one in diesem Beispiel allein aus der sogenannten Timer-Hardware des ATmega32u4-Prozessors erzeugt. Ledig-
lich zum ¨
Andern der Tonh¨
ohe oder zum Stoppen der Tonausgabe ist der eigentliche Rechenteil des Prozessors verantwortlich.
In einem einfachem Musik-Beispiel wie diesem ist der Hintergrundbedarf an Rechenleistung zu vernachl¨
assigen. Sollen aber
sehr hohe Frequenzen, z.B. im Ultraschallbereich oder h¨
oher erzeugt werden, so steigt der Bedarf an Rechenleistung im
Hintergrund, da mit h¨
oheren Frequenzen h¨
aufiger das Signal ge¨
andert werden muss. Die Verwendung der Timer-Hardware
hat dieses Problem nicht. Die zur Tonerzeugung n¨
otigen Signalwechsel, also das permanente Ein- und Ausschalten des
Ausgangs in der gew¨
unschten Ton-Frequenz wird automatisch erledigt und ben¨
otigt daher auch bei hohen Frequenzen
keinerlei Rechenzeit des Mikrocontrollers.
6.16 Der ftDuino als MIDI-Instrument
Einen Lautsprecher anzuschließen ist nur eine Art, T¨
one zu erzeugen. Baukastensysteme wie fischertechnik laden nat¨
urlich
ein, auf elektromechanische Weise T¨
one auszugeben z.B. mit Hilfe der Klangrohre aus der Dynamic-Baukastenserie.
Mit seiner flexiblen USB-Schnittstelle bietet der ftDuino eine elegante Methode, solche F¨
ahigkeiten nutzbar zu machen. Die
sogenannte MIDI-Schnittstelle32 wurde entwickelt, um Computer und elektronische Musikinstrumente zu verbinden. Neben
der elektrisch sehr speziellen MIDI-Verbindung gibt es eine Variante von MIDI ¨
uber USB. Die Arduino-Umgebung bietet
daf¨
ur die MIDIUSB-Bibliothek an, die ¨
uber die Bibliotheksverwaltung der IDE direkt installiert werden kann.
Abbildung 6.51: Installation der MIDIUSB-Bibliothek in der Arduino-IDE
6.16.1 Sketch MidiInstrument
Der ftDuino-Beispielsketch unter Datei Beispiele FtduinoSimple MidiInstrument nutzt diese Bibliothek, um
den ftDuino als MIDI-Ger¨
at f¨
ur den PC nutzbar zu machen. Treiber f¨
ur entsprechende Ger¨
ate bringen die g¨
angigen Betriebs-
systeme bereits mit und Windows, Linux und MacOS erkennen einen zum MIDI-Ger¨
at konfigurierten ftDuino ohne weitere
Treiberinstallation als USB-Audio-Ger¨
at.
32MIDI, Musical Instrument Digital Interface, https://en.wikipedia.org/wiki/MIDI
6.17. Der ftDuino am Android-Smartphone 113
Der ftDuino ist ein sogenanntes USB-Verbundger¨
at. Das bedeutet, dass er mehrere USB-Funktionen gleichzeitig umsetzen
kann. Im MIDI-Fall bedeutet das, dass er gegen¨
uber dem PC als MIDI-Ger¨
at erscheint und gleichzeitig weiterhin ¨
uber die
USB-COM:-Schnittstelle verf¨
ugt, was speziell w¨
ahrend der Sketchentwicklung sehr praktisch sein kann.
Ein mit dem MidiInstrument-Sketch versehener ftDuino wird z.B. von einem Linux-PC mit den g¨
angigen MIDI-Werkzeugen
erkannt:
$ aplaymidi -l
Port Client name Port name
14:0 Midi Through Midi Through Port-0
24:0 ftDuino ftDuino MIDI 1
$ aplaymidi -p 24:0 demosong.mid
...
Der ftDuino wird eine Stimme des Songs auf einem an O2 angeschlossenen Lautsprecher abspielen und gleichzeitig auf
dem COM:-Port Informationen ¨
uber die empfangenen Befehle ausgeben und damit als Basis f¨
ur eine elektromechanisches
Instrument dienen.
Nur wenige MIDI-Dateien lassen sich mit diesem einfachen Setup befriedigend abspielen, weil dieses einfache Beispiel nur
monophon ist und nur einen Ton zur Zeit abspielen kann. Mehrstimmige Lieder k¨
onnen nicht abgespielt werden. Diese
Beschr¨
ankung l¨
asst sich in einem mehrstimmigen mechanischen Musikmodell nat¨
urlich aufheben und ergibt sich allein aus
der sehr simplen hier verwendeten Art der Tonerzeugung.
Eine monophone Beispieldatei song.mid findet sich im Verzeichnis des Sketches.
6.17 Der ftDuino am Android-Smartphone
Schwierigkeitsgrad:
Mit den meisten modernen Android-Smartphones und -Tabletts l¨
asst sich der ftDuino ¨
uber ein passendes Kabel direkt
verbinden. Daf¨
ur ist ein sogenanntes USB-On-the-Go(USB-OTG)-Kabel notwendig. F¨
ur den ftDuino eignet sich das Lindy
31717 gut. Es verf¨
ugt an beiden Enden ¨
uber die passenden Stecker und ist mit 50cm kurz genug, um in einem Modell
untergebracht zu werden.
(a) Screenshot (b) Smartphone am ftDuino
Abbildung 6.52: Android-Demo zur Nutzung des ftDuino am Smartphone
114 Kapitel 6. Experimente
Mit USB-OTG ¨
ubernimmt das Smartphone die Rolle des PCs. Es beim Anschluss eines entsprechenden Kabels eine Spannung
am USB-Anschluss bereit und ¨
ubernimmt die Steuerung des USB-Bus als aktiver sogenannter USB-Host. Werden die
Ausg¨
ange des ftDuino nicht ben¨
otigt, so kann auf diese Weise sogar auf eines eigenen Stromversorgung des ftDuino verzichtet
werden. Der ftDuino wird dann vom Handy mit Strom versorgt.
Die gesamte Kommunikation zwischen Smartphone und ftDuino l¨
auft ¨
uber die serielle USB-Verbindung (COM-Port) und
wird ftDuino-seitig nicht anders behandelt als die ¨
ubliche Kommunikation mit dem PC. In einigen F¨
allen mag es sinnvoll sein,
wenn dem ftDuino bekannt ist, ob die USB-Verbindung zum Smartphone besteht oder nicht, wenn z.B. ohne Smartphone
eine automatische Funktion ausgef¨
uhrt werden soll w¨
ahrend mit angeschlossenem Smartphone eine manuelle Bedienung
erw¨
unscht ist. Das ist im Sketch ¨
uber die Abfrage der USB-Stromversorgung m¨
oglich.
// Ab frage der USB - St rom ve rsorg un g vo rb er ei te n ( z. B . in der setup () - Fu nk ti on )
USBCON |= ( 1 < < OTGPADE) ;
// A bfrag e der USB - S tr omv er sor gu ng
if (USBSTA & (1 < < VBUS)) {
// USB ist verbunde n
// ...
}else {
// USB ist nicht v er bu nd en
// ...
}
Ein kompletter einfacher Demo-Sketch findet sich unter Datei Beispiele FtduinoSimple USB AndroidDemo .
Er sendet ¨
uber USB einmal pro Sekunde eine Nachricht (“COUNTER: XX”) und erwartet die Nachricht “ON” oder “OFF”
und schaltet den Ausgang O1 entsprechend.
Im ftDuino-Repository findet sich die dazu passende Android-App33. Sie l¨
asst sich im AndroidStudio ¨
ubersetzen und als
Basis f¨
ur eigene Entwicklungen nutzen. Die Android-App basiert auf der UsbSerial-Bibliothek34 und kann nach minimalen
Anpassungen neben dem ftDuino auch die meisten Arduinos anbinden.
Die Benutzung ist sehr viel einfacher als die sonst verwendeten Bluetooth- oder WLAN-Verbindungen, da sie keine wei-
tere Konfiguration erfordert. Sobald Smartphone und ftDuino verbunden werden startet die entsprechende App und die
Verbindung ist vollst¨
andig.
6.18 WebUSB: ftDuino via Webbrowser steuern
Schwierigkeitsgrad:
Die ¨
ubliche Weise, auf USB-Ger¨
ate wie den ftDuino zuzugreifen folgt einem festen Schema: Auf dem PC werden passenden
Treiber installiert, die dem PC mitteilen, wie die Kommunikation mit dem dem Ger¨
at abzulaufen hat. Eine PC-Anwendung
wie die Arduino-IDE nutzt diesen Treiber, um auf das Ger¨
at zuzugreifen.
WebUSB35 ist der Versuch, die Benutzung von USB-Ger¨
aten massiv zu vereinfachen, indem auf Treiber- und Softwar-
einstallation komplett komplett verzichtet wird. Stattdessen bringt eine spezielle Webseite alles mit, um direkt mit einem
entsprechend angepassten USB-Ger¨
at zu kommunizieren. Dabei kann das USB-Ger¨
at dem PC mitteilen, unter welcher URL
die steuernde Webseite zu finden ist. F¨
ur den Anwender ergibt sich so eine echte Plug-’n-Play-L¨
osung. Nach dem Anstecken
eines bisher unbekannten WebUSB-Ger¨
ates ¨
offnet der Browser direkt die passende Webseite und das Ger¨
at kann sofort ohne
Treiber- oder Softwareinstallation verwendet werden.
6.18.1 Chrome-Browser
WebUSB ist kein offizieller Web-Standard und wird daher lediglich von Googles Chromebrowser36 unterst¨
utzt. Chrome muss
f¨
ur dieses Experiment nicht auf dem PC installiert sein, es reicht, die sogenannte Portable-Version37 z.B. von einem USB-
Stick zu starten. Aus Sicherheitsgr¨
unden hat Google in aktuellen Versionen die M¨
oglichkeit zum automatischen Start der
33ftDuino-Android-App: https://github.com/harbaum/ftduino/tree/master/android
34UsbSerial f¨
ur Android: https://github.com/felHR85/UsbSerial
35WebUSB: https://developers.google.com/web/updates/2016/03/access-usb-devices-on-the-web
36Google-Chrome-Browser: https://www.google.com/intl/de ALL/chrome/
37Chrome-Portable: https://portableapps.com/apps/internet/google chrome portable
6.18. WebUSB: ftDuino via Webbrowser steuern 115
vom Ger¨
at gemeldeten URL unterbunden. Die URL https://harbaum.github.io/ftduino/webusb/console muss daher manuell
im Browser angegeben werden.
Der Chrome-Browser ist der von Google mitgelieferte Browser auf Anrdoid-Smartphones und -Tabletts. Diese Version eignet
sich ebenfalls f¨
ur WebUSB-Experimente. Zum Anschluss des ftDuino an das Smartphone wird ein USB-Host-Kabel (z.B.
Lindy 31717, siehe Abschnitt 6.17) ben¨
otigt.
Abbildung 6.53: Der Chrome-Browser ist auf den meisten Android-Ger¨
aten vorinstalliert
Auf Linux-PCs erf¨
ullt den gleichen Zweck der Chromium-Browser. Er l¨
asst sich normalerweise ¨
uber den Paketmanager
nachinstallieren. Im Gegensatz zur Windows-Version funktioniert hier auch das automatische Weiterleiten an die vom USB-
Ger¨
at bereitgestellte URL wie in Abbildung 6.54 zu sehen.
Abbildung 6.54: Meldung beim Eistecken des ftDuino bei laufendem Chromium-Browser
Auf Linux-PCs hat der Webbrowser normalerweise keine ausreichenden Rechte, um USB-Ger¨
ate direkt ansprechen zu d¨
urfen.
Die Installation der udev-Regeln wie in Abschnitt 2.1.3 beschrieben erm¨
oglicht den Zugriff.
6.18.2 WebUSB-Sketches
Einige WebUSB-Beispiel-Sketches werden als Beispiel in der ftDuino-Installation der Arduino-IDE unter Datei
Beispiele WebUSB mitgeliefert.
Die URL eines WebUSB-Projektes wird im Sketch direkt angegeben und kann in eigenen Sketches entsprechend angepasst
werden.
WebUSB WebUSBSerial(1 /* http s :// */ ," harb aum . githu b. io / ftd ui no / webusb / c onso le " );
Neben dem passenden Sketch verlangt die WebUSB-Spezifikation weitere Anpassungen an der USB-Konfiguration des
Ger¨
ats. Die n¨
otigen ¨
Anderungen nimmt die Arduino-IDE vor, wenn man in der Board-Auswahl den Board-Typ ftDuino
(WebUSB) wie in Abbildung 6.55 dargestellt ausw¨
ahlt. Diese Einstellung sollte nur f¨
ur WebUSB verwendet werden, da die
Anpassungen nur in Zusammenhang mit der WebUSB-Bibliothek vollst¨
andig sind und Windows das Ger¨
at andernfalls nicht
erkennt.
Abbildung 6.55: Auswahl der WebUSB-Konfiguration
6.18.3 Console
Der Datei Beispiele WebUSB Console -Sketch bietet eine einfache Kommandoschnittstelle ¨
uber USB, mit der die
eingebaute Leuchtdiode ein- und ausgeschaltet werden kann.
116 Kapitel 6. Experimente
Ist der Sketch auf dem ftDuino installiert, der ftDuino an den PC angeschlossen und der Chrome- oder Chromium-Browser
ge¨
offnet, so reicht ein Klick auf Connect, um die Verbindung zum Ger¨
at aus dem Browser herzustellen. Die Leuchtdiode
kann dann ¨
uber direkt in der Console eigegebene Befehle gesteuert oder durch Klick auf die Buttons geschaltet werden.
(a) Chromium-Browser unter Linux (b) Chrome-Browser unter Android
Abbildung 6.56: WebUSB-Console des ftDuino
6.18.4 Brickly-lite
Das in Abschnitt 8.3 beschriebene Brickly-Projekt38 hat seinen Ausgangspunkt bei der Community-Firmware f¨
ur den TXT-
Controller. Brickly basiert auf Blockly39, einer grafischen Programmierumgebung zur Nutzung per Webbrowser. Im Falle
des TXTs k¨
onnen so per Smartphone, PC oder Tablett mit Hilfe des Webbrowsers Programmer erstellt und auf dem TXT
laufen gelassen werden.
(a) im Chrome-Browser am PC (b) am Android-Tablett mit Lindy-31717-Kabel
Abbildung 6.57: Brickly-lite f¨
ur den ftDuino
Brickly-lite wurde f¨
ur den ftDuino v¨
ollig neu konzipiert. Auf die Ausf¨
uhrung von Blockly-generiertem Code auf dem ftDuino
wurde dabei verzichtet. Stattdessen werden die Brickly-lite-Programme am Browser erstellt und auch im Browser ausgef¨
uhrt.
Lediglich zur Bedienung der fischertechnik-Sensoren und -Aktoren greift der Browser per USB auf einen angeschlossenen
ftDuino zur¨
uck. Auf dem ftDuino muss dabei der Sketch Datei Beispiele WebUSB IoServer laufen. Da dieser
38Brickly f¨
ur den TXT: https://cfw.ftcommunity.de/ftcommunity-TXT/de/programming/brickly/
39Blockly: https://developers.google.com/blockly/
6.18. WebUSB: ftDuino via Webbrowser steuern 117
Sketch mit einem internen OLED-Display (siehe Abschnitt 1.2.7) umgehen kann wird die “Adafruit GFX Library”40 zum
¨
Ubersetzen des Sketches ben¨
otigt.
Die Brickly-lite-Webseiten finden sich unter https://harbaum.github.io/ftduino/webusb/brickly-lite/. Zur Benutzung muss
der ftDuino mit installiertem Datei Beispiele WebUSB IoServer -Sketch direkt an PC, Smartphone oder Tablett
angeschlossen sein. Der Chrome-Browser verbindet sich dann mit dem ftDuino und sobald Ein- oder Ausgaben am Modell
erfolgen sollen sendet der Browser enstprechende Befehle an den ftDuino.
Den Anspruch eines echten “Plug-n-Play”-Erlebnisses kann die Festlegung auf den Chrome-Browser und der fehlende Auto-
Start der vom Ger¨
at gesendeten URL unter Windows leider nicht erf¨
ullen. Mit einer vorbereitenen Portable-Installation des
passenden Browsers auf einem USB-Stick kann man dennoch auch f¨
ur Anf¨
anger leicht und ohne Installation zu nutzende
Szenarien schaffen, die sich z.B. auf PC-Pools in Schulen einsetzen lassen. Das Beispiel unter Datei Beispiele
WebUSB Console kann daf¨
ur als Ausgangspunkt f¨
ur Browser-bedienbare einfache Modelle dienen.
Ein ¨
ahnliches grafisches Programmiersystem ist “Scratch for Arduino” und “Scatch 3.0”. Mehr Informationen finden sich in
Abschnitt 8.6 und 6.18.5.
6.18.5 Scratch 3.0
Scratch 3.0 basiert wie Brickly auf dem Blockly-Projekt von Google. Dementsprechend nutzen beide eine sehr ¨
ahnliche Art,
wer WebUSB aus dem Browser auf dem ftDuino zuzugreifen.
Abbildung 6.58: Scratch 3.0 im Chrome-Browser mit ftDuino-Extension
W¨
ahrend Brickly eine komplette ftDuino-spezifische Entwicklung ist ist Scratch 3.0 ein eigenst¨
andiges Projekt. Die un-
ter https://harbaum.github.io/ftduino/webusb/scratch3/ befindliche Variante von Scratch 3.0 beinhaltet zus¨
atzlich eine
segenannte Extension zur Ansteuerung des ftDuino.
Die ftDuino-Extension greift direkt auf den ftDuino zu und ben¨
otigt daher im Gegensatz zu z.B. den Lego-Extensions keine
weitere Software auf dem PC. Damit kann die Extension auf allen Plattformen genutzt werden, die prinzipiell WebUSB
unterst¨
utzen. Das sind neben den ¨
ublichen Windows-, Apple- und Linux-PCs auch die meisten Smartphones und Android-
Tabletts.
Mehr Informationen zu Scratch 3.0 und dem Einsatz des ftDuino finden sich in Abschnitt 5.1.3.
40Adafruit GFX Library: https://github.com/adafruit/Adafruit-GFX-Library
Kapitel 7
Modelle
W¨
ahrend in den Experimenten aus Kapitel 6 der ftDuino-Controller im Mittelpunkt stand und nur wenige externe Kompo-
nenten Verwendung fanden geht es in diesem Kapitel um komplexere Modelle. Der ftDuino spielt dabei eine untergeordnete
Rolle.
S¨
amtliche Modelle stammen aus aktuellen Bauk¨
asten bzw. sind nah an deren Modelle angelehnt, so dass ein Nachbau mit
dem entsprechenden Kasten m¨
oglich ist.
7.1 Automation Robots: Hochregallager
Das Modell Hochregallager stammt aus dem Baukasten “Automation Robots”. In der Originalanleitung wird der Einsatz
des TX-Controllers beschrieben. Ein Zusatzblatt beschreibt den TXT-Controller.
Abbildung 7.1: Hochregal mit ftDuino
Der Beispielsketch Datei Beispiele Ftduino HighLevelRack steuert das Modell “Hochregallager” aus dem Bau-
kasten 511933 “ROBO TX Automation Robots”. Der Anschluss des ftDuino an das Modell entspricht dabei exakt dem
Schaltplan f¨
ur den TXT.
Die Bedienung erfolgt dabei aus dem seriellen Monitor vom PC aus1.
1Hochregal-Video https://www.youtube.com/watch?v=Sjgv9RnBAbg
7.2. ElectroPneumatic: Flipper 119
Wichtig: Damit die Befehlseingabe klappt m¨
ussen im seriellen Monitor die Zeilenden auf Neue Zeile oder
Zeilenumbruch (CR) eingestellt worden sein, wie im Abschnitt 3.3.1 beschrieben.
Abbildung 7.2: Serielle Kommunikation mit dem Hochregal
7.2 ElectroPneumatic: Flipper
Die Eing¨
ange des ftDuino sind auch im Schalter-Modus mit den fischertechnik-Fototransistoren kompatibel. Ein beleuchteter
Transistor liefert dann den Wahrheitswert “wahr”, ein unbeleuchter den Wert “unwahr”.
Abbildung 7.3: Flipper auf ftDuino-Basis
Der Beispiel-Sketch des Flippers aus dem ElectroPneumatic-Set findet sich unter Datei Beispiele Ftduino
Pinball . Er nutzt die Fototransistoren als Schaltereing¨
ange f¨
ur die Lichtschranken. Eine durch eine Kugel unterbrochene
Lichtschranke liefert dann den Wert “unwahr”:
if (! ftduino.input_get(Ftduino:: I4 ) ) {
if (millis() - loose_timer > 1000) {
// ...
}
loose_timer =millis() ;
}
Dabei wird ein Timer mitgef¨
uhrt, der z.B. in diesem Fall daf¨
ur sorgt, dass fr¨
uhestens eine Sekunde (1000 Millisekunden)
nach einem Ereignis ein weiteres Ereignis erkannt wird.
Dieser Sketch nutzt ein OLED-Display, um verbliebene Spielb¨
alle und den Punktestand anzuzeigen2.DaamftDuino noch
Ausg¨
ange frei sind k¨
onnen stattdessen auch Lampen oder Leuchtdioden verwendet werden.
2Flipper-Video https://www.youtube.com/watch?v=-zmuOhcHRbY
120 Kapitel 7. Modelle
7.3 ROBOTICS TXT Explorer: Linienfolger
Der mobile Linienfolger ist an die Modelle des “ROBOTICS TXT Explorer”-Sets angelehnt und nutzt den “IR Spursensor”
dieses Sets.
Abbildung 7.4: Ein Linienfolger auf ftDuino-Basis
Ein passender Beispiel Sketch ist unter Datei Beispiele Ftduino LineSensor zu finden. Dieser Sketch wertet
kontinuierlich den Liniensensor aus, um eine schwarzen Linie zu folgen3.
Der Liniensensor wird mit seinen gelben und blauen Kabeln an zwei beliebige der Eing¨
ange I1 bis I8 angeschlossen.
Zus¨
atzlich erfolgt ¨
uber die roten und gr¨
unen Kabel die Spannungsversorgung durch den ftDuino.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 7.5: Verdrahtungsschema des Linienfolgers
In diesem Fall ist der Spursensor an die Eing¨
ange I1 und I2 angeschlossen. Der Sensor liefert nahezu maximale Spannung
(circa 9 Volt) wenn eine weiße Fl¨
ache erkannt wird und nur wenig Millivolt, wenn die schwarze Linie erkannt wurde.
// b eid en E ing ¨a ng e auf S pa nnu ng sm ess un g ei nst el len
ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: VOLTAGE) ;
ftduino.input_set_mode(Ftduino:: I2 ,Ftduino:: VOLTAGE) ;
// beid e S pa nn un gen a us lesen
uint16_ t l in ke r_ we rt =ftduino.inpu t_get (Ftduino:: I1 );
uint16_t rechter_wert =ftduino.input_get(Ftduino:: I2 );
// e ine S pan nun g kl ei ne r 1 V olt (1 00 0 m V ) b e deu te t ’ L in ie e rka nn t ’
3Linienfolger-Video https://www.youtube.com/watch?v=JQ8TLt5MC9k
7.4. Idas Ampel 121
if (( linker_wert < 1000 ) && ( rechter_wert < 1000) ) {
// beide Se ns oren h abe n die Lin ie e rkann t
// ...
}
7.4 Idas Ampel
Ein klassisches Modell ist die Ampel bzw. die Fußg¨
angerampel. Das Modell bildet eine Bedarfsampel mit je drei Lampen f¨
ur
die Autos und zwei f¨
ur Fußg¨
anger ab.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
3
2
1
I1
O1
O2
O3
O4
O5
(a) Verdrahtungsschema
(b) Modell
Abbildung 7.6: Idas Ampel
Ein passender Beispiel-Sketch ist unter Datei Beispiele FtduinoSimple PedestrianLight zu finden. Er imple-
mentiert die Ampel in Form eines Zustandsautomaten. Die Lichtfolge entspricht dabei dem ¨
ublichen Ablauf in acht Schritten
von “Autos haben gr¨
un, Fußg¨
anger rot” ¨
uber die Gr¨
unphase f¨
ur die Fußg¨
anger bis schließlich die Autos wieder fahren d¨
urfen.
122 Kapitel 7. Modelle
Zustand 7Zustand 0 Zustand 1 Zustand 2 Zustand 3 Zustand 4 Zustand 5 Zustand 6
Taste I1 5 Sekunden 2 Sekunden 2 Sekunden 15 Sekunden 2 Sekunden 2 Sekunden
5 Sekunden
Abbildung 7.7: Die Zust¨
ande der Ampel
7.4.1 Zustandsautomaten
Die einfache und naheliegenden Umsetzung der Ampelsteuerung in Software best¨
unde aus einem Programm, das dem Verlauf
der Ampelzust¨
ande direkt folgt. Der Programmablauf stoppt, wenn auf den Tastendruck oder auf den Ablauf einer Zeit
gewartet wird und setzt fort, wenn das entsprechende Ereignis eingetreten ist. Im Folgenden ist dies exemplarisch f¨
ur die
ersten zwei Zust¨
ande der Ampel dargestellt.
void loop() {
// wart e auf T as te nd ru ck
while (! ftduino.input_get(BUTTON) ) {
};
// A mpe l s ch al tet ein , Au to s hab en gr ¨un , F u ßg ¨a n ger rot
ca rs _g re en ( ) ;
pedestrians_red( ) ;
del ay (CARS_GREEN_PHASE);
// Auto s b ek ommen gelb
cars_yellow() ;
del ay (YELLOW_PHASE);
// ...
}
Dieses Programm ist kurz und leicht zu verstehen. Das ist eigentlich gut, hat aber einen entscheidenden Nachteil: W¨
ahrend
auf ein Ereignis gewartet wird stoppt der gesamte Programmablauf und es ist nicht m¨
oglich, weitere Dinge parallel zu
erledigen.
Der PedestrianLight-Sketch soll aber beispielsweise nebenbei mit der eingebauten LED des ftDuino blinken. Dies soll
unterbrechungsfrei passieren und unabh¨
angig davon sein, in welchem Zustand sich die eigentliche Ampel gerade befindet.
Die L¨
osung ist ein Zustandsautomat.
// die loop - Fun kt ion wird immer wied er a uf ge ru fe n
void loop() {
// Z eit punk t des n¨a chsten L ichtwec hs el - Ere ignisse s
sta tic unsigne d long next_event = 0;
// Aktuell er Zu stand der Amepl
sta tic char state = 0;
// Die i ntern e L eu ch td io de soll e inm al pro S ekund e blin ke n
sta tic unsigne d long flash_timer = 0;
if (millis() > flash_timer + 10)
digitalWrite(LED_BUILTIN ,LO W );
if (millis() > flash_timer + 1000) {
digitalWrite(LED_BUILTIN ,HIGH);
flash_timer =millis() ;
}
// Teste ob ein F us sg ¨a nger im Zu stan d 0 ( Amp el aus ) den
// Knop f gedr ¨u ckt hat
if (( state == 0) && ( ftduino.input_get(BUTTON)))
7.4. Idas Ampel 123
state = 1; // ja -> we chsel in Zus ta nd 1
if (state > 0) {
// Teste , ob die e in ge st ellte Zeit vergan ge n ist
if (millis() > next_event ) {
switch(state ) {
// A mpe l w ec hs elt in Z us tan d 1: Aut os hab en gr ¨un , F us sg ¨a n ge r h abe n r ot
case 1: {
// sch alte Lamp en
ca rs _g re en ( ) ;
pedestrians_red( ) ;
// setze Ze it pun kt f ¨ur n¨a c hs tes Erei gnis
ne xt _e ve nt =millis() + CARS_GREEN_PHASE;
// setze Zus tand f¨ur n¨a c hs tes Er eignis
state ++; // Ku rz sch re ibw ei se f¨u r " sta te = state + 1"
bre ak ;
}
// Ampe l w ec hselt in Zusta nd 2: Au tos haben gelb , Fussg ¨a nger haben rot
case 2: {
cars_yellow() ;
ne xt _e ve nt =millis() + YELLOW_PHASE;
state ++;
bre ak ;
}
// A mp el we chse lt in Zu sta nd 3: Aut os h aben rot , Fuss g ¨a nge r ha ben rot
case 3: {
// ...
bre ak ;
}
// ...
}
}
}
}
Dieses Listing ist deutlich komplizierter. Aber es hat den großen Vorteil, dass an keiner Stelle aktiv gewartet wird. Stattdessen
wird die Programmausf¨
uhrung st¨
andig fortgesetzt. Um trotzdem die einzelnen Ampelphasen ablaufen lassen zu k¨
onnen
werden zwei Variablen als Speicher angelegt (next event und state). Hier wir permanent vermerkt, in welchem Zustand
sich die Ampel befindet und wie lange dieser Zustand noch erhalten bleiben soll.
Auf diese Weise ist es m¨
oglich, die LED v¨
ollig unabh¨
angig blinken zu lassen und ggf. auch weitere Steueraufgaben zu
erledigen.
Geschuldet ist der große Aufwand der Tatsache, dass der ftDuino ¨
uber kein eigenes Betriebssystem verf¨
ugt, das mehrere
Programmteile (sogenannte Prozesse oder Threads) gleichzeitig bedienen k¨
onnte, wie es auf PCs und Smartphones z.B.
¨
ublich ist.
Der große Vorteil des einfachen ftDuino-Ansatzes liegt in der seiner exakten Vorhersagbarkeit. Jeder kennt es vom PC oder
Smartphone, wenn das Betriebssystem im Hintergrund unerwartet “besch¨
aftigt” ist und die Programmausf¨
uhrung stockt.
Was bei einer Bedienober߬
ache nur l¨
astig ist kann bei Steuer- und Regelaufgaben leicht zu einem Problem werden, wenn z.B.
ein Motor bei Erreichen einer bestimmten Position nicht schnell genug gestoppt wird. Aus diesem Grund kann der wesentlich
einfachere ftDuino auf viele Dinge schneller und vorhersagbarer reagieren als z.B. ein vom Linux-Betriebssystem angetriebener
TXT-Controller oder Raspberry-Pi. Ein weiterer positiver Effekt des nicht vorhandenen Betriebssystems ist der schnelle
Systemstart. Ein ftDuino ist sofort nach dem Einschalten voll funktionsf¨
ahig und man muss keinen Betriebssystemstart
abwarten, bevor das Ger¨
at seine Aufgaben erf¨
ullen kann.
Der schnelle Systemstart und das leicht vorhersagbare Verhalten sind die Hauptgr¨
unde, warum es auch im kommerziel-
len Umfeld immer einen Bedarf an solch einfachen Systemen wie dem ftDuino gibt, auch wenn der Einsatz komplexer,
betriebssystembasierter L¨
osungen mit sinkenden Hardware-Preisen auch in immer einfacheren Ger¨
aten m¨
oglich wird.
124 Kapitel 7. Modelle
7.5 Klassischer 2D-Plotter
Der fischertechnik-Plotter 305714von 1985 war eines der ersten Computing-Modelle von fischertechnik. Die Bewegung in
X- und Y-Achse wurde von 6-Volt-Schrittmotoren realisiert, der Stift wurde durch einen Magneten gehoben und gesenkt.
Die Ansteuerung erfolgte ¨
uber die acht Ausg¨
ange des damaligen Computing-Interface, wobei der Stift recht trickreich mit
einem der Motoren kombiniert wurde, um mit den insgesamt 8 Ausg¨
angen auszukommen.
Abbildung 7.8: Der Stift wird von einem fischertechnik-Servo gehoben
Das hier vorgestellte Modell hat die gleichen Maße und verwendet eine sehr ¨
ahnliche Grundmechanik. Es werden ebenfalls zwei
Schrittmotoren eingesetzt, allerdings 12-Volt-Varianten, die auch an 9 Volt genug Kraft f¨
ur den Plotterbetrieb entwickeln.
Die Schrittmotoren werden wir in Abschnitt 6.4 beschrieben angesteuert und angeschlossen.
Der Stift wird in diesem Modell von einem fischertechnik-Servo gehoben und gesenkt. Dabei k¨
onnte der Ansatz aus Abschnitt
6.5 verwendet werden. In diesem Fall wurde stattdessen das I2C-Servo-Shield5verwendet. Es ist etwas unhandlicher, erlaubt
aber einen echten I2C-Betrieb und ist so mit dem OLED-ftDuino kompatibel.
Der passenden Sketch unter Datei Beispiele FtduinoSimple Plotter ist sehr einfach gehalten und hat großes
Verbesserungspotenzial. Er akzeptiert auf der USB-/COM-Schnittstelle plotter¨
ubliche HP-GL-Kommandos6und kann daher
direkt aus vielen PC-Programmen angesprochen werden.
4fischertechnik-Datenbank: https://ft-datenbank.de/tickets?fulltext=30571
5Servo-Shield auf Thingiverse: https://www.thingiverse.com/thing:3316758
6HP-GL auf Wikipedia: https://de.wikipedia.org/wiki/Hewlett-Packard Graphics Language
7.5. Klassischer 2D-Plotter 125
Abbildung 7.9: Das Design orientiert sich stark am Plotter von 1985
Kapitel 8
Community-Projekte
Der ftDuino ist ein echtes Community-Projekt. Er basiert auf Ideen aus der fischertechnik-Community und integriert sich
entsprechend gut in bestehende Community-Projekte. W¨
ahrend kommerzielle Produkte oft in Konkurrenz mit ihren eigenen
Vorg¨
angern stehen und dem Kunden vor allem Neues geboten werden soll k¨
onnen es sich Community-Projekte leichter
erlauben, auch ¨
altere und technisch in Konkurrenz stehende Systeme einzubinden.
Der ftDuino l¨
asst sich wie in Abschnitt 6.13.5 beschrieben mit dem fischertechnik-TXT-Controller per I2C koppeln. Auf
dem TXT kommt dabei die sogenannte Community-Firmware1zum Einsatz. Entsprechende Programme zur Anbindung des
ftDuino per I2Cfinden sich ebenfalls dort2.
8.1 ftduino direct:ftDuino-Anbindung per USB an TXT und TX-Pi
Einfacher und robuster ist die Anbindung per USB an PCs, den TXT oder auch den Raspberry-Pi. Die Community stellt
dazu einen Sketch sowie eine passende Python-Bibliothek zur Verf¨
ugung3.
Mit Hilfe des Sketches stellt der ftDuino seine Anschl¨
usse einem per USB angeschlossenen ¨
ubergeordneten Ger¨
at zur
Verf¨
ugung. Die Python-Bibliothek kann auf dem ¨
ubergeordneten Ger¨
at genutzt werden, um aus einem Python-Programm
auf die Ein- und Ausg¨
ange des ftDuino zuzugreifen.
Abbildung 8.1: ftDuino per USB am Raspberry-Pi
1fischertechnik TXT Community-Firmware http://cfw.ftcommunity.de/ftcommunity-TXT
2ftDuino I2C f¨
ur die CFW https://github.com/harbaum/cfw-apps/tree/master/packages/ftDuinoI2C
3ftduino direct-Sketch https://github.com/PeterDHabermehl/ftduino direct
8.2. ftDuinIO:ftDuino-Kontroll-App f¨
ur TXT und TX-Pi 127
Mit Hilfe dieser Bibliothek lassen sich bestehende Python-Programme f¨
ur die Community-Firmware leicht auf die Nutzung
eines ftDuino erweitern. Besonders interessant ist dies auf Ger¨
aten wie dem Raspberry-Pi, da diese von Haus aus keine
Schnittstelle zu fischertechnik-Sensoren und -Aktoren mitbringen.
Abbildung 8.2: startIDE auf TX-Pi mit Zugriff auf ftDuino
Programme wie startIDE4und Brickly5k¨
onnen mit Hilfe von ftduino direct auf den ftDuino zugreifen und so auf
dem Raspberry-Pi die fischertechnik-kompatiblen Anschl¨
usse des ftDuino nutzen.
8.2 ftDuinIO:ftDuino-Kontroll-App f¨
ur TXT und TX-Pi
Die Installation des ftduino direct-Sketches auf dem ftDuino kann wie gewohnt per Arduino-IDE erfolgen, ben¨
otigt aber
einen klassischen PC. Um vom PC komplett unabh¨
angig zu sein wurde die ftDuinIO-App f¨
ur die Community-Firmware
entwickelt.
Abbildung 8.3: Die ftDuinIO-App
Die App kann auf dem fischertechnik-TXT ebenso betrieben werden wie auf dem zum TX-Pi konfigurierten Raspberry-Pi
und erlaubt es, Sketches auf den ftDuino zu laden sowie die ftduino direct-Funktionen zu testen.
4startIDE:https://forum.ftcommunity.de/viewtopic.php?f=33&t=4297
5Brickly:https://cfw.ftcommunity.de/ftcommunity-TXT/de/programming/brickly/
128 Kapitel 8. Community-Projekte
8.3 Brickly-Plugin: Grafische ftDuino-Programmierung in Brickly
Brickly6ist eine auf Googles Blockly7basierende grafische Programmierumgebung.
Abbildung 8.4: Die Brickly-Programmierober߬
ache
Brickly wurde f¨
ur den fischertechnik-TXT-Controller geschrieben und bringt alles mit, um dessen Ein- und Ausg¨
ange nutzen
zu k¨
onnen. Brickly selbst ben¨
otigt einen leistungsf¨
ahigen Controller, um darauf zu laufen. Dies kann ein fischertechnik-TXT-
Controller oder auch ein Raspberry-Pi sein. Die Bedienung und Programmierung erfolgt dann im Web-Browser mit Hilfe
eines per WLAN verbundenen Smartphones oder PCs.
Der ftDuino selbst ist nicht leistungsf¨
ahig genug, um Brickly auszuf¨
uhren. Auch die n¨
otige WLAN-Verbindung bringt der
ftDuino nicht mit.
Stattdessen kann Brickly einen an den fischertechnik-TXT-Controller oder einen Raspberry-Pi (TX-Pi) angeschlossenen
ftDuino ansteuern. Brickly nutzt dazu die in Abschnitt 8.1 beschriebene ftduino direct-Anbindung.
Das ftDuino-Plugin f¨
ur Brickly8kann in eine bestehende Brickly-Installation direkt in der Browser-Ober߬
ache installiert
werden.
Abbildung 8.5: Installation eines Brickly-Plugins
Danach k¨
onnen die ftDuino-Ein- und -Ausg¨
ange direkt in Brickly-Programmen verwendet werden. Einem Raspberry-Pi
erschließt sich so die fischertechnik-Welt, ein TXT-Controller kann so um 20 zus¨
atzliche Ein- und 8 Ausg¨
ange erweitert
werden.
Brickly existiert auch in der in Abschnitt 6.18.4 beschriebenen lite-Variante. Diese erlaubt den direkten Zurgiff aus dem
Browser auf einen per USB angeschlossenen ftDuino und ben¨
otigt keinen zus¨
atzlichen TXT-Controller oder Raspberry-Pi.
6Brickly-Anleitung https://github.com/EstherMi/ft-brickly-userguide/blob/master/de/brickly/index.md
7Google-Blockly https://developers.google.com/blockly/
8Brickly-ftDuino-Plugin https://github.com/harbaum/brickly-plugins#ftduino-io—ftduinoxml
8.4. startIDE: Programmierung direkt auf dem TX-Pi oder TXT 129
Abbildung 8.6: Ein Brickly-Programm zur Ansteuerung des ftDuino
8.4 startIDE: Programmierung direkt auf dem TX-Pi oder TXT
Die ¨
ublichen Programmierumgebung RoboPro f¨
ur den fischertechnik-TXT- und -TX-Controller ben¨
otigt einen Windows-PC
zur Programmierung. Selbst das deutlich modernere Brickly (siehe Abschnitt 8.3) ist auf ein externes Ger¨
at zur Programm-
entwicklung angewiesen.
StartIDE9wurde dagegen so konzipiert, dass schon der kleine Touchbildschirm des fischertechnik-TXT-Controllers oder
eines Raspberry-Pi ausreicht, um direkt am Ger¨
at Programme erstellen zu k¨
onnen.
(a) Hauptbildschirm (b) Funktionsauswahl (c) IO-Konfiguration
Abbildung 8.7: Die Ober߬
ache der StartIDE
Die startIDE unterst¨
utzt neben den eigenen Anschl¨
ussen des TXT auch die Anschl¨
usse einer ganzen Reihe per USB extern
anzuschließender Interfaces und damit u.a. auch die des ftDuino. Dazu bedient sich startIDE der bereits in Abschnitt 8.1
vorgestellten ftduino direct-Anbindung. Da die startIDE auch auf dem TX-Pi bzw. dem Raspberry-Pi l¨
auft verleiht sie
diesem die f¨
ur den Einsatz im fischertechnik-Modellen n¨
otigen Anschl¨
usse.
Das Gespann TX-Pi (bzw. Raspberry-Pi), ftDuino und startIDE erlaubt damit, fischertechnik-Modelle ganz ohne PC oder
Smartphone zu programmieren.
Die ausf¨
uhrliche Bedienungsanleitung10 der startIDE enth¨
alt weitere Details zur Nutzung des ftDuino.
9startIDE-Homepage: https://github.com/PeterDHabermehl/startIDE/
10startIDE-Anleitung: https://github.com/PeterDHabermehl/startIDE/blob/master/ddoc/Manual 160 de.pdf
130 Kapitel 8. Community-Projekte
8.5 ft-Extender: I2C-Erweiterung
Der ft-Extender ist wie der I2C-Expander aus Abschnitt 6.13.6 ein Ger¨
at, das es erlaubt den I2C-Bus des ftDuino zu erweitern
und so unterschiedlichste Ger¨
ate gleichzeitig anzuschließen und zu koppeln.
Abbildung 8.8: ft-Extender
¨
Uber die Funktionen des I2C-Expander hinaus bietet der ft-Extender eine zus¨
atzliche Spannungsversorgung f¨
ur angeschlossene
Ger¨
ate. Mit Hilfe des ft-Extender an den ftDuino angeschlossene Sensoren werden also anders als beim I2C-Expander nicht
vom ftDuino versorgt, sondern vom ft-Extender selbst. Dadurch steht einerseits ein etwas h¨
oherer Strom zur Verf¨
ugung.
Vor allem steht aber neben den 5 Volt, die auch der ftDuino liefert, zus¨
atzlich eine 3,3-Volt-Versorgung zur Verf¨
ugung. Der
ft-Extender ist damit flexibler einsetzbar als der I2C-Expander.
Mehr Informationen zum ft-Extender finden sich unter https://github.com/elektrofuzzis/ftExtender, speziell das Handbuch
unter https://github.com/elektrofuzzis/ftExtender/blob/master/Handbuch ft-Extender.pdf.
8.6 Scratch for Arduino (S4A)
Scratch11 ist eine grafische Programmierumgebung vergleichbar mit Blockly und Brickly (siehe Abschnitt 6.18.4).
Abbildung 8.9: S4A-Hauptbildschirm
11Scratch: https://scratch.mit.edu/
8.6. Scratch for Arduino (S4A) 131
Scratch wurde als reine Simulationsumgebung entwickelt. Die Interaktion mit echter Hardware war nicht vorgesehen. Scratch
for Arduino12 erweitert Scratch im die M¨
oglichkeit, Arduinos anzusprechen. Dazu wird auf dem Arduino ein spezieller Sketch
installiert. Der so pr¨
aparierte Arduino wird von S4A automatisch erkannt und eingebunden.
Da der ftDuino ¨
uber spezielle Ein- und Ausg¨
ange verf¨
ugt l¨
asst er sich nicht direkt mit dem S4A-Sketch ansteuern. Stattdessen
findet sich in der ftDuino-Installation ein kompatibler Sketch unter Datei Beispiele Ftduino S4AFirmware16 . Ein
mit diesem Sketch ausgestatteter ftDuino wird von S4A automatisch erkannt und eingebunden.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Analog0
S4A-Sensor
Analog5
Digital2
Digital3
Analog1
Analog2
Analog3
Analog4
digital 13
analog5
analog6
analog9
digital10
digital11
digital12
S4A-Ausgang
motor 4
motor 7
motor 8
Abbildung 8.10: ftDuino-Anschl¨
usse unter S4A
Da S4A sich mit den Bezeichnern der Ein- und Ausg¨
ange nah an die ¨
ublichen Arduino-Bezeichnungen anlehnt kann nicht
mit den ftDuino-¨
ublichen Bezeichnungen gearbeitet werden. Abbildung 8.10 zeigt, welchen Anschl¨
usse am ftDuino in S4A
unter welcher Bezeichnung auftauchen.
8.6.1 Installation
S4A auf dem ftDuino setzt eine normale Installation von S4A voraus. Die Installation ist auf der S4A-Homepage unter
http://s4a.cat/ beschrieben.
Es muss lediglich statt des dort angebenen Original-Sketches der Datei Beispiele Ftduino S4AFirmware16 -
Sketch auf den ftDuino geladen werden.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
Abbildung 8.11: Einfaches S4A-Beispiel, das eine Lampe blinken l¨
asst
In Abbildung 8.11 ist ein Beispielprogramm nebst entsprechender Verkabelung abgebildet. Bei den Analogeing¨
angen ist zu
beachten, dass der ftDuino einen Wertebereich von 0 bis 65.535 kΩmessen kann w¨
ahrend Scratch mit Werten von 0 bis
1023 arbeitet. Ein Wert von 1023 in S4A entspricht dabei 65.535 kΩbzw. einem offenen Eingang am ftDuino. Ein Wert von
0 in S4A entspricht 0 Ωbzw. einem geschlossenen Eingang.
12S4A: http://s4a.cat/
132 Kapitel 8. Community-Projekte
8.6.2 Darstellung der Pin-Zuweisungen in S4A
Da S4A f¨
ur die Benutzung mit eine Arduino entworfen wurde zeigt das Programm zun¨
achst im oberen rechten Bereich die
Belegung eines Arduino an. Es erleichtert die Arbeit mit dem ftDuino unter S4A sehr, wenn dort die abweichende Belegung
des ftDuino angezeigt wird.
Eine entsprechende sogegannte Sprite-Datei ist unter https://harbaum.github.io/ftduino/www/images/s4a sprite.png
erh¨
altlich. Sirekt unter der Anzeige des Arduino-Bildes befindet sich ein Icon zur Auswahl eines neuen Sprites.
(a) ftDuino-Sprite f¨
ur S4A (b) Auswahl eines neuen Sprites
Abbildung 8.12: Installation eines neuen Sprites
Klickt man auf dieses Icon, so kann man im folgenden “Paint”-Dialog ein neues Sprite zeichnen. Um die o.g. Datei zu
verwenden muss man diese zun¨
achst auf den eigenen PC laden. Im “Paint”-Dialog kann sie dann ¨
uber den Import-Knopf in
S3A importiert werden. Das neue Sprite-Bild muss abschließend mit “Ok” best¨
atigt werden.
Abbildung 8.13: Anzeige des ftDuino-Sprites in S4A
Die Anschluss-Belegung des ftDuino wird nun f¨
ur das aktuelle Projekt dauerhaft oben rechts in S4A angezeigt.
8.7 Minecraft und ftDuino: Computerspiel trifft reale Welt
Neben den grafischen Programm-Bauk¨
asten wie Scratch, die ihre Urspr¨
unge im didaktischen Bereich haben, gibt es auch
grafische Programmiersysteme, die auf den ersten Blick aus einer unerwarteten Richtung kommen.
8.7. Minecraft und ftDuino: Computerspiel trifft reale Welt 133
Ein popul¨
ares Beispiel daf¨
ur ist Minecraft. Dieses Spiel bietet mit dem “Redstone” und den entsprechenden Komponenten
eine M¨
oglichkeit, Kabel in der virtuellen Minecraft-Welt zu verlegen und damit Spiel-interne Aktoren und Sensoren sowie
Logikelemente zu verbinden.
Abbildung 8.14: ftDuino-Mod in Minecraft
Die Minecraft-Mod f¨
ur den ftDuino erweitert Minecraft um Bl¨
ocke, die die Minecraft-interne Welt mit den Anschl¨
ussen
eines am PC angeschlossenen ftDuino verbindet.
8.7.1 Installation der ftDuino-Mod
Die sogenannte ftDuino-Mod f¨
ur Minecraft basiert auf Forge 1.12.2 13 und setzt eine Installation dieser Minecraft- und
Forge-Versionen voraus. Die Installation der ftDuino-Mod unterscheidet sich in keiner Weise von anderen Mods.
Die ftDuino-Mod selbst kann unter https://harbaum.github.io/ftduino/minecraft/ftduino-0.0.3.jar heruntergeladen werden.
Sie eignet sich f¨
ur Windows-, Linux- und MacOS-PCs. Sie wird den ¨
ublichen Anleitungen folgend in das entsprechende
Mod-Verzeichnis von Minecraft kopiert und beim n¨
achsten Start von Minecraft automatisch geladen.
8.7.2 Vorbereitung des ftDuino
Der ftDuino muss mit dem IoServer-Sketch versehen werden. Dieser ist in der Arduino-IDE unter Datei Beispiele
WebUSB IoServer zu finden. In diesem Fall muss als Board der normale ftDuino ausgew¨
ahlt werden und nicht ftDuino
(WebUSB), da es sich bei Minecraft im keine Web-Anwendung handelt.
Da der IoServer-Sketch bei entsprechend ausger¨
usteten ftDuinos auch das interne OLED-Display nutzt muss die Adafruit-
GFX-Bibliothek installiert sein. Dies kann bei Bedarf ¨
uber das Bibliotheken-Men¨
u der Arduino-IDE mit wenigen Klicks
nachgeholt werden. Ein internes Display ist nicht zwingend n¨
otig, der Sketch funktioniert auch auf jedem ftDuino ohne
Display.
13Forge 1.12.2: http://files.minecraftforge.net/maven/net/minecraftforge/forge/index 1.12.2.html
134 Kapitel 8. Community-Projekte
8.7.3 Verwendung des ftDuino in Minecraft
Wurde die ftDuino-Mod erfolgreich eingebunden, dann stehen im Creative-Modus von Minecraft im Redstone-Bereich die
in Abbildung 8.15 dargestellten zus¨
atzlichen Bl¨
ocke zur Verf¨
ugung.
Zur Zeit stehen reine digital-Bl¨
ocke f¨
ur die Eing¨
ange I1 bis I8, die Ausg¨
ange O1 bis O8 und die interne Leuchtdiode des
ftDuino zur Verf¨
ugung.
(a) Eingang I1-I8 (b) Ausgang O1-O8 (c) interne LED
Abbildung 8.15: ftDuino-Bl¨
ocke in Minecraft
Der Input-Block (IN) stellt eine Verbindung von Redstone zu einem der Eing¨
ange I1 bis I8 des ftDuino zur Verf¨
ugung.
Durch Rechtsklick auf die Vorderseite des Blocks kann der Eingang ausgew¨
ahlt werden. Er wird durch einen gr¨
unen Stecker
symbolisiert, der in einer von acht Buchsen steckt. Ein gelber Blitz rechts daneben zeigt an, wenn der angew¨
ahlte Eingang
aktiv ist weil z.B. ein am ftDuino angeschlossener Schalter geschlossen ist. Der in der Abbildung dargestellte Eingang I1 ist
zur Zeit nicht aktiv. Es k¨
onnen mehrere Input-Bl¨
ocke mit dem gleichen Eingang des ftDuino assoziiert werden, alle Bl¨
ocke
empfangen dann geichzeitig das Signal des entsprechenden Eingangs am ftDuino.
Der Output-Block (OUT) stellt eine Verbindung von Redstone zu einem der Ausg¨
ange O1 bis O8 des ftDuino her. In diesem
Fall erfolgt die Kennzeichnung durch einen roten Stecker. Der in der Abbildung dargestellte Block wird durch aktives
Redstone angesteuert. Er ist also aktiv und steuert in diesem Fall den Ausgang O2 an und schaltet ihn in den Zustand HI
und eine zwischen dem Ausgang O2 und Masse (-) angeschlossene Lampe w¨
urde leuchten. Dies wird durch das Blitz-Symbol
angezeigt. Es kann immer nur ein Block einem der ftDuino-Ausg¨
ange zugeordnet werden, da andernfalls widerspr¨
uchliche
Signale an den gleichen Ausgang gesendet werden k¨
onnen.
Der LED-Block steuert die interne Leuchtdiode des ftDuino an. Dieser Block kann nur einmal in der Minecraft-Welt existieren,
um wiederum widerspr¨
uchlicher Ansteuerung vorzubeugen.
In der Beispielwelt in Abbildung 8.14 ist rechts hinten z.B. ein einfacher Wechselblinker zu sehen. Die Redstone-Fackel an
dem mit Ausgang O2 assoziierten ftDuino-Output-Block bildet einen Inverter, der das vorne an diesem Block anliegende
Signal negiert. Das Signal wird auf den davor liegenden Redstone-Repeater gef¨
uhrt, der das Signal leicht verz¨
ogert und
zur¨
uck auf den mit Ausgang O2 assoziierten ftDuino-Output-Block leitet. Das kontinuierliche Verz¨
ogern und Negieren des
Signals f¨
uhrt zu einem Blinken ungef¨
ahr im Sekundentakt. Ein weiterer Output-Block, diesmal mit O1 assoziiert, ist mit
dem invertierten Signal verbunden. An die Ausg¨
ange O1 und O2 angeschlossene Lampen blinken daher im Wechsel. Weiter
links im Bild sind Eing¨
ange ¨
uber ftDuino-Input-Bl¨
ocke realisiert, die unter anderem eine Redstone-Lampe ¨
uber Eingang I7
des ftDuino ansteuern.
Kapitel 9
Bibliotheken
Mit dem Schaltplan aus Anhang A und entsprechendem Know-How ¨
uber den verbauten ATmega32U4-Controller lassen
sich s¨
amtliche Anschl¨
usse des ftDuino aus einem Arduino-Sketch ansteuern. Allerdings erfordert dieses Vorgehen einiges an
Erfahrung und f¨
uhrt zu vergleichsweise komplexen Arduino-Sketches, da s¨
amtlicher Code zur Ansteuerung der diversen Ein-
und Ausg¨
ange im Sketch selbst implementiert werden m¨
usste.
Abbildung 9.1: Die ftDuino-Bibliotheken in der Arduino-IDE
Der ftDuino bringt daher sogenannte Bibliotheken mit. Das sind Code-Sammlungen, die bereits fertige Routinen zum
Ansteuern der Ein- und Ausg¨
ange des ftDuinos enthalten. Der eigentliche Arduino-Sketch wird dadurch sehr viel einfacher
und k¨
urzer und vor allem muss der Programmierer die Aspekte der Hardware selbst gar nicht komplett verstanden haben,
da er lediglich einige einfach zu benutzende Routinen zum Zugriff auf die ftDuino-Hardware nutzt. Die Bibliotheken werden
als Teil der ftDuino-Installation in der Arduino-IDE automatisch mit installiert. Aktualisierungen dieser Bibliotheken werden
von der Arduino-IDE automatisch festgestellt und zum Update angeboten.
Trotzdem ist der direkte Zugriff nat¨
urlich weiterhin m¨
oglich. Der fortgeschrittene Programmierer kann also nach wie vor an
allen Bibliotheken vorbei direkt auf die Hardware zugreifen. Der Code der Bibliotheken ist ebenfalls frei verf¨
ugbar1, sodass
der Anwender selbst gegebenenfalls Erweiterungen und Verbesserungen vornehmen kann.
Es gibt zwei Bibliotheken, um den ftDuino anzusteuern. Die FtduinoSimple-Bibliothek, die sehr einfach gehalten ist und
nur ein ganz rudiment¨
ares Funktions-Set bereit stellt und die Ftduino-Bibliothek, die deutlich komplexer ist und vielf¨
altige
Funktionen zur Signaleingabe und Signalausgabe bietet.
9.0.1 Port-Definitionen und Konstanten
F¨
ur die unterschiedlichen Ports des ftDuino werden in den beiden folgenden Bibliotheken die gleichen Konstanten verwendet.
Die acht Eing¨
ange werden beispielsweise durch die Konstanten Ftduino::I1 bis Ftduino::I8 beschrieben. Auch wenn sich
1https://github.com/harbaum/ftduino/tree/master/ftduino/libraries
136 Kapitel 9. Bibliotheken
hinter diesen Konstanten die Werte 0 bis 7 verbergen sollte man wenn m¨
oglich immer die Konstanten verwenden. Sollte es
irgendwann n¨
otig sein, die hinter den Konstanten verborgenen Werte zu ¨
andern, so werden entsprechende Sketche weiterhin
funktionieren.
Der Programmierer kann sich aber darauf verlassen, dass diese Konstanten immer direkt aufeinander folgend auftsteigend
sind. Man kann also z.B. ¨
uber alle Ports abz¨
ahlen:
// S ch le if e ¨u ber alle Ei ng ¨a nge des ftD uin o
for (uint8_t port=Ftduino:: I1 ;port <= Ftduino:: I8 ;port++) {
/* port v er weist nache in an der n auf alle Po rts I1 bis I8 */
mache_etwas(port);
}
Eine ¨
aquivalente Version ist:
for (uint8_t i=0; i< 8; i++) {
mache_etwas(Ftduino:: I1 +i);
}
9.1 FtduinoSimple
Die FtduinoSimple-Bibliothek ist eine sehr einfache Bibliothek. Sie erlaubt nur die Abfrage von einfachen Digitalwerten
(an/aus) und das Ein- und Ausschalten von Ausg¨
angen. Es ist mit ihr weder m¨
oglich, analoge Spannungen und Widerst¨
ande
einzulesen, noch die Ausg¨
ange mit variablen Werten zu schalten.
Die Vorteile der FtduinoSimple-Bibliothek sind:
Einfachheit Die Bibliothek bietet nur wenige sehr einfach zu nutzende Funktionen. Man kann kaum etwas falsch machen.
Geringer Speicherbedarf Die Bibliothek belegt kaum Flash- oder RAM-Speicher des ftDuino. Fast der gesamte Speicher
steht dem eigentlichen Sketch zur Verf¨
ugung.
Keine Seiteneffekte Die Bibliothek verwendet keine weitere interne Hardware des ATmega32u4-Controllers und imple-
mentiert z.B. keine eigenen Interrupt-Handler. Die gesamte interne Hardware (Timer, Z¨
ahler, Interrupts, . . . ) steht
f¨
ur eigenen Sketche zur Verf¨
ugung und man muss mit keinen unerwarteten Effekten rechnen, wenn man direkt auf die
ATmega32u4-Hardware zugreift.
Um die FtduinoSimple-Bibliothek zu nutzen muss zu Beginn eines Sketches die entsprechende Include-Zeile eingef¨
ugt
werden.
#include < F t du in oS imp le .h >
9.1.1 Verwendung im Sketch
Die FtduinoSimple-Bibliothek verbirgt viele Details der Sensor- und Aktoransteuerung vor dem Nutzer und erlaubt es, mit
wenigen und einfachen Code-Zeilen die Ein- und Ausg¨
ange in einem Sketch zu verwendet.
Folgendes Beispiel zeigt das periodische Schalten eines Ausganges mit Hilfe der FtduinoSimple-Bibliothek:
1#include < F t du in oS imp le .h >
2
3void setup () {
4// kein e Ini ti ali si er ung noetig
5}
6
7void loop() {
8// Aus gang O1 einsc ha lt en
9ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
10 delay (1000);
11 // Aus gang O1 aussc ha lt en
12 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: LO );
13 delay (1000);
14 }
9.1. FtduinoSimple 137
In den Zeilen 9 und 12 wird der Ausgang O1 des ftDuino ein- bzw. ausgeschaltet. Der erste Parameter der output set()-
Funktion gibt dabei den zu schaltenden Ausgang an, der zwei bestimmt, ob der Ausgang ein- oder ausgeschaltet werden
soll.
Achtung: Um die Ausg¨
ange benutzen zu k¨
onnen muss der ftDuino nat¨
urlich mit 9 Volt versorgt werden.
Die Eing¨
ange des ftDuino lassen sich ebenfalls sehr einfach mit Hilfe der FtduinoSimple-Bibliothek abfragen:
1#include < F t du in oS imp le .h >
2
3void setup () {
4// kein e Ini ti ali si er ung noetig
5}
6
7void loop() {
8// Ein gang I1 ei nl es en
9if (ftduino.input_get(Ftduino:: I1 ) ) {
10 // Aus gang O1 einsc ha lt en
11 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
12 }else {
13 // Aus gang O1 aussc ha lt en
14 ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: LO );
15 }
16 }
In Zeile 9 wird der Zustand eines an den Eingang I1 angeschlossenen Schalters ermittelt. Je nachdem ob er gedr¨
uckt
(geschlossen) ist oder offen wird in den Zeilen 11 bzw. 14 der Ausgang O1 ein- oder ausgeschaltet.
9.1.2 bool input get(uint8 t ch)
Diese Funktion liest den Zustand des Eingangs ch ein. Erlaubte Werte f¨
ur ch sind Ftduino::I1 bis Ftduino::I8. Der
R¨
uckgabewert ist true, wenn der Eingang mit Masse verbunden ist und false, wenn nicht. Auf diese Weise lassen sich z.B.
leicht Taster abfragen, die zwischen dem jeweiligen Eingang und den korrespondierenden Masseanschluss daneben geschaltet
sind.
Die Auswertung des Eingangs geschieht nicht im Hintergrund, sondern erfolgt genau in dem Moment, in dem die
input get()-Funktion aufgerufen wird. Vor allem, wenn dabei ein anderer Port abgefragt wird als im direkt vorherge-
henden Aufruf von input get() kommt es dadurch zu einer Verz¨
ogerung von einigen Mikrosekunden, da ftDuino-intern
eine Umschaltung auf den ge¨
anderten Eingang durchgef¨
uhrt werden muss.
Beispiel
// lies den Z ustan d einer Tas te an Einga ng I1
if (ftduino.input_get(Ftduino:: I1 ) ) {
/* ... tue etwas ... */
}
9.1.3 bool counter get state(uint8 t ch)
Diese Funktion entspricht von ihrer Wirkungsweise input get(). Allerdings wird counter get state() auf die
Z¨
ahlereing¨
ange angewandt. Der Wertebereich f¨
ur ch reicht demnach von Ftduino::C1 bis Ftduino::C4.
Der R¨
uckgabewerte ist true, wenn der Eingang mit Masse verbunden ist und false, wenn nicht.
Beispiel
// lies den Zus tand e in er Taste an Zaehler - E inga ng C1
if (ftduino.counter_get_state(Ftduino:: C 1 )) {
/* ... tue etwas ... */
}
138 Kapitel 9. Bibliotheken
9.1.4 void output set(uint8 t port, uint8 t mode)
Mit der Funktion output set() k¨
onnen die Ausg¨
ange O1 bis O8 gesteuert werden. Der Wertebereich f¨
ur port reicht daher
von Ftduino::O1 bis Ftduino::O8.
Der Parameter mode beschreibt, in welchen Zustand der Ausgang gebracht werden soll. M¨
ogliche Werte f¨
ur mode sind
Ftduino::OFF, wenn der Ausgang komplett unbeschaltet sein soll, Ftduino::LO, wenn der Ausgang gegen Masse geschaltet
werden soll und Ftduino::HI, wenn der Ausgang auf 9 Volt geschaltet werden soll.
Beispiel
// La mpe z wischen Aus ga ng O1 und Mas se le uc ht en lass en
ftduino.o ut pu t_ set (Ftduino:: O1 ,Ftduino:: HI );
Hinweis: Ausg¨
ange k¨
onnen nur verwendet werden, wenn der ftDuino mit einer 9-Volt-Versorgung verbunden ist (siehe
Abschnitt 1.2.5).
9.1.5 void motor set(uint8 t port, uint8 t mode)
Die Funktion motor set() bedient einen Motorausgang M1 bis M4. Motorausg¨
ange werden durch die Kombination von zwei
Ausg¨
angen gebildet (M1 =O1 und O2,M2 =O3 und O4, . . . ). Der Wert f¨
ur port liegt daher im Bereich von Ftduino::M1
bis Ftduino::M4.
Der Parameter mode gibt an, welchen Zustand der Motorausgang annehmen soll. M¨
ogliche Werte f¨
ur mode sind
Ftduino::OFF, wenn der Motor ausgeschaltet sein soll, Ftduino::LEFT, wenn der Motor sich nach links drehen soll,
Ftduino::RIGHT, wenn der Motor sich nach rechts drehen soll und Ftduino::BRAKE, wenn der Motor gebremst werden
soll.
Der Unterschied zwischen Ftduino::OFF und Ftduino::BRAKE besteht darin, dass ein noch drehender Motor bei
Ftduino::BRAKE durch Zusammenschalten der beiden Anschl¨
usse aktiv gebremst wird w¨
ahrend der Motor bei
Ftduino::OFF lediglich spannungslos geschaltet wird und langsam ausl¨
auft.
Beispiel
// Moto r an Ausga ng M1 links h erum laufen lassen
ftduino.motor_set(Ftduino: : M1 ,Ftduino:: LEFT);
Hinweis: Ausg¨
ange k¨
onnen nur verwendet werden, wenn der ftDuino mit einer 9-Volt-Versorgung verbunden ist (siehe
Abschnitt 1.2.5).
9.1.6 Beispiel-Sketches
Code-Beispiele zur Nutzung der FtduinoSimple-Bibliothek finden sich im Men¨
u der Arduino-IDE unter Datei
Beispiele FtduinoSimple .
9.2 Ftduino
Die Ftduino-Bibliothek kapselt alle Funktionen der ftDuino-Hardware, sodass der Anwender bequemen Zugriff auf alle Ein-
und Ausg¨
ange hat, ohne sich ¨
uber die konkrete technische Umsetzung Gedanken machen zu m¨
ussen.
Die Ftduino-Bibliothek ben¨
otigt selbst etwas Flash-Speicher, RAM-Speicher und Hintergrund-Rechenleistung, so dass nicht
alle Ressourcen komplett dem Anwendungssketch zur Verf¨
ugung stehen. Zus¨
atzlich macht sie Gebrauch von internen Res-
sourcen des ATmega32u4 wie Timern und Interrupts wie jeweils bei den folgenden Funktionsbeschreibungen erw¨
ahnt.
Um die Ftduino-Bibliothek zu nutzen muss zu Beginn eines Sketches die entsprechende Include-Zeile eingef¨
ugt werden.
#include <Ftduino.h>
9.2. Ftduino 139
Zus¨
atzlich muss vor Verwendung aller anderen Funktionen die init()-Funktion aufgerufen werden. Dies geschieht sinnvoller
Weise fr¨
uh in der setup()-Funktion.
// die setup - Funktion wird e inm al beim Start a ufgerufen
void setup () {
// B enutzu ng der Ftduino - B ibliothek vo rbereit en
ftduino.init() ;
}
9.2.1 Die Eing¨
ange I1 bis I8
Die Eing¨
ange I1 bis I8 sind mit Analogeing¨
angen des ATmega32u4-Mikrocontrollers im ftDuino verbunden. Diese Analo-
geing¨
ange werden von der ftDuino-Bibliothek permanent im Hintergrund ausgewertet, da die Analog-Wandlung eine gewisse
Zeit in Anspruch nimmt und auf diese Weise eine unerw¨
unschte Verz¨
ogerung bei der Abfrage von Eing¨
angen vermieden
werden kann.
Die ftDuino-Bibliothek nutzt dazu den sogenannten ADC vect-Interrupt. Die Analog-Digital-Wandler (ADCs) werden auf
eine Messrate von ungef¨
ahr 8900 Messungen pro Sekunde eingestellt. Jeder Eingang wird zweimal abgefragt, um eine
stabile zweite Messung zu erhalten, so dass f¨
ur die 8 Eing¨
ange insgesamt 16 Messungen n¨
otig sind. Daraus ergibt sich eine
Konvertierungsrate von circa 560 Messungen pro Sekunde pro Eingang, die automatisch im Hintergrund erfolgen. Beim
Auslesen ist der Messwert demnach maximal circa 2 Millisekunden alt und der Wert wird ungef¨
ahr alle 2 Millisekunden
aktualisiert.
Der ftDuino kann einen sogenannte Pull-Up-Widerstand an jedem der Eing¨
ange aktivieren, so dass einer Spannungsmessung
eine Widerstandsmessung erfolgen kann. Auch das wird von der ftDuino-Bibliothek im Hintergrund verwaltet und die
Umschaltung erfolgt automatisch vor der Messung. Sie ist auch der Grund, warum pro Kanal zwei Messungen erfolgen. Dies
erlaubt den Signalen, sich nach dem Umschaltvorgang und vor der zweiten Messung zu stabilisieren.
9.2.2 void input set mode(uint8 t ch, uint8 t mode)
Die Funktion input set mode() setzt den Messmodus des Eingangs ch. G¨
ultige Werte f¨
ur ch reichen von Ftduino::I1
bis Ftduino::I8.
Der Wert mode kann auf Ftduino::RESISTANCE,Ftduino::VOLTAGE oder Ftduino::SWITCH gesetzt werden. Die Funk-
tion input get() liefert in der Folge Widerstandswerte in Ohm, Spannungswerte in Millivolt oder den Schaltzustand eines
Schalters als Wahrheitswert.
9.2.3 uint16 t input get(uint8 t ch)
Diese Funktion liest den aktuellen Messwert des Eingangs ch aus. G¨
ultige Werte f¨
ur ch reichen von Ftduino::I1 bis
Ftduino::I8.
Der zur¨
uckgelieferte Messwert ist ein 16-Bit-Wert. Im Falle einer Spannungsmessung wird ein Wert zwischen 0 und 10.000
zur¨
uck geliefert, was einer Spannung von 0 bis 10 Volt entspricht. Im Falle einer Widerstandsmessung wird ein Wider-
standswert von 0 bis 65535 Ohm zur¨
uck geliefert, wobei der Wert 65535 auch bei allen Widerst¨
anden gr¨
oßer 65 Kiloohm
geliefert wird. Bedingt durch das Messprinzip werden die Werte oberhalb circa 10 Kiloohm immer ungenauer. Bei einer
Schaltermessung wird nur true oder false zur¨
uck geliefert, je nachdem ob der Eingang mit weniger als 100 Ohm gegen
Masse verbunden ist (Schalter geschlossen) oder nicht.
Normalerweise liefert diese Funktion den letzten im Hintergrund ermittelten Messwert sofort zur¨
uck. Nur wenn direkt zuvor
der Messmodus des Eingangs ver¨
andert wurde, dann kann es bis zu 2 Millisekunden dauern, bis die Funktion einen g¨
ultigen
Messwert zur¨
uck liefert. Die Funktion blockiert in dem Fall die Programmausf¨
uhrung so lange.
Beispiel
// Widerstand an I1 a us we rten
ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: RESISTANCE ) ;
uint16_ t w id er st an d =ftduino.i nput _get (Ftduino:: I 1 );
140 Kapitel 9. Bibliotheken
9.2.4 Die Ausg¨
ange O1 bis O8 und M1 bis M4
Die Ausg¨
ange O1 bis O8 sind acht unabh¨
angige verst¨
arkte Ausg¨
ange zum direkten Anschluss ¨
ublicher 9-Volt-Aktoren von
fischertechnik wie z.B. Lampen, Ventile und Motoren.
Je vier Ausg¨
ange werden von einem Treiberbaustein vom Typ MC33879A2angesteuert. Dieser Baustein enth¨
alt acht un-
abh¨
angig steuerbare Leistungstransistoren. Je zwei Transistoren k¨
onnen einen Ausgang auf Masse schalten, auf 9 Volt
schalten oder ganz unbeschaltet lassen. Daraus ergeben sich die drei m¨
oglichen Zust¨
ande jedes Ausgangs LO (auf Masse
geschaltet), HI (auf 9 Volt geschaltet) oder OFF (unbeschaltet).
Je zwei Ausg¨
ange Ox k¨
onnen zu einem Motorausgang Mx kombiniert werden. Ausg¨
ange O1 und O2 ergeben den Motorausgang
M1,O3 und O4 den Motorausgang M2 und so weiter. Der kombinierte Motorausgang kann die vier m¨
ogliche Zust¨
ande OFF,
LEFT,RIGHT und BRAKE annehmen. In den Zust¨
anden LEFT und RIGHT dreht ein angeschlossener Motor je nach Polarit¨
at
des Anschlusses links oder rechts-herum. Im Zustand OFF sind beide Ausg¨
ange unbeschaltet und der Motor verh¨
alt sich, als
w¨
are er nicht angeschlossen und l¨
asst sich z.B. relativ leicht drehen. Im Zustand BRAKE sind beiden Ausg¨
ange auf Masse
geschaltet und ein angeschlossener Motor wird gebremst und l¨
asst sich z.B. schwer drehen.
Die Motortreiber sind ¨
uber die sogenannte SPI-Schnittstelle des ATmega32u4 angeschlossen. Beide Motortreiber sind in
Reihe geschaltet und werden bei jedem SPI-Datentransfer beide mit Daten versorgt. Signal¨
anderungen an den Ausg¨
angen
und speziell die PWM-Signalerzeugung (siehe Abschnitt 6.3) zur Erzeugung von Analogsignalen an den Ausg¨
angen erfor-
dern eine kontinuierliche Kommunikation auf dem SPI-Bus im Hintergrund. Dazu implementiert die Ftduino-Bibliothek
einen sogenannte SPI-Interrupt-Handler, der permanent im Hintergrund l¨
auft und permanent den Status der Motortreiber
aktualisiert.
Hinweis: Die Ausg¨
ange lassen sich nur nutzen, wenn der ftDuino mit einer 9-Volt-Spannungsquelle verbunden ist.
9.2.5 void output set(uint8 t port, uint8 t mode, uint8 t pwm)
Diese Funktion schaltet einen Einzelausgang. G¨
ultige Werte f¨
ur port liegen im Bereich von Ftduino::O1 bis Ftduino::O8.
Der Parameter mode gibt an, in welchen Ausgangsmodus der Ausgang geschaltet werden soll. Erlaubte Werte f¨
ur mode sind
Ftduino::OFF (Ausgang ist ausgeschaltet), Ftduino::LO (Ausgang ist auf Masse geschaltet) und Ftduino::HI (Ausgang
ist auf 9 Volt geschaltet).
Der pwm-Parameter gibt einen Wert f¨
ur die Pulsweitenmodulation zur Erzeugung von Analogsignalen vor. Der Wert kann
von 0 (Ftduino::OFF) bis 64 (Ftduino::MAX oder Ftduino::ON) reichen, wobei 0 f¨
ur aus und 64 f¨
ur an steht. Eine
am Ausgang angeschlossene Lampe leuchtet bei 0 nicht und bei 64 maximal hell. Zwischenwerte erzeugen entsprechende
Zwischenwerte und eine Lampe leuchtet bei einem pwm-Wert von 32 nur mit geringer Helligkeit. Es sollten wenn M¨
oglich die
Konstanten Ftduino::OFF,Ftduino::ON und Ftduino::MAX herangezogen werden, da diese bei einer Ver¨
anderung des
PWM-Wertebereichs z.B. in sp¨
ateren Versionen der Ftduino-Bibliothek leicht angepasst werden k¨
onnen. Zwischenwerte
k¨
onnen dazu von den Konstanten abgeleitet werden (z.B. Ftduino::MAX/2).
Beispiel
// Aus gang O2 auf 50% e in sc ha lt en
ftduino.o ut pu t_ set (Ftduino:: O2 ,Ftduino:: HI ,Ftduino:: MAX /2 ) ;
9.2.6 void motor set(uint8 t port, uint8 t mode, uint8 t pwm)
Die Funktion motor set() schaltet einen kombinierten Motorausgang. G¨
ultige Werte f¨
ur port liegen im Bereich von
Ftduino::M1 bis Ftduino::M4.
Der Parameter mode gibt an, in welchen Ausgangsmodus der Motorausgang geschaltet werden soll. Erlaubte Werte f¨
ur mode
sind Ftduino::OFF (Ausgang ist ausgeschaltet), Ftduino::LEFT (Motor dreht links), Ftduino::RIGHT (Motor dreht
rechts) und Ftduino::BRAKE (Motor wird aktiv gebremst, indem beide Einzelausg¨
ange auf Masse geschaltet werden).
Der pwm-Parameter gibt einen Wert f¨
ur die Pulsweitenmodulation zur Erzeugung von Analogsignalen vor. Der Wert kann
von 0 (Ftduino::OFF) bis 64 (Ftduino::MAX oder Ftduino::ON) reichen, wobei 0 f¨
ur aus und 64 f¨
ur an steht. Ein am
2Datenblatt unter http://cache.freescale.com/files/analog/doc/data sheet/MC33879.pdf.
9.2. Ftduino 141
Ausgang angeschlossener Motor dreht in den Modi Ftduino::LEFT und Ftduino::RIGHT bei 0 nicht und bei 64 mit
maximaler Drehzahl. Zwischenwerte erzeugen entsprechende Zwischenwerte und ein Motor dreht bei einem pwm-Wert von
32 nur mit geringerer Drehzahl (f¨
ur Details zum Zusammenhang zwischen Motordrehzahl und PWM-Werte siehe Abschnitt
6.3). Es sollten wenn M¨
oglich die Konstanten Ftduino::OFF,Ftduino::ON und Ftduino::MAX herangezogen werden, da
diese bei einer Ver¨
anderung des PWM-Wertebereichs z.B. in sp¨
ateren Versionen der Ftduino-Bibliothek leicht angepasst
werden k¨
onnen. Zwischenwerte k¨
onnen dazu von den Konstanten abgeleitet werden (z.B. Ftduino::MAX/2). Im Modus
Ftduino::BRAKE bestimmt der pwm-Wert, wie stark der Motor gebremst wird. Im Modus Ftduino::OFF hat der pwm-Wert
keine Bedeutung.
Beispiel
// Motor an M3 mit 1/3 G esc hw ind ig ke it links dr ehen
ftduino.motor_set(Ftduino: : M3 ,Ftduino:: LEFT ,Ftduino:: MAX /3) ;
9.2.7 void motor counter(uint8 t port, uint8 t mode, uint8 t pwm, uint16 t counter)
Diese Funktion dient zur Ansteuerung von Encoder-Motoren und gleicht in ihren ersten drei Parametern der motor set()-
Funktion. Die Bedeutung dieser Parameter ist identisch.
Der zus¨
atzliche vierte Parameter gibt an, wie viele Impulse der Encoder-Motor laufen soll. Die Schritte werden auf dem
korrespondierenden Z¨
ahlereingang gemessen, also auf Z¨
ahlereingang C1 f¨
ur Motorausgang M1,C2 f¨
ur M2 und so weiter. Nach
Ablauf der angegebenen Impulse wird der Motor gestoppt (siehe void motor counter set brake()).
Das Z¨
ahlen der Impulse und das Stoppen des Motors passieren im Hintergrund und unabh¨
angig von der weiteren Sketch-
ausf¨
uhrung. Die Zahl der pro Motorumdrehung erkannten Impulse h¨
angt vom Motortyp ab. Die Motoren aus dem TXT
Discovery Set liefern 631
/3Impulse pro Drehung der Motorachse, die Motoren aus den urspr¨
unglich f¨
ur den TX-Controller
verkauften Sets liefern 75 Impulse pro Umdrehung.
9.2.8 bool motor counter active(uint8 t port)
Die Funktion motor counter active() liefert zur¨
uck, ob die Impulsz¨
ahlung f¨
ur den durch port spezifizierten Motorausgang
aktiv ist. G¨
ultige Werte von port liegen im Bereich von Ftduino::M1 bis Ftduino::M4.
Aktiv bedeutet, dass der entsprechende Motor durch den Aufruf von motor counter() gestartet wurde und der Impulsz¨
ahler
bisher nicht abgelaufen ist. Mit dieser Funktion kann u.a. auf das Ablaufen der Impulsz¨
ahlung und das Stoppen des Motors
gewartet werden:
Beispiel
// TXT - Enc odermot or an M4 f¨u r drei vol le U md rehungen st ar ten
ftduino.motor_counter(Ftduino: : M4 ,Ftduino:: LEFT ,Ftduino:: MAX , 19 0) ;
// war ten bis der Mot or stoppt
whi le (ftduino.motor_counter_active(Ftduino:: M4 ) );
// Moto r hat gest op pt
9.2.9 void motor counter set brake(uint8 t port, bool on)
Diese Funktion bestimmt das Bremsverhalten des Motors an Ausgang port, wenn er durch die Funktion motor counter()
gestartet wird.
Wird der Parameter on auf wahr (true) gesetzt, so wird der Motor nach Ablauf der Zeit aktiv gebremst. Ist er unwahr
(false), so wird der Motor lediglich abgeschaltet und er l¨
auft ungebremst aus. Die Standardeinstellung nach der Initialisie-
rung der Bibliothek ist wahr, die aktive Bremsung ist also aktiviert.
In beiden F¨
allen l¨
auft der Motor nach. Im gebremsten Fall l¨
auft ein Encoder-Motor aus dem TXT-Discovery-Set unbelastet
circa 5 Impulse nach (circa 1
/10 Umdrehung bzw. 28,5 ). Im ungebremsten Fall l¨
auft der gleiche Motor circa 90 Impulse
(circa 11
/2Umdrehungen) nach.
142 Kapitel 9. Bibliotheken
Da die Z¨
ahler nach dem Stoppen des Encoders weiterlaufen ist der Nachlauf auch per Programm messbar:
Beispiel
// Br ems e f¨u r Ausg ang M4 ab sc ha lt en
ftduino.motor_counter_set_brake(Ftduino: : M4 ,f alse ) ;
// TXT - Enc odermot or an M4 f¨u r drei vol le U md rehungen st ar ten
ftduino.motor_counter(Ftduino: : M4 ,Ftduino:: LEFT ,Ftduino:: MAX , 19 0) ;
// war ten bis der Mot or stoppt
whi le (ftduino.motor_counter_active(Ftduino:: M4 ) );
// etwa s l¨a nger warten , um dem Motor Zeit zum N ac hl au fe n zu geb en
delay (500) ;
// Z ¨a hl erstan d aus gebe n
Serial.println(ftduino.counter_get(Ftduino:: C 4 ));
9.2.10 Die Z¨
ahlereing¨
ange C1 bis C4
Die Z¨
ahlereing¨
ange arbeiten im Gegensatz zu den Analogeing¨
angen rein digital. Sie unterscheiden nur, ob der jeweilige
Eingang auf Masse geschaltet ist oder nicht. Dies geschieht ¨
ublicherweise durch einen Tester, der zwischen dem Z¨
ahlereingang
und seinem korrespondierenden Masseanschluss angeschlossen ist oder einem Encodermotor, dessen Encoderausgang mit
dem Z¨
ahlereingang verbunden ist. Die Z¨
ahlereing¨
ange haben interne Pull-Up-Widerst¨
ande. Das bedeutet, dass sie vom
ftDuino als “high” bzw mit hohem Signalpegel erkannt werden, wenn kein Signal anliegt weil z.B. ein angeschlossener
Taster nicht gedr¨
uckt ist. Ist der Taster geschlossen, dann schaltet er den Eingang auf Masse, was von ftDuino als “low”
erkannt wird.
Die vier Z¨
ahlereing¨
ange sind direkt mit einem Interrupt-f¨
ahigen Eingang am ATmega32u4 verbunden. Technisch ist damit
eine Reaktion im Bereich von mehreren hunderttausend Z¨
ahlimpulsen pro Sekunde m¨
oglich. Werden aber z.B. Tastendr¨
ucke
gez¨
ahlt, so wird das unvermeidliche Prellen (siehe Abschnitt 6.12) zu verf¨
alschten Ergebnissen f¨
uhren. Aus diesem Grund f¨
uhrt
die Ftduino-Bibliothek im Hintergrund eine Filterung durch und begrenzt die minimale Ereignisl¨
ange auf eine Millisekunde.
K¨
urzere Ereignisse werden nicht gez¨
ahlt.
Nach Systemstart sind alle vier Z¨
ahler auf Null gesetzt und deaktiviert. Ereignisse an den Eing¨
angen ver¨
andern die Z¨
ahler
also nicht.
Zus¨
atzlich erlaubt der Z¨
ahlereingang C1 den Anschluss des fischertechnik ROBO TX Ultraschall-Distanzsensors 133009 wie
in Abschnitt 1.2.6 dargestellt.
9.2.11 void counter set mode(uint8 t ch, uint8 t mode)
Diese Funktion setzt den Betriebsmodus eines Z¨
ahlereingangs. G¨
ultige Werte f¨
ur ch reichen von Ftduino::C1 bis
Ftduino::C4.
Wird der mode-Wert auf auf Ftduino::C EDGE NONE gesetzt, dann werden keine Signalwechsel gez¨
ahlt und der Z¨
ahler ist
deaktiviert. Dies ist der Startzustand.
Wird mode auf Ftduino::C EDGE RISING gesetzt, so werden steigende Signalflanken, also Wechsel des Eingangssignals von
Masse auf eine h¨
ohere Spannung, gez¨
ahlt. Dies passiert z.B. wenn ein angeschlossener Taster losgelassen (ge¨
offnet) wird.
Ein mode-Wert von Ftduino::C EDGE FALLING f¨
uhrt dazu, dass fallende Signalflanken, also Wechsel des Eingangssignals
von einer h¨
oheren Spannung auf Masse, gez¨
ahlt werden, was z.B. dann geschieht, wenn ein angeschlossener Taster gedr¨
uckt
(geschlossen) wird.
Wird der mode-Wert schließlich auf Ftduino::C EDGE ANY gesetzt, so f¨
uhren beide Signal¨
anderungsrichtungen dazu, dass
der Z¨
ahler erh¨
oht wird. Sowohl das Dr¨
ucken, als auch das Loslassen einen Testers wird dann z.B. gez¨
ahlt.
9.2.12 uint16 t counter get(uint8 t ch)
Diese Funktion liefert den aktuellen Z¨
ahlerstand zur¨
uck. G¨
ultige Werte f¨
ur ch liegen im Bereich von Ftduino::C1 und
Ftduino::C4.
9.2. Ftduino 143
Der maximale Wert, der zur¨
uck geliefert wird ist 65535. Wird dieser Wert ¨
uberschritten, dann springt der Z¨
ahler wieder auf
0 zur¨
uck.
9.2.13 void counter clear(uint8 t ch)
Mit Hilfe der Funktion counter clear() kann der Z¨
ahlerstand auf Null gesetzt werden. G¨
ultige Werte f¨
ur ch liegen im
Bereich von Ftduino::C1 und Ftduino::C4.
Beispiel
// Ei ne S eku nd e l an g s tei gen de ( low - nach - h ig h ) I mpu ls e an Ein gan g C1 z ¨a h le n
ftduino.counter_set_mode(Ftduino:: C1 ,Ftduino:: C_EDGE_RISING) ;
ftduino.counter_clear(Ftduino:: C 1 );
delay (1000);
uint16_ t impu lse =ftduino.counter_get(Ftduino:: C 1 );
9.2.14 bool counter get state(uint8 t ch)
Der Zustand der Z¨
ahlereing¨
ange kann auch direkt mit der Funktion counter get state() abgefragt werden. Die Werte
f¨
ur ch m¨
ussen im Bereich von Ftduino::C1 bis Ftduino::C4 liegen.
Diese Funktion liefert wahr (true) zur¨
uck, wenn der Eingang mit Masse verbunden ist und unwahr (false) wenn er offen
ist.
Es findet bei dieser Funktion keine Filterung statt, so dass z.B. Tastenprellen nicht unterdr¨
uckt wird. Es k¨
onnen auf diese
Weise digitale Signale mit einer sehr hohen Frequenz erfasst werden.
9.2.15 void ultrasonic enable(bool ena)
An Z¨
ahlereingang C1 kann alternativ der fischertechnik ROBO TX Ultraschall-Distanzsensors 133009 wie in Abschnitt 1.2.6
dargestellt betrieben werden. Die Funktion ultrasonic enable() aktiviert die Unterst¨
utzung f¨
ur den Sensor, wenn der
Parameter ena auf wahr (true) gesetzt wird und deaktiviert sie, wenn er auf unwahr (false) gesetzt wird.
Wird die Unterst¨
utzung f¨
ur den Ultraschallsensor aktiviert, so wird die Z¨
ahlfunktion des Eingangs C1 automatisch deaktiviert.
Ist der Ultraschallsensor aktiviert, so wird er kontinuierlich circa zweimal je Sekunde im Hintergrund ausgewertet. Der jeweils
aktuelle Messwert ist daher maximal 500 Millisekunden alt.
9.2.16 int16 t ultrasonic get()
Die Funktion ultrasonic get() liefert den Messwert eines an Z¨
ahlereingang C1 angeschlossenen Distanzsensors in Zenti-
metern zur¨
uck. Wurde seit Aktivierung kein g¨
ultiger Messwert vom Sensor empfangen, so wird als Distanz -1 zur¨
uck geliefert.
Dies geschieht auch, wenn kein Sensor angeschlossen ist.
Der Sensor selbst arbeitet im Bereich von 0 bis 1023 Zentimeter.
Beispiel
// Di st anzse ns or an Eing ang C1 abf ra ge n
ftduino.ultrasonic_enable(true) ;
delay (1000); // eine S ekund e Zeit f¨ur erste Me ss ung geben
int16_t distanz =ftduino.ultrasonic_get() ;
Kapitel 10
Selbstbau
Es ist m¨
oglich, einen ftDuino manuell zu bauen. Die ersten Prototypen sind so entstanden. Bei manuellem Aufbau bietet es
sich an, funktionsgruppenweise vorzugehen und jeweils die Funktionsf¨
ahigkeit schrittweise sicher zu stellen.
Basis f¨
ur den Selbstbau ist die industriell gefertigte Platine aus den Anh¨
angen B und C basierend auf dem Schaltplan
entsprechend Anhang A.
10.1 Erste Baustufe ”Spannungsversorgung“
Im ersten Schritt wird die Spannungsversorgung aufgebaut. Sie besteht aus den Kondensatoren C6 bis C11 sowie C14, den
Dioden D1 und D3 bis D5 sowie dem Spannungsregler U2 und der Sicherung F1. Die Spannungsversorungs-Leuchtdiode (siehe
Abschnitt 1.2.4) LED2 mit zugeh¨
origem Vorwiderstand R35 werden ebenfalls montiert. Die Spule L1 sowie der Kondensator
C1 k¨
onnen auch bereits installiert werden.
ftDuino
(c) 2017 by Till Harbaum
V1.1
PB1
1
2
6
10
1
2
U2
LED2
D1
C14
R20
R17
R21
R19
R26
R23
R27
R25
R7
R2
R8
R4
R14
R11
R15
R13
C6
R40
R41
R44
R45
C22
C7
C8
R35
R38
R42
R43
R39
C5
C11
C12
C4
R9
L1
C1
C10
C9C2C3
R29
R28
U1
J1
R5
R6
Q1
U3
U4
C15C17
C16C18
C20C23
C21C24
IC1
R34
R33
LED1
R32
SV1
SV2
121
D4
D3
D5
R1
R10
R16
R22
R3
R12
R18
R24
T1
R37
R36
D7
C13
D8
D9
D10 D11 D12 D13 D14
D6
R30
R31
C19
C25
D15
D16
D2
JMP1
Abbildung 10.1: Komponenten der Spannungsversorgung
Die 9V-Steckbuchse 121 sowie die beiden Bundh¨
ulsen 9VIN+ und 9VIN- und die USB-Buchse J1 werden ebenfalls jetzt
schon best¨
uckt.
10.1. Erste Baustufe ”Spannungsversorgung“ 145
10.1.1 Bauteile-Polarit¨
at
Bei folgenden Bauteilen ist auf die Polarit¨
at zu achten: D1 und D3 bis D5,C6 bis C8 und C14 sowie LED2.
Der positive Anschluss der Kondensatoren ist durch einen aufgedruckten Balken oder Streifen gekennzeichnet. Im
Best¨
uckungsplan ist dieser Anschluss ebenfalls durch einen Balken und zus¨
atzlich durch abgeschr¨
agte Ecken markiert.
Die verschiedenen Dioden des ftDuino nutzen unterschiedliche Symbole beim Best¨
uckungsdruck. Aber auch hier ist sowohl
auf der Diode selbst als auch auf dem Best¨
uckungssymbol ein Balken auf der Seite der Kathode vorhanden.
+
-
+
(a) Tantal-Kondensator
Kathode
Anode
(b) Diode
Kathode
Anode
(c) Leuchtdiode
Abbildung 10.2: Schaltplansymbol, Bauteilepolarit¨
at und Best¨
uckungssymbol
Bei den Leuchtdioden (LEDs) ist es etwas schwieriger, die korrekte Polarit¨
at zu bestimmen. Auf der Unterseite der LED ist
¨
ublicherweise ein Dreieck oder ein ”T“ aufgedruckt, das jeweils in Richtung Kathode weist.
Die Polarit¨
at von Leuchtdioden kann man mit einem einfachen Multimeter im Dioden-Test-Modus ¨
uberpr¨
ufen. Bringt man
die Anode der LED mit dem roten Multimeterkabel und die Kathode mit dem schwarzen Kabel in Kontakt, so leuchtet die
LED schwach.
Sind alle Komponenten der Spannungsversorgung best¨
uckt, dann sollte die gr¨
une LED leuchten, sobald der USB-Stecker
eingesteckt wird oder sobald 9 Volt ¨
uber die Bundh¨
ulsen oder den 9-V-Rundstecker eingespeist werden.
Leuchtet die LED in mindestens einem der F¨
alle nicht, so kann man mit Hilfe eines Multimeters leicht verfolgen, wo die
Spannung noch vorhanden ist und wo nicht mehr. Wahrscheinlichste Fehler liegen in der Polarit¨
at der Dioden oder der LED.
10.1.2 Kontrollmessungen
Bei einer 9-Volt-Versorgung muss an den zwischen Pin 1 und 2 des I2C-Anschlusses am noch unbest¨
uckten Wannenstecker
SV1 eine Spannung von 5 Volt (±0,4 Volt) messbar sein. Auf keinen Fall darf mit der Best¨
uckung des Mikrocontrollers
fortgefahren werden, wenn hier eine deutlich zu hohe Spannung gemessen wird.
Ebenfalls bei einer Versorgung aus einer 9-Volt-Quelle sollten an den bisher unbest¨
uckten beiden unteren 9-Volt-Ausg¨
angen
nahezu 9 Volt zu messen sein. Etwas Spannungsverlust gegen¨
uber der Quelle tritt durch die Dioden D3 bzw. D4 und der
Diode D5 auf.
Zwischen den Pads 14 und 7 am bisher unbest¨
uckten IC1 muss bei reiner USB-Versorgung eine Spannung von etwas
unter 5 Volt zu messen sein. Ist das nicht der Fall, dann besitzt der Spannungsregler U2 keine sogenannte Body-Diode
(der empfohlene MCP 1755S hat diese) und die Funktion dieser Diode muss durch D6 extern nachger¨
ustet werden. Bei
Verwendung des empfohlenen MCP 1755S kann D6 ersatzlos entfallen.
Die Diode D5 verhindert, dass der Strom ¨
uber die Body-Diode zu den Ausgangstreiber des ftDuino gelangt. Andernfalls
w¨
urden die Ausg¨
ange des ftDuino auch aus einer USB-5-Volt-Versorgung gespeist, was gegebenenfalls eine ¨
Uberlastung des
USB und/oder der Body-Diode zur Folge h¨
atte.
146 Kapitel 10. Selbstbau
10.2 Zweite Baustufe ”Mikrocontroller“
Ist die Spannungsversorgung sichergestellt und vor allem liegen auch im 9-Volt-Betrieb am I2C-Anschluss stabile 5 Volt an,
dann kann mit dem Mikrocontroller U1 fortgefahren werden.
ftDuino
(c) 2017 by Till Harbaum
V1.1
PB1
1
2
6
10
1
2
U2
LED2
D1
C14
R20
R17
R21
R19
R26
R23
R27
R25
R7
R2
R8
R4
R14
R11
R15
R13
C6
R40
R41
R44
R45
C22
C7
C8
R35
R38
R42
R43
R39
C5
C11
C12
C4
R9
L1
C1
C10
C9C2C3
R29
R28
U1
J1
R5
R6
Q1
U3
U4
C15C17
C16C18
C20C23
C21C24
IC1
R34
R33
LED1
R32
SV1
SV2
121
D4
D3
D5
R1
R10
R16
R22
R3
R12
R18
R24
T1
R37
R36
D7
C13
D8
D9
D10 D11 D12 D13 D14
D6
R30
R31
C19
C25
D15
D16
D2
JMP1
Abbildung 10.3: Komponenten des Mikrocontrollers
Auch der Mikrocontroller darf nicht verpolt werden, was in diesem Fall bedeutet, dass er korrekt orientiert aufgel¨
otet werden
muss. Sowohl auf der Platine als auch auf dem Chip-Geh¨
ause findet sich in einer Ecke eine runde Markierung bzw. Vertiefung.
Diese Markierung verweist auf den Pin 1 des Mikrocontrollers und bestimmt die korrekte Orientierung. Ist U1 verl¨
otet werden
direkt daneben C5 und R29 montiert.
Die ¨
ubrigen in dieser Baustufe zu montierenden Komponenten beinhalten die Reset-Logik bestehend aus Taster PB1, sowie
Diode D2 und Widerstand R9. Kondensator C4 und die Widerst¨
ande R5 und R6 vervollst¨
andigen die USB-Schaltung. Den
16-MHz-Systemtakt erzeugen der Quarz Q1 mit den Kondensatoren C2 und C3.
Der I2C-Anschluss SV1 mit seinen Pull-Up-Widerst¨
anden R30 und R31 kann ebenfalls jetzt best¨
uckt werden.
Die Leuchtdiode LED1 mit ihrem Vorwiderstand R28 wird direkt vom Mikrocontroller angesteuert und wird ebenfalls jetzt
montiert. Bei der Leuchtdiode muss wieder auf korrekte Polarit¨
at geachtet werden.
Der sogenannte ISP-Steckverbinder SV2 wird lediglich zum einmaligen Aufspielen des Bootloaders (siehe Abschnitt 1.2.1
ben¨
otigt und muss nicht unbedingt fest montiert werden, wenn das Standardgeh¨
ause genutzt werden soll, da es im Geh¨
ause
keinen Ausschnitt f¨
ur diesen Steckverbinder gibt. Die frei verf¨
ugbare Druckvorlage1hat einen entsprechenden Ausschnitt
und kann auch bei fest montiertem SV2 genutzt werden.
10.2.1 Funktionstest des Mikrocontrollers
Der Mikrocontroller wird von Atmel (bzw. Microchip) mit einem USB-Bootloader2ausgeliefert. Beim Anschluss an einen
PC sollte der Mikrocontroller daher vom PC als Ger¨
at namens ATm32U4DFU erkannt werden. Ist das der Fall, dann sind die
wesentlichen Komponenten funktionsf¨
ahig. Dass Windows keinen Treiber f¨
ur dieses Ger¨
at hat kann ignoriert werden.
Der DFU-Bootloader ist nicht kompatibel zur Arduino-IDE und die Arduino-IDE bringt ihren eigenen Bootloader mit. Dieser
wird einmalig mit einem Programmierger¨
at ¨
uber den Steckverbinder SV2 eingespielt (”gebrannt“).
Zum Brennen des Arduino-Bootloaders unterst¨
utzt die Arduino-IDE eine ganze Reihe von Programmierger¨
aten. Es reicht
eine einfache Variante, wie der USBasp3. Der USBasp wird per USB mit dem PC und ¨
uber das 10-polige Flachbandkabel mit
1Geh¨
ausedruckvorlage https://github.com/harbaum/ftduino/tree/master/case
2DFU-Bootloader, http://www.atmel.com/Images/doc7618.pdf
3USBasp - USB programmer for Atmel AVR controllers, http://www.fischl.de/usbasp/
10.3. Dritte Baustufe ”Eing¨
ange“ 147
Abbildung 10.4: Brennen des Bootloaders ¨
uber die Arduino-IDE
SV2 des ftDuino verbunden. Ist SV2 nicht best¨
uckt, so kann man einen entsprechenden Stecker lose in die Platine stecken
und leicht so verkannten, dass alle Kontakte hergestellt werden. Der eigentliche Flashvorgang dauert nur wenige Sekunden
und man kann den Stecker problemlos so lange leicht verkanntet festhalten.
Nach dem Brennen sollte der ftDuino unter diesem Namen vom Betriebssystems des PC erkannt werden. Er sollte sich von der
Arduino-IDE ansprechen und mit einem Sketch programmieren lassen. Es bietet sich f¨
ur einen ersten Test der Blink-Sketch
unter Datei Beispiele FtduinoSimple Blink an, da die daf¨
ur n¨
otige LED1 ebenfalls gerade montiert wurde.
10.3 Dritte Baustufe ”Eing¨
ange“
Die dritte Baustufe ist sehr einfach zu l¨
oten und besteht prim¨
ar aus Widerst¨
anden, die zum Schutz der Eing¨
ange verwendet
werden.
ftDuino
(c) 2017 by Till Harbaum
V1.1
PB1
1
2
6
10
1
2
U2
LED2
D1
C14
R20
R17
R21
R19
R26
R23
R27
R25
R7
R2
R8
R4
R14
R11
R15
R13
C6
R40
R41
R44
R45
C22
C7
C8
R35
R38
R42
R43
R39
C5
C11
C12
C4
R9
L1
C1
C10
C9C2C3
R29
R28
U1
J1
R5
R6
Q1
U3
U4
C15C17
C16C18
C20C23
C21C24
IC1
R34
R33
LED1
R32
SV1
SV2
121
D4
D3
D5
R1
R10
R16
R22
R3
R12
R18
R24
T1
R37
R36
D7
C13
D8
D9
D10 D11 D12 D13 D14
D6
R30
R31
C19
C25
D15
D16
D2
JMP1
Abbildung 10.5: Komponenten der Eing¨
ange
Die Komponenten der Analogeing¨
ange I1 bis I8 sowie der Z¨
ahlereing¨
ange C1 bis C4 werden gleichzeitig montiert.
Die Best¨
uckung beginnt mit den Widerst¨
anden ganz links und IC1 nach deren Montage die Eing¨
ange I1 bis I8 vollst¨
andig
sind.
148 Kapitel 10. Selbstbau
Im zweiten Schritt werden dann die Widerst¨
ande R36 bis R46 sowie der Transistor T1 best¨
uckt, was die Z¨
ahlereing¨
ange ver-
vollst¨
andigt. Die Triggerschaltung f¨
ur den Ultraschall-Entfernungsmesser (siehe Abschnitt 1.2.6) ist damit auch vollst¨
andig.
Mit einem passenden Testprogramm sollte nun jeder Eingang einzeln getestet werden, um auch Kurzschl¨
usse zwischen
den Eing¨
angen zu erkennen. Sollte ein Eingang nicht wie gew¨
unscht funktionieren, so kommt als Fehlerquelle auch der
Mikrocontroller aus Baustufe 2 in Betracht.
10.4 Vierte Baustufe ”Ausg¨
ange“
In der vierten und letzten Baustufe werden die Komponenten montiert, die zum Betrieb der Ausg¨
ange ben¨
otigt werden.
ftDuino
(c) 2017 by Till Harbaum
V1.1
PB1
1
2
6
10
1
2
U2
LED2
D1
C14
R20
R17
R21
R19
R26
R23
R27
R25
R7
R2
R8
R4
R14
R11
R15
R13
C6
R40
R41
R44
R45
C22
C7
C8
R35
R38
R42
R43
R39
C5
C11
C12
C4
R9
L1
C1
C10
C9C2C3
R29
R28
U1
J1
R5
R6
Q1
U3
U4
C15C17
C16C18
C20C23
C21C24
IC1
R34
R33
LED1
R32
SV1
SV2
121
D4
D3
D5
R1
R10
R16
R22
R3
R12
R18
R24
T1
R37
R36
D7
C13
D8
D9
D10 D11 D12 D13 D14
D6
R30
R31
C19
C25
D15
D16
D2
JMP1
Abbildung 10.6: Komponenten der Ausg¨
ange
Die Leistungstreiber U3 und U4 sollten zuerst best¨
uckt werden, da sie nicht ganz einfach zu l¨
oten sind. Vor allem sollten die
Bundh¨
ulsen nicht best¨
uckt sein, da sie den Zugang zu den Anschlusspads der Treiber sehr erschweren. Erg¨
anzt werden die
Treiber durch nur wenige Widerst¨
ande und Kondensatoren.
10.4.1 Ausgangstests mit 5 Volt
Da die Treiber an der 9-Volt-Versorgung angeschlossen sind sind Kurzschl¨
usse zwischen 9 Volt und 5 Volt f¨
uhrenden Signalen
potenziell m¨
oglich.
+9V +9V
Reset
I1
I2
I3
I4
I5
I6
I7
I8
O1 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
9V=
+ -
USB Run d-
stec ker
LEDs
gegenpolig
angeschlossene
LEDs zum Test
von Ausgang M1
Keine externe 9V-Versorgung!!
Abbildung 10.7: Testweise Br¨
ucke zwischen 5V und 9V
10.4. Vierte Baustufe ”Ausg¨
ange“ 149
Neben der sorgf¨
altigen Kontrolle der L¨
otstellen ist es daher sinnvoll, den 9-Volt-Zweig f¨
ur erste Funktionstests aus dem
5-Volt-Zweig zu versorgen. Kurzschl¨
usse zwischen 5 Volt f¨
uhrenden Signale f¨
uhren in der Regel nicht zu Besch¨
adigungen
w¨
ahrend Kurzschl¨
usse von 5-Volt-Komponenten mit h¨
oheren Spannungen sehr leicht gr¨
oßere Sch¨
aden nach sich ziehen.
Achtung: Dabei darf nat¨
urlich keine externe 9-Volt-Quelle angeschlossen sein, andernfalls w¨
urden die meisten Komponenten
des ftDuino sofort Schaden nehmen!
Ist die Br¨
ucke gesetzt, so werden auch die Ausg¨
ange des ftDuino mit den internen 5 Volt des ftDuino versorgt und Kurz-
schl¨
usse zwischen den Ausg¨
angen und anderen Teilen des ftDuino sind weniger gef¨
ahrlich. Nun k¨
onnen die Ausg¨
ange mit
einer Leuchtdiode auf korrekte Funktion getestet werden. Gr¨
oßere Lasten (Motoren oder Gl¨
uhlampen) sollten f¨
ur diesen Test
nicht verwendet werden, da die interne 5-Volt-Versorgung nicht daraus ausgelegt ist, solche Lasten zu treiben.
Erst wenn alle Ausg¨
ange bei 5 Volt korrekt funktionieren darf die Br¨
ucke entfernt und eine echte 9-Volt-Versorgung ange-
schlossen werden.
Anhang A: Schaltplan
Abbildung A.1: Schaltplan ftDuino Version 1.1
Anhang B: Platinenlayout
ftDuino
(c) 2017 by Till Harbaum
V1.1
PB1
1
2
6
10
1
2
U2
LED2
D1
C14
R20
R17
R21
R19
R26
R23
R27
R25
R7
R2
R8
R4
R14
R11
R15
R13
C6
R40
R41
R44
R45
C22
C7
C8
R35
R38
R42
R43
R39
C5
C11
C12
C4
R9
L1
C1
C10
C9C2C3
R29
R28
U1
J1
R5
R6
Q1
U3
U4
C15C17
C16C18
C20C23
C21C24
IC1
R34
R33
LED1
R32
SV1
SV2
121
D4
D3
D5
R1
R10
R16
R22
R3
R12
R18
R24
T1
R37
R36
D7
C13
D8
D9
D10 D11 D12 D13 D14
D6
R30
R31
C19
C25
D15
D16
D2
JMP1
Abbildung B.1: Platinenlayout ftDuino Version 1.1
Anhang C: Best¨
uckungsplan
ftDuino
(c) 2017 by Till Harbaum
V1.1
PB1
1
2
6
10
1
2
U2
LED2
D1
C14
R20
R17
R21
R19
R26
R23
R27
R25
R7
R2
R8
R4
R14
R11
R15
R13
C6
R40
R41
R44
R45
C22
C7
C8
R35
R38
R42
R43
R39
C5
C11
C12
C4
R9
L1
C1
C10
C9C2C3
R29
R28
U1
J1
R5
R6
Q1
U3
U4
C15C17
C16C18
C20C23
C21C24
IC1
R34
R33
LED1
R32
SV1
SV2
121
D4
D3
D5
R1
R10
R16
R22
R3
R12
R18
R24
T1
R37
R36
D7
C13
D8
D9
D10 D11 D12 D13 D14
D6
R30
R31
C19
C25
D15
D16
D2
JMP1
Abbildung C.1: Best¨
uckungsplan ftDuino Version 1.1
Anhang D: Maße
82mm
82mm
10
8
4
3,5
7,5
3,5
7,5
45
7
7
12
4
19,37 5 4 2 ,7 5
9
16
33
10
2
Abbildung D.1: Maße A ftDuino Version 1.1
3
1,75
3,5
5
3
1,25 2
1
4
3,5
+0,4
3,5+2
1,5
2 2 1
2
1
4,5
Abbildung D.2: Maße B ftDuino Version 1.1
Anhang E: Geh¨
ause
Abbildung E.1: Untere Geh¨
auseschale
Abbildung E.2: Obere Geh¨
auseschale

Navigation menu