Massimo Banzis Arduino-Plattform verdankt ihren Erfolg – unter anderem – der Tatsache, dass sie in Form von fertigen Platinen vertrieben wird. Wer einen Arduino kauft, bekommt ein fertiges Computerchen. Eine komfortable Software erlaubt die Programmierung ohne Assemblerkenntnisse, dank der flexiblen Erweiterungsmöglichkeiten wartet diverse Peripherie auf ihren neuen Meister. Trotz dieser an sich eher antiintellektuellen Ausrichtung ist das Steuerungssystem geradezu ideal für erste Schritte in die Welt der Mikroelektronik geeignet. In diesem Artikel werden wir den Arduino zur Realisierung einiger elementarer Schaltungen nutzen, die Ihnen wertvolles Grundlagenwissen verschaffen. Die hier vorgestellten Experimente lassen sich normalerweise ohne Löten realisieren. Wer eine Steckplatine, zwanzig oder dreißig Drähte und eine primitive Stromversorgung sein Eigen nennt, kann die Versuche ohne größeren Aufwand nachvollziehen. Der Text ist allerdings auch für reine Theoretiker geeignet, die die Abläufe durchdenken.

Die Qual der Wahl

Aufgrund des enormen Erfolgs der Plattform gibt es mittlerweile ein gutes Dutzend verschiedener Arduino-Platinen. Wer die Angebote der diversen Dritthersteller dazurechnet, darf sich mit einer Hundertschaft herumschlagen. In den folgenden Schritten werden wir mit dem Arduino Uno arbeiten. Dabei handelt es sich um den Arduino schlechthin: Er ist zwar nicht besonders leistungsfähig, genießt aber aufgrund seiner geringen Kosten und der weiten Verbreitung absoluten Kultstatus. Es ist relativ egal, ob Sie einen R3 oder einen „normalen“ Uno erwerben – wichtig ist nur, dass der Prozessor nicht in einem SMD-Gehäuse sitzt.

Erste Schritte

Die Verwendung des Arduinos setzt auf Seiten des Programmiersystems eine passende Version der Arduino-IDE voraus. Die unter http://arduino.cc/en/main/software zum Download angebotene Software gibt es mittlerweile in mehreren Varianten – für den Arduino Uno verwenden Sie bitte die Version Arduino 1.0.5. Nutzer von Windows 8.1 dürfen die Datei ebenfalls „direkt“ herunterladen, da der Downloadlink auf die aktualisierte Version r2 verweist. Über die Installation gibt es an dieser Stelle nicht viel zu berichten – die Sicherheitsmeldung bezüglich des unsignierten Treibers muss natürlich quittiert werden. Informatiker beginnen die Arbeit mit einer neuen Programmiersprache durch das Ausgeben von Hello World. Im Bereich der Elektronik hat sich das Blinkenlassen einer LED als Äquivalent dafür etabliert, weshalb wir unseren Arduino dafür einspannen wollen. Da wir im Moment ohne Pulsbreitenmodulation arbeiten, müssen wir das Blinken komplett in Software realisieren. Vorher wollen wir jedoch noch einen kurzen Blick auf Leuchtdioden werfen: Die weit verbreiteten Komponenten bieten die Gelegenheit zur Erklärung einiger Grundlagen.

Ohm und Co.

Der Name Leuchtdiode weist darauf hin, dass Sie es hier mit einer Abart einer normalen Diode zu tun haben. Abbildung 1 zeigt eine handelsübliche LED neben einer „weit entfernten“ Verwandten namens Kleinsignaldiode.

Abb. 1: Eine rote LED und eine „normale“ Diode in Großaufnahme

Beide Bauelemente haben je zwei Pins, die – wie in Abbildung 2 gezeigt – als Anode und Kathode bezeichnet werden. Das Verhalten einer Diode ist einfach: Wenn die an der Anode anliegende Spannung höher ist als die der Kathode, so schaltet das Bauteil auf „Durchzug“. Wenn die umgekehrte Situation vorliegt, lässt die Diode keinen Strom durch, der Elektroniker spricht in diesem Fall von Sperrung.

Abb. 2:: Pro Diode sind – normalerweise – zwei Anschlüsse erforderlich

