ATtiny: Winzlinge ganz groß

Der Pragmatische Architekt  –  9 Kommentare
Anzeige

Arduino Boards gibt es in unterschiedlichen Formfaktoren und Leistungsklassen. Für kompaktere Schaltungen sind mitunter aber auch die kleineren Arduino-Boards mit "Mini", "Micro" oder "Nano" zu schwergewichtig. Wem es auf geringe Ausmaße und ein gutes Preis-Leistungs-Verhältnis ankommt, sollte einen Blick auf die ATtiny-Familie werfen.

Arduino-Boards wie Arduino Uno, Mega, Mini, Nano oder Micro mit den leistungsstarken ATmega-Chips eignen sich für vielfältige Einsatzzwecke. Sie integrieren neben der MCU eine Reihe weiterer Komponenten wie einen Quarz, Stromversorgungslogik, LEDs, RESET-Taster und vieles andere mehr. Allerdings haben sie dadurch auch eine Größe, mit der sie sich nicht so einfach für kompakte Schaltungen verwenden lassen. Zum Glück gibt es eine Alternative namens ATtiny.

Anzeige

Die fast 40 Prozessoren der ATtiny-Produktfamilie besitzen eine 8-Bit-Architektur. Ihr Flash-Speicher bewegt sich in einer Bandbreite von 512 KBytes bis zu 16 KBytes. Die Zahl ihrer Pins reicht von 6 bis 32. Auch die anderen Leistungsdaten variieren von Chip zu Chip. Daher sollten Entwickler je nach Einsatzzweck problemlos einen passenden ATtiny-Vertreter finden können, und das nicht nur für den Fall, dass Kompaktheit zu den Anforderungen gehört.

Der ATtiny85 wird relativ häufig von Arduino-Makern eingesetzt (Bild: sparkfun.com)

Der winzigste ATtiny-Prozessor bringt es dabei gerade einmal auf Ausmaße von 1,4 mm x 1,5 mm und gibt sich mit einer Spannung von 0,7 V zufrieden, sodass zur Stromversorgung eine Batterie oder Knopfzelle genügt. Die einzelnen Pins eines ATtiny erweisen sich als sehr flexibel, da Maker einzelne Pins wahlweise für Ein-/Ausgabe, Analog/Digital-Wandlung oder Pulsweitenmodulation nutzen können. Sogar der RESET-Pin lässt sich für I/O umkonfigurieren (siehe unten). Für die Taktfrequenz sorgt der interne Oszillator des Chips. Den erkennt der interessierte Leser rechts oben im Architekturbild des abgebildeten ATtiny25/45/85:

Architektur eines ATtiny 25/45/85-Chips (Bild: ATMEL)

Alle ATtiny-Chips im Detail zu besprechen, ist aufwendig und langweilig. Daher fokussiert sich der vorliegende Beitrag exemplarisch auf häufig genutzte Repräsentanten. Unter den ATtiny-Chips genießen die Vertreter ATtiny25, ATtiny45 und ATtiny85 eine besondere Attraktivität, weil sie Kompaktheit mit Leistungsstärke kombinieren. Besonders der letztgenannte ATtiny85 findet sich sehr häufig in der freien Wildbahn. Mit 8 K Flash, 512 Bytes EEPROM und 512 Bytes SRAM besitzt er genügend Potenzial für kleinere Projekte. Im Gegensatz zu ihrem winzigen Formfaktor haben es die genannten ATtiny-Vertreter auch bezüglich der Rechenleistung in sich. Sie basieren auf einer RISC-Architektur mit 120 Befehlen, die fast ausnahmslos nur einen einzelnen Taktzyklus benötigen. Wie für RISC-Prozessoren typisch steht ein großer Satz von 32 allgemeinen (8-Bit-)Registern zur Verfügung.

Der Betrieb der Chips kann mit verschiedenen Frequenzen und Spannungen erfolgen:

