Fünf GPIO-Pins für ein Smart Home

JavaScript: Hardwareinteraktion mit Johnny Five
Keine Kommentare

Embedded-Systeme waren einst Domäne der Rüstungselektroniker, die mit Assembler oder gar C an stark echtzeitkritischen Aufgaben arbeiteten. In der schönen neuen Welt der Informatik ist die Situation dank des Moore’schen Gesetzes und der Umgebungsänderungen anders.

Anstatt aufwändig mit hardwarenahen Programmiersprachen zu arbeiten, hat der Entwickler Interesse daran, Hochsprachen zu verwenden. Das ist aus mehreren Gründen vorteilhaft: Neben dem „schnelleren“ Programmiervorgang reduziert sich die Koppelung innerhalb des Projekts. Im Dunstkreis des Autors findet sich ein Unternehmen, das am Prozessrechner und am Server in vielen Bereichen Code verwendet, der aus denselben Dateien entsteht – Fehler bei der „Adaption“ sind so, frei nach Ted Faison, von Anfang an ausgeschlossen.

Das Framework Johnny Five

Die Tessel-Plattform hat uns in den Fachmagazinen immer wieder beschäftigt. Im Projekt herrscht im Moment allerdings verdächtige Ruhe – der T2 ist seit einiger Zeit auf dem Markt, von einem Nachfolger hört man nichts. Als „Alternative“ etabliert sich ein als Johnny Five bezeichnetes Framework, das seine Arbeit unter Node.js bewerkstelligt und mit verschiedensten Prozessrechnersystemen zurechtkommt. Die Entwickler von Johnny Five wünschen sich die Verwendung von Node.js 4.0. Die nachfolgenden Schritte erfolgen auf einem unter Ubuntu 14.04 laufenden AMD-Achtkernrechner, auf dem dieser Versionsstand vorherrschte:

tamhan@TAMHAN14:~/workspaceJohnny/bsp1$ node -v
v10.1.0
tamhan@TAMHAN14:~/workspaceJohnny/bsp1$ npm -v
5.6.0

Wie bei allen Node-Projekten muss auch hier mittels npm ein neues Projekt erstellt und die Johnny-Five-Bibliothek installiert werden. Zum Zeitpunkt der Drucklegung dieses Magazins ist die Version 1.0 aktuell:

tamhan@TAMHAN14:~/workspaceJohnny/bsp1$ npm init
tamhan@TAMHAN14:~/workspaceJohnny/bsp1$ npm install johnny-five
. . .
+ johnny-five@1.0.0
added 217 packages in 15.723s

Auf der Workstation des Autors mussten dabei einige Module kompiliert werden, was der Compiler mit Warnungen quittierte – diese sind für das Programmverhalten irrelevant, ignorieren Sie sie einfach. Als Nächstes stellt sich die Frage nach der gewünschten Zielplattform. Zum Zeitpunkt der Drucklegung dieses Magazins ist Johnny Five mit so gut wie allem kompatibel – Abbildung 1 zeigt den entsprechenden Inhalt der Firmenwebseite. Die Links auf der Unterseite erlauben das Filtrieren der angezeigten Prozessrechner nach verschiedenen Betriebsmodi.

Abb. 1: Johnny Five unterstützt eine Vielzahl von Prozessrechnern

Abb. 1: Johnny Five unterstützt eine Vielzahl von Prozessrechnern

Wir wollen in den folgenden Schritten aus Gründen der Bequemlichkeit auf einen Arduino Uno setzen. Die einst von Massimo Banzi entwickelte Platine gewinnt mit Sicherheit keinen Innovationspreis, ist aber universell erhältlich, nicht allzu teuer und demonstriert die Vorgehensweise bei der Arbeit mit Dumb-Terminal-Prozessrechnern anschaulich. Im ersten Schritt müssen Sie – wie immer – dafür sorgen, dass eine Arduino-Programmierumgebung zur Verfügung steht. Besuchen Sie die Webseite der Arduino-Gruppe und laden Sie eine halbwegs aktuelle Version der IDE herunter. Arbeiten Sie die Installationsanweisungen anschließend der Reihe nach ab, als ob Sie den Arduino „normal“ programmieren wollen.