Leuchtdioden haben die angenehme Eigenschaft, bei Stromdurchfluss aufzuleuchten. Dazu ist – je nach Farbe der Diode – mehr oder weniger Spannung erforderlich, die „an der Diode“ abfällt. Als Näherungswert für alle Farben hat sich im Unternehmen des Autors 1,8 Volt etabliert, bei spezielleren Leuchtdioden ist die Konsultation des Datenblatts ratsam. Dioden sind vergleichsweise dumm: Wenn mehr Spannung an ihnen anliegt, erhöhen Sie ihren Durchflussstrom. Dadurch kommt es, je nach Stärke des Stroms, über kurz oder lang zur Zerstörung des Bauelements. Zur Behebung dieses Problems bietet sich die Verwendung eines ohmschen Widerstands an. Dabei handelt es sich um ein Bauteil, dessen Stromspannungsverhalten von der in Abbildung 3 gezeigten Formel abhängig ist.

Abb. 3: Das ohmsche Gesetz gilt als eine der Grundformeln der Elektrotechnik

Mit diesen Informationen können wir uns an die Realisierung der Schaltung wagen. An unserer Diode fällt 1,8 Volt ab, als Rest verbleibt bei 5 Volt Versorgungsspannung somit 3,2 Volt. Unsere Leuchtdiode soll mit einem Strom von 10 mA arbeiten, womit sich ein rechnerischer Widerstandswert von 320 ergibt. Da Dioden erfreulicherweise sehr flexibel sind, griff der Autor ohne Probleme zu einem Widerstand von 300 Ohm. Als Endresultat erhalten wir somit die in Abbildung 4 gezeigte Schaltung. Die Leuchtdiode wird im Moment aus dem Arduino heraus „mitversorgt“. Da die Pins des Microcontrollers bis zu 50 mA liefern können, ist die Versorgung einer einzelnen LED kein besonderes Problem.

Abb. 4: Die LED bezieht ihre Energie direkt aus dem Arduino

Auf Softwareseite ist der Sketch aus Listing 1 erforderlich.

void setup() 
{
  pinMode(8, OUTPUT);
}
 
void loop() 
{
  delay(500);
  digitalWrite(8, HIGH);
  delay(500);
  digitalWrite(8, LOW); 
}

Sketches bestehen aus mindestens zwei Routinen. Setup ist für die Initialisierung des Systems zuständig, während die eigentliche Regelintelligenz in loop() untergebracht ist. Das Betriebssystem des Arduinos ruft die Methode in einer Endlosschleife auf – dazwischen werden einige Housekeeping-Aktivitäten erledigt. Wir schließen unsere LED an einen der Digital-Pins an. Dabei handelt es sich um so genannte GPIOs, deren Verwendungsart vorher durch Aufruf von pinMode festgelegt werden muss. Loop wechselt den Zustand des Pins periodisch, und legt aus visuellen Gründen eine kleine Pause zwischen den Schaltvorgängen ein.

Von C zu Assembler

Massimo Banzi setzt im Arduino nicht ohne Grund auf Prozessoren aus der AVR-Serie – Atmel hat beim Entwurf der Architektur extremen Wert auf Hochsprachenfreundlichkeit gelegt. Eines der „Nebenprodukte“ davon ist die Verfügbarkeit eines exzellenten und quelloffenen C-Compilers, der im Hintergrund der Sketches agiert. Die IDE bietet zwei Knöpfe an. Das Anklicken des Häkchens startet eine Kompilation, die das Programm auf Fehler untersucht. Mit dem Pfeil können Sie das Programm zur Ausführung auf angeschlossener Hardware freigeben.

Einlesen und Mehr

Die in der Rubrik „Digital“ zusammengefassten Pins werden nicht umsonst als GPIO bezeichnet. Der Begriff bedeutet soviel wie General Purpose Input Output. Die Verwendung dieses Teils des Arduinos lässt sich am Einfachsten durch das Einlesen der von einem Taster angelieferten Werte demonstrieren. Dazu müssen wir unsere Messschaltung ein wenig erweitern. Die „vulgo“ als Taster bezeichneten Knöpfe haben – sofern Sie einen der handelsüblichen Schließer erwerben – die angenehme Eigenschaft, den Stromkreis nur bei Druck zu schließen. In diesem Fall ist der Widerstand des Tasters „fast null“, der Strom kann ungehindert fließen. Dieser Zusammenhang ist in Abbildung 5 illustriert.

