Mikrocontroller für das IoT - Teil 1: Zu neuen Ufern!

Arduino Uno mit Eclipse programmieren – das Tutorial

Tam Hanna

©iStockphoto.com/mikdam

Massimo Banzi, Erfinder des ersten Arduino-Boards, hat die Welt der Elektronik weiterentwickelt. Der mit einem eigenwilligen Charakter ausgestattete Italiener erlöste Entwickler von der undankbaren Aufgabe des Designs von Hauptplatinen. Wer heute einen Arduino kauft, muss sich nicht mit Programmiergeräten und anderen lästigen Hardware-Fragen herumplagen. Die online zum kostenlosen Download bereitstehende Arduino IDE und ein USB-Kabel genügen für erste Schritte in die faszinierende Welt der Mikroelektronik. Wer ernsthaft mit Arduino arbeiten möchte, greift besser zu Eclipse.

Leider erweist sich die von Arduino bereitgestellte Entwicklungsumgebung bei größeren Projekten als Hemmnis. Die von Banzis Mannen in Eigenregie entwickelte IDE ist etwa im Bereich von IntelliSense nicht mit Eclipse vergleichbar: Wer produktiv mit der AVR-Controllerserie programmieren möchte, sollte sich über kurz oder lang nach einer anderen IDE umsehen.

Arduino Uno: Alles mit Eclipse

In den folgenden Schritten verbinden wir Eclipse mit einem Arduino Uno, der danach ein wenig malträtiert wird. Zudem gehen wir auf Methoden zur praktischen Fehlersuche ein. Als erste Amtshandlung sollten sie dennoch Version 1.5.6 der Arduino-IDE herunterladen und installieren. Das Produkt enthält Treiber und andere hilfreiche Elemente, die wir uns nicht von Hand auf die Station herunterladen möchten.

Weshalb Windows?

Die Arduino-IDE wird auch für Mac und Linux angeboten. Da die meisten Entwickler ihre Arbeit aber unter Windows ausführen, wollen wir uns hier an diesen Pattern orientieren.

Das seit dem Jahr 2013 nicht mehr weiterentwickelte AVR-Plug-in für Eclipse bekam vor einiger Zeit Konkurrenz. Besuchen Sie die Downloadseite des Arduino-Eclipse-Projekts und laden Sie das rund 150 MB umfassende Archiv herunter. Es enthält eine vollwertige Installation des Eclipse-CDT-Projekts und die für das Parsing von AVR-Code notwendigen Erweiterungen. Extrahieren Sie das in Form eines .tar.gz-Archivs ausgelieferte Produkt in einen Ordner Ihrer Wahl und führen Sie danach die Applikation Eclipse-Arduino-IDE.exe aus.

Wie in so vielen Fällen von Unix-zu-Windows-Portierungen dürfen die verwendeten Verzeichnisse auch hier keine Leerzeichen enthalten. Das gilt sowohl für das Installations- als auch für das Workspace-Verzeichnis. Achten sie zudem darauf, die Version 1.5.6 der Arduino-IDE herunterzuladen: In späteren Versionen haben Massimo Banzis Männer das Make-Werkzeug aus der Distribution entfernt, das für die Abarbeitung der in Arduino Eclipse enthaltenen Skripte zwingend erforderlich ist.

Vor dem Beginn der Entwicklung prüfen Sie die unter Window | Preferences | Arduino befindlichen Einstellungen. Achten Sie darauf, dass der Arduino-IDE-Path auf C:/Arduino zeigt: Der Installationsassistent findet ihn normalerweise nicht selbsttätig.

Lass’ es blinken!

Im nächsten Schritt beginnt die Erstellung eines neuen Projekts vom Typ Arduino Sketch. Benennen Sie es SUSSketch1 und klicken Sie auf Next, um den Generator anzuwerfen. Er fragt Sie nach Port und Board. Wenn Sie – wie der Autor dieser Zeilen – mit realer Hardware arbeiten wollen, so ist nun die Zeit gekommen, um Ihren Arduino mit Ihrem Computer zu verbinden. Im Feld „Board“ wählen Sie den Prozessrechnertyp aus (in unserem Fall UNO). Der für die Kommunikation zu verwendende COM-Port ist von Computer zu Computer unterschiedlich.

Die restlichen Einstellungen des Assistenten werden eins zu eins übernommen. Dieser Artikel geht nicht auf die Nutzung des physikalischen AVR-Debuggers ein, weshalb wir die für seine Verwendung vorgesehene Konfiguration nicht benötigen.