Da unser vorliegender Arduino keine WLAN- oder sonstige Hardware mitbringt, erfolgt die Kommunikation über das universal unbeliebte Firmata-Protokoll. Öffnen Sie die Arduino-IDE und wählen Sie die Vorlage File | Examples | Firmata | StandardFirmata, um den Editor mit dem Firmata-Programm zu laden. Klicken Sie danach auf das bekannte Deployment-Symbol in der Toolbar, um den Arduino zu einem Empfänger von Firmata-Befehlen umzufunktionieren. Firmata ist ein von MIDI abgeleitetes Protokoll zur Steuerung von Prozessrechnern. Die auf GitHub im Detail beschriebene Kommunikationsumgebung erlaubt einem Host, auf einem Zielsystem beispielsweise GPIO-Pins ein- und auszuschalten und sonstige Hardwaresteuerungsoperationen vorzunehmen. Trennen Sie den Arduino vom PC und schließen Sie die Arduino-IDE, um die Umwandlung vom Arduino-Bootloader-Betrieb in einen gewöhnlichen Firmata-Rezipienten abzuschließen. Erzeugen Sie eine neue Datei namens Index.js und laden Sie im ersten Schritt die Johnny-Five-Bibliothek:

var five = require("johnny-five");
var board = new five.Board();

Der verwendete Code unterscheidet sich von Arduino zu Arduino minimal – bei der Arbeit mit dem als Standard geltenden Arduino Uno ist die aus der Arduino-IDE geladene Version jedenfalls korrekt. Im nächsten Schritt müssen wir für die eigentliche Abarbeitung der Blink-Funktion sorgen. Da die Initialisierung des Boards etwas Zeit in Anspruch nimmt, nutzen wir die on-Funktion des Objekts zum Einschreiben eines Event Handlers, der beim Auftreten des ready-Ereignisses aktiviert wird.

board.on("ready", function() {
  var led = new five.Led(13);
  led.blink(500);
});

Nach dem Eintreffen des Events rufen wir new five.led auf, um eine neue Instanz der LED-Klasse zu beschaffen. Der Aufruf von Blink sorgt für kontinuierliches Blinken. Im Interesse der Vollständigkeit zeige ich hier auch, wie man Johnny Files für den Tessel konfiguriert. Er unterscheidet sich von unserem Arduino durch das Vorhandensein einer vollwertigen Linux-Runtime, die das direkte Ausführen der Software auf dem Prozessrechner erlaubt:

var five = require("johnny-five");
var Tessel = require("tessel-io");
var board = new five.Board({
  io: new Tessel()
});

Nach dem abermals erforderlichen Laden mit require() rufen wir den Konstruktor five.board nun mit einem Parameterobjekt auf, das den Wert von io festlegt. Dieses Feld erlaubt der Runtime das Einsammeln mehr oder weniger beliebiger Treiber, die die Bibliothek zur Interaktion mit der Hardware befähigen.

Auch in der eigentlichen Payload sind kleinere Änderungen erforderlich:

board.on("ready", function() {
  var led = new five.Led("a1");
  led.blink(500);
});

Während unser Arduino Uno von Haus aus eine mit dem GPIO-Pin Nummer 13 verdrahtete LED mitbringt, beschreibt das Tessel-Team die einzelnen Pins ihrer Prozessrechner mit alphanumerischen IDs. Der restliche Code verhält sich dann so, wie man es vom Arduino Uno erwarten würden. Ein Aufruf von blink mit dem Parameter 500 sorgt auch hier für ein bequem mit bloßem Auge sichtbares Blinken.

