Für warme Momente: der Teemann

Der Teemann

Es war in der Vorweihnachtszeit. Draußen ist es nass und kalt und zum Aufwärmen trinke ich öfter mal einen Tee. Tee bin ich nicht gewohnt, weshalb ich gut auf die Zeit des Ziehens achte. Zieht der Tee nämlich zu lange, bringt er mich zum einschlafen. Ich habe mich dabei an denn Teehasen “Teeodohr” erinnert. Das war mal ein Projekt aus der Zeitschrift Make, in dem ein 3D-gedruckter Hase mit seinem Ohr den Teebeutel nach bestimmter Zeit aus der Tasse zieht. Nach langer Pause war das eine schöne Idee für ein eigenes kleines Projekt. Nur gab es einige Tücken. Ich besitze keinen 3D-Drucker und bin auch nicht erfahren mit der Laubsäge. Überhaupt passt ein Hase nicht recht in die Vorweihnachtszeit. Wenn es auch im Rheinland eher selten schneit, so ist es mehr die Jahreszeit für einen Schneemann. Das ist es, ich baue einen Teemann!

Die Technik

Das Rad brauchte ich nicht neu erfinden. Die Make hat bereits vorgearbeitet: Ein Servomotor senkt und hebt den Teebeutel. Zwei Tasten ermöglichen die Bedienung, wobei der eine Taster die Zieh-Zeit auswählt und der zweite den Vorgang startet oder auch vorzeitig unterbricht. Zudem sind LEDs als Status vorgesehen. Sie signalisieren insbesondere die laufende Zeit.

Diese Konfiguration empfinde ich allerdings als zu eingeschränkt, denn es gibt nur zwei vorgegebene Zieh-Zeiten. Es macht aber einen Unterschied, ob ich einen schwarzen Tee drei Minuten oder einen grünen zwei Minuten ziehen lasse. Der Kräutertee darf auch gerne länger im Wasserbad verweilen. Ich beschloss deshalb, die Ursprüngliche Steuerung etwas zu modifizieren. Eine Taste ist weiterhin für die Zeit zuständig. Sie wird in Schritten von jeweils einer Minute herauf gezählt, bis die neun erreicht ist. Dann beginnt das Zählen wieder von vorn. Die Anzahl der zu ziehenden Minuten ist somit einstellig und einfach mit einer 7-Segment-Anzeige darstellbar. Der Punkt der Anzeige blinkt, wenn der Tee zieht.

Zwei Taster, ein Servo-Motor, eine 7-Segment-Anzeige und ein Signalgeber, der den fertigen Tee verkündet, dafür hat ein Arduino noch immer ausreichend Anschlüsse.

Die rote 7-Segment-Anzeige ist direkt am Arduino angeschlossen, wobei Diode noch einen 220 Ohm Widerstand spendiert bekommt.  Die Anschlüsse sind D2 für Segment “a”, D3 für “b” bis D9 für den Punkt. An D10 hängt der Tongeber und D11 ist für den Servo-Motor gedacht. Die beiden Taster sind mit den analogen Eingängen A1 für die Zeit und A2 für Start/Stop verbunden.

Die konkrete Wahl der Ausgänge ist einmal der Funktion geschuldet. Die Ansteuerung des Signalgeber und des Servo-Motor erfordert Pulsweitenmodulation (PWM). Für die Anzeige liegen die Ausgänge direkt nebeneinander, so das die Verbindung mit einer Anzeige-Platine und die Ansteuerung einfach ist (siehe unten).

Das Programm des Teemann

Das zugehörige Programm ist auf Githup zu finden. Es basiert auf der Make-Vorlage zu Teeodohr. Einige Schlenker des Servo-Motors, habe ich allerdings entfallen lassen. Sie könnten den schlichte Aufbau des Teemanns sonst in Mitleidenschaft ziehen.

Neu ist die Ansteuerung der 7-Segment-Anzeige. Der anzuzeigende Wert steht in einer globalen Variable time. Er wird durch den Minuten-Schalter erhöht, bis zum Wert neun und anschließend wieder auf eins gesetzt. Während des Ziehens, reduziert sich der Wert im Minutentakt.

Bei der eigentlichen Ansteuerung hilf ein konstantes Bytefeld z wie Ziffer. Die Bits eines Bytes steht für den Zustand eines Segments: an oder aus. Die Position des Bytes im Feld ist der Index für die darzustellende Ziffer. Angenommen es verbleiben noch zwei Minuten zu ziehen, dann gibt z[time] das dritte Byte im Feld zurück, den die Indizierung beginnt mit Null.

Dieses Byte bekommt die Prozedur segmente für die Ansteuerung. Darin ist eine Schleife, die für die anzusteuernden Ausgänge von 2 bis 9 läuft. In der Schleife wird für den aktuellen Ausgang dieser ein oder aus geschaltet, abhängig vom vordersten Bit des Parameters. Nachdem ein Bit für die Ansteuerung gesorgt hat, schiebt das Programm alle Bits um eine Stelle nach links. Das zuvor betrachtete Bit entfällt und das nächste kann zur Steuerung herangezogen werden.

Die Ansteuerung des Punktes erfolgt unabhängig davon in der Zählschleife des Ziehens. Das Timing erfolgt mit delay-Anweisungen, wodurch die Zeitnahme etwas ungenau ist. Die paar Millisekunden wird ein Tee aber durchaus ertragen.

Der Aufbau

Praktisch und Mechanisch ungeübt ist das für mich der härteste Teil. Die Elektronik ist freischwebend auf zwei Lockraster-Platinen verlötet. Eine Platine mit dem Arduino Nano und die zweite für die Anzeige, die auch die Widerstände enthält. Die Verbindungen sind alle über Stecker auch wieder zu lösen.

Der Teemann selbst bekommt aus eine Basisplatte aus einem Postkartenbrettchen. Durch ein mittiges Loch kommt eine M3 Gewindestange, die mit Scheibe und Mutter beidseitig fest verschraubt wird. Die Mutter auf der Unterseite landet dabei in dem Abschnitt, der für die Postkarte bestimmt ist, so dass sie versenkt ist und das Brett gerade aufliegt.