ATtiny25V/45V/85V:  0 –  4 MHz  @ 1.8 - 5.5V,  0 - 10 MHz @ 2.7 - 5.5V 
ATtiny25/45/85: 0 – 10 MHz @ 2.7 - 5.5V, 0 - 20 MHz @ 4.5 - 5.5V

Im aktiven Modus mit niedriger Frequenz und niedriger Spannung (1 MHz, 1,8 V) liegt die Leistungsaufnahme bei durchaus bescheidenen 300 µA.

Der ATtiny85 und seine Brüder ATtiny25 beziehungsweise ATtiny45 besitzen 8 Ausgänge. Im Bild zu sehen ist die DIP-8-Gehäusevariante. Selbstredend sind auch SMT-Varianten verfügbar.

Die 8 Pins des ATtiny85 (Bild: sparkfun.com)

Pinbelegung:

  • Zur Stromversorgung dienen Pin 8 (5 V) und Pin 4 (GND)
  • Der RESET-Eingang liegt an Pin 1
  • Ports 0-4 (d.h., Pins 5, 6, 7, 2, 3) sind als digitale Ein-/Ausgänge nutzbar
  • Davon unterstützen Port 0 (Pin 5) und Port 1 (Pin 6) Pulsweitenmodulation
  • Ports 2, 3 und 4 (= Pins 7, 2, 3) sind ebenfalls als analoge Eingänge zu verwenden und besitzen einen entsprechenden ADC-Wandler mit 10 Bit Auflösung

Insgesamt sind die Pins des ATtiny85 daher auf vielfältige Weise nutzbar, wie auch die nachfolgende Abbildung veranschaulicht:

Beim ATtiny85 können alle Pins mehrere Funktionen bzw. Rollen bereitstellen

Preisfrage: Besitzt ein ATtiny einen I2C oder einen SPI-Bus? Die komplizierte Antwort lautet, je nach Perspektive, entweder "weder ... noch" oder "sowohl ... als auch". Das Thema Bus-Unterstützung ist über eine universelle Komponente gelöst. Der ATtiny85 ermöglicht dank eines USI-Bausteins (Universal Serial Interface) sowohl I2C (TWI)- als auch SPI-Protokoll-Unterstützung. Dazu befinden sich in jedem ATtiny85 ein normaler und ein zusätzlicher hochauflösender Timer, um für das benötigte genaue Timing zu sorgen

Die ATtiny25/45/85 besitzen übrigens keinen seriellen Bus, weshalb eine Kommunikation mit dem seriellen Monitor auf der Arduino IDE standardmäßig nicht möglich ist. Wie sich dem softwaretechnisch begegnen lässt, beschreibt die Webseite "Communication with Tiny's".

Wie kommt eigentlich die Firmware oder der Bootloader auf einen ATtiny? ATtiny-Vertreter lassen sich über ISCP bzw. ISP (In-Circuit Serial Programming) programmieren. ICSP umfasst dabei die sechs Anschlüsse MOSI, MISO, SCK, RESET, VCC und GND. Übrigens: Auf einem Arduino Uno befindet sich der sechspolige, rechteckige ISCP-Anschluss am Fuße des ATmega-Chips.

Für das Programmieren eines ATtiny85 gibt es zahlreiche Programmer, etwa USBtiny oder USBasp. Entsprechende Lösungen kauft der Maker auf eBay für eine Handvoll Euro.

Im Arduino-Menü Tools | Programmer findet sich Unterstützung für diverse vordefinierte Programmer. Auch die Option Arduino as ISP ist dort im Angebot. Sprich: Ein Arduino Uno oder ein anderes Arduino-Board lässt sich als Programmer nutzen. Das ist die einfachste und preiswerteste Lösung, wenn man von der notwendigen Verdrahtung absieht. Bastler, die des Öfteren einen ATtiny programmieren möchten, können sich natürlich eine einfache, aber dauerhafte Lösung auf Basis eines Arduino-Uno-Boards konstruieren.

Um einen Arduino Uno als Programmer zu nutzen, spielen Sie den Sketch ArduinoISP.ino in der Arduino IDE über das Menü ( File > Examples > ArduinoISP ) ein. Beim Besuch dieser Website finden Sie ein Tutorial für das Flashen anderer Boards mit Hilfe eines Arduino Uno.