An dieser Stelle können wir durch Eingabe von node index einen Lauf anweisen – die Leuchtdiode auf dem Prozessrechner beginnt zu blinken. Auf Seiten der Workstation sehen Sie die in Abbildung 2 gezeigte Ausgabe – zum Beenden der Programmausführung müssen wir, wie bei Node.js im Allgemeinen, zweimal hintereinander Ctrl+C senden.

Abb. 2: Die Johnny Five-Ausführungsumgebung ist sehr kommunikativ

Abb. 2: Die Johnny Five-Ausführungsumgebung ist sehr kommunikativ

Der Fünfte unter Druck

An dieser Stelle können wir einen ersten Test durchführen, um festzustellen, wie sich Johnny Five in einer Stresssituation verhält. Ersetzen Sie dazu den an blink übergebenen „Wartezeitparameter“ durch den Minimalwert eins, um die maximale Performance des Systems bereitzustellen:

board.on("ready", function() {
  var led = new five.Led(13);
  led.blink(1);
});

Verbinden Sie einen Modulation Domain Analyzer mit dem Pin Nummer 13 und lassen Sie ihn einige Zeit Daten einsammeln. Abbildung 3 zeigt, dass es um die Wellenformstabilität nicht sonderlich gut bestellt ist.

Abb. 3: Die Erfüllung von Echtzeitanforderungen wird mit Johnny Five schwierig

Abb. 3: Die Erfüllung von Echtzeitanforderungen wird mit Johnny Five schwierig

Johnny Five steuert den Arduino Uno durch regelmäßiges Absetzen von Befehlen – würden Sie die Workstation abschalten, so würde auch die Ausgabe der Wellenform stoppen. Bei derartigen Architekturen kommt es zu einem klassischen Problem der Pufferüberfütterung. Zu seiner Demonstration wollen wir ein weiteres kleines Testprogramm zusammenschustern:

board.on("ready", function() {
  var led = new five.Led(13);
  while(1==1){
    led.on();
    led.off();
  }
});

Auf den ersten Blick wirkt dieser Code vernünftig. Nach dem Eintreffen des ready-Ereignisses starten wir eine Endlosschleife, die permanente Ein- und Ausschaltereignisse generiert. In der Theorie müssten wir als Reaktion darauf eine Wellenform sehen, die mit der maximalen Arbeitsgeschwindigkeit des Verbunds ausgegeben wird.

Wer das Programm in der Praxis auszuführen sucht, macht eine ernüchternde Erfahrung. Abbildung 4 zeigt, was einige Sekunden nach dem Programmstart am Bildschirm erscheint – am Oszilloskop ist während dieser Zeit übrigens nichts zu sehen.

Abb. 4: Die Endlosschleife stirbt mit einem Buffer Overflow

Abb. 4: Die Endlosschleife stirbt mit einem Buffer Overflow

Die Ursache für dieses Verhalten, das für von der Informatik kommende Personen verwirrend ist, liegt darin, dass Johnny Five die auf JavaScript-Seite generierten Firmata-Befehle nicht sofort in Richtung des Arduinos schickt. Das System wartet stattdessen so lange, bis der JavaScript-Code in Ruhe ist, um dann alle Ereignisse abzuschicken.

In unserem Fall würde eine „Gruppe“ von Frames entstehen, die aber nie abgeschickt werden kann und irgendwann den Speicher der Runtime vollständig eliminiert. Zur Demonstration dieses Verhaltens passen wir den an on übergebenen Event Handler in Listing 1 ein wenig an.

board.on("ready", function() {
  var led = new five.Led(13);
  var limit=0;
  while(limit<25){
    led.on();
    led.off();
    limit++;
  }
});

Das genaue Ausmessen der Ausgabe dieses Programms ist etwas haarig – die saubere Methode bestünde darin, die komplexen Trigger-Funktionen eines Oszilloskops zu verwenden. Da der Autor dieser Zeilen ein ungeduldiger Mensch ist, gibt es auch eine rabiatere Methode, die ich Ihnen in Abbildung 5 demonstriere. Wer ein ausreichend stark ausgestattetes Oszilloskop hat und sorgfältig mitdenkt, spart auf diese Art und Weise Zeit.