Auf die Stange kommen hohle Styropor Kugeln. Sie sind mit einem scharfen Messer gut zu bearbeiten. In die untere Kugel gibt es einen Abschnitt für das Panel, welches ich mit der Laubsäge erstellt habe. In die obere Kugel wird seitlich der Servo-Motor eingelassen. Die Kabel passen durch kleine Löscher in den Kugeln.

Last but nut least bekommt der Teemann einen Kopf aus einer kleineren, massiven Styropor-Kugel, die auf das Ende der Gewindestange gesteckt wird.

Der Servo bewegt die Teebeutel mit Hilfe eines stärkeren Drahtes, der per Heißkleber an den Servo und mit einer kleinen Klammer versehen ist.

Mach mal Tee man

Es ist Zeit für einen Testlauf. Das ganze funktioniert nicht schlecht, doch wie man sieht ist etwas Tuning notwendig:

Teemann_bekleckert

Die Winkel für den Servo-Motor habe ich aus dem Teeodohr-Projekt übernommen. Die gehen offensichtlich ziemlich auf den Latz. Hier liegt ein Vorteil der Stromversorgung über den Arduino-USB-Anschluss. Dies ist auch gleichzeitig der Programmierzugang und nach einer Anpassung funktioniert das dann ganze dann auch wie gewünscht.

Teemann_in_aktion

Die Uhrzeit im Griff mit Timer und Unterbrechung

Die Anzeige ist aufgebaut, jetzt fehlt noch die Software mit dem richtigen Timing und die Uhr läuft. Damit das funktioniert gilt es nun die im Mikrocontroller enthaltenen Timer nutzbar zu machen.

Warum nicht wie im Testprogramm?

Ja, das Testprogramm hat die Anzeige gesteuert. Allerdings zeitlich nicht sehr präzise. Ein genauerer Blick auf das Blink-Programm macht den Haken jedoch deutlich.

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

Das Programm schaltet den Ausgang ein, wartet eine Sekunde, schaltet den Ausgang aus und wartet wieder. Anschließend beginnt der Zyklus von vorne. Die Verzögerungen mögen exakt eine Sekunde dauern, aber wie lange dauert das Schalten? Schon die Zahl der Kommandos kann durch bedingte Ausführungen, beispielsweise einen Übertrag auf die nächste Stelle unterschiedlich sein.  Folglich ist die Laufzeit unterschiedlich. Das Multiplex braucht nur ausreichend schnell sein, so dass die Anzeige nicht flimmert. Für eine genaue Uhr taugt das allerdings nicht.

Die Zeit im Griff durch Unterbrechung

Was meint das? Im Mikrocontroller des Arduino sind drei sogenannte Timer/Counter integriert. Im Grunde handelt es sich um Zähler. Sie zählen Ereignisse wie den Systemtakt und führen eine gegeben Funktion aus, wenn ein definierter Wert oder die Zählerobergrenze erreicht ist. Das Ausführen startet der Timer mit Hilfe einer Unterbrechung – einem Interrupt. Der Interrupt unterbricht das laufende Programm und ruft den Unterbrechungscode auf. Ein Beispiel dafür ist der Reset, der durch einen Taster auf dem Arduino-Board ausgelöst werden kann. Der Mikrocontroller beginnt dann mit der Ausführung seines Programmes von ganz vorne.

Die Timer zählen vollständig unabhängig vom laufenden Programm. Zählen sie nun den Systemtakt,  bilden sie eine gute Basis für eine Uhr. Der ist immerhin quarzgenau bei 16000000 Impulse in der Sekunde.

Was gibt es für Timer?

Das hängt vom zugrundeliegen Controller ab. Auf dem Arduino stehen die beiden 8-Bit-Timer/Counter 0 und 2 sowie der 16-Bit-Timer/Counter 1 zur Verfügung.

Die 8-Bit Zähler können bis 255 Zählen, Timer 1 schafft es immerhin bis 65535. Anschließend beginnen sie wieder bei 0. Wenn sie von vorn beginnen, erfährt der Zähler einen Überlauf. Den kann er durch einen Interrupt markieren. Genauso ist ein Interrupt konfigurierbar, sobald ein bestimmter Wert erreicht ist.

 

Timer 2 könnte auch externe Ereignisse zählen. An den dafür vorgesehenen Eingängen betreibt der Arduino allerdings seinen Quarz. Eine mögliche Taktquelle für die Timer ist wie gesagt der Systemtakt. Die 16 MHz sind recht schnell für den Zahlenumfang der Timer und die Zähler laufen in Bruchteilen einer Sekunde über. Für längere Distanzen kann der Takt vor dem Zähler vorgeeilt werden. Als Vorteile sind die 8/32/64/128/256 und 1024 möglich.

Die Programmierung

Die Timer besitzen diverse Kontrollregister. Die Register sind Adressen im Programmraum. Die Programmierung erfolgt durch setzen bestimmter Steuer-Bits dieser Register. Die Arduino IDE basiert letztlich auf dem C++ für die Atmel-Prozessoren. Die Header definieren Konstanten für die Adressen und die Steuerbits, mit denen die Programmierung einbänglicher ist.

Die benötigten Register sind im Einzelnen

  • OCRxy
    Output Compare Register. Hier können zwei Vergleichswerte hinterlegt werden, bei deren Erreichen ein TIMERx_COMPy_vect-Interrupt ausgelöst wird. x ist die Nummer des Timers (0,1, 2). y steht für die beiden möglichen Werte (A und B)
  • TCCRxy
    Timer/Counter Control Register: Einstellen des Vorteile
  • TIMSKx
    Timer/Counter Interrupt Mark Register: welche Interrupts soll ein Timer aus auslösen

Weiterhin sind noch die Funktionen cli() – Interrupts deaktivieren – und das Gegenstück sei() – Interrupt aktivieren wichtig. Während der Timerprogrammierung sollten die Interrupts deaktiviert sein, damit die Programmierung nicht unterbrochen wird und ein bisher erfolgte Programmierung ein ungewolltes Verhalten hinterlässt.