Nach Abarbeitung des Assistenten erscheint ein neues Projekt im Explorer. Es unterscheidet sich primär durch das Vorhandensein einer .ino-Datei, deren Inhalt so aussieht:

//The setup function is called once at startup of the sketch
void setup()
{
// Add your initialization code here
}

// The loop function is called in an endless loop
void loop()
{
//Add your repeated code here
}

Erfahrene Programmierer bemerken sofort, dass es sich hier um normalen C-Code handelt. .ino-Dateien sind – im Grunde genommen – normale C++-Files. Der Unterschied zwischen einer .ino-Datei und einer C-Datei liegt darin, dass die IDE beim Kompilieren alle .ino-Dateien zusammenfasst. Dies führt zu einem seltsamen Verhalten, wenn Sie die für die Konfiguration eines Headers benötigten Includes in die umgebenden Files platzieren. Die einzig richtige Methode zur #Define-Konfiguration eines Headers für .ino-Dateien besteht darin, die Defines direkt in der .h-Datei anzulegen.

Sonst sind Arduino-Programme vergleichsweise einfach aufgebaut: Nach dem Start des Prozessrechners wird die Funktion setup aufgerufen, die für die Konfiguration der angeschlossenen Hardware zuständig ist. Ab diesem Zeitpunkt ruft der immer auf dem Arduino befindliche Boot-Loader die Funktion loop in einer Endlosschleife auf: Die eigentliche Steuerungslogik sollte also an dieser Stelle sitzen.

Im Bereich der Arduino-Entwicklung hat sich die Nutzung eines Blink-Programms als Quasistandard etabliert: Die meisten Prozessrechner der Banzi-Entwurfsreihe werden mit einer Leuchtdiode ausgeliefert, die samt Vorwiderstand mit Pin Numero 13 verdrahtet ist. Zu ihrer Nutzung müssen wir das Programm folgendermaßen anpassen:

void setup()
{
  pinMode(13, OUTPUT);   
}

void loop()
{
  digitalWrite(13, HIGH);
  delay(1000);
  digitalWrite(13, LOW); 
  delay(1000); 
}

An dieser Stelle sind zwei Änderungen interessant. Im Setup sorgt der Aufruf von pinMode dafür, dass der Port des Microcontrollers in einen Ausgang umgewandelt wird. Moderne Microcontroller verfügen über GPIO-Pins: Der Begriff steht für General-Purpose-Input-Output. Ein GPIO-Pin kann sowohl als Eingang als auch als Ausgang agieren. Aus Gründen der Sicherheit werden die Pins nach dem Start normalerweise alle als hochohmige Eingänge deklariert – ein Zustand, den wir zwecks Beeinflussung der LED ändern müssen. Der in Loop befindliche Code schaltet die Leuchtdiode danach periodisch ein und aus, um ein Blinkverhalten zu erzeugen.

Für die eigentliche Programmausführung stellt Arduino Eclipse die zwei von der Arduino-IDE bekannten Werkzeuge zur Verfügung: Das Häkchen kompiliert das Programm, während der Pfeil es auf einen angeschlossenen Prozessrechner schickt. Achten Sie dabei darauf, dass Arduino-Eclipse-Projekte im Moment vor dem Deployment nicht automatisch kompiliert: Sie sollten sich angewöhnen, vor jedem Deployment auf das Häkchen zu klicken.

Die Auswahl des gerade verbundenen Prozessrechners lässt sich nach der Projekterstellung ändern: Klicken Sie die Projektmappe im Project Explorer rechts an und wählen Sie die Option Properties | Arduino.

Im Rahmen der ersten Kompilation können zwei Fehlerarten auftreten. Der erste ist eine nach dem Schema #error the file: SUSSketch1.ino is not found in the indexer though it exists on the file system aufgebaute Fehlermeldung. Dabei handelt es sich um eine Überprüfung der Konfiguration: Die Niederländer überprüfen im Rahmen der Kompilation eines Arduino-Projekts, ob .inoDateien auch wirklich in den Index von Eclipse aufgenommen werden. Ist dies nicht der Fall, so klicken Sie auf Window | Preferences | C/C++ | File types und deklarieren Sie die benötigten Files.