Abb. 5: Das machen wir zu Hause nicht nach!

Abb. 5: Das machen wir zu Hause nicht nach!

Der Oszillograph wurde hierbei in ein Sonderregime versetzt, in dem die volle Speichertiefe zur Verfügung steht. Wundern Sie sich nicht darüber, wenn das Benutzerinterface in diesem Betriebsmodus ruckelt – das Pfeifen der Kühlung ist ebenfalls normal.

Sodann bekam der Arduino einen Startbefehl, die erste der im Rahmen des Hochfahrens ausgegebenen Zuckungen triggerte das Scope. Der Oszillograph merkte sich die gesamte Startsequenz, über den Zoom-Befehl haben wir die letzte Wellenform vergrößert und sehen die einzelnen Bewegungen. Damit ist bewiesen, dass das Absenden von Befehlen in Johnny Five erst dann erfolgt, wenn die JavaScript-Runtime als Ganzes „up“ ist.

Alleinstehende Peripheriegeräte

Aus dem soeben erforschten Sachverhalt ergeben sich für das praktische Design Besonderheiten. Bevor wir uns die einzelnen Elemente genauer anschauen, wollen wir einen Blick auf die Dokumentation  werfen. Das Johnny-Five-Entwicklerteam spendiert uns eine Gruppe von Treibern und Bibliotheken, die Interaktion mit häufig benötigten Hardwarekomponenten erleichtern und hardwarenahes Programmieren unnötig machen. Wir wollen in den folgenden Schritten die Piezo-Bibliothek benutzen. Ein Piezo-Summer ist ein elektromechanisches Bauteil, das auf die Ausgabe von Tönen optimiert ist. Er gewinnt mit Sicherheit keine Preise bei der Wiedergabe von Puccini oder Pavarotti – doch für die einfache Emission von Zustandsinformationen ist er, auch aufgrund des geringen mechanischen Umfangs, geradezu ideal geeignet.

Bei der Auswahl des geeigneten Summers sind Sie im Allgemeinen frei, wenn Sie Ausgangsspannung und Frequenzgang beachten. Der Autor nutzt in den folgenden Schritten einen PKMCS0909E4000 aus dem Hause Murata, den er aufgrund eines Consultingprojekts zur Hand hatte. Das Bauteil ist in der Praxis nicht allzu teuer – Abbildung 6 bietet einen Übersicht der aktuellen Distributorenpreise.

Abb. 6: Mit OEMsecrets Preise vergleichen und günstiger kaufen

Abb. 6: Mit OEMsecrets Preise vergleichen und günstiger kaufen

Montieren Sie das SMD-Bauteil im nächsten Schritt auf eine Adapterplatine und verbinden Sie diese einerseits mit Masse und andererseits mit Pin zwölf des Arduinos. Da wir mit einem Arduino Uno arbeiten, der einen sehr stromlieferfreudigen Mikrocontroller mitbringt, ist das Zwischenschalten eines Transistors nicht erforderlich – wenn Sie mit einem Raspberry Pi oder einen anderen Prozessrechner arbeiten, werden Sie mit höchster Wahrscheinlichkeit keine hörbaren Ergebnisse erhalten.

Legen Sie im nächsten Schritt jedenfalls ein neues Codebeispiel an, in dem Sie wie gewohnt die Johnny-Five-Bibliothek laden. Im Code zum Heft hört dieses Sample auf den Namen hanna_johnnyfive_bsp2.zip. Dieser steht auf der Magazindetailseite dieser Ausgabe zum Download bereit. Erstellen Sie darin eine Datei namens Index.js und starten Sie sie mit folgendem Code:

board.on("ready", function() {
  var piezo= new five.Piezo({
    pin: 12
  });

Im ersten Schritt muss die Initialisierung der Klasse erfolgen. Hierzu melden wir einfach den Pin an, der mit dem Summer verbunden ist. Bei wenig leistungsfähigen Prozessrechnern unterstützt Johnny Files auch noch per I2C angeschlossene Erweiterungsbausteine. Nach der erfolgreichen Initialisierung können wir für die Ausgabe von etwas Musik sorgen (Listing 2).

piezo.play({
    song: [
      ["C4", 1 / 4],
      ["D4", 1 / 4],
      [null, 1 / 4],
      . . .
    ],
    tempo: 100
  });

});

Die play-Funktion zeigt die Verspieltheit der Johnny-Five-Entwickler. Sie nimmt ein Array von Musiknoten und dazugehörenden Längeninformationen entgegen und spielt diese dann wie ein virtuelles Orchester ab. Der tempo-Parameter erlaubt dem Entwickler das Festlegen der Länge einer vollen Note. Wundern Sie sich nicht, wenn nach dem Start des Programms etwas Zeit ins Land geht, bevor die ersten Töne erscheinen. Johnny Five lässt sich zum Starten aufgrund der komplexen Infrastruktur vergleichsweise viel Zeit.

Ereignisgesteuerte Programmierung

Unsere weiter oben gemachte Feststellung zeigt, dass Johnny Five nicht wirklich für Polling-Aufgaben vorgesehen ist. Eine vernünftigere Programmierweise besteht darin, den Firmata-Code darüber zu informieren, dass er bei Änderungen bestimmter Pins Ereignisse in Richtung der JavaScript Runtime schicken soll. Da wir hier schon einen Summer angeschlossen haben, wollen wir im nächsten Schritt ein einfaches Klavier realisieren. Hierzu sind vier Taster und vier Vorwiderstände erforderlich, die wir mehr oder weniger nach Belieben mit dem Arduino verbinden können.

Der Autor setzt in den folgenden Schritten auf die in Abbildung 7 gezeigte Schaltung.

Abb. 7: Ein paar Widerstände, ein paar Taster, und der erste Schritt zum Klavier ist getan

Abb. 7: Ein paar Widerstände, ein paar Taster, und der erste Schritt zum Klavier ist getan

Angemerkt sei, dass die Vorwiderstände aus technischen Gründen erforderlich sind – das Kurzschließen der Versorgungsspannung gegen Masse ist wenig vernünftig. Bei der eigentlichen Auswahl des Widerstandswerts haben Sie hier im Allgemeinen freie Hand – wäre unsere Applikation batteriebetrieben, würde die Situation etwas kritischer ausfallen.

Im nächsten Schritt können wir zur JavaScript-Datei zurückkehren und bsp2 um die Anmeldung von vier Event Handlern bereichern (Listing 3).

var p1 = new five.Pin({
  pin: 8,
  mode: 0
});
var p2 = new five.Pin({
  pin: 9,
  mode: 0
});
var p3 = new five.Pin({
  pin: 10,
  mode: 0
});
var p4 = new five.Pin({
  pin: 11,
  mode: 0
});

Das Anlegen von pin-Objekten unterscheidet sich nicht wesentlich von der weiter oben vorgeführten Erzeugung von LEDs oder Summern. Wichtig ist, dass der Konstruktor ein vergleichsweise kompliziertes Parameterobjekt übernimmt. Sie können Pins schon im Rahmen der Initialisierung als Eingang oder Ausgang deklarieren, indem sie die in der Tabelle 1 genannten Werte übergeben.

Konstante Wert Rolle
Pin.INPUT 0 Pin agiert als Eingang
Pin.OUTPUT 1 Pin agiert als digitaler Ausgang
Pin.ANALOG 2 Pin arbeitet als analoges Interfaceelement
Pin.PWM 3 Pin liefert PWM-Wellenform
Pin.SERVO 4 Pin steuert Servomotor an