Abb. 5: Der Taster ist an einen GPIO-Pin des Arduinos angeschlossen

Damit sind wir bei der Frage der Spannungsteiler angelangt. Zwei hintereinander (also in Serie) geschaltete Widerstände teilen die anliegende Gesamtspannung gemäß dem in Abbildung 6 gezeigten Schema auf.

Abb. 6: Mehrere in Serie geschaltete Widerstände ergeben – im unbelasteten Zustand – einen Spannungsteiler

Beim Design von Peripherie für Digitalrechner ist es, sofern es sich nicht um sehr alte Geräte oder um Applikationen mit extremen Genauigkeitsanforderungen handelt, zulässig, den Eingang des Prozessors als extrem hochohmig anzusehen. Damit erhalten wir die beiden in Abbildung 7 gezeigten Schaltzustände.

Abb. 7: Die Potenziale verändern sich je nach Schalterzustand

Die auf Softwareseite erforderlichen Änderungen beginnen mit dem Setzen der korrekten Arbeitsmodi für die beiden GPIO-Pins (Listing 2).

void setup() 
{
  pinMode(7, INPUT);
  pinMode(8, OUTPUT);
}

Die Loop-Methode ist für die Verarbeitung der Daten zuständig. Die digitalRead-Methode liefert den am jeweiligen Pin anliegenden Wert zurück, er wird direkt in die Leuchtdiode geschrieben. Die Inversion ist notwendig, da der Pin bei unserem Stromlaufplan bei gedrücktem Schalter auf Masse liegt (Listing 3).

void loop() 
{
  int val=digitalRead(7);
  if(val==0)
  {
    digitalWrite(8, HIGH);
  }
  else
  {
    digitalWrite(8, LOW); 
  }
}

Eine Frage der Entropie

In CMOS-Technik realisierte Chips haben die unangenehme Eigenschaft, auf atmosphärische Störungen sehr empfindlich zu reagieren. Für Sie bedeutet dies, dass ein „mit nichts“ verbundener Pin einen zufälligen (und sich unter Umständen regelmäßig verändernden) Wert annehmen kann. Dieser Zustand tritt bevorzugt bei kleinen Schaltungsfehlern ein.

Pulsbreitenmodulation

Leuchtdioden wurden von Anfang an in Rot, Grün und Gelb angeboten. Die Entwicklung ihrer blauen Leidensgenossen ist ein Kapitel für sich, das der Autor an dieser Stelle aus Platzgründen nicht näher erörtern möchte. Für uns genügt die Feststellung, dass Leuchtdioden mittlerweile in allen drei für die additive Farbmischung erforderlichen Komponenten verfügbar sind. Daraus folgt, dass wir das Verhalten handelsüblicher Computerbildschirme „im Kleinen“ nachbilden können, wenn wir über drei passende Dioden verfügen. Der Handel begegnet dieser Fragestellung durch das Anbieten von RGB-LEDs. Dabei handelt es sich um fertige Module, die je nach Bauart drei oder mehr Dioden vereinen. Je nach Hersteller ist die genaue Beschaltung unterschiedlich. Wir verwenden im folgenden Beispiel eine Diode, deren Struktur der in Abbildung 8 gezeigten entspricht.

Abb. 8: Unsere Diode hat eine gemeinsame AnodeSchalterzustand

Die Helligkeit von Leuchtdioden ist per se eine Funktion der darin abfallenden Leistung. Da unser Arduino an seinen GPIO-Pins nur 0 oder 5 Volt ausgeben kann, müssen wir die Leistung durch ein als Pulsbreitenmodulation bezeichnetes Verfahren adjustieren. Dahinter steht eine vergleichsweise einfache Idee. Die meisten Bauelemente haben eine gewisse „Kapazität“, die sie sich wie eine Art Speicher vorstellen müssen. Als Analogie aus dem realen Leben wollen wir hier ein verschlossenes Waschbecken annehmen. Wenn sie den Zulauf die gesamte Zeit geöffnet lassen, so füllt sich das Becken in der Zeit t. Wenn Sie den Zulauf jedoch abwechselnd ein und ausschalten, so ist die Füllrate vom Verhältnis der Ein- und Ausschaltzeiten abhängig. Im Bereich der Elektronik erfolgt dies (normalerweise) durch das gepulste Ein- und Ausschalten der Spannung, womit Signale nach dem in Abbildung 9 gezeigten Schema entstehen.