Diese auf den ersten Blick pedantisch wirkende Maßnahme ist wichtig: IntelliSense funktioniert nur dann, wenn .ino-Dateien Teil des C++-Baums sind. Der zweite Fehler ist ein klassischer Bug. Wenn die Kompilation eines leeren Sketches mit Verweisen auf die Redefinition von Setup und/oder Loop fehlschlägt, müssen Sie die Linienendzeichen anpassen. Arduino Eclipse funktioniert nämlich nur dann, wenn die Linienendzeichen auf UNIX-Standard basieren. Erfreulicherweise lässt sich dies durch die Menüoption File | Convert Line Delimeters To | Unix beheben.

Nach dem erfolgreichen Durchlauf der Kompilation können Sie unser Programm durch Klick auf den Pfeil in Richtung des Prozessrechners schieben, um sich der Resultate zu erfreuen.

Arduino Eclipse überprüft den Erfolg des Brennvorgangs im Moment nicht. Analysieren Sie die im Feld Output angezeigte Ausgabe von avrdude bei Problemen – das von AVR gewartete Programm wirft normalerweise leicht verständliche Fehlermeldungen.

AD/DA

Unser Arduino ist mit einem AD-Konverter ausgestattet: Es handelt sich dabei um ein Bauteil, das anliegende analoge Spannungen in digitale Signale umwandelt, mit denen der Prozessrechner nachher weiterrechnen kann.

Leider steht der umgekehrte Weg nicht offen: Wer analoge Signale aus einem Arduino ausgeben möchte, muss normalerweise auf externe Hardware zurückgreifen. Als „DA für Arme“ hat sich die Nutzung der Pulsbreitenmodulation etabliert. Es handelt sich dabei um ein vergleichsweise einfaches elektronisches Verfahren, in dem der Prozessrechner Wellenpakete ausgibt. Die „Stärke“ des Antriebs ist dabei von der Länge der Impulse abhängig: Will man beispielsweise 50 Prozent Fahrt, so ist die Spannung 50 Prozent der Zeit eingeschaltet und 50 Prozent der Zeit ausgeschaltet. Eine gegen Spannungs- oder Stromänderungen träge Last gleicht diese wie ein Integrator aus: Der Lohn der Mühen ist eine mehr oder weniger konstante Spannung.

PWM lässt sich bei ausreichend hoher Schaltfrequenz unter anderem zum Ansteuern von Lampen und Motoren verwenden: Wir wollen dies zur Realisierung eines kleinen Propellers nutzen, dessen Drehzahl durch zwei Knöpfe angepasst werden kann. Aus Gründen der Übersichtlichkeit wollen wir die Logik zudem in mehrere Unterteile aufteilen.

Die Motorsteuerungslogik befindet sich in einer eigenen Klasse. Da .ino-Dateien auf die Nutzung von funktionalem Code beschränkt sind, müssen Sie das Projekt im Project Explorer rechts anklicken und im erscheinenden Menü die Option New | Class wählen. Arbeiten Sie die restlichen Einstellungen dann wie gewohnt ab, um ein neues Klassenskelett zu erstellen. Der Korpus von MotorManager.h sieht wie in Listing 1 gezeigt aus.

 #ifndef MOTORMANAGER_H_
#define MOTORMANAGER_H_

class MotorManager {
  public:
  MotorManager(int whichPin);
  void goFaster();
  void goSlower();
  int myPin;
  int mySpeed;
};

#endif

Die eigentliche MotorManager-Klasse ist vom Aufbau her vergleichsweise primitiv (Listing 2).

 #include "MotorManager.h"
#include "Arduino.h"

MotorManager::MotorManager(int whichPin)
{
  //sanity check
  mySpeed=50;
  myPin=whichPin;

}

void MotorManager::goFaster()
{
  if(mySpeed<255)   {     mySpeed++;   }   analogWrite(myPin, mySpeed); } void MotorManager::goSlower() {   if(mySpeed>0)
  {
    mySpeed--;
  }
  analogWrite(myPin, mySpeed);
}

goFaster erhöht die Pulsbreite, während sie durch goSlower gesenkt wird. Der Aufruf von analogWrite konfiguriert alle notwendigen Register: Es ist nicht notwendig, den GPIO-Pin vorher als Ausgang zu deklarieren. Wesentlich wichtiger wäre die Prüfung des dem Konstruktor übergebenen Pins: Die PWM-Engine des AVR-Microcontrollers lässt sich nämlich nur mit manchen Pins verbinden. Wer eine ungültige Pin übergibt, wird vom System mit einem nicht funktionierenden PWM-Ausgang belohnt.