Tabelle 1: Werte zur Initialisierung des Pins

Johnny Five unterscheidet sich von anderen Programmierumgebungen insofern, als die Pins von Haus aus nicht inertialisiert werden – wer five.Pin() ohne mode aufruft, bekommt mitunter einen Ausgang samt fließenden Ausgleichsströmen. Im Vollausbau würde das Objekt übrigens wie in Listing 4 aussehen – dass nicht alle in der Tabelle genannten Optionen mit allen Pins funktionieren, folgt aus der Logik.

{
  supportedModes: [ 0, 1, 3, 4 ],
  mode: 0,
  value: 0,
  report: 1,
  state: 1,
  analogChannel: 127
}

Anmeldung der Event Händler

Johnny Five kennt drei verschiedene Zustandshandler. High wird immer dann aufgerufen, wenn der Pin den logischen Hoch-Zustand einnimmt. Aus der Logik folgt, dass sich Low genau umgekehrt verhält – dieser Event Handler kommt nur dann zum Einsatz, wenn der Spannungspegel gegen Masse tendiert. Zu guter Letzt gibt es noch die Methode Data, die immer dann aufgerufen wird, wenn das Board eine Änderung seines GPIO-Zustands anmeldet (Listing 5).

p1.on('high', function(){
  console.log('T1');
});
p2.on('high', function(){
  console.log('T2');
});
p3.on('high', function(){
  console.log('T3');
});
p4.on('high', function(){
  console.log('T4');
});

Die vorliegende Version emittiert eine Gruppe von Ereignissen in die Konsole. Führen sie das Programm aus und überzeugen Sie sich – wie in Abbildung 8 gezeigt – davon, dass das Drücken der Taste vom Arduino und von Johnny Five erkannt wird.

Abb. 8: Das Einlesen der Tastaturereignisse funktioniert problemlos

Abb. 8: Das Einlesen der Tastaturereignisse funktioniert problemlos

Die Auswahl zwischen High und Low lässt sich mit einem einfachen Trick verifizieren. Drücken Sie eine Taste und halten Sie sie kurz gedrückt – erscheint die Meldung in der Konsole erst beim Loslassen, haben Sie die Firmware versehentlich auf dem falschen Pin aktiviert.

Als Nächstes ersetzen wir die Aufrufe von console.log durch Aktivierungen der Funktion piezo.frequency. Laut der Dokumentation nimmt sie zwei Parameter entgegen: eine Arbeitsfrequenz und einen Wert in Millisekunden, der angibt, wie lang der jeweilige Ton ausgegeben werden soll (Listing 6).

p1.on('high', function(){
  piezo.frequency(400, 200);
});
p2.on('high', function(){
  piezo.frequency(1000, 200);
});
p3.on('high', function(){
  piezo.frequency(2000, 200);
});
p4.on('high', function(){
  piezo.frequency(3000, 200);
});

Wer das vorliegende Programm ausführt und auf die Knöpfe drückt, stellt fest, dass nur zwischen 400 Hz und 1 000 Hz merkbare Unterschiede hörbar sind – die Kombination aus unserem Piezo-Piepser und dem Arduino funktioniert nicht sonderlich gut. Trotzdem ist damit demonstriert, dass unser Programm in der Lage ist, Töne auszugeben.

Eine Frage der Geschwindigkeit

Als nächsten Versuch wollen wir feststellen, wie schnell Johnny Five in der Praxis arbeitet. Hierzu setzen wir ein trickreiches Messverfahren ein. Entfernen Sie die diversen Schaltungen von Arduino und beschaffen Sie sich stattdessen einen arbiträren Funktionsgenerator. Es handelt sich dabei um ein Gerät, das mehr oder weniger zufällige Wellenformen an einem oder mehreren Kanälen ausgeben kann.