Die notwendige Schaltung ist auf dem nachfolgenden Fritzing-Diagramm illustriert:

Programmieren eines ATtiny85 mit dem Arduino Uno als Programmer-Hardware

Die Verdrahtung der Pins beider Komponenten lautet wie folgt:

ATtiny85                   Arduino
Pin 1 .................... Pin 10 (RESET)
Pin 2 .................... n/a
Pin 3 .................... n/a
Pin 4 .................... GND
Pin 5 .................... Pin 11
Pin 6 .................... Pin 12
Pin 7 .................... Pin 13
Pin 8 .................... 5V

Empfehlenswert ist des Weiteren für die beschriebene Eigenbaulösung ein Elektrolytkondensator, den Sie am Arduino Uno-Board in den RESET-Eingang (Plus) und einen GND-Ausgang (Minus) stecken.

Damit die Arduino IDE auch ATtiny-ICs unterstützt, braucht es einen entsprechenden Boardsmanager. Geben Sie in Preferences (Arduino | Preferences) folgende zusätzliche Boardsmanager-URL ein:

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager
/package_damellis_attiny_index.json

Um den ATtiny85 über den Uno mittels der Arduino IDE programmieren zu können, müssen Sie nun noch im Boards-Manager (Tools | Boards manager) nach attiny suchen. Sie sollten dann folgende Boards-Bibliothek finden und installieren:

Installation von ATtiny-Unterstütztung in der Arduino IDE

Nun selektieren Sie im Menü (Tools | Boards) den entsprechenden Eintrag: ATtiny25/45/85.

Laden Sie einen Beispielsketch, etwa das obligatorische Blink-Beispiel, bei dem Sie LED Pin 13 durch 0 ersetzen. Dazu sollten Sie freilich an Digitalausgang 0 des ATtiny85 auch eine echte LED anschließen.

Als Programmer geben Sie in Tools | Programmer ein: Arduino as ISP. Sollten Sie eine andere Programmer-Hardware nutzen (siehe oben), dann spezifizieren Sie stattdessen den von Ihnen genutzten Programmer.

Jetzt endlich kann der Maker den Sketch auf den ATtiny85 laden. Den Strom enthält der Chip über den Arduino UNO oder den angeschlossenen ICSP/ISP-Programmer. Selbstredend lässt sich der ATtiny85 danach vom Arduino beziehungsweise vom Programmer trennen und anderweitig mit Strom versorgen, also beispielsweise über Batterie oder FTDI-Board.

Der RESET-Pin lässt sich, wie am Anfang dieses Artikels erwähnt, über Einstellungen der sogenannten "Fuses" des ATtiny zu einem normalen Eingang rekonfigurieren. Das geschieht mit einem gewöhnlichen ISP-Programmer. Allerdings führt dies dazu, dass der Anwender die MCU (Micro Controller Unit) nicht mehr über den ISP-Programmer programmieren kann, sondern einen Programmer mit höherer Spannung benötigt.

Um die veränderte Konfiguration rückgängig zu machen, ist ebenfalls ein solcher "Hochspannungs-Programmer" vonnöten. Der ist käuflich zu erwerben oder lässt sich stattdessen als Eigenbau erstellen, wie zum Beispiel auf der hinterlegten Webseite beschrieben. Eine andere Webseite illustriert, wie Entwickler den RESET-Pin auch ohne zusätzliche Eingriffe als Ausgang benutzen.

Die bequemste und einfachste Option, einen ATtiny ohne größeren Aufwand einzusetzen, sind fertige Mini-Boards wie das Olimexino-85, das es entweder als Selbstbau-Kit oder fertig bestückt für wenige Euro zu kaufen gibt.

Olimexino-85 enthält einen ATtiny85 plus alle weiteren notwendigen Bauteile (Bild: olimex.com)