Abb. 9: Das Verhältnis der Ein- und Ausschaltzeit wird als Pulsbreite bezeichnet

In der Anfangszeit der Mikroelektronik wurde Pulsbreitenmodulation normalerweise von Hand realisiert. Mittlerweile sind die meisten CPUs mit einem oder mehreren PWM-Subsystemen ausgestattet, die die Realisierung von PWM-Wellenformen in Hardware erlauben. Die Generierung erfolgt dabei durch einen speziellen Schaltkreis, der nach der Parametrierung keine weitere Aufmerksamkeit benötigt. Da unsere LED – wie weiter oben beschrieben – eine gemeinsame Anode aufweist, ergibt sich in der in Abbildung 10 gezeigten Beschaltung eine kleine Besonderheit.

Abb. 10: Die RGB-LED ist mit dem Arduino verbunden

Auf Softwareseite beginnen wir mit der Einrichtung der Pins. Ein für PWM vorgesehener Pin ist im Rahmen der Initialisierung als Ausgang zu deklarieren (Listing 4).

int pwmFreq;
void setup() 
{
  pwmFreq=255;
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
}

Die eigentliche Parametrierung der Ausgabefrequenz erfolgt durch Aufruf von analogWrite. Die Funktion nimmt einen Wert von 0 bis 255 entgegen, der die Tastrate am Ausgangssignal angibt. 0 steht hierbei für „permanent aus“, während 255 für „permanent ein“ steht (Listing 5).

void loop() 
{
  pwmFreq-=10;
  if(pwmFreq<=0)pwmFreq=255;
  analogWrite(3, pwmFreq);
  analogWrite(5, pwmFreq);
  analogWrite(6, pwmFreq);
  delay(50);
}

Wenn Sie dieses Programm ausführen, so wird sich die Helligkeit der LED „pulsierend“ verändern. Ein angeschlossenes Oszilloskop würde das in Abbildung 11 gezeigte Bild liefern.

Er springt!

RGB-Leuchtdioden sind nur dann wirklich reizvoll, wenn sie ihre Farbe dynamisch einstellen. Dazu genügt es, den Strom durch die einzelnen Teile der Diode zu verändern: Wenn die grüne Diode aus ist, erscheint als Summe von „voll rot“ und „voll blau“ ein sattes Pink. Wir wollen an dieser Stelle auf ein neues Bauteil zurückgreifen. Das in Abbildung 12 gezeigte Potentiometer ist ein variabler Widerstand, der sich – anders als ein klassischer Rheostat – auch als Spannungseinsteller für Verbraucher mit minimaler Stromaufnahme einsetzen lässt.

Abb. 12: Potentiometer sehen unbeeindruckend aus

Der am Potentiometer aufgedruckte Wert liegt als „Widerstandsbahn“ zwischen den Pins 1 und 3. Der zwischen 1 und 2 anliegende Widerstand lässt sich durch Drehen des Reglers einstellen. Wir schließen unser Potentiometer wie in Abbildung 13 gezeigt an einen der Analogeingänge des Arduinos an. Dadurch entsteht ein variabler Spannungsteiler, der den Ausgang an verschieden hohe Spannungen anlegt.

Abb. 13: Unser Potentiometer versorgt den Analogeingang mit variabler Spannung

Da Potentiometer vergleichsweise groß sind, wollen wir mit einem solchen Bauteil auskommen. Als „zweite Komponente“ verwenden wir einen Taster, der die Auswahl des zu beeinflussenden Farbkanals erlaubt. Auf Softwareseite ruft dies nach einem Zustandsautomaten. Dabei handelt es sich um ein Programm, das sein gesamtes Leben in einer Gruppe von Zuständen verbringt. Ein Gebersignal animiert den Code zum Wechsel des Betriebsmodus. Abbildung 14 gibt einen groben Überblick über die dahinterstehende Theorie.

Abb. 14: Wenn der Taster gedrückt wird, ändert sich der Zustand des Programms