Damit können wir uns auch schon an die Realisierung des Hauptprogramms wagen (Listing 3).

 #include <Arduino.h>
#include "MotorManager.h"

MotorManager myMotE(12);
unsigned long myMillis=0;

void setup()
{
  pinMode(6,INPUT);
  pinMode(7,INPUT);
  myMillis=millis()+50;
}

void loop()
{
  if(millis()>myMillis)
  {//Updaten der Schalter
    if(digitalRead(6))
    {
      myMotE.goFaster();
    }
    if(digitalRead(7))
    {
      myMotE.goSlower();
    }
  }
}

Wir überprüfen den Zustand der Knöpfe einmal alle fünfzig Millisekunden: Ist einer der Knöpfe gedrückt, so passen wir den im PWM-Register gespeicherten Wert an die neue Situation an. Auf Hardwareseite ist die in Abbildung 1 gezeigte Schaltung erforderlich.

Abb. 1: Ein Leistungstransistor „bändigt“ das Ungetüm auch ohne Hilfe von Ferdinand Brandner

Abb. 1: Ein Leistungstransistor „bändigt“ das Ungetüm auch ohne Hilfe von Ferdinand Brandner

Unser vergleichsweise kleiner Motor mag im Gesamtgefüge der Welt nicht sonderlich bedeutend sein. Sein Strombedarf von zwischen siebzig und einigen hundert Milliampere reicht trotzdem mehr als aus, um den Ausgang des Arduino massiv zu überfordern. Aus diesem Grund schließen wir ihn über einen Transistor an: Es handelt sich dabei um eine Komponente, die aus einem vergleichsweise kleinen Eingangsstrom einen wesentlich größeren Ausgangsstrom macht. Da wir einen besonders stark verstärkenden Darlingtontransistor einsetzen, können wir den über die Basis-Emitter-Strecke fließenden Strom besonders knapp bemessen. Bei der Berechnung ist es hilfreich, den BE-Übergang wie eine normale Kleinsignaldiode mit einem Spannungsabfall von 0,7 Volt zu betrachten.

Die gegen den Laufsinn zeigende Diode dient als Freilauf. Sie ist aufgrund eines relativ komplexen elektrotechnischen Phänomens erforderlich, das auf den Namen „Kickback“ hört. Wir können dies hier aus Platzgründen nicht weiter besprechen. Informationen zum Thema finden Sie in einschlägiger Literatur.

Propeller herbei

Im nächsten Schritt wollen wir eine Rückkoppelung zwischen Drehzahl und Prozessrechner realisieren: Der Prozessrechner soll in Form einer klassischen Feedbackschleife die Drehzahl messen, um anhand dieser Informationen genauere Regelungen durchzuführen.

Die Realisierung der Drehzahlmessung kann auf mehrere Arten erfolgen: Da wir die Belastung unseres Motors nicht genau wissen und die Realisierung einer Strommessung aufwändig ist, greifen wir stattdessen auf einen klassischen optischen Encoder zurück. Es handelt sich dabei um eine Art Propeller, der regelmäßig durch eine Lichtschranke läuft (Abb. 2).

Abb. 2: Der – hier im Aufbau befindliche – Propeller besteht aus einem mit Papier beklebten Streifen einer Platine

Abb. 2: Der – hier im Aufbau befindliche – Propeller besteht aus einem mit Papier beklebten Streifen einer Platine

Der Zeitabstand zwischen dem Durchlaufen der einzelnen Schritte wird gemessen. Dies erlaubt die Ermittlung der Drehzahl anhand der in der Abbildung 3 gezeigten Formel. Da lichtabhängige Widerstände nicht universell verfügbar sind, nutzen wir stattdessen den Mims-Effekt. Dieses auf Forrest Mims zurückgehende Phänomen beschreibt ein paradoxes Verhalten von Leuchtdioden: Sie generieren eine (wenn auch kleine) Spannung, die von der Umgebungshelligkeit abhängig ist.

Abb. 3: Die Periode ermöglicht die Ermittlung der Drehzahl

Abb. 3: Die Periode ermöglicht die Ermittlung der Drehzahl

Da der Arduino die von der Diode emittierten Signale ob der geringen Amplitude und der hohen Impedanz nicht ohne Weiteres messen kann, schalten wir einen Operationsverstärker vor (Abb. 4). Er verstärkt die vergleichsweise kleine Spannung und erlaubt uns so die Realisierung eines Komparators: Sein Ausgang ist entweder High (also 5 Volt) oder Low (also 0 Volt).