Das Kit integriert ein FTDI-Board zur Stromversorgung, einen gesockelten ATtiny85, einen Reset-Knopf sowie LEDs und passive Bauteile. Das fertige Board ist Breadboard-kompatibel und führt alle Ausgänge des ATtiny85 nach außen. Demos, Bibliotheken und Firmware stellt der Hersteller Olimex auf dieser GitHub-Seite zur Verfügung.

Kommen wir zum Thema Bootloader. Für ATtiny-Prozessoren hat die Open-Source-Community ein eigenes Projekt namens micronucleus ins Leben gerufen. Dessen primäres Entwurfsziel lautet Kompaktheit. Das Olimexino-85 Board enthält beispielsweise standardmäßig den Micronucleus-Bootloader.

Um das Olimexino-85-Board unter der Arduino IDE zu nutzen, müssen Entwickler dem Boardmanager der IDE in Preferences folgende URL hinzufügen: http://digistump.com/package_digistump_index.json.

Eintrag der URL in die Einstellungen des Boardmanagers der Arduino IDE

Danach werden im Menü Tools | Board | Boards manager die ATtiny-Boards zur Installation angeboten:

Installation der ATtiny-Boards (Digistump) im Boardmanager der Arduino IDE

Suchen Sie einfach nach Digistump AVR Boards.

Wählen Sie für das Olimexino-85 das Board Digispark (Default - 16.5 mhz).

Sobald Sie einen Sketch auf das Board aufspielen wollen, trennen Sie das Board vom USB-Eingang des Hostcomputers. Nach Drücken des Upload-Schalters fordert Sie die IDE auf, das Board über den USB anzuschließen, und anschließend lädt Micronucleus automatisch das Sketch auf den ATtiny.

Neben Olimex bietet auch Adafruit ein Board auf Basis des ATtiny85 für wenige Euro an. Das Trinket-Board inkludiert ebenfalls den auch vom Olimexino-85 genutzen Micronucleus. Adafruit liefert das Board in einer 3-V- oder einer 5-V-Variante aus.

adafruit Trinket Board mit Micro USB (Bild: adafruit.com)

Nähere Information zu dessen Features, Nutzung und Installation befinden sich auf der Trinket-Webseite.

Ein weiteres vergleichbares Board ist das Digistump:

Ein weiteres ATtiny85-Board stammt von Digistump (Bild: digistump)

Doch damit ist noch lange nicht genug. Den Wattuino Nanite 85 gibt es für sechs Euro bei Watterott. Dieses Board folgt dem Nanite-Design. Daneben bietet Watterott auch ein Board auf Basis des ATtiny841 an, der über ein DIP-14-Gehäuse und damit über mehr Anschlüsse verfügt:

Watterott Nanite 86 (Bild: watterott.com)

Und es lassen sich im Internet durchaus einige weitere preisgünstige Boards aufspüren, die ähnliche Funktionalität besitzen. All zu viele Differenzierungsmöglichkeiten gibt es ohnehin nicht.

Um die Arbeit mit dem ATtiny-Prozessoren zu veranschaulichen, folgt nun ein simpler Beispielsketch, der eine einfache Ampelschaltung realisiert. Dazu müssen wir zunächst verstehen, wie eigentlich eine Ampelschaltung funktioniert. Insgesamt gibt es bekanntlich vier Ampelphasen (siehe Abbildung):