Der auszuführende Code für einen Interrupt ist in einer Callback-Funktion zu hinterlegen:

ISR(Interruptname) {
   // auszuführender Code
}

Damit die Interrupts sich nicht „selbst überholen“ sollte der Code natürlich möglichst kurz sein.

Eine Übungsprogramm

Um mich mit der Programmierung vertraut zu machen, schadet ein einfaches Beispielsprogramm nicht. Ich mag das Blink-Programm dafür mit Hilfe eines Timers umsetzen. Der dabei entstandene Code findet sich auch auf Github.

Natürlich ist bei diesem Programm ein abweichender Setup-Code erforderlich. Die eigentliche Aktivität erfolgt allerdings in der Interrupt-Behandlung (ISR(.)) infolge dessen ist die Loop-Prozedur leer. Der Arduino wartet. Ist die vorgegebene Zeit des Timers um, schaltet die Interrupt-Behandlung den Ausgang der Onboard-LED um.

Bevor ich kurz auf die Timereinstellungen eingehe, möchte ich noch kurz auf eine Besonderheit bei der Deklaration der Zustandsvariable für den Status des Ausgangs hinweisen:

volatile boolean blink = false;

Der Compiler versucht zu optimieren. Stellt er nun fest, dass eine Variable in einem Codeblock nicht geschrieben wird, könnte er sie infolgedessen durch eine Konstante ersetzen. Soll also eine Variable  in einem Block festgelegt und in einem anderen ausgelesen werden, müssen das dem Compiler mitteilen. Genau dafür ist die Variable blink als volatile deklariert.

Kommen wir nun zu den Einstellungen. Ich möchte die delay(.)-Anweisungen durch die Interrupt-behandlung ersetzen. Diese schaltet die Leuchtdiode ein und vice versa. Der Aufruf sollte entsprechend einmal in der Sekunde erfolgen.

Dafür wähle ich den 16-Bit-Timer. Er erhält den Systemtakt geteilt durch 1014. Damit ist die Eingangsfrequenz 16.000.000 / 1014 = 15.625 Hz. Zählt der Timer nun bis 15624 und startet mit dem nächsten Takt den Interrupt, ist folglich der Aufruf je Sekunde erreicht.

Die Details zu den Steuerregistern

Die Bits der Register sind ausführlich im Datenblatt von Atmel beschrieben. Damit der Timer bei erreichen des Zielwertes zurückgesetzt wird, ist in das TCCR1B Register die WGM-Bits entsprechend zu setzen WGM12 auf 1 die beiden anderen auf 0. Sie befinden sich im TCCR1A-Register.

Der Precaller wird über die CS-Bits gesteuert, die ebenfalls im TCCR1B-Register zu finden sind. Daraus ergeben sich die Zeilen

TCCR1A = 0;
TCCR1B = 0;
// Set CS12 and CS10 bits for 1:1024 prescaler
TCCR1B |= (1 << CS12) | (1 << CS10);
// turn on CTC mode
TCCR1B |= (1 << WGM12);

Das Vergleichsregister A ist mit den oben genannten 15624 zu füllen (es könnte genauso gut B Verwendung finden)

OCR1A = 15624;

Zuletzt muss der Vergleichseinheit A gesagt werden, den Interrupt bei erreichen zu aktivieren

TIMSK1 |= (1 << OCIE1A);

Vor der Programmierung des Timers sind Interrupts zu deaktivieren und anschließend wieder zu aktivieren.

Resumee

Das Blink-Programm auf Timer Basis zeigt einen sehr schönen Weg zur Steuerung der Digitaluhr auf. Die Zeitmessung damit ist quarzgenau. Die Programmierung kann durch diese “Event”-Behandlung auch etwas leichter werden.

Einen Zeitgeber für eine Sekunde ist nun schon gefunden. Der nächste Beitrag betreibt die Anzeige und Zählt dann die Sekunden.

Bisherige Beiträge zum Winterprojekt

 

Winterprojekt: Die Anzeige der Digitaluhr

Das neue Jahr hat begonnen und es kann mit der Anzeige weitergehen. Dieser Beitrag beschreibt insbesondere die Hardware, also den Aufbau und die Verdrahtung. Für den Test gibt es ein erstes kleines Programm.

Die eigentliche Anzeige

Eine digitale Uhr benötigt jeweils zwei Ziffern für die Stunden und die Minuten. Die Anzeige besteht demnach aus vier 7-Segment-Anzeigen. in einer ersten Hochrechnung sind folglich für die Ansteuerung 7 x 4 = 28 digitale Ausgänge erforderlich. So viele Ausgänge besitzt der Arduino allerdings nicht. Deshalb erfolgt die Ansteuerung multiplex.

Das Multiplex-Prinzip

Bei Bildschirmen oder Fernsehern gibt es immer eine Frequenzangabe, Die Angabe von beispielsweise 50 Hertz (Hz) bedeutet, dass fünfzig mal in der Sekunde das Bild erneuert wird. Unser Auge ist träge, deshalb sind schnelle, einzelne Bilder nicht mehr zu unterscheiden. Entsprechend verschmelzen sie zu einer laufenden Bewegung.

Mit den Ziffern der Uhr funktioniert es genauso. Eigentlich zeigen die 7-Segment-Anzeigen nacheinander ihre Ziffern an. Erfolgt der Wechsel allerdings schnell genug, so sehen unsere Augen vier leuchtende Ziffern.

Für die Ansteuerung benötigt dieses Verfahren sieben Ausgänge gleichzeitig für alle vier Segmente. Vier weitere Ausgänge steuern jeweils den gemeinsamen Gegenpol der Segmente und wählen die jeweils anzuzeigende Ziffer aus. Die Anzahl der benötigten Ausgänge reduziert sich immerhin von 28 auf 11 und die kann der Arduino ansteuern.

Unter Strom