Abb. 4: Zur Realisierung der MIMS-Messung ist etwas Zubehör notwendig

Abb. 4: Zur Realisierung der MIMS-Messung ist etwas Zubehör notwendig

Aus programmtechnischer Sicht sind diverse Änderungen erforderlich. Erstens legen die beiden Knöpfe fortan nicht mehr die PWM-Stufe, sondern die gewünschte Drehzahl fest. Die eigentliche Ermittlung der am Motormanager weiterzugebenden Werte erfolgt danach in der in Listing 4 zu sehenden Methode.

 
void loop()
{

  if(millis()>myMillis)
  {//Updaten der Schalter
    ...
  }
  if(myCurrentRPM<myIdealRPM)
  {
    myMotE.goFaster();
  }
  else
  {
    myMotE.goSlower();
  }
}

Zur Ermittlung der Drehzahl müssen wir die von der LED-OPV-Kombination generierte Pulsfolge auswerten. Dazu greifen wir auf ein als Interrupt bezeichnetes Feature des AVR-Microcontrollers zurück, das auch bei den meisten anderen Prozessrechnern analog implementiert ist.

Ein Interrupt ist – im Grunde genommen – ein spontanes Ereignis, das vom Prozessrechner sofort zu bearbeiten ist. Im Fall eines Reaktors wäre ein Interrupt beispielsweise das unberechtigte Betreten des Perimeters: Wenn ein Angreifer einzubrechen versucht, kann die Ausspeisung der Mitarbeiter für einige Minuten unterbrochen werden.

Im Fall unseres AVRs stehen zwei Kanäle zur Verfügung: Interruptkanal 0 inspiziert die an Pin 2 anliegenden Spannungen. Durch das Übergeben von Rising weisen wir den AVR darauf hin, dass er den mimsHandler() beim Auftreten einer Spannungsflanke (also eines Übergangs von 0 auf 5 V) aktivieren soll (Listing 5).

 void setup()
{
  pinMode(6,INPUT);
  pinMode(7,INPUT);
  myMillis=millis()+20;

  //Registrierung der MIMS-Diode
  pinMode(2,INPUT);
  myLastMimsTick=millis();
  attachInterrupt(0, mimsHandler, RISING); //Pin 2
  . . .
}

Die eigentliche Interrupt-Serviceroutine muss in Form einer parameterlosen void-Methode vorliegen. Im Fall unseres Beispiels berechnet sie die verstrichene Drehzahl anhand des von micros() zurückgegebenen Werts (Listing 6).

void mimsHandler()
{
  unsigned long myMimsDelta=micros()-myLastMimsTick;
  myCurrentRPM=1000000*((60)/(myMimsDelta))/2;

  digitalWrite(13,false);
  mCount++;
  myLastMimsTick=micros();
}

Wenn Sie das Programm in der vorliegenden Form ausführen, wird der Motor entweder stehen bleiben oder „wie verrückt herumeiern“. Die Frage lautet: weshalb?

Es prellt …

Die Suche von Fehlern in Software ist vergleichsweise einfach. Als Entwickler können Sie in den meisten Fällen davon ausgehen, dass sowohl Hardware als auch Betriebssystem einwandfrei funktionieren. Bei der Arbeit mit selbstentworfenen Prozessrechnerschaltungen ist dies nicht der Fall: Neben Softwarefehlern können auch Fehler in der Hardware auftreten. Zur Suche nach Problemen empfiehlt es sich, ein gut eingerichtetes elektronisches Labor zur Hand zu haben. Als erstes Messgerät wollen wir einen klassischen Digitalspeicheroszillografen verwenden. Es handelt sich dabei um ein Messgerät, das Spannungsverläufe nach der als Triggerung bezeichneten Auslösung aufzeichnet. Im ersten Schritt nutzen wir dieses Verfahren zur Prüfung, ob der Verstärker der Leuchtdiode problemlos funktioniert. Dazu bauen wir die später vom Propeller zu durchlaufende Strecke auf und schalten die LED ein und aus. Bei korrekter Einstellung des Oszillografen (Trigger: Single Shot, Rising Flank) sehen wir, wie die Spannung beim Öffnen des Übergangs (beim Aktivieren der Beleuchtung) ansteigt. Im Labor des Autors sah dies wie in Abbildung 5 gezeigt aus.

