Mit dem Schaltplan aus Anhang A und
entsprechendem Know-How über den verbauten ATmega32U4-Controller
lassen sich sämtliche Anschlüsse des ftDuino aus einem
Arduino-Sketch ansteuern. Allerdings erfordert dieses Vorgehen einiges
an Erfahrung und führt zu vergleichsweise komplexen Arduino-Sketches,
da sämtlicher Code zur Ansteuerung der diversen Ein- und Ausgänge
im Sketch selbst implementiert werden müsste.
Der ftDuino bringt daher sogenannte Bibliotheken mit. Das sind Code-Sammlungen, die bereits fertige Routinen zum Ansteuern der Ein- und Ausgänge des ftDuinos enthalten. Der eigentliche Arduino-Sketch wird dadurch sehr viel einfacher und kürzer und vor allem muss der Programmierer die Aspekte der Hardware selbst gar nicht komplett verstanden haben, da er lediglich einige einfach zu benutzende Routinen zum Zugriff auf die ftDuino-Hardware nutzt. Die Bibliotheken werden als Teil der ftDuino-Installation in der Arduino-IDE automatisch mit installiert. Aktualisierungen dieser Bibliotheken werden von der Arduino-IDE automatisch festgestellt und zum Update angeboten.
Trotzdem ist der direkte Zugriff natürlich weiterhin möglich. Der fortgeschrittene Programmierer kann also nach wie vor an allen Bibliotheken vorbei direkt auf die Hardware zugreifen. Der Code der Bibliotheken ist ebenfalls frei verfügbar1 , sodass der Anwender selbst gegebenenfalls Erweiterungen und Verbesserungen vornehmen kann.
Es gibt zwei Bibliotheken, um den ftDuino anzusteuern. Die FtduinoSimple-Bibliothek, die sehr einfach gehalten ist und nur ein ganz rudimentäres Funktions-Set bereit stellt und die Ftduino-Bibliothek, die deutlich komplexer ist und vielfältige Funktionen zur Signaleingabe und Signalausgabe bietet.
Für die unterschiedlichen Ports des ftDuino werden in den beiden folgenden Bibliotheken die gleichen Konstanten verwendet. Die acht Eingänge werden beispielsweise durch die Konstanten Ftduino::I1 bis Ftduino::I8 beschrieben. Auch wenn sich hinter diesen Konstanten die Werte 0 bis 7 verbergen sollte man wenn möglich immer die Konstanten verwenden. Sollte es irgendwann nötig sein, die hinter den Konstanten verborgenen Werte zu ändern, so werden entsprechende Sketche weiterhin funktionieren.
Der Programmierer kann sich aber darauf verlassen, dass diese Konstanten immer direkt aufeinander folgend auftsteigend sind. Man kann also z.B. über alle Ports abzählen:
// Schleife über alle Eingänge des ftDuino
for(uint8_t port=Ftduino::I1; port <= Ftduino::I8; port++) {
/* port verweist nacheinandern auf alle Ports I1 bis I8 */
mache_etwas(port);
}
for(uint8_t i=0; i < 8; i++) {
mache_etwas(Ftduino::I1+i);
}
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ängen. Es ist mit ihr weder möglich, analoge Spannungen und Widerstände einzulesen, noch die Ausgänge mit variablen Werten zu schalten.
Die Vorteile der FtduinoSimple-Bibliothek sind:
Um die FtduinoSimple-Bibliothek zu nutzen muss zu Beginn eines Sketches die entsprechende Include-Zeile eingefügt werden.
#include <FtduinoSimple.h>
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änge in einem Sketch zu verwendet.
Folgendes Beispiel zeigt das periodische Schalten eines Ausganges mit Hilfe der FtduinoSimple-Bibliothek:
1 #include <FtduinoSimple.h>
2
3 void setup() {
4 // keine Initialisierung noetig
5 }
6
7 void loop() {
8 // Ausgang O1 einschalten
9 ftduino.output_set(Ftduino::O1, Ftduino::HI);
10 delay(1000);
11 // Ausgang O1 ausschalten
12 ftduino.output_set(Ftduino::O1, Ftduino::LO);
13 delay(1000);
14 }
Achtung: Um die Ausgänge benutzen zu können muss der ftDuino natürlich mit 9 Volt versorgt werden.
Die Eingänge des ftDuino lassen sich ebenfalls sehr einfach mit Hilfe der FtduinoSimple-Bibliothek abfragen:
1 #include <FtduinoSimple.h>
2
3 void setup() {
4 // keine Initialisierung noetig
5 }
6
7 void loop() {
8 // Eingang I1 einlesen
9 if(ftduino.input_get(Ftduino::I1)) {
10 // Ausgang O1 einschalten
11 ftduino.output_set(Ftduino::O1, Ftduino::HI);
12 } else {
13 // Ausgang O1 ausschalten
14 ftduino.output_set(Ftduino::O1, Ftduino::LO);
15 }
16 }
Diese Funktion liest den Zustand des Eingangs ch ein. Erlaubte Werte für ch sind Ftduino::I1 bis Ftduino::I8. Der Rückgabewert ist true, wenn der Eingang mit Masse verbunden ist und false, wenn nicht. Auf diese Weise lassen sich z.B. leicht Taster abfragen, die zwischen dem jeweiligen Eingang und den korrespondierenden Masseanschluss daneben geschaltet sind.
Die Auswertung des Eingangs geschieht nicht im Hintergrund, sondern erfolgt genau in dem Moment, in dem die input_get()-Funktion aufgerufen wird. Vor allem, wenn dabei ein anderer Port abgefragt wird als im direkt vorhergehenden Aufruf von input_get() kommt es dadurch zu einer Verzögerung von einigen Mikrosekunden, da ftDuino-intern eine Umschaltung auf den geänderten Eingang durchgeführt werden muss.
Beispiel:
1 // lies den Zustand einer Taste an Eingang I1
2 if(ftduino.input_get(Ftduino::I1)) {
3 /* ... tue etwas ... */
4 }
Diese Funktion entspricht von ihrer Wirkungsweise input_get(). Allerdings wird counter_get_state() auf die Zählereingänge angewandt. Der Wertebereich für ch reicht demnach von Ftduino::C1 bis Ftduino::C4.
Der Rückgabewerte ist true, wenn der Eingang mit Masse verbunden ist und false, wenn nicht.
Beispiel:
1 // lies den Zustand einer Taste an Zaehler-Eingang C1
2 if(ftduino.counter_get_state(Ftduino::C1)) {
3 /* ... tue etwas ... */
4 }
Mit der Funktion output_set() können die Ausgänge O1 bis O8 gesteuert werden. Der Wertebereich für port reicht daher von Ftduino::O1 bis Ftduino::O8.
Der Parameter mode beschreibt, in welchen Zustand der Ausgang gebracht werden soll. Mögliche Werte für 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:
1 // Lampe zwischen Ausgang O1 und Masse leuchten lassen
2 ftduino.output_set(Ftduino::O1, Ftduino::HI);
Die Funktion motor_set() bedient einen Motorausgang M1 bis M4. Motorausgänge werden durch die Kombination von zwei Ausgängen gebildet (M1 = O1 und O2, M2 = O3 und O4, ...). Der Wert für port liegt daher im Bereich von Ftduino::M1 bis Ftduino::M4.
Der Parameter mode gibt an, welchen Zustand der Motorausgang annehmen soll. Mögliche Werte für 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üsse aktiv gebremst wird während der Motor bei Ftduino::OFF lediglich spannungslos geschaltet wird und langsam ausläuft.
Beispiel:
1 // Motor an Ausgang M1 links herum laufen lassen
2 ftduino.motor_set(Ftduino::M1, Ftduino::LEFT);
Code-Beispiele zur Nutzung der FtduinoSimple-Bibliothek finden sich im Menü der Arduino-IDE unter Datei ► Beispiele ► FtduinoSimple.
Die Ftduino-Bibliothek kapselt alle Funktionen der ftDuino-Hardware, sodass der Anwender bequemen Zugriff auf alle Ein- und Ausgänge hat, ohne sich über die konkrete technische Umsetzung Gedanken machen zu müssen.
Die Ftduino-Bibliothek benötigt selbst etwas Flash-Speicher, RAM-Speicher und Hintergrund-Rechenleistung, so dass nicht alle Ressourcen komplett dem Anwendungssketch zur Verfügung stehen. Zusätzlich macht sie Gebrauch von internen Ressourcen des ATmega32u4 wie Timern und Interrupts wie jeweils bei den folgenden Funktionsbeschreibungen erwähnt.
Um die Ftduino-Bibliothek zu nutzen muss zu Beginn eines Sketches die entsprechende Include-Zeile eingefügt werden.
#include <Ftduino.h>
// die setup-Funktion wird einmal beim Start aufgerufen
void setup() {
// Benutzung der Ftduino-Bibliothek vorbereiten
ftduino.init();
}
Die Eingänge I1 bis I8 sind mit Analogeingängen des ATmega32u4-Mikrocontrollers im ftDuino verbunden. Diese Analogeingänge 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ünschte Verzögerung bei der Abfrage von Eingängen vermieden werden kann.
Die ftDuino-Bibliothek nutzt dazu den sogenannten ADC_vect-Interrupt. Die Analog-Digital-Wandler (ADCs) werden auf eine Messrate von ungefähr 8900 Messungen pro Sekunde eingestellt. Jeder Eingang wird zweimal abgefragt, um eine stabile zweite Messung zu erhalten, so dass für die 8 Eingänge insgesamt 16 Messungen nötig sind. Daraus ergibt sich eine Konvertierungsrate von circa 560 Messungen pro Sekunde pro Eingang, die automatisch im Hintergrund erfolgen. Beim Auslesen ist der Messwert demnach maximal circa 2 Millisekunden alt und der Wert wird ungefähr alle 2 Millisekunden aktualisiert.
Der ftDuino kann einen sogenannte Pull-Up-Widerstand an jedem der Eingänge aktivieren, so dass einer Spannungsmessung eine Widerstandsmessung erfolgen kann. Auch das wird von der ftDuino-Bibliothek im Hintergrund verwaltet und die Umschaltung erfolgt automatisch vor der Messung. Sie ist auch der Grund, warum pro Kanal zwei Messungen erfolgen. Dies erlaubt den Signalen, sich nach dem Umschaltvorgang und vor der zweiten Messung zu stabilisieren.
Die Funktion input_set_mode() setzt den Messmodus des Eingangs ch. Gültige Werte für ch reichen von Ftduino::I1 bis Ftduino::I8.
Der Wert mode kann auf Ftduino::RESISTANCE, Ftduino::VOLTAGE oder Ftduino::SWITCH gesetzt werden. Die Funktion input_get() liefert in der Folge Widerstandswerte in Ohm, Spannungswerte in Millivolt oder den Schaltzustand eines Schalters als Wahrheitswert.
Diese Funktion liest den aktuellen Messwert des Eingangs ch aus. Gültige Werte für ch reichen von Ftduino::I1 bis Ftduino::I8.
Der zurückgelieferte Messwert ist ein 16-Bit-Wert. Im Falle einer Spannungsmessung wird ein Wert zwischen 0 und 10.000 zurück geliefert, was einer Spannung von 0 bis 10 Volt entspricht. Im Falle einer Widerstandsmessung wird ein Widerstandswert von 0 bis 65535 Ohm zurück geliefert, wobei der Wert 65535 auch bei allen Widerständen größer 65 Kiloohm geliefert wird. Bedingt durch das Messprinzip werden die Werte oberhalb circa 10 Kiloohm immer ungenauer. Bei einer Schaltermessung wird nur true oder false zurück 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ück. Nur wenn direkt zuvor der Messmodus des Eingangs verändert wurde, dann kann es bis zu 2 Millisekunden dauern, bis die Funktion einen gültigen Messwert zurück liefert. Die Funktion blockiert in dem Fall die Programmausführung so lange.
Beispiel:
1 // Widerstand an I1 auswerten
2 ftduino.input_set_mode(Ftduino::I1, Ftduino::RESISTANCE);
3 uint16_t widerstand = ftduino.input_get(Ftduino::I1);
Die Ausgänge O1 bis O8 sind acht unabhängige verstärkte Ausgänge zum direkten Anschluss üblicher 9-Volt-Aktoren von fischertechnik wie z.B. Lampen, Ventile und Motoren.
Je vier Ausgänge werden von einem Treiberbaustein vom Typ MC33879A2 angesteuert. Dieser Baustein enthält acht unabhängig steuerbare Leistungstransistoren. Je zwei Transistoren können einen Ausgang auf Masse schalten, auf 9 Volt schalten oder ganz unbeschaltet lassen. Daraus ergeben sich die drei möglichen Zustände jedes Ausgangs LO (auf Masse geschaltet), HI (auf 9 Volt geschaltet) oder OFF (unbeschaltet).
Je zwei Ausgänge Ox können zu einem Motorausgang Mx kombiniert werden. Ausgänge O1 und O2 ergeben den Motorausgang M1, O3 und O4 den Motorausgang M2 und so weiter. Der kombinierte Motorausgang kann die vier mögliche Zustände OFF, LEFT, RIGHT und BRAKE annehmen. In den Zuständen LEFT und RIGHT dreht ein angeschlossener Motor je nach Polarität des Anschlusses links oder rechts-herum. Im Zustand OFF sind beide Ausgänge unbeschaltet und der Motor verhält sich, als wäre er nicht angeschlossen und lässt sich z.B. relativ leicht drehen. Im Zustand BRAKE sind beiden Ausgänge auf Masse geschaltet und ein angeschlossener Motor wird gebremst und lässt sich z.B. schwer drehen.
Die Motortreiber sind über die sogenannte SPI-Schnittstelle des ATmega32u4 angeschlossen. Beide Motortreiber sind in Reihe geschaltet und werden bei jedem SPI-Datentransfer beide mit Daten versorgt. Signaländerungen an den Ausgängen und speziell die PWM-Signalerzeugung (siehe Abschnitt 6.3) zur Erzeugung von Analogsignalen an den Ausgängen erfordern eine kontinuierliche Kommunikation auf dem SPI-Bus im Hintergrund. Dazu implementiert die Ftduino-Bibliothek einen sogenannte SPI-Interrupt-Handler, der permanent im Hintergrund läuft und permanent den Status der Motortreiber aktualisiert.
Hinweis: Die Ausgänge lassen sich nur nutzen, wenn der ftDuino mit einer 9-Volt-Spannungsquelle verbunden ist.
Diese Funktion schaltet einen Einzelausgang. Gültige Werte für 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ür 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ür 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ür aus und 64 für 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öglich die Konstanten Ftduino::OFF, Ftduino::ON und Ftduino::MAX herangezogen werden, da diese bei einer Veränderung des PWM-Wertebereichs z.B. in späteren Versionen der Ftduino-Bibliothek leicht angepasst werden können. Zwischenwerte können dazu von den Konstanten abgeleitet werden (z.B. Ftduino::MAX/2).
Beispiel:
1 // Ausgang O2 auf 50% einschalten
2 ftduino.output_set(Ftduino::O2, Ftduino::HI, Ftduino::MAX/2);
Die Funktion motor_set() schaltet einen kombinierten Motorausgang. Gültige Werte für 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ür 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änge auf Masse geschaltet werden).
Der pwm-Parameter gibt einen Wert für 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ür aus und 64 für 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ür Details zum Zusammenhang zwischen Motordrehzahl und PWM-Werte siehe Abschnitt 6.3). Es sollten wenn Möglich die Konstanten Ftduino::OFF, Ftduino::ON und Ftduino::MAX herangezogen werden, da diese bei einer Veränderung des PWM-Wertebereichs z.B. in späteren Versionen der Ftduino-Bibliothek leicht angepasst werden können. Zwischenwerte können 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:
1 // Motor an M3 mit 1/3 Geschwindigkeit links drehen
2 ftduino.motor_set(Ftduino::M3, Ftduino::LEFT, Ftduino::MAX/3);
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ätzliche vierte Parameter gibt an, wie viele Impulse der Encoder-Motor laufen soll. Die Schritte werden auf dem korrespondierenden Zählereingang gemessen, also auf Zählereingang C1 für Motorausgang M1, C2 für M2 und so weiter. Nach Ablauf der angegebenen Impulse wird der Motor gestoppt (siehe void motor_counter_set_brake()).
Das Zählen der Impulse und das Stoppen des Motors passieren im Hintergrund und unabhängig von der weiteren Sketchausführung. Die Zahl der pro Motorumdrehung erkannten Impulse hängt vom Motortyp ab. Die Motoren aus dem TXT Discovery Set liefern 63 1/3 Impulse pro Drehung der Motorachse, die Motoren aus den ursprünglich für den TX-Controller verkauften Sets liefern 75 Impulse pro Umdrehung.
Die Funktion motor_counter_active() liefert zurück, ob die Impulszählung für den durch port spezifizierten Motorausgang aktiv ist. Gültige 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ähler bisher nicht abgelaufen ist. Mit dieser Funktion kann u.a. auf das Ablaufen der Impulszählung und das Stoppen des Motors gewartet werden:
Beispiel:
1 // TXT-Encodermotor an M4 für drei volle Umdrehungen starten
2 ftduino.motor_counter(Ftduino::M4, Ftduino::LEFT, Ftduino::MAX, 190);
3 // warten bis der Motor stoppt
4 while(ftduino.motor_counter_active(Ftduino::M4));
5 // Motor hat gestoppt
Diese Funktion bestimmt das Bremsverhalten des Motors an Ausgang port, wenn er durch die Funktion motor_counter() gestartet wird.
Wird der Parameter on auf wahr (true) gesetzt, so wird der Motor nach Ablauf der Zeit aktiv gebremst. Ist er unwahr (false), so wird der Motor lediglich abgeschaltet und er läuft ungebremst aus. Die Standardeinstellung nach der Initialisierung der Bibliothek ist wahr, die aktive Bremsung ist also aktiviert.
In beiden Fällen läuft der Motor nach. Im gebremsten Fall läuft ein Encoder-Motor aus dem TXT-Discovery-Set unbelastet circa 5 Impulse nach (circa 1/10 Umdrehung bzw. 28,5°). Im ungebremsten Fall läuft der gleiche Motor circa 90 Impulse (circa 1 1/2 Umdrehungen) nach.
Da die Zähler nach dem Stoppen des Encoders weiterlaufen ist der Nachlauf auch per Programm messbar:
Beispiel:
1 // Bremse für Ausgang M4 abschalten
2 ftduino.motor_counter_set_brake(Ftduino::M4, false);
3 // TXT-Encodermotor an M4 für drei volle Umdrehungen starten
4 ftduino.motor_counter(Ftduino::M4, Ftduino::LEFT, Ftduino::MAX, 190);
5 // warten bis der Motor stoppt
6 while(ftduino.motor_counter_active(Ftduino::M4));
7 // etwas länger warten, um dem Motor Zeit zum Nachlaufen zu geben
8 delay(500);
9 // Zählerstand ausgeben
10 Serial.println(ftduino.counter_get(Ftduino::C4));
Die Zählereingänge arbeiten im Gegensatz zu den Analogeingängen rein digital. Sie unterscheiden nur, ob der jeweilige Eingang auf Masse geschaltet ist oder nicht. Dies geschieht üblicherweise durch einen Tester, der zwischen dem Zählereingang und seinem korrespondierenden Masseanschluss angeschlossen ist oder einem Encodermotor, dessen Encoderausgang mit dem Zählereingang verbunden ist. Die Zählereingänge haben interne Pull-Up-Widerstände. Das bedeutet, dass sie vom ftDuino als ``high'' bzw mit hohem Signalpegel erkannt werden, wenn kein Signal anliegt weil z.B. ein angeschlossener Taster nicht gedrückt ist. Ist der Taster geschlossen, dann schaltet er den Eingang auf Masse, was von ftDuino als ``low'' erkannt wird.
Die vier Zählereingänge sind direkt mit einem Interrupt-fähigen Eingang am ATmega32u4 verbunden. Technisch ist damit eine Reaktion im Bereich von mehreren hunderttausend Zählimpulsen pro Sekunde möglich. Werden aber z.B. Tastendrücke gezählt, so wird das unvermeidliche Prellen (siehe Abschnitt 6.12) zu verfälschten Ergebnissen führen. Aus diesem Grund führt die Ftduino-Bibliothek im Hintergrund eine Filterung durch und begrenzt die minimale Ereignislänge auf eine Millisekunde. Kürzere Ereignisse werden nicht gezählt.
Nach Systemstart sind alle vier Zähler auf Null gesetzt und deaktiviert. Ereignisse an den Eingängen verändern die Zähler also nicht.
Zusätzlich erlaubt der Zählereingang C1 den Anschluss des fischertechnik ROBO TX Ultraschall-Distanzsensors 133009 wie in Abschnitt 1.2.6 dargestellt.
Diese Funktion setzt den Betriebsmodus eines Zählereingangs. Gültige Werte für ch reichen von Ftduino::C1 bis Ftduino::C4.
Wird der mode-Wert auf auf Ftduino::C_EDGE_NONE gesetzt, dann werden keine Signalwechsel gezählt und der Zähler 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öhere Spannung, gezählt. Dies passiert z.B. wenn ein angeschlossener Taster losgelassen (geöffnet) wird.
Ein mode-Wert von Ftduino::C_EDGE_FALLING führt dazu, dass fallende Signalflanken, also Wechsel des Eingangssignals von einer höheren Spannung auf Masse, gezählt werden, was z.B. dann geschieht, wenn ein angeschlossener Taster gedrückt (geschlossen) wird.
Wird der mode-Wert schließlich auf Ftduino::C_EDGE_ANY gesetzt, so führen beide Signaländerungsrichtungen dazu, dass der Zähler erhöht wird. Sowohl das Drücken, als auch das Loslassen einen Testers wird dann z.B. gezählt.
Diese Funktion liefert den aktuellen Zählerstand zurück. Gültige Werte für ch liegen im Bereich von Ftduino::C1 und Ftduino::C4.
Der maximale Wert, der zurück geliefert wird ist 65535. Wird dieser Wert überschritten, dann springt der Zähler wieder auf 0 zurück.
Mit Hilfe der Funktion counter_clear() kann der Zählerstand auf Null gesetzt werden. Gültige Werte für ch liegen im Bereich von Ftduino::C1 und Ftduino::C4.
Beispiel:
1 // Eine Sekunde lang steigende (low-nach-high) Impulse an Eingang C1 zählen
2 ftduino.counter_set_mode(Ftduino::C1, Ftduino::C_EDGE_RISING);
3 ftduino.counter_clear(Ftduino::C1);
4 delay(1000);
5 uint16_t impulse = ftduino.counter_get(Ftduino::C1);
Der Zustand der Zählereingänge kann auch direkt mit der Funktion counter_get_state() abgefragt werden. Die Werte für ch müssen im Bereich von Ftduino::C1 bis Ftduino::C4 liegen.
Diese Funktion liefert wahr (true) zurück, 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ückt wird. Es können auf diese Weise digitale Signale mit einer sehr hohen Frequenz erfasst werden.
An Zählereingang 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ützung für den Sensor, wenn der Parameter ena auf wahr (true) gesetzt wird und deaktiviert sie, wenn er auf unwahr (false) gesetzt wird.
Wird die Unterstützung für den Ultraschallsensor aktiviert, so wird die Zählfunktion des Eingangs C1 automatisch deaktiviert.
Ist der Ultraschallsensor aktiviert, so wird er kontinuierlich circa zweimal je Sekunde im Hintergrund ausgewertet. Der jeweils aktuelle Messwert ist daher maximal 500 Millisekunden alt.
Die Funktion ultrasonic_get() liefert den Messwert eines an Zählereingang C1 angeschlossenen Distanzsensors in Zentimetern zurück. Wurde seit Aktivierung kein gültiger Messwert vom Sensor empfangen, so wird als Distanz -1 zurück geliefert. Dies geschieht auch, wenn kein Sensor angeschlossen ist.
Der Sensor selbst arbeitet im Bereich von 0 bis 1023 Zentimeter.
Beispiel:
1 // Distanzsensor an Eingang C1 abfragen
2 ftduino.ultrasonic_enable(true);
3 delay(1000); // eine Sekunde Zeit für erste Messung geben
4 int16_t distanz = ftduino.ultrasonic_get();
| Befehl | Beschreibung |
| bool input_get(uint8_t ch) | Einlesen eines Digitaleingangs I1-I8 |
| bool counter_get_state(uint8_t ch) | Einlesen eines Zählereingangszustands C1-C4 |
| void output_set(uint8_t port, uint8_t mode) | Schalten eines Einzelausgangs O1-O8 |
| void motor_set(uint8_t port, uint8_t mode) | Schalten eines Motorausgangs M1-M4 |
| Befehl | Beschreibung |
| void input_set_mode(uint8_t ch, uint8_t mode) | Setzen eines Eingangsmodus I1-I8 |
| uint16_t input_get(uint8_t ch) | Einlesen eines Eingangs I1-I8 |
| void output_set(uint8_t port, uint8_t mode, uint8_t pwm) | Schalten eines Ausgangs O1-O8 |
| void motor_set(uint8_t port, uint8_t mode, uint8_t pwm) | Schalten eines Motorausgangs M1-M4 |
| void motor_counter(uint8_t port, uint8_t mode, | Schalten eines Encodermotors M1-M4 |
| uint8_t pwm, uint16_t counter) | |
| bool motor_counter_active(uint8_t port) | Auswerten eines Encodermotorzählers C1-C4 |
| void motor_counter_set_brake(uint8_t port, bool on) | Setzen der Encodermotorbremse M1-M4 |
| void counter_set_mode(uint8_t ch, uint8_t mode) | Setzen eines Zählermodus C1-C4 |
| bool counter_get_state(uint8_t ch) | Einlesen eines Zählereingangszustands C1-C4 |
| void ultrasonic_enable(bool ena) | Aktivieren eines Ultraschallsensors |
| int16_t ultrasonic_get() | Einlesen eines Ultraschallsensors |