Mit den Strom einer einzelne Leuchtdiode kann der Arduino umgehen. An den gemeinsamen Gegenpol geben beispielsweise für die Ziffer Acht immerhin sieben Dioden Strom ab. In Foren liest man häufiger der Arduino kann bis zu 50 mA liefern. Laut Datenblatt sind es allerdings nur 40 mA. Da die blauen Dioden sehr hell sind, könnten größere Vorwiderstände gewählt werden, beispielsweise 1 Kiloohm. Von 5 Volt fallen 2,8 Volt Spannung an der Diode ab und folglich verbleiben 2,2 Volt am Widerstand. Geteilt durch 1000 Ohm mal 7 Segmente = 15,4 mA, das funktioniert. Bei einem Experiment ergab sich allerdings das die Ausgänge meines Arduino unterschiedlich viel Strom liefern, so dass ein Segment deutlich dunkler war als die anderen. Nach einem Tausch war es wieder das Segment dieses Ausgangs, das dunkler war. Das ist unschön, deshalb habe ich den Strom mit Hilfe von Transistoren geschaltet.

Der Transistor als Schalter

In der Restekiste habe ich noch BC 547C Transistoren. Die Verstärkung (das “C”) ist für diese Anwendung eigentlich übertrieben, trotzdem erfüllen sie ihren Zweck. Sie können mit einem kleinen Strom einen großen schalten. Bei den von mir verwendeten 220 Ohm Widerständen ist das 7 x (2,2/220) = ca. 70 mA. Meine kleine Testschaltung sieht wie folgt aus:

Schalten mit dem Transistor

Auf diesem Video habe ich das Schalten durch den Arduino durch einen Taster simuliert. Diese Schaltung kann ich dementsprechend auf den gemeinsamen Pol aller 7-Segement-Anzeigen anwenden.

Der Schaltplan für die Anzeige insgesamt ist

Schaltung Anzeige

Testprogamme

Die Funktion ziffer(int) aus dem letzten Beitrag sowie das Feld mit den Ansteuerungscodes benutze ich genauso wie im letzten Beitrag. Die Initialisierungsschleife des Setup nimmt zudem vier weiteren Ausgänge 3 bis 6 auf, die ebenfalls als Ausgang eingestellt werden. Die Werte für die darzustellenden Ziffern enthält das Feld

int ausgabe[] = { 4, 3, 2, 1};

Im Loop rufe ich zunächst nur eine Prozedur  doAusgabe() auf, in der eine Schleife die nächste Ziffer schaltet.

for(int z=0; z<4; z++) {
  selectZiffer(z);
  ziffer(ausgabe[z]);
  delay(5);
}

Sie selektiert zunächst das zu schaltende Segment, steuert anschließend die Segmente entsprechend der zugehörigen Ziffer an und wartet. Die Prozedur selectZiffer(int) schaltet alle außer dem angeben Segment ein.

void selectZiffer(int z) {
  for(int i=0; i<4; i++) {
    if(i==z) digitalWrite(6-i, HIGH);
    else digitalWrite(6-i, LOW);
  }
}

Die Verzögerung in doAusgabe() definiert im Moment für die maximale Wiederholrate. Ist die Wartezeit zu lang, so flimmert die Anzeige oder extremer, der Wechsel ist erkennbar. Für den Funktionstest ist das allerdings so gewollt. So lässt sich der Ablauf schließlich auf gut verfolgen.

Resumee

Technisch funktioniert die Anzeige nun. Ein kleines Programm existiert bereits, doch das ist ausbaufähig. Die “softe” Seite der Anzeige ist Thema des nächsten Beitrags.

Bisherige Beiträge zum Winterprojekt

Winterprojekt: Ansteuern der 7-Segment-Anzeige

Mit der nun gelieferten 7-Segment-Anzeige kann das die Programmierung und die Ansteuerung durch den Arduino erfolgen. Zunächst bin ich auf Draht …

Der Anschluss

Was steckt in der 7-Segment-Anzeige?

Die 7-Segment-Anzeig hat gleich eine Überraschung bereit: sie hat eine gemeinsame Anode.

schaltplan-7-segmentDie einzelne LED des vorausgehenden Blogs wurde durch einen aktiven Ausgang (high, 5 Volt) aktiviert. Für die Segment-Anzeige dagegen heisst es umdenken. Nur die Kathoden der einzelnen Dioden sind zugänglich, folglich kann der Arduino sie nur durch ein Low-Pegel, 0 Volt, zum leuchten bringen. Das gilt es anschließend bei der Programmierung zu berücksichtigen.
Anschlussbelegung 7-Segment-AnzeigeDer Schaltplan der Anzeige enthält die Nummern der Pins für das jeweilige Segment. Zudem bezeichnen die Buchstaben “a” bis “f” die jeweiligen Dioden und den Dezimalpunkt. Anhand der Beschreibung aus dem Datenblatt können nun die Verbindungen zum Arduino hergestellt werden. Zwischen jedem Digitalausgang und dem Anschluß habe ich zudem ein Widerstand geschaltet.

Die Verdrahtung

Prinzipiell könnte auch ein einzelner Widerstand an der gemeinsamen Anode genutzt werden. Hierdurch wird allerdings der Strom für alle Dioden begrenzt. Wenn für eine Ziffer 8 alle Segmente leuchten, teilt er sich auf und ist folglich je Diode niedriger als bei weniger leuchten Segmenten. Die Helligkeit könnte dadurch abhängig von der dargestellten Ziffer schwanken. Ich sag mal könnte, weil die Helligkeit durch den Strom nur schlecht steuerbar ist. Beim Ausprobieren habe ich keinen Unterschied sehen können. Durch Materialstreuung könnte es aber dennoch passieren und sähe dann unschön aus.

Die Ansteuerung der sieben Segmente erfordern ebenfalls sieben Digitalausgänge. Ich habe mich dazu entschieden die Ausgänge 13 – Segment “a” bis 7 – Segment “g” zu nutzen. Schließlich besitzen die Digital-Pins 1 und 2 Sonderfunktionen, die ich nicht unnötig blockieren möchte.

Die Software

Das Rahmenprogramm

In der Initialisierung der Ansteuerung definiere ich in einer Schleife die Digitalen Ausgänge und setze sie in einen definierten Zustand.