Abb. 5: Die Spannung springt nicht rapide von 0 auf 5 Volt: ein als Prellen bezeichnetes Phänomen

Abb. 5: Die Spannung springt nicht rapide von 0 auf 5 Volt: ein als Prellen bezeichnetes Phänomen

Da Speicheroszillografen auch in gebrauchtem Zustand vergleichsweise teuer sind, können wir als Alternative auch auf den seriellen Monitor zurückgreifen. Zwecks Einsparung von Rechenleistung wollen wir unseren Motormanager an dieser Stelle zudem um die rechenleistungsfressende Berechnung der Drehzahl erleichtern – die neue Version des Codes beginnt so:

 void setup()
{
  . . .
  Serial.begin(9600);
  myIdealDelta=14000;
}

Wer den seriellen Monitor mit einem Arduino befüllen möchte, muss dies durch Aufruf von Serial.begin() anmelden. Die nächste Änderung erfolgt im mimsHandler, der nun in zu kurzem Abstand eingehende Ereignisse verwirft und eine weitere Zählvariable inkrementiert (Listing 7).

 void mimsHandler()
{
  if((micros()-myLastMimsTick)<=1000)
  {//Optische Ungenauigkeit, Adios!
    mRCount++;
    return;
  }

  myMimsDelta=micros()-myLastMimsTick;
  mCount++;
  myLastMimsTick=micros();
}

In Loop folgt eine Gruppe von Aufrufen von Serial.print() – die Befehle schreiben die übergebenen Parameter über die serielle Verbindung an den Rechner (Listing 8).