Leider sind wir damit noch nicht am Ziel. Preiswerte Taster haben die unangenehme Eigenschaft, kein „sauberes“ Signal zu liefern – das in Abbildung 15 gezeigte Oszillogramm kommt von einem vergleichsweise teuren Knopf.

Abb. 15: Trotz des hohen Preises springt das Eingangssignal „ein wenig“, bevor es den neuen Wert annimmt

Dieses als Taster- bzw. Schalterprellen bezeichnete Phänomen ist in höchstem Maße ärgerlich, da es aufgrund der schnellen Abtastrate Eingaben „multiplizieren“ kann. Die früher geläufige Entprellung durch das Paralellschalten eines Kondensators ist mittlerweile außer Mode gekommen – heutige Elektroniker arbeiten mit diversen Programmroutinen (Stichwort gleitender Durchschnitt).

Entprellung digital

Nach diesen einführenden Überlegungen können wir uns an die Realisierung der Software wenden. Sie ist im Großen und Ganzen am im vorherigen Beispiel verwendeten Sketch angelehnt (Listing 6).

int rFreq, gFreq, bFreq;
int counter;
int colorChan;

Die Set-up-Routine stellt die Pin-Modi ein und legt außerdem die Ausgangszustände für den Zustandsautomaten und für die drei Frequenzkanäle fest (Listing 7).

void setup() 
{
  counter=0;
  colorChan=0;
  rFreq=bFreq=gFreq=255;
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(8, INPUT);
}

In der Loop-Methode ist analogRead() interessant. Die Funktion liefert die am jeweiligen Pin anliegende Spannung zurück. Wichtig ist, dass der retournierte Wert stets im Bereich von 0 bis 1024 liegt. Dies liegt daran, dass ein Analog-Digital-Wandler normalerweise „spannungsagnostisch“ arbeitet: Er teilt seine Referenzspannung in x gleiche Schlitze auf und gibt die anliegende Spannung als „Anteile von Referenz“ zurück (Listing 8).

void loop() 
{
  // Taster entprellen
  if(digitalRead(8)==HIGH && counter==0)
  {
    counter=50;
    colorChan++;
    if(colorChan>2)colorChan=0;
  }
  if(counter>0)counter--;
  
  // Modifiziere Variable
  switch(colorChan)
  {
    case 0:
      rFreq=analogRead(0)/4;
      break;
    case 1:
      gFreq=analogRead(0)/4;
      break;
    case 2:
      bFreq=analogRead(0)/4;
      break;
  }
  
  // Aktualisiere PWM
  analogWrite(3, rFreq);
  analogWrite(5, gFreq);
  analogWrite(6, bFreq);
  delay(30);
}

Multiplexe mich

Unser Arduino bringt von Haus aus dreizehn GPIO-Pins mit. Leider gibt es immer wieder Anwendungsfälle, in denen Sie mit dieser Anzahl nicht auskommen. In dieser Situation sind so genannte Schieberegister das Mittel der Wahl: Sie sind eine Art „Eimerkette“, die sich nacheinander mit Daten versorgen lassen. Im Laufe der letzten Jahre haben sich zwei Bauteile als Quasistandard etabliert. Wir verwenden in den folgenden Schritten ein CD4094. Die Nutzung eines 74HC595 unterscheidet sich aus softwaretechnischer Sicht nur minimal.

Abb. 16: Ein Schieberegister besteht aus mehreren hintereinander geschalteten „Eimern“

Die Grundidee des in Abbildung 16 schematisch dargestellten Schieberegisters ist einfach. Jeder Übergang von 0 auf 1 – der Elektroniker spricht von einer Flanke – führt dazu, dass jedes „Eimerchen“ seinen Inhalt an das nächste Eimerchen weiterwirft. Um die an die Ausgänge angeschlossenen Empfänger durch dieses Weiterreichen nicht zu verwirren, ist ein Pufferspeicher dazwischengeschaltet. Er schreibt die in den Eimern befindlichen Informationen nur dann an die Ausgänge, wenn der für ihn zuständige Eingang mit einer Flanke versehen wird.

Mit diesem Wissen können wir uns an die Realisierung der Ausgabe heranwagen. Als Anzeigeglieder dienen diesmal acht Leuchtdioden, die an das in Abbildung 17 gezeigte Schieberegister-IC angeschlossen sind.

