Manual

User Manual:

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

ftDuino
ein fischertechnik-kompatibler Arduino
Bedienungsanleitung
Dr.-Ing. Till Harbaum
8. Juni 2018
2
F¨
ur Tanja, Maya, Fabian und Ida
2017 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 ............................................. 9
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................................................ 12
1.2.7 Hinweise f¨
urArduino-erfahreneNutzer................................. 15
1.3 Probleml¨
osungen ................................................ 15
1.3.1 Die gr¨
une Leuchtdiode im ftDuino leuchtetnicht ........................... 15
1.3.2 Der ftDuino taucht am PC nicht als COM:-Portauf .......................... 15
1.3.3 Der ftDuino funktioniert, aber die Ausg¨
angenicht........................... 15
2 Installation 17
2.1 Treiber...................................................... 17
2.1.1 Windows10............................................... 17
2.1.2 Windows7undWindowsVista..................................... 17
2.1.3 Linux................................................... 19
2.2 Arduino-IDE................................................... 21
2.2.1 Installation mit dem Boardverwalter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.2 Updates ................................................. 22
3 Erste Schritte 23
3.1 DerersteSketch................................................. 23
3.1.1 Download des Blink-Sketches auf den ftDuino ............................. 24
3.1.2 Die Funktionsweise des Sketches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.3 Die Funktionen setup() und loop() ................................. 25
3.1.4 AnpassungenamSketch ........................................ 25
3.2 Ansteuerung von fischertechnik-Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.1 DerSketch................................................ 26
3.2.2 Eing¨
ange................................................. 27
3.3 KommunikationmitdemPC .......................................... 28
3.3.1 DerserielleMonitor........................................... 29
3.3.2 Sketchbeschreibung ........................................... 30
3.3.3 USB-Verbindungsaufbau ........................................ 30
4 Experimente 31
4.1 Lampen-Zeitschaltung.............................................. 31
4.1.1 Sketch LampTimer ........................................... 31
4.2 Not-Aus ..................................................... 33
4.2.1 Sketch EmergencyStop ......................................... 33
4.3 Pulsweitenmodulation.............................................. 36
Inhaltsverzeichnis 5
4.3.1 Sketch Pwm ............................................... 36
4.4 Schrittmotoransteuerung ............................................ 40
4.4.1 Vollschrittsteuerung........................................... 42
4.4.2 Halbschrittsteuerung .......................................... 43
4.5 Servomotoransteuerung ............................................. 45
4.5.1 Externe6-Volt-Versorgung ....................................... 46
4.6 Die Eing¨
ange des ftDuino ............................................ 48
4.6.1 Spannungsmessung ........................................... 48
4.6.2 Widerstandsmessung .......................................... 48
4.6.3 EinEingangalsAusgang ........................................ 49
4.7 Temperaturmessung............................................... 49
4.7.1 Sketch Temperature .......................................... 50
4.8 Ausg¨
angean,ausodernichtsdavon?...................................... 52
4.8.1 Sketch OnOffTristate ......................................... 52
4.8.2 Leckstr¨
ome ............................................... 53
4.9 AktiveMotorbremse............................................... 53
4.10USB-Tastatur .................................................. 55
4.10.1 Sketch USB/KeyboardMessage ..................................... 55
4.11USB-GamePad.................................................. 56
4.11.1 Sketch USB/GamePad .......................................... 57
4.12Entprellen .................................................... 58
4.12.1 Sketch Debounce ............................................ 58
4.13 Nutzung des I2C-Bus .............................................. 61
4.13.1 Sketch I2C/I2cScanner ........................................ 62
4.13.2 MPU-6050-Sensor............................................ 62
4.13.3 OLED-Display.............................................. 63
4.13.4 VL53L0X LIDAR-Distanzsensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.13.5 ftDuino als I2C-Client und Kopplung zweier ftDuinos ......................... 65
4.14WS2812B-Vollfarb-Leuchtdioden ........................................ 71
4.14.1 Sketch WS2812FX ............................................ 72
4.15 Musik aus dem ftDuino ............................................. 72
4.15.1 Sketch Music .............................................. 73
4.15.2 Sketch MusicPwm ............................................ 73
4.16 Der ftDuino alsMIDI-Instrument........................................ 74
4.16.1 Sketch MidiInstrument ........................................ 74
5 Modelle 75
5.1 Automation Robots: Hochregallager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.2 ElectroPneumatic:Flipper............................................ 76
5.3 ROBOTICS TXT Explorer: Linienfolger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.4 IdasAmpel.................................................... 78
5.4.1 Zustandsautomaten........................................... 79
6 Community-Projekte 81
6.1 ftduino direct:ftDuino-Anbindung per USB an TXT und TX-Pi . . . . . . . . . . . . . . . . . . . . . 81
6.2 ftDuinIO:ftDuino-Kontroll-App f¨
urTXTundTX-Pi............................. 82
6.3 Brickly-Plugin: Grafische ftDuino-Programmierung in Brickly . . . . . . . . . . . . . . . . . . . . . . . 83
6.4 startIDE: Programmierung direkt auf dem TX-Pi oder TXT . . . . . . . . . . . . . . . . . . . . . . . . . 83
7 Bibliotheken 85
7.1 FtduinoSimple ................................................. 86
7.1.1 VerwendungimSketch ......................................... 86
7.1.2 bool input get(uint8 t ch) .................................... 87
7.1.3 bool counter get state(uint8 t ch) ............................... 87
7.1.4 void output set(uint8 t port, uint8 t mode) ......................... 87
7.1.5 void motor set(uint8 t port, uint8 t mode) .......................... 88
7.1.6 Beispiel-Sketches ............................................ 88
7.2 Ftduino ..................................................... 88
6Inhaltsverzeichnis
7.2.1 Die Eing¨
ange I1 bis I8 ......................................... 88
7.2.2 void input set mode(uint8 t ch, uint8 t mode) ........................ 89
7.2.3 uint16 t input get(uint8 t ch) .................................. 89
7.2.4 Die Ausg¨
ange O1 bis O8 und M1 bis M4 ................................. 89
7.2.5 void output set(uint8 t port, uint8 t mode, uint8 t pwm) ................ 90
7.2.6 void motor set(uint8 t port, uint8 t mode, uint8 t pwm) ................. 90
7.2.7 void motor counter(uint8 t port, uint8 t mode, uint8 t pwm, uint16 t counter) . . 91
7.2.8 bool motor counter active(uint8 t port) ............................ 91
7.2.9 void motor counter set brake(uint8 t port, bool on) .................... 91
7.2.10 Die Z¨
ahlereing¨
ange C1 bis C4 ...................................... 92
7.2.11 void counter set mode(uint8 t ch, uint8 t mode) ....................... 92
7.2.12 uint16 t counter get(uint8 t ch) ................................ 92
7.2.13 void counter clear(uint8 t ch) .................................. 92
7.2.14 bool counter get state(uint8 t ch) ............................... 93
7.2.15 void ultrasonic enable(bool ena) ................................ 93
7.2.16 int16 t ultrasonic get() ...................................... 93
8 Selbstbau 94
8.1 Erste Baustufe ”Spannungsversorgung“..................................... 94
8.1.1 Bauteile-Polarit¨
at ............................................ 95
8.1.2 Kontroll-Messungen........................................... 95
8.2 Zweite Baustufe ”Mikrocontroller“ ....................................... 96
8.2.1 Funktionstest des Mikrocontrollers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
8.3 Dritte Baustufe ”Eing¨
ange“........................................... 97
8.4 Vierte Baustufe ”Ausg¨
ange“ .......................................... 98
A Schaltplan 99
B Platinenlayout 100
C Best¨
uckungsplan 101
D Maße 102
E Geh¨
ause 103
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 Conroller 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 einges 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 technikorientertes 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: Der ftDuino im 3D-gedruckten Geh¨
auseprototyp
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-
1.2. Der ftDuino-Controller 9
nisch kleine Computer und informationsverarbeitende Module, die innerhalb einer Maschine Steuer- und Regelaufgaben
¨
ubernehmen und immer h¨
aufiger auch mit der Außenwelt kommunizieren.
(a) Arduino-Entwicklungsumgebung (IDE) (b) Arduino-Leonardo-Controller
Abbildung 1.3: Die Arduino-Entwicklungsumgebung und -Controller
Die Arduino-IDE ist eine ¨
ubersichtliche und leicht zu bedienende Programmerober߬
ache, die sich auf Windows-, Linux-
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 (Temperaturlogging, . . . ) und Steu-
eraufgaben (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 hinutergeladen 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.
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.
Der ATmega32u4-Controller ist ein Mitglied der sogenannten AVR-Famile, auf der die meisten Arduino-Boards 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.
10 Kapitel 1. Einleitung
+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
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
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 Hinterladen 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
Bezeichnug LED BUILTIN angespochen 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-Versorung
verwendet werden. Zus¨
atzlich ist die Genauigkeit einer Widerstandsmessung an den Analogeing¨
angen deutlich herab
gesetzt (siehe 1.2.6).
12 Kapitel 1. Einleitung
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 Batterieset 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 4.13.5).
max. 3,45mm
+9V
Masse
min. 1,3mm
Abbildung 1.7: 3,45mm fischertechnik-Hohlstecker
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 angechlossenen Widerstands gemessen werden. Alle von fischertechnik-Modellen
¨
ublicherweise verwendeten Widerst¨
ande k¨
onnen so erfasst werden.
1fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=505287
2fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=505283
3fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=134863
4fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=34969
1.2. Der ftDuino-Controller 13
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,
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 Pulsweitemodulation (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 7) 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 4.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 1330095
auszuwerten.
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 4.13 beschrieben.
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
max. 100mA entnommen werden, um die ftDuino-interne Spannungsversorung nicht zu ¨
uberlasten
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 dirkete Verbindung zwischen TXT und ftDuino kann
5fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=133009
14 Kapitel 1. Einleitung
+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.8: Anschluss des Ultraschallsensors 133009
Masse
+5V
SDA
SCL
Masse
+5V
SDA
SCL
Abbildung 1.9: Buchsen- und Kabelbelegung des I2C-Bus am ftDuino
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 4.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.
Abbildung 1.10: Entfernen der Schutzkappe vom I2C-Anschluss des ftDuino
1.3. Probleml¨
osungen 15
1.2.7 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.
Aus diesem Grund werden die fischertechnik-kompatiben Ein- und Ausg¨
ange des ftDuino ¨
uber eigene Bibliotheken ange-
steuert, wie in Kapitel 7 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 Booloader-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-Spannunsgquelle 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 Soannung l¨
auft ist dessen
Funktion kein sicheres Indiz daf¨
ur, dass eine ausreichende 9-Volt-Versorung vorhanden ist.
Ist der ftDuino ¨
uber USB mit dem PC verbunden, dann versorgt er sich bei mangelhafter oder fehlender 9-Volt-Versorung
von dort. Geht der ftDuino ganz aus, sobald man die USB-Verbindung trennt, dann ist keine 9-Volt-Versorgung gegeben
16 Kapitel 1. Einleitung
und es muss sichergestellt werden, dass Polarit¨
at und Spannung korrekt bzw. ausreichend sind. Ggf. 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 bingen den passsenden 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 uner “Andere Ger¨
ate” aufgef¨
uhrt
wird.
Die .inf-Datei ist unter https://raw.githubusercontent.com/harbaum/ftduino/master/ftduino/driver/ftduino.inf zu finden.
18 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 eingebuden.
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 wir der Benutzer nur den Anwendungsmodus zu
sehen bekommen.
2.1. Treiber 19
(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
“Abstract Control Model” (ACM) implementiert taucht er im Linux-System als /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 4.10 oder 4.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.
20 Kapitel 2. Installation
Abbildung 2.5: Fehlermeldung bei installiertem ModemManager
In diesem Fall ist die wahrscheinlichste Ursache, dass ModemManager, ein Programm zur Bedienung von Modems, installiert
ist und sich mit dem ftDuino verbunden hat. Um das 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 danach problem zu
verwenden sein.
Das Kommandos 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.
2.2. Arduino-IDE 21
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 Konfoiguration 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://raw.githubusercontent.com/harbaum/ftduino/master/package ftduino index.json in den Vorein-
stellungen 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.
22 Kapitel 2. Installation
Abbildung 2.8: Im Boardverwalter kann das ftDuino-Board installiert werden
Durch Klick auf Installieren... werden alle f¨
ur den ftDuino n¨
otigen Dateien automatisch heruntergeladen und installiert.
Nach erfolgreicher Installtion kann der ftDuino unter den Boards ausgew¨
ahlt werden.
Abbildung 2.9: Auswahl des ftDuino-Boards
Ist bereits ein ftDuino angeschlossen und wurde der n¨
otige Treiber installiert, so l¨
asst sich der ftDuino nun unter Port
ausw¨
ahlen.
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 .
Abbildung 2.10: Beispiele zum ftDuino-Board
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.
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 seperate 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
4Schaltet die int erne rote LED des ftDu ino f¨ur eine S ekund e ein
5und f¨ur eine S ekunde aus und wie de rholt dies e ndlos .
6
7Original :
8ht tp : // ww w . a rd ui no . cc / en / Tut or ia l / Bli nk
9*/
24 Kapitel 3. Erste Schritte
10
11 // die setup - Funktion wird ei nmal beim Start auf gerufen
12 void setup () {
13 // Konfigu rie re den Pin , an den die i ntern e LED ang esc hlos sen ist , als Ausg ang
14 pinMode(LED_BUILTIN ,OUTPUT);
15 }
16
17 // die loop - Funktion wird immer w ieder auf ger ufe n
18 void loop() {
19 digitalWrite(LED_BUILTIN ,HIGH); // schal te die LED ein ( HIGH ist der hohe Spa nnu ngsp ege l )
20 delay (1000); // warte 1000 M il li se kun de n ( ei ne Sekun de )
21 digitalWrite(LED_BUILTIN ,LOW); // sc halte die LED aus , inde m die Sp annung auf
22 // nie dr ig en Pegel ( LOW ) g es ch al tet w ird
23 delay (1000); // warte eine Sek unde
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-Verbdinung 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.
3.1. Der erste Sketch 25
+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.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 */ eingechlossen. 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 eingechaltet
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
26 Kapitel 3. Erste Schritte
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); // schal te die LED ein ( HIGH ist der hohe Spa nnu ngsp ege l )
20 delay (500) ; // wa rte 500 Mil lis ek un de n ( ei ne halbe Sek un de )
21 digitalWrite(LED_BUILTIN ,LOW); // sc halte die LED aus , inde m die Sp annung auf
22 // nie dr ig en Pegel ( LOW ) g es ch al tet w ird
23 delay (500) ; // warte eine halbe Se kunde
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// Bli nk O1 . i no
2//
3// Bli nken einer Lamoe an Ausg ang O1
4//
5// ( c ) 20 18 b y T il l H ar b au m < t il l @h a rb a um . org >
6
3.2. Ansteuerung von fischertechnik-Komponenten 27
+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 ftDuino
7#include < F td u in oSi mp l e . h >
8
9void setup () {
10 // LED initialisieren
11 pinMode(LED_BUILTIN ,OUTPUT);
12 }
13
14 void loop() {
15 // schalte die inte rne LED und den Ausgang O1 ein ( HIGH bzw . HI )
16 digitalWrite(LED_BUILTIN ,HIGH);
17 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: HI );
18
19 delay (1000); // warte 1000 M il li se kun de n ( ei ne Sekun de )
20
21 // schalte die inte rne LED und den Ausgang O1 aus ( LOW bzw . LO )
22 digitalWrite(LED_BUILTIN ,LOW);
23 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: LO );
24
25 delay (1000); // warte eine Sek unde
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 7.
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 7.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 7 dargestellt. ¨
Uber die FtduinoSimple-
Bibliothek kann der Schaltzustand eines Tasters abgefragt werden:
1#include < F td u in oSi mp l e . h >
28 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
3
2
1
Abbildung 3.9: Taster am Eingang I1 des ftDuino
2
3void setup () {
4// keine Ini tial isi erun g noe tig
5}
6
7void loop() {
8// lies den Z ustan d ein er Taste 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 ial is ierun g der Ftduino - B iblio the k
5ftduino.init() ;
6
7// Ein gang I1 zur Wid erst ands mess ung vor bereite n
8ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: RE SISTANCE ) ;
9}
10
11 void loop() {
12 // Auswert ung des W idersta nds an Eing ang I1
13 uint16_t wid ers tan d =ftduino.inp ut_g et (Ftduino:: I1 );
14 /* ... tue etwas ... */
15 }
In den Experimenten in Kapitel 4 finden sich diverse Beispiel, in denen die Eing¨
ange des ftDuino ausgertet werden inklusive
spezieller Sensoren wie dem Temperatursensor in Abschnitt 4.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 Sketck 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-
3.3. Kommunikation mit dem PC 29
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
Spannungsversorung.
1/*
2ComPo rt - Ko mmunika tio n mit dem PC ¨u ber den COM:- Port
3
4*/
5
6int zaehler = 0;
7
8void setup () {
9// Port i ni tia li sie re n und auf USB - Ve rbindung w arten
10 Serial.be gin (9600);
11 while (! Serial) ; // warte auf USB - Ve rbi ndu ng
12
13 Serial.println(" ftD uino COM :- Port test " );
14 }
15
16 void loop() {
17 Serial.pr int ("Z ¨a h ler : " ); // gib "Z¨a hler :" aus
18 Serial.println(zaehler ,D EC ); // gib z aehler als Dez ima lza hl aus
19
20 zaehler =zaehler+1; // z aehle r um eins hochz ¨a hlen
21
22 delay (1000); // warte 1 S ekunde (1000 Mil li sek unden )
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 prakischerweise 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 seperat 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.
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
30 Kapitel 3. Erste Schritte
Abbildung 3.11: Der serielle Monitor
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 widerholt 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 seperaten 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-Kommunikaiton selbst. Das bedeutet, dass die logische
USB-Verbindung jedes Mal getrennt und neu aufgebaut wird, wenn ein neuer Sketch auf den Mikrocontroller ¨
ubertragen
wird.
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 i ni tia li sie re n und auf USB - Ve rbindung w arten
10 Serial.be gin (9600);
11 // while (! Se rial ) ; // wa rte auf USB - Ve rb indung
12
13 Serial.println(" ftD uino COM :- Port test " );
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
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 5.
4.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 4.1: Lampen-Zeitschaltung
4.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 ei tsc haltu hr
3
4(c) 2017 by Till Har baum < t ill @ha rbaum .org >
5
32 Kapitel 4. Experimente
6Schaltet eine Lampe an Ausgan g O1 f¨ur 10 Sekun den ein ,
7sobald ein Tast er an Eingang I1 gedr ¨u ckt wird.
8*/
9
10 #include < F td u in oSi mp l e . h >
11
12 uint32_t sta rtz eit = 0;
13
14 // Die Setup - Fu nkt ion wird ei nmal au sgef ¨uhrt , wenn Reset gedr ¨u ckt oder
15 // d as B oard g es ta rt et wird .
16 void setup () { }
17
18 // Die Loop - Funkt ion wird endl os immer und immer wie der ausgef ¨u hrt
19 void loop() {
20 // T este , ob der T aste r an I1 ge dr ¨u ckt is t
21 if (ftduino.input_get(Ftduino:: I1 )) {
22 // merke S tar tze it
23 startzeit =millis() ;
24
25 // sch alte Lampe ein ( Aus gang HI )
26 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: HI );
27 }
28
29 // g¨u l tige Startzeit und sei tdem mehr als 10 S ekunden
30 // (10.0 00 M illis eku nd en ) ver str ichen ?
31 if (( s tar tze it != 0) &&
32 (millis() > start zei t + 10000)) {
33 // ver giss Startzeit
34 startzeit = 0;
35 // sch al te Lam pe aus ( Au sg an g OFF )
36 ftduino.output_se t (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 7.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 Lamoe 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 (( s tar tze it != 0) &&
32 (millis() > start zei t + 20000)) {
4.2. Not-Aus 33
Aufgabe 2: Keine Verl¨
angerung
Sorge daf¨
ur, dass ein weiterer Druck auf den Taster, w¨
ahrend die Lampe bereits leutet, 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, english niedrig und meint in diesem Fall 0 Volt. Die Leuchtdiode
erlischt nun komplett nach Ablauf der Zeit.
36 ftduino.output_se t (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 Abchnitt 4.8.
4.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.
4.2.1 Sketch EmergencyStop
1/*
2Eme rge nc yS top - Not - Aus
3
4(c) 2017 by Till Har baum < t ill @ha rbaum .org >
5
6Schaltet einen Ventila tor aus , s obald der Not - Aus - Taster
34 Kapitel 4. 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
3
2
1
Abbildung 4.2: Not-Aus
7bet ¨a tigt wird .
8*/
9
10 #include < F td u in oSi mp l e . h >
11
12 // D ie Setup - Fun kt io n w ird e inma l bei St art des Sys tems a us ge f ¨u hrt
13 void setup () {
14 // Ventilator bei Start des Sys tems eins cha lte n
15 ftduino.motor_set(Ftduino:: M1 ,Ftduino:: LEFT);
16
17 // Aus gang der internen roten LED aktivieren
18 pinMode(LED_BUILTIN ,OUTPUT);
19 // und LED a uss cha lten
20 digitalWrite(LED_BUILTIN ,LOW);
21 }
22
23 // Die Loop - Funkt ion wird endl os immer und immer wie der ausgef ¨u hrt
24 void loop() {
25 // T este , ob der T aste r an I1 ge dr ¨u ckt is t
26 if (ftduino.input_get(Ftduino:: I1 )) {
27 // Motor b remse n
28 ftduino.motor_set(Ftduino:: M1 ,Ftduino:: BRAKE );
29 // inter ne rote LED ei nsc hal ten
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 Ummantelung unbesch¨
adigt aussieht, durch zu starke Belastung aber dennoch
die Kupferleiter im Inneren unterbrochen sind. Der Resultat ist ein sogenannter Kabelbruch.
4.2. Not-Aus 35
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 fischertechni-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 4.3: Kabelbruchsicherer 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 Verbdindung 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 funkionieren. 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.
36 Kapitel 4. Experimente
3
2
1
Abbildung 4.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?
4.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 verglaich-
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 auschaltet.
+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 4.5: Pulsweitenmodulation
4.3.1 Sketch Pwm
1/*
2Pwm - Pulsweitenmodulation
3
4(c) 2017 by Till Har baum < t ill @ha rbaum .org >
5*/
6
7#include < F td u in oSi mp l e . h >
8
9uint16_t sch alt zei t = 8192; // 8192 entspricht je 1/2 Sekunde an und aus
10
11 // Die Setup - Fu nkt ion wird ei nmal au sgef ¨uhrt , wenn Reset gedr ¨u ckt oder
12 // d as B oard g es ta rt et wird .
4.3. Pulsweitenmodulation 37
13 void setup () { }
14
15 // wa rte die ang eg eb en e Z eit . Der " zeit "- W ert 8192 soll dabei e iner hal ben Se ku nde
16 // ent sp re ch en . Es mu ss al so " ze it " ma l 5 00 00 0/ 81 92 Mik ro se kun de n gewar te t w er den
17 void warte (uin t1 6_ t zeit ) {
18 while (zeit - -)
19 _delay_us(5 000 00/81 92) ;
20 }
21
22 // Die Loop - Funkt ion wird endl os immer und immer wie der ausgef ¨u hrt
23 void loop() {
24 static uint8 _t an_ aus =false ;// de r a kt ue l le Ausg ang - an / aus - Z us ta nd
25 static uint8_t i1=false ,i2 =f alse ;// letzter Zustan d der T asten an I1 und I2
26
27 // i st d ie T as te an I1 gedr ¨u ckt ?
28 if (ftduino.input_get(Ftduino:: I1 )) {
29 // und war die Taste v orher nic ht gedr ¨u ckt und ist die
30 // akt uel le Sch alt zei t kleine r 8192?
31 if (! i1 && ( sc hal tze it < 8192) ) {
32 // dann ver dop ple die S cha ltz eit
33 sch alt zei t *= 2;
34 // warte eine Mi lliseku nde , falls die T aste nachprellt
35 _delay_ms(1) ;
36 }
37 // merke , dass die Taste an I1 zur Zeit gedr ¨u ckt ist
38 i1 =true;
39 }else
40 // merke , dass die Taste an I1 zur Zeit nicht gedr ¨u ckt ist
41 i1 =false ;
42
43 // i st d ie T as te an I2 gedr ¨u ckt ?
44 if (ftduino.input_get(Ftduino:: I2 )) {
45 // und war die Taste v orher nic ht gedr ¨u ckt und ist die
46 // a kt ue ll e S ch a lt ze it gr ¨o ß er 1?
47 if (! i2 && ( sc hal tze it > 1 ) ) {
48 // dann halbiere die Schalt zei t
49 sch alt zei t /= 2;
50 // warte eine Mi lliseku nde , falls die T aste nachprellt
51 _delay_ms(1) ;
52 }
53 // merke , dass die Taste an I2 zur Zeit gedr ¨u ckt ist
54 i2 =true;
55 }else
56 // merke , dass die Taste an I2 zur Zeit nicht gedr ¨u ckt ist
57 i2 =false ;
58
59 // schalte den Ausg and O2 je nach Zus tand der an_aus - Var iable an oder aus
60 if (an_aus)
61 // wenn der aktuelle an_aus - Zusta nd wahr ist , dann schalt e den Au sgang ein
62 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: HI );
63 else
64 // wenn der aktuelle an_aus - Zusta nd un wahr ist , dann schal te den A usgan g aus
65 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: OFF );
66
67 // warte die akt uel le Schaltzeit
68 warte (sch altzeit );
69
70 // wechs 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
38 Kapitel 4. Experimente
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 Zylus 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 hinuterteilen 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 haltem, 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 ca. 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 4.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.
4.3. Pulsweitenmodulation 39
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 wirddas Laufger¨
asch
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¨
auch 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 steigener 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 dad¨
urch 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 4.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
40 Kapitel 4. Experimente
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 4.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 kontinuerlich 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 4.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 ca 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.
4.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
4.4. Schrittmotoransteuerung 41
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 4.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 4.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”
42 Kapitel 4. Experimente
Zustand l¨
asst sich die Achse des Motors verlgeichsweise leicht drehen. Der dabei sp¨
urbare Widerstand resultiert daraus, dass
der Permanentmagnet von den Eisenkernen der Elektromagnete auch im spannungslosen Zustand angezogen wird.
Abbildung 4.12: Vereinfachtes Schema eines Schrittmotors
Der in der Abbildung dargestellte vereinfachte Schrittmotor verf¨
ugt ¨
uber einen Permanentmagneten und zwei Elekomagnete.
Reale Schrittmotoren haben in der Regel mehr als zwei Spulen und der Anker bidet 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 Elekromagneten magnetisiert. In der Folge richtet sich der Anker entsprechend
aus. Die Polarit¨
at der angelegten Spannung bestimmt die Richtung des Magnetfelds der Elektromagneten.
4.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 Signalefolge an
die Elektromagneten angelegt, so folgt der Anker den Signalen und dreht sich. Er folgt dabei exakt den sich welchselnden
Magnetfeldern und dreht sich sychron zum angelegt Signalmuster. Geschwidigkeit 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 4.13: Vollschrittansteuerung eines Schrittmotors
Ein Sketch, der kontinuiertlich 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:: RIGHT );
delay (5) ;
ftduino.motor_set(Ftduino:: M2 ,Ftduino:: RIGHT );
4.4. Schrittmotoransteuerung 43
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 ensprechend 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.
4.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
Vollschrittansteuerung 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 4.14: Halbschrittansteuerung 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 Halbschrittansteuerung 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 Abschmitt verwendete Sketch zur Schrittmotoranszteuerung 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 großte
2fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=30571
44 Kapitel 4. Experimente
Nachteil: W¨
ahrend der Sketch einen Motor bedient kann er kaum etwas anderes tun. Einen zweiten Motor gleichzeit mit
ggf. 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 PQM-Drehzahlregelung der Motorausg¨
ange und die Auswertung der Z¨
ahler
beanstruchen permant 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 Zeit-
punkten ggf. 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 fpr 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 Millesekunden 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 td u in oSi mp l e . h >
2
3// d ie sog eg an nt e In terr upt - Serv ice - R ou tine ( I SR ) wird
4// nicht vom Sketch selbst zur Ausf ¨u h rung gebracht , sondern
5// die H ardware des A Tme ga3 2u l¨a st die Ausf ¨u hrung auf Bas is
6// ei nes Timer - Ere ign isses aus
7IS R (TIMER1_COMPA_vect) {
8// Di es e F un kt io n w ird alle 5 ms aus ge f ¨u hrt .
9// Das Weite rdr ehen des Sc hrittmotor - Ma gnet fel des
10 // k¨o nnte z . B. hier geschehen .
11 // ...
12 }
13
14 void setup () {
15 // Kon figu rat ion des Ti mer 1 des ATme ga 32u4 , die gen aue
16 // B esc hre ibung der Reg ister fi ndet sich in Kapitel 14
17 // des Datenblatt :
18 // http :// ww1 . mi crochip . com / do wnlo ads /en / De viceDoc / Atmel -7766 -8 - bit - AVR - ATmeg a16U4 -32
U4_Datasheet.pdf
19
20 // Timer 1 soll im soge nan nte n CTC - Modus s cha lten mit OCR1A
21 // als obere Grenze . Der Timer l¨a uft mit 1/256 CPU - Takt . Dieser
22 // wie de ru m b etr ¨a gt 16 Mhz , de r Timer l ¨a u ft a lso mi t 62 ,5 kH z .
23 // Um den Motor 200 Schri tte pro Sekun de zu drehen muss der
24 // Motor immer dann einen Schri tt machen , wenn der Time r 312
25 // ( 62 50 0/ 20 0) s ei ne r Z¨a h ls chr it te d ur ch la uf en hat .
26 TCCR1A = 0;
27 TCCR1B = (1 < < WGM12 ) | (1 < < CS12); // Starte Timer 1 mit 1/ 256 F_CPU = 62.5 kHz
28 TCCR1C = 0;
29
30 // Ere ig ni s a usl ¨o se n wenn 6 24 00 /2 00 Z ¨a h le rs chr it te e rr ei ch t si nd
31 TCNT1 = 0;
32 OCR1A = 625 00/ 200;
33
34 // E re gn ise rze ugu ng b ei Err ei ch en d er Zie ls chr it te ausl ¨o sen
35 TIMSK1 = (1 < < OCIE1A) ;
36 }
37
38 void loop() {
39 // die H auptrou tin e kann ben lie big genut zt wer den und
40 // d er Timer 1 - I nte rr upt w ird u na bh ¨a n gi g r eg el m ¨a ß ig
41 // ausge f ¨u hrt
4.5. Servomotoransteuerung 45
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 Hauptorpgramm des Sketches durch Timer 3
steuern. Mit zwei Schrittmotoren ist so recht elegant z.B. ein sogegannter Plotter zu realisieren.
4.5 Servomotoransteuerung
Schwierigkeitsgrad:
Neben den normalen Gleichspannungsmotoren und den Schrittmotoren aus Abschnitt 4.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 O2
O3 O4
O5 O6
O7 O8
C1
C2
C3
C4
I²C
(a) Versorgung 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
7806
(b) Versorgung mit 7806-Regler
Abbildung 4.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 4.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/search.php?keyword=132292
4fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=132292
5fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=540585
6fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=30275
46 Kapitel 4. Experimente
4.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 4.15(b) dargestellt, so l¨
asst sich der Stecker des
Servos mit den zwei verbliebenden 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
4.16(b) 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 ftDuino (b) Spannungsregler und Adapterkabel
Abbildung 4.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 widerholt 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 () {
4.5. Servomotoransteuerung 47
1ms 20ms 1,5ms 20ms 2ms 20ms
Abbildung 4.17: Servo-Winkel in Anh¨
angigkeit vom Stellsignal
2// Po rt D . 1 ( SDA - An s ch l us s ) au f A us g an g s ch al t en
3bitSet(DDRD , 1) ;
4}
5
6void loop() {
7// Po rt D .1 au f Hig h - P eg el (5 V ) leg en
8bitSet(PORTD , 1) ;
9
10 // 1500 us (1.5 ms) wa rten
11 _delay_us(1500);
12
13 // Po rt D .1 a uf Low - Pe gel ( GND ) le gen
14 bitClear (PORTD , 1) ;
15
16 // 18 500 us (18.5 ms ) warten
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// Se rv o . ino
3//
4
5#include " Se rvo .h"
6
7void setup () {
8servo .begin () ;
9}
10
11 void loop() {
12 static uint8 _t value =S ervo :: VALUE_MAX/2;
13
14 if (value <Ser vo :: VALUE_MAX)value ++;
15 else value = 0;
16 servo .set(value ) ;
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.
48 Kapitel 4. Experimente
4.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 Microcontroller in der Richtung umgeschaltet werden
k¨
onnen. Beim ftDuino konnte diese F¨
ahigkeit nicht erhaltem werden, da an den Eing¨
agen 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 4.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.
4.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.
4.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.
4.7. Temperaturmessung 49
Die Widerstandsmessung wird von der Ftduino-Bibliothek im Hintergrund ausgef¨
uhrt. Dabei findet auch eine automatrische
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 7.2.2) abfragen.
4.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
is 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 4.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 ca. 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 wurd. Das folgenden Code-Fragment l¨
asst
eine LED an Eingang I1 im Sekundentakt blinken.
1#include < F td u in oSi mp l e . h >
2
3void loop() {
4// lies Wert von Ei ngang I1 , akt ivi ert Wid ers tan d auf I1
5ftduino.input_get(Ftduino:: I1 );
6delay (1000);
7// lies Wert von E ingan g I2 , dea kti vie rt W ide rstand auf I1
8// ( und akt ivi ert ihn auf I2 )
9ftduino.input_get(Ftduino:: I2 );
10 delay (1000);
11 }
4.7 Temperaturmessung
Schwierigkeitsgrad:
50 Kapitel 4. Experimente
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 4.20: Anschluss des Temperaturensors an Eingang I1
4.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// Tem pe rau re . in o
3//
4// Abf rage eines fis cher tec hnik T emperatur - Wide rst and s an E ingan g I1
5//
6// ( c ) 20 18 b y T il l H ar b au m < t il l @h a rb a um . org >
7//
8
9#include <Ftduino.h>
10 #include < ma th .h > // F¨u r Flie sspunkt - Ari thmetik
11
12 #define K2C 273.15 // Offset K elvin nach Grad Celsiu s
13 #define B 3900.0 // s og . B - We rt de s S en so rs
14 #define R_N 1500.0 // W iderstand bei 25 Grad Celsi us R efer enzt emp e rat ur
15 #define T_N ( K2C + 25 .0) // Ref eren ztem pera tur in Kelvin
16
17 float r2deg (uint16 _t r) {
18 if (r== 0) return NA N ;// ein Widerstand von 0 Ohm erg ibt keine sinnvolle T emp era tur
19
20 // Widerstand in K elvin u mre chn en
21 float t=T_N *B/ (B+T_N *l og (r/R_N));
22
23 // Kel vin in Grad C elsiu s umrechnen
24 return t-K2 C ;
25
26 // alt ernativ : Kelv in in Grad Fahrenheit umr echnen
27 // ret urn t * 9 / 5 - 459 .67;
28 }
29
30 void setup () {
31 // LED initialisieren
32 pinMode(LED_BUILTIN ,OUTPUT);
7fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=36437
4.7. Temperaturmessung 51
33 digitalWrite(LED_BUILTIN ,LOW);
34
35 Serial.be gin (11 5200 ) ;
36 while (! Serial) ;
37
38 ftduino.init() ;
39
40 // Die T empe ratu rmes sun g e rfolgt mit einem
41 ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: RE SISTANCE ) ;
42 }
43
44 void loop() {
45 uint16_t r =ftduino.input _get (Ftduino:: I1 ) ;
46
47 Serial.pr int (" I1 : " ) ;
48 Serial.pr int (r2deg (r));
49 Serial.println(" Grad C elsius ") ;
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 fischertechik
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 Umrechung liegt die Temperatur in Kelvin vor. Zur Umrechung 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
52 Kapitel 4. Experimente
4.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 4.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-Versorgungspannung 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 leuchtet nun weder die rote noch die
blaue Lampe. 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 gleichtzeitig auf voller Helligkeit betreiben.
4.8.1 Sketch OnOffTristate
1/*
2OnO ffTrist ate - der dritte Zusta nd
3*/
4
5#include < F td u in oSi mp l e . h >
6
7void setup () { }
8
9// Die Loop - Funkt ion wird endl os immer und immer wie der ausgef ¨u hrt
10 void loop() {
11 // Aus gang O1 auf 9V sch alt en
12 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: HI );
13 delay (1000);
14 // Aus gang O1 auf Masse schalt en
15 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: LO );
16 delay (1000);
4.9. Aktive Motorbremse 53
17 // Aus gang O1 unbe sch alt et las sen
18 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: OFF );
19 delay (1000);
20 }
4.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 Verbauchers feststellen zu
k¨
onnen. Diese sogenannten Leckstr¨
ome wurden in Abschnitt 4.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.
4.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 Engergie 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 4.22: Der TXT-Encoder-Motor als Generator
Dieser Effekt l¨
asst sich mit einer Leuchdiode 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 passenen 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 Energieaufnahe erfordert
aber ggf. 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 verleichsweise 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
4.2 genutzt, um den Motor im Notfall schnell zu stoppen. Ist dagegen z.B. einer der Anschl¨
usse des Motors offen, so ist
kein geschlossener Stromkreis vorhanden und es fließt kein Strom und es tritt keine Bremswirkung auf. Wie groß ist dieser
Effekt aber?
54 Kapitel 4. Experimente
MM
gebremst ungebremst
Abbildung 4.23: Elektrisch gebremster und ungebremster Elektromotor
Der fischertechnik-Encoder-Motor enth¨
alt eine M¨
oglichkeit zur Drehzahlmessung wie schon im PWM-Experiment in Ab-
schnitt 4.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 4.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, wieviele weitere Impule der Encoder an Eingang C1 liefert,
nachdem er die drei Umdrehungen vollendet hat und abgeschaltet wurde.
Die Funktion motor counter set brake() (siehe Abschnitt 7.2.9) wird dabei im Wechsel so eingerufen, dass der Motor
frei ausl¨
auft bzw. dass er aktiv gebremst wird.
Abbildung 4.25: Ausgabe bei Verwendung des TXT-Encoder-Motors
Wie in Abbildung 4.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 aktiber Bremse bereits
nach f¨
unf weiteren Impulse zum Stillstand. Das entspricht lediglich knapp 1
/13 Umdrehung.
4.10. USB-Tastatur 55
4.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 seperaten 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 4.26: Tastatur-Nachricht
4.10.1 Sketch USB/KeyboardMessage
1/*
2Key bo ar dMess ag e - USB - T asta tur
3
4Der f tDui no gibt sich als USB - Ta st atur aus und " tippt " eine Nachricht , so bald
5ein T aste r an Ein gang I1 f ¨u r mi nd es te ns 10 M il li se ku nde n g edr ¨u ck t wi rd .
6
7Bas iere nd auf dem Sketc h :
8ht tp : // ww w . a rd ui no . cc / en / Tut or ia l / K eyb o ar dM e ss a ge
9
10 Dieser Bei sp ie lc ode ist Public - Domain .
11 */
12
13 #include < F td u in oSi mp l e . h >
14 #include < K ey bo ar d . h >
15
16 unsigned long lastButtonEvent = 0;
17 uint16_t previousButtonState =Ftduino:: OFF ;// for checking the state of a p ush But ton
18
19 void setup () {
20 // ini tialize c ontr ol over the ke yboa rd :
21 Keyboard .b eg in () ;
22 }
23
24 void loop() {
25 // Taste an Eing ang I1 au slesen
26 uint16_t buttonStat e =ftduino.input_get (Ftduino:: I1 );
27
28 // Hat sich der Zustand der Taste ge ¨a ndert ?
29 if (buttonState != previousButtonState) {
30 // ja , Ze it des Wechsels merken
56 Kapitel 4. Experimente
31 lastButtonEvent =millis() ;
32 // und den neuen Zusta nd merken , damit wir we itere
33 // ¨
A nde ru ng en erk enne n k¨o nnen
34 previousButtonState =buttonState;
35 }
36
37 // Gibt es ein unb ear beit ete s E regnis und hat sich der Z ustan d der Taste seitdem
38 // f ¨u r me hr al s 10 M il l is ek u nd e n n ic ht ge ¨a n de rt ?
39 if (lastButtonEvent && (( millis() - lastButtonEvent) > 10) ) {
40 // Zeit dieses E reignisses ver gessen
41 lastButtonEvent = 0;
42
43 // Ta st e w urde ge dr ¨u ckt
44 if (buttonState) {
45 // Nac hric ht " ti ppen "
46 Keyboard .println(" H allo vom f tDui no ! ") ;
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 komplizieten USB-Detail bleiben in den Bibliotheken verborgen. Entsprechend kurz ist
auch dieser Sketch.
In der setup()-Funktion muss lediglich die Methode Keyboard.begin() aufgerunfen werden, um beim Start des ftDuino
alle USB-settigen 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 4.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.
4.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
4.11. USB-GamePad 57
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 4.27: GamePad mit vier Richtungstasten und zwei Feuerkn¨
opfen
4.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.
9static cons t uint8_t _hidReportDescriptor[] PROGMEM = {
10 0x05 , 0 x01 ,// US AG E_PAGE ( Generic Deskt op )
11 0x09 , 0 x05 ,// USA GE ( Gam epad )
12 0x85 ,REPORT_ID ,// REPORT_ID (3)
13 0xa1 , 0 x01 ,// CO LLECTION ( Applicati on )
14 0x09 , 0 x01 ,// USAGE ( Point er )
15 0xa1 , 0 x00 ,// CO LL ECT ION ( Ph ysical )
16 0x09 , 0 x30 ,// USAGE ( X)
17 0x09 , 0 x31 ,// USAGE ( Y)
18 0x15 , 0 x00 ,// LOGI CAL _MIN IMUM (0)
19 0x26 , 0 xff , 0 x00 ,// LOG ICAL _MA XIMU M (255)
20 0x35 , 0 x00 ,// PHYSICAL_MINIMUM(0)
21 0x46 , 0 xff , 0 x00 ,// PHYSICAL_MAXIMUM(255)
22 0x75 , 0 x08 ,// REPORT_SIZ E (8)
23 0x95 , 0 x02 ,// REPORT_COUNT(2)
24 0x81 , 0 x02 ,// INPUT ( Data , Var , Abs )
25 0xc0 ,// END_COLLECTION
26 0x05 , 0 x09 ,// US AG E_PAGE ( Butto n )
27 0x19 , 0 x01 ,// USA GE_MI NI MUM ( Butto n 1)
28 0x29 , 0 x02 ,// USA GE_MA XI MUM ( Butto n 2)
29 0x15 , 0 x00 ,// LOG ICA L_MI NIM UM (0)
30 0x25 , 0 x01 ,// LOG ICA L_MA XIM UM (1)
31 0x95 , 0 x02 ,// REPORT_COUNT(2)
32 0x75 , 0 x01 ,// RE PORT_SIZE (1)
33 0x81 , 0 x02 ,// INPU T ( Data , Var , Ab s )
34 0x95 , 0 x06 ,// REPORT_COUNT(6)
35 0x81 , 0 x03 ,// IN PUT ( Const ,Var , Abs )
36 0xc0 // END_COLLECTION
37 };
Diese vergleichweise 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/
58 Kapitel 4. Experimente
Usage-Tabellen11 sieht wesentlich originellere Eingabeger¨
ate f¨
ur diverse Sport-, VR-, Simulations- und Medinzinger¨
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.
4.12 Entprellen
Schwierigkeitsgrad:
In einigen der vorherigen Sketches wurde unerwartet viel Aufwand betrieben, um Taster abzufragen. Im Pwm-Sketch aus
Abschnitt 4.3.1 wurde in den Zeilen 35 und 51 eine Verz¨
ogerung von einer Millisekunde eingebaut und im KeyboardMessage-
Sketch in Abschnitt 4.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 4.28: Entprellen
4.12.1 Sketch Debounce
1/*
2Debounce
3
4Demonstriert Tastenprellen
5*/
6
7#include < F td u in oSi mp l e . h >
8
9// die setup - Funktion wird ei nmal beim Start auf gerufen
10 void setup () {
11 Serial.be gin (9600);
12
13 while (! Serial) ; // warte auf USB - Ve rbi ndu ng
14
15 Serial.println(" ft Duin o Tas tenprell - Bei spie l ") ;
16 }
17
18 uint8 _t l etz ter_ zust and =f alse ;
19 uint8_t wechselzaehler = 0;
20
21 // die loop - Funktion wird immer w ieder auf ger ufe n
11http://www.usb.org/developers/hidpage/Hut1 12v2.pdf
4.12. Entprellen 59
22 void loop() {
23 uint8_t zustand =ftduino.input_get(Ftduino:: I1 ); // Taster aus les en
24
25 if (zustand != letzter_zustand) { // Hat der Zusta nd sich ge ¨a n dert ?
26 wechselzaehler =wechselzaehler + 1; // Ja , Z¨a hler rum e ins er h ¨o he n
27
28 Serial.pr int (" I1 "); // und eine Meldu ng a usgeb en
29 Serial.pr int (wechselzaehler);
30 Serial.println(" mal ge ¨a nde rt ");
31 letzter_zustand =zustand;// neuen Zustand als let zten mer ken
32 }
33 }
Sketchbeschreibung
In den Zeilen 10 is 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 zuviel
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 4.3.1 getan wurde.
31 letzter_zustand =zustand;// neuen Zustand als let zten mer ken
32 delay (10) ; // warte zehn Mill ise kun 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 Eregnis als g¨
ultig zu erkennen, wenn das letzte Ereignis l¨
anger als 10 Millisekunden zur¨
uck liegt.
Der KeyboardMessage-Sketch aus Abschnitt 4.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?
60 Kapitel 4. Experimente
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/*
2Bou nce Vis u
3
4visualisiert Tastenprellen
5*/
6
7#include < F td u in oSi mp l e . h >
8
9#define EVENT_TIM E 480 // 480 us
10 uint8 _t eve nt [EVE NT_ TIM E ];
11
12 // die setup - Funktion wird ei nmal beim Start auf gerufen
13 void setup () {
14 Serial.be gin (9600);
15 while (! Serial) ; // warte auf USB - Ve rbi ndu ng
16 }
17
18 // die loop - Funktion wird immer w ieder auf ger ufe n
19 void loop() {
20
21 // Wa rt e bi s T aste r gedr ¨u ckt
22 if (ftduino.input_get(Ftduino:: I1 )) {
23
24 // hole 480 Mik ros ekun den la ng im MiK rose kund ent akt je einen Ein gangswe rt
25 fo r (ui nt 16 _t i =0;i<EVE NT_ TIME ;i++) {
26 event [i] = ftduino.input_get (Ftduino:: I1 ) ;
27 _delay_us(1) ;
28 }
29
30 // g ib z un ¨a c hst 20 Nulle n aus
31 fo r (ui nt 16 _t i =0;i<2 0; i++)
32 Serial.println(0) ;
33
34 // gib die e ingeles ene n 480 Werte aus
35 fo r (ui nt 16 _t i =0;i<EVE NT_ TIME ;i++)
36 Serial.println(ev ent [i]) ;
37
38 // Warte eine Sekun de
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 aufgezeichent 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 representieren 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 ca. 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
4.13. Nutzung des I2C-Bus 61
Abbildung 4.29: Verlauf des Prellens im seriellen Plotter
das Auslesen des Eingangs I1 etwas Zeit und das Zeiterhalten unser Messung ist nicht sehr genau. Es gen¨
ugt aber, um die
prinzipiellen Abl¨
aufe darzustellen.
4.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 4.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 4.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.
62 Kapitel 4. Experimente
Abbildung 4.31: Diverse I2C-Sensoren mit passendem Anschlusskabel an den ftDuino
4.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 4.32: Ausgabe von I2cScanner bei angeschlossenem MPU-6050
4.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 4.33: Ausgabe von MPU6050Test
4.13. Nutzung des I2C-Bus 63
4.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 CL SDA
128x64 OLED
(a) Vorderseite
VCC
GNDSCL
SDA
Ad dress S el ec t
0x7A
0x7B
0
(b) R¨
uckseite
(c) im Geh¨
ause
Abbildung 4.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 seperat installiert werden. Anderfalls wird die ¨
Ubresetzung 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 // # define SSD1 306_1 28 _3 2
75 // # define SSD 13 06 _9 6_ 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
64 Kapitel 4. Experimente
Zus¨
atzlich muss im Sketch selbst die I2C-Adresse von 0x3D nach 0x3C angepasst werden:
60 // by default , we ’ ll gene rat e the high v oltag e from the 3.3 v line i nte rnally ! ( neat !)
61 display.be gin (SS D13 06_ SWI TCH CAP VCC , 0 x3C ); // initialize with the I2C addr 0x3D (for the
12 8 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 ggf. eine Lampe an O1.
4.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 Hinternis 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 4.35: Anschlussschema des VL53L0X an den ftDuino
Ein passendes Geh¨
ause zum selbst-drucken findet sich im ftDuino-Repository17.
Abbildung 4.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 -Skeches
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
4.13. Nutzung des I2C-Bus 65
4.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 4.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. Enstprechende 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.be gin (43); // tr itt I2C - Bus an Adresse #43 als " Slave " bei
17 Wire.onReceive (receiveEvent); // Auf Schreib - Ereignis se reg ist riere n
18 Wire.onRequest (requestEvent); // Auf Lese - Ere ign iss e r egi striere n
19
20 ftduino.init() ;
21
66 Kapitel 4. 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
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 4.38: Kopplung von vier ftDuinos¨
uber I2C
22 // al le Au sg ¨a nge sind hoc ho hm ig
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// Li st e de r a nz ust eu ern de n I2c - C lie nts , beg in ne nd mit 0 ( der M aste r s el bst )
10 // und -1 als E nde mark ier ung . In diesem Fall sind drei Cl ients unter den Adress en
11 // 43 , 44 und 45 angesch los sen
12 static cons t int8_t clien ts [] = { 0 , 43 , 44 , 45 , -1 };
Die Stromversorgung aller vier ftDuinos kann aus einem fischertechik-Netzteil erfolgen, das an den Master angeschlossen
wird. Die Slaves werden dann vom 9-Volt-Ausgang des Masters ¨
uber zweipolige fischertechnik-Kabel versorgt.
Abbildung 4.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.
4.13. Nutzung des I2C-Bus 67
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 linksdrehend an
0x13 - Motorausgang rechsdrehend 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 Ausgangwert O1 (Register 0x01)
0x06 Ausgangs-Modus O4, siehe Ausgang-Modus O2 (Register 0x02)
0x07 Ausgangswert O4, siehe Ausgangwert O2 (Register 0x03)
0x08 Ausgangs-Modus O5/M3, siehe Ausgang-Modus O1 (Register 0x00)
0x09 Ausgangswert O5/M3, siehe Ausgangwert O1 (Register 0x01)
0x0aAusgangs-Modus O6, siehe Ausgang-Modus O2 (Register 0x02)
0x0bAusgangswert O6, siehe Ausgangwert O2 (Register 0x03)
0x0cAusgangs-Modus O7/M4, siehe Ausgang-Modus O1 (Register 0x00)
0x0dAusgangswert O7/M4, siehe Ausgangwert O1 (Register 0x01)
0x0eAusgangs-Modus O8, siehe Ausgang-Modus O2 (Register 0x02)
0x0fAusgangswert O8, siehe Ausgangwert 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.
68 Kapitel 4. Experimente
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)
4.13. Nutzung des I2C-Bus 69
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 4.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 Paramter -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
unfangreicherer auf der Ftduino-Bibliothek basierende Variante gibt es ebenfalls ein Python-Beispiel im Repository22.
ftDuino als I2C-Slave am TXT
Wie im Abschnitt 4.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://raw.githubusercontent.com/harbaum/ftduino/master/ftduino/libraries/FtduinoSimple/examples/I2C/I2cSlave/master.py
22 https://raw.githubusercontent.com/harbaum/ftduino/master/ftduino/libraries/Ftduino/examples/I2C/I2cSlave/master.py
70 Kapitel 4. Experimente
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 C C
ASCL
ASDA
AGND
BVCC
BSCL
BGND
BSDA
TXT
ftDuino
(a) Kabelschema (b) Anschluss an den TXT
Abbildung 4.41: Levelshifter zur Verbindung von TXT und ftDuino
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 4.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.
TXT-I2C-Sensoren am ftDuino
Das Kabel zum Anschluss des ftDuino an den TXT ist nicht auf eines feste Richtung festgelegt. Es kann 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
4.14. WS2812B-Vollfarb-Leuchtdioden 71
Getestet wurde dies 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-Ausf¨
ange des ftDuino.
(a) am Levelshifter (b) am I2C-Expander
Abbildung 4.43: Orientierungssensor von fischertechnik am ftDuino
4.14 WS2812B-Vollfarb-Leuchtdioden
Schwierigkeitsgrad:
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¨
at 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 Lechtdioden 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
seperate 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 4.44: Anschluss von zwei WS2812B-Vollfarb-Leuchtdioden
25fischertechnik-Datenbank: https://ft-datenbank.de/search.php?keyword=158402
26https://content.ugfischer.com/cbfiles/fischer/Zulassungen/ft/158402-Kombisensor-Kurzanleitung-BMX055-2017-06-09.pdf
27https://github.com/ControlEverythingCommunity/BMX055
72 Kapitel 4. Experimente
Jeder WS2812B-Leuchtdiodenstreifen vef¨
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.
4.14.1 Sketch WS2812FX
Das Beispiel zu Ansteuern der WS2812B-Leuchtdioden sowie die n¨
otige Code-Bibliothek k¨
onnen beispielsweise der
WS2812BFX-Bibliothek28 entnommen werden. Andere Bibliotheken zur Absteuerung 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 2F X . h >
2
3#define LED_COUNT 2
4#define LED_P IN SCL
5
6#define TIMER _MS 5000
4.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 4.45: 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.
28https://github.com/kitesurfer1404/WS2812FX
4.15. Musik aus dem ftDuino 73
Schaltet man nun den Ausgang O2 mit 50% PWM-Verh¨
altnis ein, so kann man das PWM-Signal direkt h¨
oren.
ftduino.output_se t (Ftduino:: O2 ,Ftduino:: HI ,Ftduino:: MAX /2 ) ;
Durch das 50% PWM-Signal wird der Ausgang permanent zwischen HI und OFF umgeschaltet (siehe auch Abschnitt 4.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 ca. 200 Hertz betr¨
agt h¨
ort man dann einen Ton in dieser Frequenz.
Die PWM-Erzeugung wird wie im Abschnitt 4.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 Rechenzeit
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 Megaherz-Bereich
n¨
otig. Das kann der ATmega32u4 ¨
uber den SPI-Bus nicht leisten.
Die MC33879-Ausgangstreiber haben jeweils zwei Eing¨
ange29, 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 - Treiber von Ausg ang O2 f¨ur eine S ekund e a kti vie ren
pinMode(11 , OUTPUT);
digitalWrite(11 , HIGH);
delay (1000);
digitalWrite(11 , LO W );
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.
4.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.
// Kam merton A f¨ur e ine Sekun de s pielen
tone(11 , 440 , 1000) ;
4.15.2 Sketch MusicPwm
Schwierigkeitsgrad:
Der verwendete Pin PB7 ist Teil des ATmega32u4-internen Timer 1. Das bedeutet, dass spezielle Hardware des ATme-
ga32u4 zur Signalerzeugung herangezogen werden kann. Damit k¨
onnen Signale hoher Prequenz 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 Hinterund 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. Lediglich 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
29EN5 und EN6, siehe http://cache.freescale.com/files/analog/doc/data sheet/MC33879.pdf
74 Kapitel 4. Experimente
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.
4.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-Schnittstelle30 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 4.46: Installation der MIDIUSB-Bibliothek in der Arduino-IDE
4.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 Betrieb-
systeme bereits mit und Windows, Linux und MacOS erkennen einen zum MIDI-Ger¨
at konfigurierten ftDuino ohne weitere
Treiberinstallation als USB-Audio-Ger¨
at.
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.
30MIDI, Musical Instrument Digital Interface, https://en.wikipedia.org/wiki/MIDI
Kapitel 5
Modelle
W¨
ahrend in den Experimenten aus Kapitel 4 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¨
ogich ist.
5.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 5.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
76 Kapitel 5. Modelle
Abbildung 5.2: Serielle Kommunikation mit dem Hochregal
5.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 5.3: Flipper auf ftDuino-Basis
Der Beispiel-Sketch des Flippers aus dem ElectroPneumatic-Set findet sich unter Datei Beispiele Ftduino
Pinball . Er nutzt die Fototransmistoren 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 > 10 00) {
// ...
}
loose_timer =millis() ;
}
Dabei wird ein Timer migef¨
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
5.3. ROBOTICS TXT Explorer: Linienfolger 77
5.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 5.4: Ein Linienfolger auf ftDuino-Basis
Ein passender Beispiel Sketch ist unter Datei Beispiele Ftduino LineSensor zu finden. Dieser Sketch wertet
kontinuiertlich den Liniensensor aus, um eine schwarzen Linue 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 5.5: Verdrahtunsgschema des Linienfolgers
In diesem Fall ist der Spursensor an die Eing¨
ange I1 und I2 angeschlossen. Der Sensor liefert nahezu maximale Spannung
(ca. 9 Volt) wenn eine weiße Fl¨
ache erkannt wurd und nur wenig Millivolt, wenn die schwarze Linie erkannt wurde.
// beide n E ing ¨a nge auf S pa nn ung sme ss ung e in st el le n
ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: VOLTAGE);
ftduino.input_set_mode(Ftduino:: I2 ,Ftduino:: VOLTAGE);
// beide S pannungen aus lesen
uint16_t linker_wer t =ftduino.input_get (Ftduino:: I1 );
uint16_t rechter_wert =ftduino.input_get(Ftduino:: I2 );
// ei ne S pa nnu ng k l ei ne r 1 Vo lt ( 10 00 mV ) be d eu te t ’ L in ie e rk ann t ’
3Linienfolger-Video https://www.youtube.com/watch?v=JQ8TLt5MC9k
78 Kapitel 5. Modelle
if (( linker_wert < 1000) && ( rechter_wert < 1000) ) {
// beide S ens oren haben die Linie e rkann t
// ...
}
5.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 5.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.
5.4. Idas Ampel 79
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 5.7: Die Zust¨
ande der Ampel
5.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() {
// warte auf T ast end ruc k
while (! ftduino.input_get(BUTTON) ) {
};
// Am pe l sch al te t ei n , Au to s h ab en gr ¨un , Fu ß g ¨a ng er ro t
car s_g ree n () ;
pedestrians_red() ;
delay (CARS_GREEN_PHASE);
// Autos b eko mmen gelb
cars_yellow() ;
delay (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 eingebauen LED des ftDuino blinken. Dies soll
unterbrechnungsfrei passieren und unabh¨
angig davon sein, in welchem Zustand sich die eigentliche Ampel gerade befindet.
Die L¨
osung ist ein Zustandsautomat.
// die loop - Funktion w ird immer w ieder auf ger ufe n
void loop() {
// Zei tpun kt des n¨a c hsten Li chtwec hsel - Ereigni sses
static unsigned long next_event = 0;
// Aktuel ler Zustand der Amepl
static char state = 0;
// Die inte rne Leu cht dio de soll e inmal pro Sekunde blink en
static unsigned long flash_timer = 0;
if (millis() > flash_timer + 10)
digitalWrite(LED_BUILTIN ,LOW );
if (millis() > flash_timer + 10 00) {
digitalWrite(LED_BUILTIN ,HIGH);
flash_timer =millis() ;
}
// Te ste ob ein Fussg ¨a nger im Zusta nd 0 ( Am pel aus ) den
// Knopf gedr ¨u ckt hat
if (( s tate == 0) && ( ftduino.input_get(BUTTON)))
80 Kapitel 5. Modelle
state = 1; // ja -> we chsel in Zus tand 1
if (state > 0) {
// Teste , ob die einges tel lte Zeit ver gangen ist
if (millis() > next_event ) {
switch(st ate ) {
// Am pe l wec hs el t i n Z us ta nd 1: Aut os hab en g r ¨u n , Fu ss g ¨a n ge r h ab en ro t
case 1: {
// sch alte Lam pen
car s_g ree n () ;
pedestrians_red() ;
// se tze Z ei tpun kt f¨u r n¨a c hstes Ereig nis
nex t_e ven t =millis() + CARS_GREEN_PHASE;
// se tze Z usta nd f ¨u r n ¨a chstes Ereignis
state ++; // K urz schr eibw eis e f ¨ur " st ate = state + 1"
break ;
}
// Ampel w ech selt in Zustan d 2: Autos hab en gelb , Fussg ¨a nger habe n rot
case 2: {
cars_yellow() ;
nex t_e ven t =millis() + YELLOW_PHASE;
state ++;
break ;
}
// Am pel we ch se lt in Zusta nd 3: Autos haben rot , F ussg ¨a ng er haben rot
case 3: {
// ...
break ;
}
// ...
}
}
}
}
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.
Kapitel 6
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 4.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.
6.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 Pythin-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 6.1: ftDuino per USB am Raspberry-Pi
1Cfischertechnik 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
82 Kapitel 6. Community-Projekte
Mit Hilfe dieser Bibliothek lassen sich bestehende Python-Programme f¨
ur die Community-Firmware leicht auf die Nutzung
eines ftDuino erweitern. Besoders interessant ist dies auf Ger¨
atem wie dem Raspberry-Pi, da diese von Haus aus keine
Schnittstelle zu fischertechnik-Sensoren und -Aktoren mitbringen.
Abbildung 6.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.
6.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 6.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/
6.3. Brickly-Plugin: Grafische ftDuino-Programmierung in Brickly 83
6.3 Brickly-Plugin: Grafische ftDuino-Programmierung in Brickly
Brickly6ist eine auf Googles Blockly7basierende grafische Programmierungebung.
Abbildung 6.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 6.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 6.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.
6.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 6.3) ist auf ein exteres Ger¨
at zur Programm-
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
84 Kapitel 6. Community-Projekte
Abbildung 6.6: Ein Brickly-Programm zur Ansteuerung des ftDuino
entwicklung angewiesen.
StartIDE9wurde dagegen so konzipiert, dass schon der kleine Touchbildschirm des fischertechnik-TXT-Controllers oder
eines Rasapberry-Pi ausreicht, um direkt am Ger¨
at Progamme erstellen zu k¨
onnen.
(a) Hauptbildschirm (b) Funktionsauswahl (c) IO-Konfiguration
Abbildung 6.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 6.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 140 de.pdf
Kapitel 7
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 7.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 Askpekte 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 Bibliothekten werden
von der Arduino-IDE automatisch festgestellt und zum Update angeboten.
Trotzdem ist der direkte Zugriff nat¨
urlich weiterhin m¨
oglich. Der fortgeschtittene 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 ggf. 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 Signalein- und -ausgabe bietet.
1https://raw.githubusercontent.com/harbaum/ftduino/master/ftduino/libraries
86 Kapitel 7. Bibliotheken
7.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 Wiederst¨
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 impleme-
tiert 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 td u in oSi mp l e . h >
7.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 td u in oSi mp l e . h >
2
3void setup () {
4// keine Ini tial isi erun g noe tig
5}
6
7void loop() {
8// Aus gang O1 einscha lte n
9ftduino.output_se t (Ftduino:: O1 ,Ftduino:: HI );
10 delay (1000);
11 // Aus gang O1 ausscha lte n
12 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: LO );
13 delay (1000);
14 }
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 td u in oSi mp l e . h >
2
3void setup () {
4// keine Ini tial isi erun g noe tig
5}
6
7void loop() {
8// Ein gang I1 ein les en
9if (ftduino.input_get(Ftduino:: I1 )) {
10 // Aus gang O1 einscha lte n
11 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: HI );
12 }else {
13 // Aus gang O1 ausscha lte n
14 ftduino.output_se t (Ftduino:: O1 ,Ftduino:: LO );
15 }
7.1. FtduinoSimple 87
16 }
In Zeile 9 wird der Zustand eines an den Eingang I1 angeschlossenen Schalters ermittelt. Je nachdem ob er grdr¨
uckt
(geschlossen) ist oder offen wird in den Zeilen 11 bzw. 14 der Ausgang O1 ein- oder ausgeschaltet.
7.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 Eigang und den korrespondierenden Masseanschluss daneben geschaltet
sind.
Die Auswertung des Eingangs geschiet 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 vorhergehenden 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 ein er Taste an Einga ng I1
if (ftduino.input_get(Ftduino:: I1 )) {
/* ... tue etwas ... */
}
7.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 Z usta nd einer Tas te an Zaehler - Eing ang C1
if (ftduino.counter_get_state(Ftduino:: C1 )) {
/* ... tue etwas ... */
}
7.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
// Lamp e zwischen Ausgang O1 und Masse leuchte n lassn
ftduino.output_se t (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).
88 Kapitel 7. Bibliotheken
7.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
// Motor an Ausg ang M1 links herum lau fen l assn
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).
7.1.6 Beispiel-Sketches
Code-Beispiele zur Nutzung der FtduinoSimple-Bibliothek finden sich im Men¨
u der Arduino-IDE unter Datei
Beispiele FtduinoSimple .
7.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 Resourcen komplett dem Anwendungssketch zur Verf¨
ugung stehen. Zus¨
atzlich macht sie Gebrauch von internen Resour-
cen 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>
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 ei nmal beim Start auf gerufen
void setup () {
// Ben utzung der Ftduino - Bib liothek vorber eit en
ftduino.init() ;
}
7.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¨
unchte 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 ca 8900 Messungen pro Sekunde eingestellt. Jeder Eingang wird zweimal abgefragt, um eine stabile
7.2. Ftduino 89
zweite Messung zu erhalten, so dass f¨
ur die 8 Eing¨
ange insgesamt 16 Messungen n¨
otig sind. Daraus ergibt sich eine
Konvertierungsrate von ca. 560 Messungen pro Sekunde pro Eingang, die automatisch im Hintergrund erfolgen. Beim
Auslesen ist der Messwert demnach maximal ca 2 Millisekunden alt und der Wert wird ungef¨
ahr alle 2 Millisekunden
aktualisiert.
Der ftDuino kann einen sogenannte Pullup-Wiederstand an jedem der Eing¨
ange aktivieren, so dass einer Spannungsmessung
eine Wiederstandsmessung 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.
7.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.
7.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 Widerstands-
werk von 0 bis 65535 Ohm zur¨
uck geliefert, wobei der Wert 65535 auch bei allen Wiederst¨
anden gr¨
oßer 65 Kiloohm geliefert
wird. Bedingt durch das Messprinzip werden die Werte oberhalb ca. 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 auswerten
ftduino.input_set_mode(Ftduino:: I1 ,Ftduino:: RE SISTANCE ) ;
uint16_t wid ers tan d =ftduino.inp ut_g et (Ftduino:: I1 );
7.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 enh¨
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 Polit¨
ar
des Anschlusses links oder rechts-herum. Im Zustand OFF sind beide Ausg¨
ange unbeschaltet und der Motor verh¨
alt sich, als
2Datenblatt unter http://cache.freescale.com/files/analog/doc/data sheet/MC33879.pdf.
90 Kapitel 7. Bibliotheken
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-Datenstransfer beide mit Daten versorgt. Signal¨
anderungen an den Ausg¨
angen
und speziell die PWM-Signalerzeugung (siehe Abschnitt 4.3) zur Erzeugung von Analogsignalen an den Ausg¨
angen er-
fordern eine kontinuierliche Kommunikation auf dem SPI-Bus im Hintergrund. Dazu implemetiert die Ftduino-Bibliothek
einen sogenannte SPI-Interrupt-Handler, der permament 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.
7.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 ins chalten
ftduino.output_se t (Ftduino:: O2 ,Ftduino:: HI ,Ftduino:: MAX /2 ) ;
7.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
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
4.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 esch win digk eit links dre hen
ftduino.motor_set(Ftduino:: M3 ,Ftduino:: LEFT ,Ftduino:: MAX /3) ;
7.2. Ftduino 91
7.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, wieviele 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.
7.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 - Encode rmo tor an M4 f¨u r dre i vo ll e U mdr ehungen st arten
ftduino.motor_counter(Ftduino:: M4 ,Ftduino:: LEFT ,Ftduino:: MAX , 190) ;
// war ten bis der Motor stoppt
while (ftduino.motor_counter_active(Ftduino:: M4 ));
// Motor hat ges top pt
7.2.9 void motor counter set brake(uint8 t port, bool on)
Diese Funktion bestimmt das Bremsverhaltren 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
ca. 5 Impulse nach (ca. 1
/10 Umdrehung bzw. 28,5 ). Im ungebremsten Fall l¨
auft der gleiche Motor ca. 90 Impulse (ca. 11
/2
Umdrehungen) nach.
Da die Z¨
ahler nach dem Stoppen des Encoders weiterlaufen ist der Nachlauf auch per Programm messbar:
Beispiel
// Bremse f¨u r Ausga ng M4 abs cha lte n
ftduino.motor_counter_set_brake(Ftduino:: M4 ,false ) ;
// TXT - Encode rmo tor an M4 f¨u r dre i vo ll e U mdr ehungen st arten
ftduino.motor_counter(Ftduino:: M4 ,Ftduino:: LEFT ,Ftduino:: MAX , 190) ;
// war ten bis der Motor stoppt
while (ftduino.motor_counter_active(Ftduino:: M4 ));
// etwas l¨a nger warten , um dem Motor Zeit zum N ach lau fen zu geben
delay (500) ;
// Z¨a h lerstand au sgeb en
Serial.println(ftduino.counter_get(Ftduino:: C4 ));
92 Kapitel 7. Bibliotheken
7.2.10 Die Z¨
ahlereing¨
ange C1 bis C4
Die Z¨
ahlereing¨
ange arbeiten im Gegensatz zu den Analogeing¨
angen rein digital. Sie untescheiden 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 Endoderausgang 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 angeschlossender 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 hundertausend Z¨
ahlimpulsen pro Sekunde m¨
oglich. Werden aber z.B. Tastendr¨
ucke
gez¨
ahlt, so wird das unvermeidliche Prellen (siehe Abschnitt 4.12) zu verf¨
alschten Ergebnissen f¨
uhren. Aus diesem Grund f¨
uhrt
die Ftduino-Bibliothek im Hintergrund eine Filterungg durch und begrenzt die minimale Ereignisl¨
ange auf eine Millisekunde.
K¨
urzere Ereignisse werden nicht gez¨
ahlt.
Nach Systemstart sind alle vier Z¨
ahler genullt und deaktiviert. Eregnisse 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.
7.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.
7.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.
Der maximale Wert, der zur¨
uck geliefert wird ist 65535. Wird dieser Wert ¨
uberschritten, dann springt der Z¨
ahler wieder auf
0 zur¨
uck.
7.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
// Eine S ekun de lang s te ig en de ( low - nach - high ) I mp ulse an Ein ga ng C1 z¨a hlen
ftduino.counter_set_mode(Ftduino:: C1 ,Ftduino:: C_EDGE_RISING);
ftduino.counter_clear(Ftduino:: C1 ) ;
delay (1000);
uint16_t impul se =ftduino.counter_get(Ftduino:: C1 ) ;
7.2. Ftduino 93
7.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.
7.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 ca. zweimal je Sekunde im Hintergrund ausgewertet. Der jeweils
aktuelle Messwert ist daher maximal 500 Millisekunden alt.
7.2.16 int16 t ultrasonic get()
Die Funktion ultrasonic get() liefert den Messwert eines an Z¨
ahlereingang C1 angeschlossenen Disanzsensors 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
// D ist anz enso r an Eingan g C1 abfrag en
ftduino.ultrasonic_enable(true);
delay (1000); // eine S ekund e Ze it f¨ur erste Mes sung ge ben
int16_t distanz =ftduino.ultrasonic_get() ;
Kapitel 8
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.
8.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 8.1: Komponenten der Spannungsversorung
Die 9V-Steckbuchse 121 sowie die beiden Bundh¨
ulsen 9VIN+ und 9VIN- und die USB-Buchse J1 werden ebenfalls jetzt
schon best¨
uckt.
8.1. Erste Baustufe ”Spannungsversorgung“ 95
8.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 8.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.
8.1.2 Kontroll-Messungen
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 empfohlenden 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 ggf. eine ¨
Uberlastung des USB
und/oder der Body-Diode zur Folge h¨
atte.
96 Kapitel 8. Selbstbau
8.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 8.3: Komponenten des Mikrocontrollers
Auch der Mikrocontroller darf nicht verpolt werden, was in diesem Fall heisst, 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 Wiederstand R9. Kondensator C4 und die Widerst¨
ande R5 und R6 vervollst¨
andigen die USB-Schaltung. Den
16-MHz-Systemtakt erzeugen der Quartz Q1 mit den Kondensatoren C2 und C3.
Der I2C-Anschluss SV1 mit seinen Pullup-Widerst¨
anden R30 und R31 kann evenfalls 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 Auschnitt f¨
ur diesen Steckverbinder gibt. Die frei verf¨
ugbare Druckvorlage1hat einen entsprechenden Ausschnitt und
kann auch bei fest montiertem SV2 genutzt werden.
8.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 unerst¨
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/
8.3. Dritte Baustufe ”Eing¨
ange“ 97
Abbildung 8.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.
8.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 8.5: Komponenten der Eing¨
ange
Die Komponenten der Analogeing¨
ange I1 bis I8 sowie der Z¨
ahlereing¨
ange C1 bis C4 werden gleichtzeitig 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.
98 Kapitel 8. Selbstbau
Im zweiten Schritt werden dann die Widerst¨
ande R36 bis R46 sowie der Transistor T1 best¨
uckt, was die Z¨
ahlereing¨
ange
vervollst¨
andigt. Die Triggerschaltung f¨
ur den Ultraschall-Entferungsmesser (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 zwischden
den Eing¨
angen zu erkennen. Sollte ein Eingang nicht ie gew¨
unscht funktionieren, so kommt als Fehlerquelle auch der
Mikrocontroller aus Baustufe 2 in Betracht.
8.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 8.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 Kondesatoren.
Auch die Ausg¨
ange sollte einzel getestet werden, um sicherzustellen, dass keine K¨
urzschl¨
usse zwischen den Ausg¨
angen
existieren.
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 ,75
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