Es gibt vier Ampelphasen (Bild: http://bascom-forum.de/mediawiki/index.php/Datei:Ampelphasen.png)
  • Die erste Phase ist die Rotphase.
  • In der zweiten Phase erfolgt der Übergang zur Grünphase. In dieser Zwischenphase sind sowohl das rote als auch das gelbe Signallicht zu sehen.
  • In der dritten Phase leuchtet ausschließlich grün (Grünphase).
  • In der vierten Phase erfolgt der Übergang von Grün zu Rot, den ein gelbes Signal anzeigt.

Natürlich lassen sich bei Ampeln die verschiedenen Phasen unterschiedlich lang gestalten. Das Ganze lässt sich auch beliebig verkomplizieren. Einige Ampeln werden bei wenig Verkehr ganz abgeschaltet oder zeigen ein blinkendes gelbes Signal. In der echten Welt erfolgt zudem an Kreuzungen die gleichzeitige und koordinierte Schaltung mehrerer Ampeln.

Eine triviale Ampelsteuerung wie im nachfolgend beschriebenen Mini-Projekt benötigt allerdings nur begrenzten Aufwand.

Ein Fritzing-Diagramm soll die triviale Breadboard-basierte Schaltung mit drei LEDs (rot, grün, gelb), drei 220-Ohm-Widerständen, und ein wenig Schaltdraht veranschaulichen:

Einfache Ampelschaltung mit OLIMEXINO-85 (Board schematisch dargestellt)

Der Code für die Ampelsteuerung implementiert die vier genannten Phasen in Form einer einfachen Zustandsmaschine (State-Pattern), bei der Methoden die verschiedenen Zustände (phaseOne, phaseTwo, phaseThree, phaseFour) repräsentieren. Ein Zustandswechsel geschieht entsprechend über einfachen Methodenaufruf, etwa Aufruf von phaseTwo() im Rumpf von loop(). Das Listing ist selbsterklärend.

/////////////////////////////////////////////////////////////
//
// Simpler Sketch für ATtiny85
// Ampelsteuerung
//
/////////////////////////////////////////////////////////////


const int RED = 4; // Rote LED
const int YEL = 2; // Gelbe LED
const int GRN = 0; // Grüne LED



// Hilfsdeklarationen:

// Rote LED an / aus:

#define RedOn() digitalWrite(RED, HIGH)
#define RedOff() digitalWrite(RED, LOW)
// Gelbe LED an / aus:
#define YellowOn() digitalWrite(YEL, HIGH)
#define YellowOff() digitalWrite(YEL, LOW)
// Grüne LED an / aus:
#define GreenOn() digitalWrite(GRN, HIGH)
#define GreenOff() digitalWrite(GRN, LOW)
// Timer Rotphase:
#define DelayOne() delay(5000)
// Timer Übergang Rot nach Grün:
#define DelayTwo() delay(2000)
// Timer Grünphase:
#define DelayThree() delay(5000)
// Timer Übergang Grün nach Rot:
#define DelayFour() delay(2000)

void setup() {
// LEDs als Ausgänge:
pinMode(RED, OUTPUT);
pinMode(YEL, OUTPUT);
pinMode(GRN, OUTPUT);
// erst einmal alle LEDs aus:
initialize();
}

// Alle LEDs aus:
void initialize() {
RedOff();
YellowOff();
GreenOff();
}

// Rotphase:
void phaseOne() {
RedOn();
YellowOff();
GreenOff();
DelayOne();
}

// RotNachGrünPhase:
void phaseTwo() {
RedOn();
YellowOn();
GreenOff();
DelayTwo();
}

// Grünphase:
void phaseThree() {
RedOff();
YellowOff();
GreenOn();
DelayThree();
}

// GrünNachRotPhase:
void phaseFour() {
RedOff();
YellowOn();
GreenOff();
DelayFour();
}

// Ausfall => Gelbes Signal blinkend:
void emergency() {
RedOff();
GreenOff();
YellowOn();
delay(500);
YellowOff();
delay(500);
}

void loop()
// Mit Grünphase starten:
phaseThree();
phaseFour();
phaseOne();
phaseTwo(); }
}

Zugegeben, das war eine triviale Anwendung. Ein weiteres Beispiel soll einen etwas komplexeren Anwendungsfall illustrieren. Im diesem komplexeren Beispiel kommt ein 0,96" OLED mit 128 x 64 Pixeln zum Einsatz (der Typ des OLEDs ist SSD1306). Da diese Anzeige einen I2C-Anschluss benötigt, zeigt der Sketch auch exemplarisch die Nutzung von I2C auf dem ATtiny85.

Der Port 0 (PB0) des ATtiny85 fungiert als Datenverbindung (SDA), während der Port 2 (PB2) als SCL-Leitung der Taktung dient.