Abb. 17: Das Schieberegister hängt direkt am Arduino

Aus didaktischen Gründen wollen wir das (einfache) Protokoll nicht „direkt“ realisieren. Die Taktgenerierung soll diesmal von einem als Timer bezeichneten Baustein übernommen werden, der in regelmäßigen Abständen so genannte Interrupts sendet. Diese lassen sich – bei kreativer Programmierung – als eine Art Multi-Threading-Ersatz nutzen. Microcontroller brechen die Codeausführung beim Eintreffen eines Interrupts ab und arbeiten stattdessen in der Interruptroutine weiter. Wenn diese erledigt ist, folgt ein Sprung zurück an den „Arbeitspunkt“. Da wir uns in diesem Artikel nicht mit der Programmierung in Assembler beschäftigen, genügt diese Beschreibung fürs Erste. Zur Nutzung des Gebers ist eine unter http://playground.arduino.cc/Code/Timer1 erhältliche Bibliothek erforderlich. Laden Sie das zip-Archiv herunter, und entpacken Sie es in den Ordner Arduino/hardware/libraries/Timer1/. Die IDE erkennt neue Bibliotheken erst nach einem kompletten Neustart, weshalb Sie alle Fenster schließen sollten. Nach dem nächsten Start wird Timer1 in der unter Sketch → Library befindlichen Bibliotheksliste erscheinen. Danach können Sie die Software gemäß folgendem Schema realisieren (Listing 9).

#include "TimerOne.h"
#define sclockPin 1
// dataPin is owned by system
#define sdataPin 2
#define sstrobePin 3
 
byte datenwort;
bool mussSenken;
byte sendeGerade;

Arduino reserviert die Werte clockPin und dataPin für den internen Gebrauch. Das Neudefinieren dieser Pins führt zu seltsamen Compilerfehlern, weshalb wir unsere Konstanten mit einem s präfixen. Die erste Amtshandlung der setup-Routine besteht darin, den Timer mit einem Ticktakt zu versorgen. Der Wert 1 000 000 steht hierbei für einen Tick pro Sekunde, wir wollen derer 2 000. Mittels attachInterrupt teilen wir dem Betriebssystem mit, welche Methode für die Abarbeitung des Timerereignisses zuständig ist (Listing 10).

void setup() 
{
  Timer1.initialize(500); // 2 KhZ Arbeitstakt
  Timer1.attachInterrupt(intSr);
  sendeGerade=0;
  mussSenken=0;
  datenwort=B01010101;
  
  pinMode(sclockPin, OUTPUT);
  pinMode(sdataPin, OUTPUT);
  pinMode(sstrobePin, OUTPUT);
}

Interrupt Handler dürfen im Großen und Ganzen alle Systemfunktionen ausnutzen. Wichtig ist, dass sie nicht allzu komplex ausfallen. Das liegt daran, dass eine zu lange Interruptroutine mitunter zu einem IRQ-Stau führt, in dem der Prozessor gar nicht mehr zur Abarbeitung des Hauptprogramms kommt. Wir unterteilen unsere Interruptroutine in insgesamt sechzehn Schritte. Die „ungeraden“ Schritte sind für das Herausschreiben der einzelnen Datenbits zuständig, während wir bei einem „geraden“ Schritt die Taktleitung auf 0 ziehen und das Schieberegister so für das nächste Datenwort vorbereiten. Nach dem Schreiben eines Worts müssen wir strobe für einen Zyklus hochziehen, um die im Eimerspeicher befindlichen Informationen an die Ausgänge zu schieben (Listing 11).

void intSr()
{
  digitalWrite(sstrobePin, LOW);
  if(mussSenken==1)
  {
    if(sendeGerade==7)
    {// Strobe senden, resetten
      digitalWrite(sstrobePin, HIGH);
      sendeGerade=0;
    }
    digitalWrite(sclockPin, LOW);
    mussSenken=0;
  }
  else
  {// Sende Nutzdaten
    digitalWrite(sclockPin, HIGH);
    mussSenken=1;  
    // Ermittle Daten
    byte mySendBit=datenwort&(1<<sendeGerade);
    if(mySendBit==0)
      digitalWrite(sdataPin, LOW);
    else
      digitalWrite(sdataPin, HIGH);
    
    sendeGerade++;
  }
}