Kritisch in diesem Zusammenhang ist die Terminierung, um den Arduino Uno nicht versehentlich zu beschädigen. Insbesondere Funktionsgeneratoren höherer Leistungsfähigkeit sind nicht in der Lage, ihre Ausgangsimpedanz anzupassen. Danach brauchen wir das Testprogramm aus Listing 7.

board.on("ready", function() {
  var p1 = new five.Pin({
    pin: 8,
    mode: 0
  });
  var p2 = new five.Pin({
    pin: 9,
    mode: 1
  });
  p1.on('high', function(){
  p2.high();
  });
  p1.on('low', function(){
  p2.low();
  });
});

Projektbeispiel bsp3 unterscheidet sich vom soeben realisierten Piezo-Klavier durch eine etwas andere Herangehensweise. Das Programm meldet sowohl für die positive als auch für die negative Flanke einen Event Handler an. Es spiegelt zudem die angelieferten Informationen sofort in Richtung eines Ausgangspins.

Auf einem digitalen Phosphoroszillographen präsentiert sich das Ausgabesignal wie in Abbildung 9 gezeigt – im Interesse der Vollständigkeit auch noch die Erregerkonfiguration in Abbildung 10.

Abb. 9: Der digitale Phosphoroszillograph zeigt, dass die Reaktionszeit unruhig ist

Abb. 9: Der digitale Phosphoroszillograph zeigt, dass die Reaktionszeit unruhig ist

 

Abb. 10: Ein 10-Hz-Signal ist alles andere als schnell

Abb. 10: Ein 10-Hz-Signal ist alles andere als schnell

Johnny Five benötigt – wie an den Cursoren abzulesen – gemittelt 16,6 ms, um auf eine Änderung des Zustands zu reagieren. Der breite blaue Bereich zeigt allerdings, dass es auch wesentlich länger dauern kann – für Echtzeitaufgaben ist Johnny Five mit Sicherheit nicht geeignet.

Der fertige Sensor

Wegen der extremen Latenz der Kommunikation via Firmata – die Firmware arbeitet von Haus aus mit einer Baudrate von nur 57 600 bps – ist es vernünftig, so viel Arbeit wie möglich in Richtung des Arduinos abzuschieben. Ein schöner Weg zur Erreichung dieses höheren Ziels ist die Nutzung vorgefertigter Sensoren. Das von Maxim aufgekaufte Unternehmen Dallas Semiconductor kontrolliert den Markt der Temperatursensoren mit den hauseigenen DS18X20-Chips. Sie kommunizieren über das sehr effiziente OneWire-Protokoll mit dem Computer und versorgen sich bei Bedarf über die Datenleitung mit Energie.

Wir wollen als letztes Übungsbeispiel Johnny Five mit einem derartigen Sensor verbinden, was die in Abbildung 11 gezeigte Schaltung erforderlich macht.

Abb. 11: Der OneWire-Sensor ist mit dem Arduino verbunden

Abb. 11: Der OneWire-Sensor ist mit dem Arduino verbunden

Jeder OneWire-IC bekommt vom Hersteller eine weltweit eindeutige ID verpasst. Es ist problemlos möglich, mehrere Sensoren „nacheinander“ an einen OneWire-Bus zu hängen. In der Praxis gibt es, wenn überhaupt, nur mit Stromversorgung und Leitungslänge Probleme. Erzeugen Sie im nächsten Schritt ein weiteres Projektbeispiel namens bsp4, das mit der Generierung einer Instanz der Klasse five.Thermometer beginnt:

board.on("ready", function() {
  var thermo = new five.Thermometer({
    controller: "DS18B20",
    pin: "2"
  });  

Analog zum weiter oben verwendeten Piezo-Summer legen wir auch hier eine Instanz einer Convenience-Klasse an, die im Johnny-Five-Framework implementiert ist. Über den Parameter pin weisen wir den GPIO-Pin zu, der mit dem Data-Pin unserer Sensoren verbunden ist. Im nächsten Schritt müssen wir dafür sorgen, dass beim Eingeben von Informationen eine Ausgabe in die Konsole erfolgt:

thermo.on("data", function() {
        console.log("celsius: %d", this.C);
        console.log("fahrenheit: %d", this.F);
        console.log("kelvin: %d", this.K);
    });
});