(Hinweis: Port 0 bzw. PB0 liegt an Pin 5, Port 2 bzw. PB2 an Pin 7 des ATtiny85-Chips.)

Um das OLED über I2C am ATtiny85 zum Laufen zu bringen, ist eine spezielle Bibliothek notwendig, da die I2C-Standardbibliothek Wire für einen ATtiny85 einen zu üppigen Happen darstellt. Zum Glück gibt es Abhilfe:

  • TinyWireM fungiert als IIC-Bibliothek für ATtiny und damit als Ersatz für die codemäßig zu umfangreiche Wire-Bibliothek. "M" steht für Master. Daneben gibt es auch eine separate Slave-Bibliothek TinyWireS, sollten Sie den Tiny als Slave am I2C betreiben wollen. Dass beide Bibliotheken getrennt vorliegen, ist ebenfalls den geringeren Resourcen eines ATtiny85 geschuldet.

Die Schaltung gestaltet sich wie folgt:

Blauer  Draht: ATtiny85 GND                  mit       SSD1306 GND
Roter Draht: ATtiny85 3.3V oder 5V mit SSD1306 Vcc
Grüner Draht: ATtiny85 Port 0 (= Pin 5) mit SSD1306 SDA
Gelber Draht: ATtiny85 Port 2 (= Pin 7) mit SSD1306 SCL

was sich ebenfalls im nachfolgenden Fritzing-Schaltbild zeigt:

OLED Display SSD1306 an Adafruit Trinket 5V

Auf dem Schaltbild ist zwar ein Adafruit-Trinket-Board zu sehen, das sie aber jederzeit durch ein Olimexino-85, ein Wattuino Nanite 85 oder ein beliebiges anderes Breakout-Board mit ATtiny85 ersetzen können.

User AndyB2 hat auf instructables.com eine sehr gute Anleitung und Sourcecode für den Anschluss eines OLEDs an den ATtiny85 zur Verfügung gestellt, sodass Sie auch zwei umfangreichere Beispiele als Anschauungsmaterial beziehen und nutzen können. Maker finden die Anleitung an dieser Stelle. Ich habe mich in meinem eigenen Beispiel an AndyB2 orientiert.

Wegen des begrenzten Datenspeichers des ATtiny85 legt der folgende Sketch unveränderliche Informationen wie zum Beispiel die Bitmuster des verwendeten Thermometer-Logos im Programmspeicher ab. Das ist anhand des Attributs PROGMEM im Programmcode ersichtlich.

Die Storyline des Demoprogrammes ist schnell erzählt.

  • In setup() erfolgt die Initialisierung des OLED, worauf ein Startbildschirm (zeige StartAnzeige()) die textuellen Inhalte "Heise Developer" und "ATtiny85 Demo" ausgibt.
  • Anschließend stellt setup() die Betriebsanzeige dar (zeigeBetriebsAnzeige()). Dort ist die Titelzeile "Anschluss OLED" und das grafische Logo eines Thermometers zu sehen, auf dessen rechter Seite die aktuelle Temperatur (Textfeld mit Label "Temperatur") erscheint.
  • in der loop()-Schleife ermittelt das Programm bei jeder Iteration einen zufälligen Temperaturwert (temperaturmessen()), den es formatiert auf der Betriebsanzeige ausgibt, und eine halbe Sekunde wartet, bis der nächste Schleifendurchlauf erfolgt.
#include "SSD1306_minimal.h" // OLED-Treiber

// Abspeichern von Daten in Programmspeicher:
#include <avr/pgmspace.h>

#define DEG "\xa7" "C"

SSD1306_Mini oled; // ein 128x64 OLED Display 0.97"

// Bild eines kleinen Thermometers:
const unsigned char ThermometerIcon[] PROGMEM = {
0x00, 0xfe, 0x03, 0xfe, 0x50,
0x00, 0xff, 0x00, 0xff, 0x55,
0x60, 0x9f, 0x80, 0x9f, 0x65,
};