void setup() {
  for(int i=13; i>6; i--) {
    pinMode(i, OUTPUT);
    digitalWrite(i, HIGH); // Erst mal ausschalten
  }
}

Für den Test soll die 7-Segment-Anzeige die Ziffern 0 bis 9 anzeigen. Jedoch erfolgt nach jeder Ausgabe eine Verzögerung, sonst könnten den Ziffernwechsel wegen der hohen Geschwindigkeit nicht wahrnehmen.

void loop() {
  for(int i=0; i<10; i++) {
    ziffer(i);
    delay(1000);
  }
}

Nachdem die Schleife die Ziffern durchlaufen hat, lässt die übergeordnete Endlosschleife die Ziffern erneut anzeigen. Der spannendere Teil der Ansteuerung liegt darin, wie die Ziffern der 7-Segement-Anzeige auszugeben sind. Dafür ist Prozedur ziffer(int) zuständig.

Ansteuerung der 7-Segment-Anzeige

Ein erster Ansatz

Der erste Gedanke zur Umsetzung ist eine direkte Aufteilung nach anzuzeigender Ziffer

void ziffer(int z) {
  switch(z) {
  case 0:
   ziffer0();
   break;
  case 1:...

und eine zugehörige Aktivieren der Ausgänge. Für die Ziffer 0 auf der 7-Segement-Anzeige sieht das beispielsweise wie folgt aus.

void ziffer0() {
  digitalWrite(A, LOW); 
  digitalWrite(B, LOW);
  digitalWrite(C, LOW);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
}

Das Positive vorweg: es funktioniert. Das geht aber auch anders und besser. Zum einen ist es einfach toll, wenn sich eine Funktion “knackig” ausdrücken lässt. Ein kompakterer Code ist im Folgenden auch besser zu pflegen. Als Nebeneffekt kann aber Speicherersparnis dabei herauskommen. Zur Erinnerung: der Arduino hat 2K freien Speicher und 32K Programmspeicher. Das ist in dieser Baureihe sogar recht viel, denn die kleinen Brüder des verwendeten Chips besitzen nur 16K oder gar nur 8K Programmspeicher. Wenn ein Programm dort hinein passt, wird eine Serie halt auch preiswerter.

Vermeiden von doppelten Code

Was geht also besser? Für jede Ziffer auf der 7-Segment-Anzeige gibt es eine eigene Prozedur, wie die oben dargestellte. Mit Ausnahme der Pegel sieht jedoch jede dieser Prozedur gleich aus. Das ist eine unnötige Wiederholung, die zudem der Faulheit einer Entwicklers widerspricht. Soll nun an der Grundstruktur etwas geändert werden, ist danach jede der anderen Prozeduren anzupassen. Immerhin zehn Prozeduren nach dem gleichen Schema ändern.

Die Alternative heisst ein Feld definieren. Darin stehen nur die Pegel und eine Schleife weist sie jeweiligen Ausgang zu:

const int ZIFFERN[][] = {
          { LOW, LOW, LOW, LOW, LOW, LOW, HIGH },
          { ... 

        }

...

void ziffer(int z) {;
  for(int i=0; i<7; i++) { 
    digitalWrite(13-i, ZIFFERN[z][i]);
  }
}

Meine ursprüngliche Lösung belegt bei mir 1296 Bytes Programm- und 9 Bytes dynamischen Speicher. Die neue dagegen 1128 Bytes Programm- und 149 Bytes dynamischen Speicher. Die “schönere” Lösung ist kleiner benötigt trotzdem viel Platz für das Feld mit den Pegeln, und zwar vom ohnehin kleinen dynamischen Speicher.

Speicheroptimierung

Die Ansteuerung der 7-Segment-Anzeige kann nun noch über eine kompaktere Speicherung der Pegel optimiert werden. Für die Ausgabe ist eigentlich nur interessant, ob er an oder aus geschaltet wird. Als Datentyp habe ich zuvor int gewählt. Dieser Datentyp benötigt deutlich mehr Platz als nur ein Bit. Die sieben Pegel für die 7-Segement-Anzeige finden aber auch als Bit in einem Byte platz. Die Pegel lassen sich dann beispielsweise wir folgt ablegen:

const byte ZIFFERN[] = {
    B0000001, // 0
    B1001111, // 1
    B0010010, // 2
    B0000110, // 3
    B1001100, // 4
    B0100100, // 5
    B0100000, // 6
    B0001111, // 7
    B0000000, // 8
    B0000100, // 9
  };

Für den westlichen Menschen ist eine Kodierung der Segmente von links nach rechts nachvollziehbarer. Entsprechend steht das erste Bit nach dem B für Segment “a”, das zweite für “b”, etc.

Bitte ein Bit

Danach muss die  Prozedur das richtige Bit für den zugehörigen Ausgang setzen. Meine Lösung:

void ziffer(int z) {;
  for(int i=0; i<7; i++) {
    digitalWrite(13-i, (ZIFFERN[z] & 1 << (6-i))==0?LOW:HIGH);
  }
}

Hier spiele ich mit Bit-Operationen. Das ist allerdings nicht auf einen Blick zu lesen. Mit ZIFFERN[z] bekomme ich das Bytes für die gewünschte Ziffer. Die Laufvariable i zählt durch die sieben möglichen Segmente. Für das Segment “c” hat die Variable i den Wert 2. Das ist das dritte Segment, aber die Schleife beginnt mit 0 und nicht mit 1. Mit 1 << (6-i) erhalte ich ein Byte, das nur an der 6-2=4-ten Stelle eine 1 hat. Bei sieben Bits ist das die dritte Stelle von Links, sie soll in den Konstanten die “c”-Stelle darstellen. Die Vorgabe und das Zielsegment verknüpfe ich mit einem logischen “Und”. Das Ergebnis für die jeweiligen Eingangsdaten ist dann

Ziffern-Bit Masken-Bit Ergebnis
0 0 0
0 1 0
1 0 0
1 1 1

Ist also für Segment “c” eine 1 codiert, so sorgt die entstandene Maske B10000 für ein Byte, das ebenfalls eine 1 enthält. Dessen Zahlenwert ist größer als 0. Sonst ist der Wert des Bytes 0, alle Bits auf 0. Diesen Wert prüft nun der ?-Operator und setzt den jeweiligen entsprechend Ausgang auf LOW oder HIGH.

Tipp

Die Programmierung klappt nicht immer auf anhieb. Beispielsweise ist das letzte Bit der Maske auf der Stelle 0, folglich ist der intuitive Ansatz (7-i) für die Maske falsch. Es gibt einen einfachen Weg, um das zu prüfen: einfach Zwischenwerte auf die Serielle Schnittstelle zum Rechner ausgeben lassen. Dazu ist im Setup die Schnittstelle mit Serial.beginn(9600); zu initialisieren. Ausgaben erfolgen dann mit Serial.println(<wert>); Den seriellen Monitor (die Lupe oben links im Fenster) in der IDE starten, die bei der Initialisierung angegebene Geschwindigkeit (9600 Baud) auswählen und schon können wir dem Programm bei der Arbeit zusehen.

Zum Abschluss

Die für die einzelne 7-Segment-Anzeige gefundene Lösung belegt 1000 Bytes Programm- und 19 Bytes dynamischen Speicher. Offensichtlich lohnt es sich Gedanken über seine Programme zu machen. Wenn die Idee dann auch noch funktioniert … Film der zählenden Anzeige

Bisherige Beiträge

Winterprojekt: LED there be light – Aufbau der Anzeige

Die Grundlegende Hardware liegt vor und die Software ist eingerichtet. Also wird das Winterprojekt Digitaluhr nun konkreter. Im Folgenden soll die Anzeige entstehen, die ich schrittweise entwickeln möchte. Zunächst mit einer externen, blinkenden LED, wie in diesem Film.

Die technische Basis

Die Ziffern der Uhr werden mit 7-Segmentanzeigen aufgebaut. Zuerst beginne ich mit der Ansteuerung einer einzelnen externen LED. Die späteren Ziffern sind genauso zu betreiben. Die Segmentanzeigen bestehen allerdings aus mehrere Dioden.

Das aktive Element: die LED

LED ist die Abkürzung für light-emitting Diode, zu deutsch Licht-emittierende Diode. Inzwischen kennen wir sie als Strom sparende Alternative zu Glühlampen. Die Stromsparer bestehen dabei aus den eigentlichen Leuchtdioden und ein wenig Elektronik.

Aktives Bauelement LED
Eine blaue LED

Eine einzelne LED aus dem Elektronik-Laden sieht z.B. aus wie im folgenden Bild. Es gibt sie in unterschiedlichen Größen.

Als Diode leitet sie nur in eine Richtung. Die Anode ist mit dem Pluspol zu verbinden, die Kathode mit dem Minuspol. Nur bei dieser Polung leuchtet die LED. Sollte eine Leuchtdiode bei einem Aufbau also nicht wie erwartet funktionieren, sollte deshalb der Steckrichtung überprüft werden. Die Anode ist im Build am längeren Anschluss zu erkennen.

Die LED leuchtet ab einer bestimmten Spannung, die von der Farbe abhängig ist (siehe auch Elektronik Kompendium). Für rote Dioden ist das 1,6 Volt. Bei blauen wie im Beispiel immerhin schon 2,9 Volt. Erst nachdem diese Spannung überschritten ist, leuchtet die Diode. Die Betriebsspannung des Arduino beträgt nun 5V. Das ist über der Grenzspannung, aber auch oberhalb der zulässigen Marke von ca. 4V. Deshalb ist für Leuchtdioden regelmäßig ein Vorwiderstand erforderlich.

Der Widerstand

Strom begrenzen, Spannungen teilen, Widerstände sind passive Bauteile und werden häufiger gebraucht. Hier eben als Vorwiderstand zur LED. Details über Widerstände gibt es z.B. auf Wikipedia. Hier gibt es unter Anderem auch den Farbcode, mit dem der Wert eines Widerstandes ablesbar ist.

Größe des Torwiderstand ermitteln

Die Grundlagen der Widerstandsberechnung können im Internet gefunden werde, beispielsweise im Elektronik Kompendium. Des Weiteren findet sich dort ein Widerstandsrechner. Am Widerstand sollen 5 – 2,9 = 2,1 Volt abfallen also quasi “vernichtet werden”. Die LED benötigt einen Strom zwischen 10 und 20 mA. Der Widerstandsrechner schlägt hier 18 mA vor. Das ist nicht der maximal mögliche Wert, ein Sicherheitsabstand schadet aber nicht.

Mit Hilfe des Ohmschen Gesetzes ergibt sich aus 2,1 Volt / 0,018 A = 116,66 Ohm. Sicherheitshalber sollte dieser Wert eher auf- als abgerundet werden. Der nächste Wert aus den typischen Reihen ist dann 120 Ohm (Farbcode braun, rot, braun).

Der Aufbau

Auf Bilder und Videos, wie das in der Einleitung, ist der Aufbau eher schwer zu erkennen. Deshalb möchte ich den Aufbau in Schalt- und Steckplänen dokumentieren. Mit Hilfe von Fritzing – einem freien Programm – ist das Ergebnis durchaus ansehnlich.

Schaltplan

Schaltplan externe LEDDer Schaltplan enthält nur die wesentlichen Informationen. In diesem Fall das Arduino-Board, den Widerstand, die Leuchtdiode und natürlich die Verbindungen der Bauteile.

Für die externe Ansteuerung, habe ich den digitalen Ausgang zwölf gewählt. Als Programm dient wieder Blink wie im letzten Beitrag, nur ist der Ausgang geändert, damit ist nachvollziehbar, dass die Programmänderung wirksam ist.

Am Ausgang direkt ist der Widerstand mit einem der beiden Drähte angeschlossen, die andere Seite führt zur Anode der Leuchtdiode, der Anode. Im Bild oben war das der längere der beiden Anschlüsse. Die andere Seite wird an Masse (Englisch “ground” – GND) am Board angeschlossen. Das Symbol der Diode deutet als Pfeil die Flussrichtung an. Schaltet das Programm den Ausgang nun auf an, high, 5 Volt, so heutet die LED.

Der Aufbau

Der Aufbau – wie im Video der Einleitung zu erkennen – ist erst mal auf einem Steckbord realisiert.

Aufbau auf der Steckplatine

Wichtig ist hier auf die richtige Polung der LED zu achten. Falls sie nicht wie erwartet blinkt, könnte ein drehen helfen.

In der Entwicklungsumgebung kann nun, wie im letzten Blog, das Blink-Programm aufgerufen werden. Hierin ist nun die Portnummer sowohl in setup() als auch in loop() von 13 auf 12 zu ändern. Hochladen in den Arduino und schon geht es los.

Als nächstes geht es weiterhin um die Anzeige der Digitaluhr. Anstelle der einzelnen LED soll dann eine 7-Segementanzeige Ziffern anzeigen.

Bisherige Beiträge

 

 

 

 

 

 

 

Winterprojekt: Setup Arduino-Programmierung

Der Arduino Uno ist eingetroffen. Nun kann es mit dem Winterprojekt weitergehen. Zuvor ist aber etwas Installationsaufwand zu treiben.

Für den Uno gibt es eine Entwicklungsumgebung, die weiterhin auch für andere Controller verwendbar ist. Auf der Homepage finden sich neben vielen Informationen und Anleitungen die Download-Seite mit dem Installer der IDE. Das ist die Abkürzung für integrierte Entwicklungsumgebung. Sie kann hier jeder passend zum jeweiligen Betriebssystem herunterladen.

Der Arduino unterhält sich technisch über eine serielle Schnittstelle, wie sie bei den ersten Mäusen benutzt wurde. Die gibt es heute aber an keinem Rechner mehr. Aber es gibt USB, den universellen seriellen Bus. Dafür bringt der Installer gleich einen passenden Treiber für die Kommunikation des Arduino mit dem Computer mit. Die USB-Geräte unterhalten sich auch seriell und deshalb sorgt der Treiber für eine Übersetzung zwischen den beiden seriellen Varianten.

Hinweis:
Bei einer Internetsuche können zwei Seiten gefunden werden: arduino.cc und arduino.org. Auch in die Welt der offenen Soft- und neuerdings auch Hardware sind die Menschen sich ebenfalls nicht immer einig. Das ist hier genauso. Ich bevorzuge die erste Adresse. Sie ist die ursprüngliche und ich vermute deshalb wirken mehr Menschen mit. Das lässt mehr Stabilität erwarten.

Aufbau

Steckt man ein neues USB-Gerät an einen Computer, dauert es immer einen Moment bis es erkannt wird. Die IDE muss den Arduino ebenfalls erkennen, folglich stecke ich ihn an den Rechner bevor ich die Umgebung starte.

Die Installation ist abgeschlossen. Der Uno ist mit dem Computer verbunden und anschliessend die IDE gestartet. Zeit das Zusammenspiel der beiden zu testen. Bei Programmiersprachen ist es üblich, zunächst ein “Hallo World” auszugeben. Klingt albern, zeigt aber deutlich: die Umgebung ist eingerichtet und funktioniert. Der Arduino hat keinen Bildschirm für eine Ausgabe, aber eine kleine Leuchtdiode auf der Platine. Das mitgelieferte Beispielsprogramm Blink läßt diese Diode blinken.

Arduino-IDE

Und da ist auch schon die erste Hürde. Der Arduino ist mit dem Rechner verbunden, bloß das die  Diode auf dem Board bereits zu blinken beginnt. Das heisst, der Hersteller verwendet dieses Programm offensichtlich für den Test des Aufbaus. Das stört aber nur bedingt. Das Blinken ist gleichmäßig und das Programm kann einen abweichenden Rhythmus vorgeben, so dass ein Unterschied zu erkennen ist.
Nun also erst mal die IDE starten. Im erscheinen Fenster ist ein Programmrumpf zu sehen. Darüber befinden sich Icons. Das Häkchen-Icon ganz Links überprüft die KorreStartfenster der IDEktheit eines Programmes. Es folgt das Icon, dass ein Programm auf das Board überträgt. Die folgenden dienen dem Öffnen, Speichern und beginnen neuer Programmdateien. Die IDE verrät die Funktion in einem Hilfetext, sobald der Mauszeiger über den Icon verweilt. Unter dem Programmcode-Fenster befindet sich die Konsole. Sie enthält die Ausgaben der Umgebung. Fortschritt beim Verarbeiten und Übertragen oder entdeckte Fehler im Code.

Beim öffnen eines neuen Programms – die Arduino IDE nennt dies Sketch – sind die Rümpe einer setup() und der loop()-Funktion zu erkennen. Für setup() gilt: der Name ist Programm. Hier können Variablen oder Hardware initialisieren werden. Die loop()-Funktion wird in einer Endlosschleife ausgeführt und enthält das, was der Controller verrichten soll.

Konfiguration

Bevor das Blink-Programm gestartet wird, ist die Entwicklungsumgebung noch zu konfigurierten. Im Menü “Werkzeuge” stelle ich unter “Platine” den “Arduino/Genunio Uno” ein. Unter Port ist die serielle Schnittstelle auszuwählen, die der Treiber zur für die Kommunikation mit dem Board bereitstellt. Bei meinem Mac heisst sie “/dev/usbmodem411” auf Windows erscheint ein “COM” gefolgt von einer Nummer. Im Idealfall weisst die IDE darauf hin, dass mit Port ein Board verbunden ist.

Blinkprogramm aktivieren

Das Test-Programm, “Blink”, ist eins von mehren mitgelieferten Beispielen. Es ist wie im Bild gezeigtPfad zum Blinkprogramm im Datei-Menü zu finden. Die Beispiele liefern Vorlagen für die verschiedenen Themen, in denen sich angehende Bastler zu unterschiedlichen Themen orientieren können.

Alldieweil ist das Testprogramm Blink geöffnet. An Pin 13 ist die Leitdiode (LED) auf dem Board angeschlossen. Deshalb definiert die setup()-Funktion diesen Pin als Ausgang. In loop() wird nun

  1. die LED eingeschaltet,
  2. eine Sekunde gewartet,
  3. die LED ausgeschaltet,
  4. wieder eine Sekunde gewartet
  5. und das ganze beginnt von vorn.

Damit eine die Wirkung des Programmes zu sehen ist, verändere ich das An-/Aus-Verhältnis der LED zu

void loop() {
  digitalWrite(13, HIGH);
  delay(200); // warte nur kurz
  digitalWrite(13, LOW);
  delay(800); // pausiere deutlich länger
}

Noch einem Klick auf das Hochladen-Icon, anschliessend sind in der Konsole die IDE-Aktivitäten zu verfolgen: Übersetzen und Packen des Programmes und die folgende Übertragung. Sobald sie startet, ist ein “Flimmern” zweier Kontrolle-LEDs auf dem Board zu erkennen. Anschließend blinkt die Diode auf dem Board nicht mehr gleichmäßig, sondern blitzt entsprechend kurz auf.

Ein Programm wurde übertragen, anschliessend wird es ausgeführt und die LED blitzt.

Winterprojekt: selbstgebaute Digitaluhr

Wie wäre es mit einer gelbgebauten Digitaluhr? Die Segelsaison ist zu Ende. Es folgt die Jahreszeit der kurzen Tage. Nach einem herrlichen Absegeln darf feuchtes und kaltes Wetter gerne draußen bleiben. Drinnen kann ich mich nun mit anderen Dingen beschäftigen.
Segelboot im Oktober

Computer und Programmieren sind mein Beruf. Sie sind aber auch mein Hobby, wobei es nicht immer wilde virtuellen Welten sein müssen. Also zurück zu den Nullen und Einsen. Der Bau einer einfachen Digitaluhr wäre eine schöne Reminiszenz an meinen Einstieg in die Computerwelt,

Der Ursprung

Meine ersten Erfahrungen mit Computern, habe ich als junger Teen gemacht. Für 50 DM! erstand ich einen Sinclair ZX81. Der hatte immerhin 2 KB (in Worten: zwei Kilobyte) RAM-Speicher. Die Busleitungen der 8-Bit-CPU waren am Erweiterungsport verfügbar. Zwei statische Speicherchips mit ein paar Logikgatter und schon hatte dieser Computer ganze 16KB. Um das zu vergegenwärtigen : mein Handy hat einen Speicher von 16 GB. Das ist tausendmal mehr. Dabei ist es bereits drei Jahre alt.

Mit ein den “Peek”- und “Poke”-Befehlen aus dem Betriebs-Basic-Sprachsatz konnte mit ZX81 auch mal was angesteuert werden. Mit Steckboard oder Lochrasterplatinen und ein wenig Löten hatte ich einfach mal eine Experiment aufgebaut.Basismaterial für eine Digitaluhr

Der Spaß kehrt zurück

Kleine Computer für hardwarenahe Experimente gibt es wieder: die Mikrocontroller. Diese Chips vereinen alle Komponenten eines Computers und mehr auf einem Chip. Dieser benötigt nur noch eine Stromversorgung und los geht’s. Sie sind preiswert und steuern heute so mache Spül- oder Waschmaschine.

Für die Programmierung ist allerdings eine Programmierumgebung erforderlich und ein Programmer, der ein Programm auf den Chip transferiert. Das klingt nach mehr Zeit und Geld als man für kleine Experimente ausgeben mag.

Dieses Problem gab es auch mal ein einer italienischen Universität. Für Steuerungsaufgaben sollten Mikrocontroller eingesetzt werden. Die Studenten hatten allerdings keine Erfahrung mit Elektronik oder Programmierung.

Deshalb ersonnen kluge Köpfe eine standardisierte Umgebung, den Arduino und seine Entwicklungsumgebung. Der Arduino ist ein kleines Board mit Mikrocontroller, USB-Schnittstelle und Pfostenleisten. Die Pfostenleisten sind mit den die Mikrocontroller-Ein- und Ausgängen verknüpft. Über Sie ist die Außenwelt einfach und schnell mit dem Mikrocontroller verbunden. Dabei können diese Input-/Output-Verbindungen digitale und analoge Signale ausgeben und einlesen, wie es ein Programm vorgibt. Die Baupläne des Board und die Entwicklungsumgebung sind frei und kostenlos verfügbar. Diverse Hersteller vertreiben fertige Boards.

Über einen normalen USB-Anschluß ist der Arduino mit einem Computer verbunden. Die Entwicklungsumgebung überträgt darüber die Programme zum Arduino. Mit der Entwicklungsumgebung, die das Programmieren des Arduino wirklich kinderleicht macht, können Profis schnell Prototypen entwickeln. Oder aber Hobbyisten ein wenig experimentieren. Genau das habe ich vor.

Das Ziel – die selbstgebaute Digitaluhr

Der Arduino soll meine Basis für meine einfache Digitaluhr werden.

Im Hinterkopf habe ich ein Wecker. Die Uhr zeigt die Zeit an, ich muss sie stellen können und vielleicht bekommt sie auch eine Weckfunktion. Einige Besonderheiten möchte ich dabei schon haben. Die Ziffernanzeige soll blau sein. Das Standard-Rot gibt es ständig bei Anzeigen. Außerdem soll sie eine Spezialität meines derzeitigen Weckers haben: die Zeit soll beim stellen auch zurückdrehbar sein.

Der typische Wecker hat zwei Knöpfe für langsamen und schnellen Vorlauf. Beide drücken setzt die Uhr auf 0 Uhr. Meinem aktueller Wecker hat sowohl einen Vor- als auch einen Rücklauf. Um 23 Uhr ins Bett gehen und noch gerade den Wecker auf Winterzeit eine Stunde zurückdrehen? Mit dem Rücklauf ist das ganz einfach. Wie oft habe ich vorher neu ansetzen müssen, weil ich nicht zeitig genug von schnellen auf langsamen Vorlauf gewechselt bin?

Vielleicht wird mein Eigenbau meinen Wecker nicht ersetzen, aber eine Digitaluhr mit blauer Anzeige…. blau macht doch glücklich 😉