void loop()
{

  if(millis()>myMillis)
  {//Updaten der Schalter
    . . .
    myMillis=millis()+100;
    if(myLastMCount==mCount)
    {
      Serial.println("Motor steht!");
      myMimsDelta=999999999;
    }
    myLastMCount=mCount;
    Serial.print("RPM Soll ");
    Serial.print(myIdealDelta);
    Serial.print("Delay ist ");
    Serial.print(myMimsDelta);
    Serial.print("MIMSzahl ");
    Serial.print(mCount);
    Serial.print("MIMSrej ");
    Serial.println(mRCount);
  }

Zur Entgegennahme bietet sich der in die Arduino-IDE integrierte serielle Monitor an – achten Sie nur darauf, ihn vor jedem Programmierprozess zu schließen. Die eigentliche Prüfung ist dann einfach: Trennen Sie die Verbindung zwischen Arduino und Transistorbasis, um die Ansteuerung des Motors zu stoppen. Richten Sie das Konvolut dann auf eine Lampe, und drehen Sie den Propeller von Hand.

Dank der Ausgabe der Werte für RPM, Delay, Mims-Zahl und Mims-Rejektion können Sie überschüssige Impulse ohne Aufwand orten. Zur Bekämpfung bietet sich – neben dem Anpassen der Einstellung des Potentiometers – auch die Veränderung der Ablehnungskonstante in der Interruptroutine an.

Ob des für unseren kleinen Motor relativ hohen Gewichts des Propellers gibt es zudem Probleme mit der Trägheit: Zu aggressives Regeln führt zu unruhigem Lauf. Neben der Einführung eines gleitenden Durchschnitts können Sie hier auch auf klassische Regelstrukturen aus der Welt der Regelungstechnik zurückgreifen (Stichwort PID-Regler). Leider gilt auch hier, dass eine komplette Besprechung den Rahmen des Artikels sprengen würde – weitere Informationen finden sich in der einschlägigen Literatur.

Verstärker sind böse

Das hier gezeigte Schwingen des Verstärkers ließe sich durch Einführung einer Hysterese drosseln. Beachten Sie, dass Operationsverstärkerschaltungen eine Wissenschaft für sich darstellen: Wenn Sie sich mit OPVs näher befassen möchten, so sollten Sie einige Tage Laborzeit einplanen.

Fehlerjagd, zur Dritten

Der Erwerb eines klassischen Oszillografen ist nicht immer zweckführend. Im Prozessrechnerwesen ist die – zweifelsohne höhere – Genauigkeit aus dem Hause Iwatsu nicht unbedingt notwendig.

Es ist in den meisten Fällen wichtiger, dass der Oszillograf die anliegenden Signale auswertet und eventuelle Protokolle direkt dekodiert. Dazu sind Logic Analyzer besonders geeignet. Die in China preiswerten Nachbauten des Salae Logic16 sind so billig, dass jeder Entwickler einen in der Schublade haben sollte. Zur Verdeutlichung der Vorteile wollen wir eine Applikation realisieren, die einen Sensor per I²C anspricht. Die auf dem Open-Drain-Prinzip basierende Verbindung erlaubt das Zusammenschalten von einigen Dutzend Sensoren, die über eine gemeinsame Daten- und Taktleitung kommunizieren.

Da wir uns für die genaue Ansteuerung des Sensors nicht weiter interessieren, nutzen wir die vom Hersteller entwickelte Wire-Bibliothek. Der Code für die Initialisierung sieht wie in Listing 9 gezeigt aus.

 #include <Wire.h>
void setup()
{
  Wire.begin(); 
}
void loop()
{
  Wire.beginTransmission(5);
  Wire.write("Hallo SUS!");    
  Wire.endTransmission(); 
  delay(500);
}

Die eigentliche Analyse erfolgt dann durch anschließende des Logic. Er dekodiert die I²C-Informationen bei korrekter Konfiguration direkt – man kann den ob des fehlenden Sensors scheiternden Übertragungsprozess wie in Abbildung 6 gezeigt ohne Aufwand erkennen.

Mit klassischen Oszillographen aufgewachsene Elektroniker sträuben sich normalerweise gegen die Anschaffung eines derartigen „Spielzeugs“. Es handelt sich aber dabei um einen Kauf, den man auf keinen Fall bereut.

Abb. 6: Manuelle Dekodierung ist nicht mehr notwendig

Abb. 6: Manuelle Dekodierung ist nicht mehr notwendig

Fazit

Arduino Eclipse unterscheidet sich von Eclipse-AVR dadurch, dass es die von Massimo Banzi bereitgestellte Arduino-Toolchain benutzt. Dies ist unter anderem deshalb vorteilhaft, weil man Code für den ARM-basierten Arduino-Due erzeugen kann, ohne dabei eine neue Toolchain zu benötigen. Klar ist: Wer einmal mit Eclipse gearbeitet hat, vermisst bei der Nutzung der Arduino-IDE die Komfortfunktionen der fortgeschrittenen Entwicklungsumgebung. Die Erzeugung von Klassen ist unter Eclipse wesentlich einfacher: Wenn Sie den Arduino semiprofessionell einsetzen, sollten Sie den Aufwand für die Installation des Plug-ins auf keinen Fall scheuen.

Im Bereich des Debuggings kommt es darauf an, was Sie in Ihrem Unternehmen erreichen möchten. Bei sporadischer Nutzung genügt ein Logic 16 normalerweise voll und ganz: Die offiziellen Versionen des Analysators taugen sogar als kleiner Oszilloskop-Ersatz, da sie auch einen oder sogar zwei analoge Kanäle bieten.

Über den Erwerb von AVR ICE und/oder Oszilloskop müssen Sie von Fall zu Fall entscheiden: Da brauchbare Geräte aus China bereits bei 300 Euro beginnen, sollten Sie sich ein Oszilloskop spätestens dann gönnen, wenn Sie es sich ein paarmal wünschen. Teure Geräte sind für den Hausgebrauch Overkill: Wer ein Iwatsu- oder Teledyne-Oszilloskop ausnutzen kann, hat sich beim Lesen dieses Artikels sicher bereits gelangweilt.

Geschrieben von
Tam Hanna
Tam Hanna
Tam Hanna befasst sich seit der Zeit des Palm IIIc mit der Programmierung und Anwendung von Handcomputern. Er entwickelt Programme für diverse Plattformen, betreibt Onlinenewsdienste zum Thema und steht unter tamhan@tamoggemon.com für Fragen, Trainings und Vorträge gern zur Verfügung.
Kommentare

1
Hinterlasse einen Kommentar

avatar
4000
1 Kommentar Themen
0 Themen Antworten
0 Follower
 
Kommentar, auf das am meisten reagiert wurde
Beliebtestes Kommentar Thema
1 Kommentatoren
Martin Kurth Letzte Kommentartoren
  Subscribe  
Benachrichtige mich zu:
Martin Kurth
Gast
Martin Kurth

Bei einem Darlington Transistor sind BE 2 PN Übergänge. Die Verstärkung beider Einzeltransistoren multiplizieren sich. Also etwa 1.2V – 1.4V.