///////////////////////////////////////////////////
//
// zeigeStartAnzeige()
// gibt initiale Info am Display aus
//
///////////////////////////////////////////////////


void zeigeStartAnzeige(){

oled.startScreen(); // Anzeige einschalten
oled.clear(); // Anzeige löschen

oled.cursorTo(0,7); // Cursor positionieren
oled.printString( "Heise Developer");

delay(3000);

oled.clear();
oled.cursorTo(15,1);// Cursor positionieren
oled.printString( "ATtiny85 Demo");
}

///////////////////////////////////////////////////
//
// zeigeBetriebsAnzeige()
// gibt Betriebsinfo aus
// ein Logo (Thermometer)
// und einen Temperaturwert
//
///////////////////////////////////////////////////


void zeigeBetriebsAnzeige(){

oled.clear(); // Anzeige löschen
oled.startScreen(); // Anzeige einschalten


oled.cursorTo(0,0);
oled.printString( "Anschluss OLED");
oled.cursorTo(10,2);
oled.printString( "Temperatur");
// und noch Grafik anzeigen:
oled.drawImage( ThermometerIcon, 20,4, 5, 3 );
}



///////////////////////////////////////////////////
//
// temperaturmessen
// simuliert ein Thermometer
//
///////////////////////////////////////////////////
char temperaturmessen() {
return 20 + random(-5,5);
}


///////////////////////////////////////////////////
//
// setup
// OLED initialisieren
// Startbildschirm einblenden
// Betriebsanzeige einblenden
//
///////////////////////////////////////////////////


void setup(){
pinMode(3, INPUT);

oled.init(0x3c); // OLED hängt an IIC-Id 0x3c
oled.clear(); // Anzeige löschen

delay(1000);
zeigeStartAnzeige(); // Initialer Startbildschirm
delay(2000);
zeigeBetriebsAnzeige(); // Betriebsanzeige
}



///////////////////////////////////////////////////
//
// loop
// die eigentliche Messschleife
// laufend messen and auf Betriebsanzeige
// ausgeben
//
///////////////////////////////////////////////////


void loop(){

char buf[10];

// Temperatur ermitteln:
char temperatur= temperaturmessen();

// Formatierte Information erstellen:
sprintf(buf, "%+0.2hd" DEG , temperatur);

// Cursor positionieren:
oled.cursorTo(30, 5);

// Ausgabe des Temperaturwertes:
oled.printString( buf );
delay(500); // Pause zwischen Messungen
}

Wie immer, lässt das abgedruckte Beispiel noch viele Wünsche offen. Wenn Sie Lust haben, könnten Sie zum Beispiel statt des simulierten Temperaturmessers einen echten Sensor nutzen und die Schaltung entsprechend erweitern oder natürlich einen anderen Sensor Ihrer Wahl. Natürlich ist ein entsprechend aufgerüstetes ATtiny-System auch in der Lage, Daten über Radio (RF) zu übertragen. Lassen Sie Ihrer Fantasie ruhig freien Lauf.

Der Ausflug zu den Vertretern der ATtiny-Familie zeigt, dass wir für Projekte nicht unbedingt auf ein Arduino-Board als eierlegende Wollmilchsau zugreifen müssen. Wer es kompakt, günstig und stromsparend liebt, kann auch mit Hilfe eines ATtiny Schaltungen zusammenstellen. Dann reicht unter Umständen auch eine kleinere Batterie oder eine Solarzelle zum Betrieb.

Allerdings hat dieser Ansatz auch physikalische Einschränkungen, was die Mächtigkeit der verfügbaren Kommunikationsmechanismen, die Größe der Speicher oder die Zahl der Ein- und Ausgänge betrifft. Zudem arbeiten Arduino-Bibliotheken nur bedingt und oft nur nach größeren Anpassungen mit den ATtiny-Systemen zusammen.

Sobald die Nachteile keine Rolle spielen und die Vorteile überwiegen, steht dem Einsatz der ATtiny-Famile freilich nichts mehr im Wege.

Anzeige