In einer realen Anwendung würden Sie die herauszuschreibenden Werte in der loop()-Methode aktualisieren. Auf Wunsch kann die Abarbeitung des Interrupts unterbrochen werden, wenn gerade keine Änderungen der im Schieberegister befindlichen Werte notwendig sind:

void loop() 
{
  
}

Damit ist unser Programm fürs Erste einsatzbereit. Bei logischer Analyse der Software stellen Sie mitunter fest, dass die per Schieberegister angebundenen Ein- bzw. Ausgänge mit den GPIOs performancemäßig nicht mithalten können. Auch bei einer (durchaus möglichen) Erhöhung des Arbeitstakts kommen Sie keinesfalls auf die Geschwindigkeit, die ein einzelner GPIO-Pin erreicht. Hierbei handelt es sich um einen klassischen Flaschenhals. Derartige Probleme treten immer dann auf, wenn die vom Chiphersteller vorgesehenen Ressourcen aus irgendeinem Grund nicht ausreichen. Erfreulicherweise stellen Flaschenhälse in der Praxis eher selten ein Problem dar: Wenn Sie mit dem Schieberegister beispielsweise Relais (über einen Transistor!!!) ansteuern, sorgt die enorme Langsamkeit der Peripherie dafür, dass Ihnen die Arbeitsgeschwindigkeit ihres Bussystems geradezu rekordverdächtig erscheint.

Mehr lernen

Es ist unmöglich, alle für Elektroniker interessanten Grundlagen in einen einzigen Artikel zu verpacken. Nach der Lektüre dieses Texts stehen Sie mit Sicherheit besser da, sind aber noch weit vom Expertengrad entfernt. Aufgrund des Niedergangs der Hobbyelektronik ist es heute schwer, ein zeitgeistiges und aktuelles Lehrbuch zu finden. Die bei Elektor erschienene Serie „Elektronik gar nicht schwer“ ist für Einsteiger durchaus brauchbar, leider sind viele der Bauteile veraltet und dementsprechend teuer (74-Logikbausteine lassen sich durch billigere 74HC- oder 74HCT-Elemente ersetzen). Leider gehen Sie überhaupt nicht auf die Berechnung von Schaltkreisen unter Nutzung komplexer Zahlen ein. Im Bereich der Rüstungselektronik gilt „The Art of Electronics“ von Paul Horowitz und Winfield Hill als Standardwerk. Das sehr schwere und dementsprechend teure englischsprachige Buch wurde seit über zehn Jahren nicht mehr aktualisiert, die verwendeten Bauteile sind dementsprechend veraltet. Trotzdem lohnt sich ein Blick – auf alibris.com ist das aufgrund seines Umfangs und hohen fachlichen Niveaus schwierig zu lesende Buch immer wieder mal preiswert zu bekommen.

Fazit

Elektronikbasteln ist ein faszinierendes und lehrreiches Hobby: Die Möglichkeiten reichen vom selbstgebauten Funkmodul für die Kaffeemaschine über die Reparatur eines Geräts bis hin zur Konstruktion von diversen Rüstungsgütern. Die Lebenserfahrung des Autors lehrt, dass die Anzahl der Fehlschläge direkt mit dem angesammelten Wissen korreliert. Schon allein aus diesem Grund sollten Sie sich vom sprichwörtlichen Iwan Lokomofeilow beeinflussen lassen: Eine Lösung muss nicht perfekt sein, sondern muss funktionieren. Kleinere Ungenauigkeiten oder Unsauberkeiten sind, solange Sie nicht mit Netzspannung oder teurem Equipment arbeiten, meist völlig unproblematisch. Zu guter Letzt sei noch darauf hingewiesen, dass die Güte der Beziehung zum Bauteillieferanten von eminentester Bedeutung für die Arbeit des Elektronikers ist. Der Autor dieser Zeilen bezieht seine Komponenten seit Jahren bei rlx. Die manchmal etwas höheren Handelsaufschläge werden durch Kundenservice und Beratung mehr als aufgewogen.

Aufmacherbild: Internet of Things Highway Signpost with wording on Sky Background. von Shutterstock / Urheberrecht: Tashatuvango