In der Theorie könnten wir unser Programm an dieser Stelle ausführen. Wer es tatsächlich probiert, bekommt einige Sekunden nach dem Start den in Abbildung 12 gezeigten Fehler angezeigt.

Abb. 12: Die Firmata-Version passt nicht zum vorliegenden System

Abb. 12: Die Firmata-Version passt nicht zum vorliegenden System

Die Ursache des Problems liegt darin, dass die Standard-Firmata-Bibliothek keine Unterstützung für fortgeschrittene Protokolle wie OneWire mitbringt. Zur Lösung klicken wir in der Arduino-IDE im ersten Schritt auf Sketch > Include Library | Manage Libraries, um den übrigens einst von Microsoft beigesteuerten Bibliotheksmanager zu laden. Suchen Sie nach der Bibliothek ConfigurableFirmata und laden Sie sie wie gewohnt durch Anklicken des Knopfs.

Die Arduino-IDE ist ab diesem Zeitpunkt um einen neuen Menüeintrag namens File | Examples | Examples from Custom Libraries | ConfigurableFirmata | ConfigurableFirmata reicher, mit dem sie eine Standardimplementierung der soeben heruntergeladenen Spezialversion von Firmata installieren. Während der Kompilation wirft die IDE einen Fehler der Bauart „Low memory available, stability problems may occur.“, der in der vorliegenden Situation aber ohne Relevanz ist.

Im nächsten Schritt starten Sie das Programm wie gewohnt – es liefert einen Datenstrom, der aufgrund der schnellen Arbeitsweise des Sensors das Terminal bald überfordert. Wer dem Chip einige Zeit lang bei der Arbeit zusieht, bemerkt, dass die Temperatur des Chips minimal ansteigt. Es handelt sich dabei um eine Besonderheit der Dallas-Semiconductor-Temperatursensoren: Sie neigen dazu, beim Konvertieren der Informationen Abwärme zu erzeugen, die Messergebnisse verfälscht. Zur Umgehung dieses Problems könnten Sie die Lesegeschwindigkeit reduzieren.

Fazit

Wer im Unternehmen viel mit JavaScript programmiert, hat mit Johnny Five seine helle Freude. Das Framework erlaubt das unbürokratische „Recyclen“ von serverseitigem Code, um auch mit Hardware zu interagieren. Ein sehr dankbares Beispiel hierfür wäre eine Kaffeemaschine: Ein Touchscreen würde ausreichen, um die als extrem schwierig zu bedienend geltende Gerätefamilie aufzuwerten.

Die Arbeit mit JavaScript ist allerdings nicht der allein seligmachende Weg. Mit etwas Einsatz kann man auch PHP dazu bringen, auf einem Prozessrechner zu leben. In einem der nächsten Hefte greifen wir uns einen Arduino Yun und wenden uns dieser Aufgabe zu – bis dahin wünschen wir Ihnen viel Freude bei der Programmierung.

PHP Magazin

Entwickler MagazinDieser Artikel ist im PHP Magazin erschienen. Das PHP Magazin deckt ein breites Spektrum an Themen ab, die für die erfolgreiche Webentwicklung unerlässlich sind.

Natürlich können Sie das PHP Magazin über den entwickler.kiosk auch digital im Browser oder auf Ihren Android- und iOS-Devices lesen. In unserem Shop ist das Entwickler Magazin ferner im Abonnement oder als Einzelheft erhältlich.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Hinterlasse einen Kommentar

Hinterlasse den ersten Kommentar!

avatar
400
  Subscribe  
Benachrichtige mich zu:
X
- Gib Deinen Standort ein -
- or -