ATTiny 13 (1-4/4)

Grundbausteine aller Prozessoren, auch des ATTiny-13-Microcontrollers, sind Transistoren. Transistoren kann man sich in der Digitaltechnik als spannungsgesteuerte Schalter vorstellen.

[npn-Tranistor mit LED]

Liegt am Eingang B (Basis) eine positive Spannung an, so schaltet der Transistor durch, und es fließt ein Strom von C (Collector) zu E (Emitter).

Transistoren bestehen aus Halbleiterelementen, das sind Elemente, am häufigsten wird Silizium verwendet, die gezielt mit sogeannten Störatomen "verunreinigt" (dotiert) sind.

 
[Links: n-Dotierung mit Phosphor, rechts: p-Dotierung mit Aluminium. Von Markus A. Hennig; SVG-Umsetzung: Cepheiden - Datei:Silizium-p-Dotiert.png, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=10515060]

Im n-dotierten Material wird ein Elektronenüberschuss erzeugt, im p-dotierten Material ein Elektronenmanko. Durch Kombination von drei Halbleiterschichten, etwa n-p-n, kann durch günstige Schichtdicken (im Vergleich sehr dünne p-Schicht) der für Transistoren typische Schaltungs- und Verstärkungseffekt erzeugt werden.

Wenn in der Abbildung [npn-Transitor mit LED] am Eingang E eine positive Spannung anliegt, dann schaltet der Transistor durch, die LED leuchtet, und Ausgang A wird negativ (der Transistor wirkt wie ein geschlossener Schalter, und A liegt an Masse (GND).

Ein solche Baugruppe heißt in der Halbleitertechnik ein Inverter, weil er praktisch das positive Eingangssignal in ein negatives Ausganssignal und umgekehrt wandelt.

Werden zwei (oder mehrere Transistoren verwendet, dann können Eingänge miteinander logisch verknüpft werden:

[Links: zwei Tranistoren bilden ein NOR-Gatter, rechts: zwei Tranistoren als NAND-Gatter]

Diese Baugruppen nennt man logische Gatter. Ein NOR-Gatter schaltet den Ausgang auf 0, wenn entweder E1 oder E2 1 sind. Ein NAND-Gatter schaltet den Eingang auf 0, wenn E1 und E2 1 sind. Das N vor OR und AND steht für die Invertierung des Ausgangs. Beide Gattertype gehören zu den Grundelementen der digitalen Schaltungstechnik. Alle weiteren lassen sich aus diesen ableiten. Um die grafische Darstellung zu vereinfachen haben sich folgende Symbole eingebürgert:

 
[Logik-Gatter]

Verbindet man nun die Gattertypen zu einem sogenannten D-Flip-Flop, dann hat man damit im Prinzip eine Speicherzelle, die ihren Zustand auch nach Änderung der Dateneingänge beibehält, wenn kein Clock-Signal anliegt:

[D-Flip-Flop]

Auch dafür gibt es ein eigenes Symbol zur Vereinfachung:

[D-Flip-Flop-Symbol]

Schaltet man nun acht dieser D-Flips-Flops mit einer gemeinsamen Clock-Leitung zusammen, erhält man ein 8-Bit-Register (RAM oder Arbeitsregister):

[8-Bit-Register]

In einem Prozessor gibt es zwei verschiedene Bündel von Leitungen: den Daten-Bus und den Adress-Bus. Während der Daten-Bus direkt an den Registereingängen (D0 - D7) anliegt, filtert eine eigene Logik aus dem Adressbus die richtige Clock-Leitung heraus, damit das richtige Register adressiert wird.

Die "mathematischen" Fähigkeiten eines Prozessors werden ebenfalls mit Logikgattern realisiert. Dieses Rechenwerk wird ALU (Arithmetisch-logische Einheit) genannt. Ein spezielles Register, das Statusregister registriert dabei, ob bei der letzten Operation z. B. ein Überlauf (Carry) stattgefunden hat, das Ergebnis 0 oder negativ war u. a. m.. Ein Programm kann dann davon ausgehend eine gezielte Aktion starten.

Wem die eingeblendete Werbung nicht zu viel ist, kann Näheres dazu hier finden.

Im Folgenden einige Vorschläge für den Einsatz des ATTiny 13 im Unterricht. Natürlich ist es von Vorteil, schon beim Entwurf des Microcontroller-Boards dieses auf den Einsatzzweck hin zu optimieren. So können alle benötigten Bauteile schon aufgelötet werden.

Hier einige Ideen für das vorgestellte Experimentierboard mit Zusatzverdrahtung oder eigenen neuen Boards:

1. Ausgabe eines Registerinhalts mit einer eingebauten LED

Oft ist es für Fehlersuche notwendig, einen Register- oder Speicherinhalt zu kennen. Selbst mit den begrenzten Anzeigemöglichkeiten des Experimentierboard gibt es die Möglichkeit dazu. Eine Variante ist das oder die anzuzeigende/n Byte/s als eine Art Morsecode (0 = kurz, 1 = lang) seriell als Blinkzeichen über eine LED anzuzeigen.

2. Lauflicht

Wem die zwei eingebauten LEDs nicht reichen, kann man mit einer trickreichen Beschaltung bis zu 8 LEDS mit dem ATTiny 13 ansteuern, wie z. B. hier verdeutlicht: https://www.elektronik-labor.de/AVR/0113Lauflicht.html. Damit kann ein Lauflicht betrieben werden.

3. Thermostat

Der Attiny 13 kann gut als Thermostat arbeiten, er besitzt die nötigen Eingänge für analoge Temperaturmessung und kann mit den Ausgängen ein oder mehrere Relais schalten. Die Programmierung eines analogen Temperatursensor ist hier zu finden.

4. Verkehrsampel

Eine Verkehrsampelsimulation mit drei LEDs. Ein Taster dient als Fußgängeranfrage für die Ampelumschaltung.

5. Verbinden mehrer Geräte

Zwei ATTinys koppeln und eine Datenübertragung zwischen den Teilen aufbauen. Dazu entweder auf etablierte Protokolle, wie das  I²C-Protokoll (für den Arduino MicroCore gibt es eine Bibliothek dazu) verwenden, oder warum nicht ein eigenes, ein proprietäres Protokoll ersinnen lassen. Gut geeignet für Teamarbeit.

6. Bewegungsmelder

Ein einfacher Ultraschall-Entfernungsmesser kann mit dem ATTiny verbunden dazu dienen, Bewegungen zu detektieren und zusammen mit einem Relais z. B. Licht oder Ventilator einzuschalten.

7. CO2-Detektor

Der hier beschriebene CO2-Detektor kann auch mit dem ATTiny 13 realisiert werden, einzig die Anzeige muss sich auf z. B. LEDs (z. B. als Ampel) oder ein Relais beschränken. Zur Abfrage des Messwerts muss die PWM-Methode gewählt werden.

8. Luftdruckmessung

Wie hier beschrieben kann auch der ATTiny 13 den Arduino ersetzen, auch hier gilt: Die Anzeige kann mit LEDs realisiert werden.

9. LED-Display-Anzeige

Der ATTiny 13 hat für ein I²C-OLED genug Anschlusspins, um es direkt anzusteuern und auch der Speicherplatz reicht, wenn sparsame Rouinen verwendet werden (z. B. bei diesem Projekt eingesetzt). Für anspruchsvoller Aufgaben weicht man am besten auf Modelle mit mehr Speicher (z. B. ATTiny 85) oder auf ein Modell mit mehr Pins (z. B. ATTiny 24) aus. Hier eine Lösung mit dem ATTiny 13 und externen Bauelementen für eine Standard-LED-Anzeige:

[Porterweiterung mit 74HC959 für Ansteuerung eins 2x16 LEDs]

10. Infrarot Fernsteuerung

Eine wirklich kleine (tiny !) IR-Fernsteuerung mit dem ATTiny 13 wird hier: https://github.com/wagiminator/ATtiny13-TinyRemote  vorgestellt. Man kann diese natürlich auch ohne SMD-Technik, mit etwas größerer Platine und TH-Baulelementen realisieren. Naürlich kann man auch den passenden Empfänger dazu herstellen: https://github.com/wagiminator/ATtiny13-TinyDecoder

11. Drehzahlmesser

Ein Drehzahlmesser mit OLED-Anzeige wird hier: https://github.com/wagiminator/ATtiny13-TinyTacho vorgestellt.

Für den ATTiny 13 gibt es auch die Möglichkeit, ihn mit der Arduino IDE zu programmieren. Dazu muss die Erweiterung MicroCore installiert werden, die die Arduino Systemaufrufe für den ATTiny 13 zurechtschrumpft.

Unter Datei -> Voreinstellungen findet sich der Eintrag "Zusätzliche Boardverwalter-URLs". Hier die Bezugsadresse

https://mcudude.github.io/MicroCore/package_MCUdude_MicroCore_index.json

eintragen. Unter Werkzeuge -> Board ->Bordverwalter anklicken. Im anschließenden Dialog sollte evtl. nach kurzer Wartezeit der Eintrag MicroCore zu finden sein. Diesen anklicken und installieren.

Aufgrund des geringen Speichers, sind nicht alle Arduino-Befehle verfügbar. Die Arduino-IDE erzeugt natürlich auch einen gewissen zusätzlichen Speicherbedarf (Overhead).

Auf der Projektseite des Entwicklers gibt es eine Beschreibung der zur Verfügung stehenden Arduino Befehle, ggf. mit Einschränkungen.

Anleitungen und Tutorials zu Arduino finden sich hier. Das Programm (in der Arduino-IDE "Sketch" genannt) kommt dann wie hier beschrieben auf das Experimentierboard.

Blinken mit Arduino-IDE

/**
 * Ein Arduino-Sketch zum Testen des ATTiny-Experimentierboards
 * Lässt die Leuchtdioden im Rhythmus eine, beide, keine aufleuchten.
 * 
 * Die Konstanten OUTPUT, HIGH und LOW gehören zum Arduino Framework
 */

/**
 * LED1 an pin 3 (entspricht PB3 lt. MicroCore-Konvention)
 * LED2 an pin 4 (entpsricht PB4 lt. MicroCore-Konvention)
 */
#define LED1 3
#define LED2 4

/**
 * Die setup-Funktion wir beim Programmstart nur einmal aufgerufen
 */
 
void setup() {

  // Datenrichtungsregister für LEDs
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);

}

/**
 * Die loop-Funktion wird in einer Endlosschleife wiederholt aufgerufen.
 */
 
void loop() {

  // LED1 einschalten
  digitalWrite(LED1,HIGH);
  delay(500);

  // LED2 einschalten
  digitalWrite(LED2,HIGH);
  delay(500);

  // beide aus
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,LOW);
  delay(500);
  
}

Der ATTiny 13 kommt zwar aus derselben Chipfamilie wie der ursprüngliche Arduino, lässt sich aber nicht wie dieser zum Progammieren einfach an den PC anschließen.

Das notwendige Interface mit dem PC wird als ISP-Programmer bezeichnet. ISP steht für In-System-Programming und bezeichnet die Fähigeit des ATTiny im fertig eingelöteten Zustand programmiert zu werden. Auf dem Board findet sich dazu ein ISP-Anschluss im 10-pin-Standardformat. Die für die Programmierung nötigen Ports dürfen dafür aber nicht inkompatibel beschaltet werden (z. B. auf Masse gelegt werden, oder Relais antreiben). Ist so etwas für einen entsprechenden Port notwendig, muss z. B. mit einem Jumper dafür gesorgt werde, dass diese Funktionalität während des Programmiervorgangs abgetrennt werden kann.

 
[Pinbelegung der 6-pin und 10-pin Standardverbindung, Steckeranschlüsse von unten, Pin-1-Markierung beachten!]

Es gibt ISP-Programmer für kleines Geld bei verschiedenen Anbietern. Die Geräte heißen meist USBASP-Programmer.

[USBASP-Programmiergerät]

Leider wird bei Billiggeräten der USB-Chip auf dem Programmer unter Windows nicht immer erkannt, in diesem Fall ist es notwendig, einen Zusatztreiber zu installieren, z. B. den Zadig-Treiber.

ISPASP-Programmer in Microchip Studio

Um den Microcontroller mit einem USB-ISP (USBASB) oder Arduino zu programmieren, braucht es ein Zusatzprogramm, das die Kommunikation mit dem Microcontroller herstellt: Avrdude.

Avrdude kann entweder direkt heruntergeladen werden oder kommt mit der Installation von WinAVR oder Arduino auf den Rechner.

Im Menüpunkt Tools -> External Tools kann der Avrdude mit den für den USB-ISP nötigen Paramtern eingerichtet werden:

 
[Microchip Studio -> Tools -> External Tools]

Unter "Command" wird der Pfad zu avrdude.exe angegeben (falls das Programm über WinAVR installiert wurde, reicht avrdude.exe als Angabe).

Unter "Arguments" kommen die für Avrdude nötigen Kommandozeilenargumente:

• Release-Version: -c usbasp -p t13 -U flash:w:"$(TargetDir)$(TargetName).hex":i
  
• Debug version: -c usbasp -p t13 -U flash:w:"$(ProjectDir)/Debug/$(ItemFileName).hex"
• Verwendet man das mit der Arduino-IDE installierte avrdude ist die Arguments-Zeile um die Angabe des Pfads zur avrdude.conf-Datei zu ergänzen, z. B.: -C"C:\Program Files (x86)\Arduino\hardware\tools\avr\etc\avrdude.conf"

Leider kann bei der Verwendung des USB-ISP (USBASP) nicht der Kompilierungsprozess (Build) und die Übertragung des Programms auf den Microcontroller in einem Durchlauf geschehen, sondern zuerst wird das Programm kompiliert (Build -> Build Solution oder F7) und danach mit Tools->USBASP Release (oder wie immer man die Tools benannt hat) programmiert.

USBASP mit Arduino-IDE

In der Arduino-IDE kommt ein USBAsp-Interface beispielsweise mit der Installation der ATTiny 13 MicroCore-Erweiterung in die Auswahlliste unter Werkzeuge -> Programmer -> USBAsp (MicroCore). Die Übertragung des Programms geht über den Menüpunkt: Sketch -> Hochladen mit Programmer. Wird das Gerät nicht erkannt, bzw. kommt die Meldung, dass der serielle Port falsch ist, dann sollte mit Hilfe des Zadig-Tools ein neuer Treiber ausprobiert werden. Mit der Arduino-IDE funktioniert normalerweise der libusbK-Treiber.

Arduino als ISP-Programmiergerät

Auch der Arduino kann als USB-Programmiergerät verwendet werden. Dazu ist mit der Arduino-IDE der Sketch "ArduinoISP", zu finden unter Dateien -> Beispiele auf den Arduino zu laden.

Die Verbindungs-Pins können ggf. im Sketch angepasst werden, die Standardbelegung für die meisten Arduinomodelle ist wie folgt:

[Die Status-LEDs sind optional]

Achtung: Wenn Arduino und Microcontrollerboard verschiedene Spannungen haben, dann entsprechende Vorsichtsmaßnahmen ergreifen, Versorgungen separat und ggf. TTL-Wandler zwischenschalten.

Beim Arduino-UNO können auch folgende Pins verwendet werden, VCC und GND sind beliebig:

• PIN 10 -> RESET
• PIN 11 -> MOSI
• PIN 12 -> MISO
• PIN 13 -> SCK

Arduino-ISP mit Microchip Studio

Für die Programmierung des ATTiny 13 mit Hilfe eines Arduino UNO (oder eines anderen Modells) wird ebenfalls avrdude verwendet. Sie können es hier herunterladen oder das in der Arduino-IDE enthaltene verwenden (ggf. mit der Suchfunktin nach avrdude.exe suchen).

In Microchip Studio unter Tools -> External Tools auf "Add" und dann die drei Felder:

• Title: Arduino Debug
• Command: Pfad zur avrdude.exe, z. B.: C:\avrdude\avrdude.exe
• Arguments: Debug-Version: -e -v -p t13 -c arduino -P COM9 -b 19200 -D -U flash:w:"$(ProjectDir)Debug$(ItemFileName).hex":i

[Arduino als ISP-Programmer mit Microchip Studio verwenden]

Zu beachten:

• Der serielle Anschluss, den der Arduino belegt (hier COM9) ist den eigenen Gegebenheiten anzupassen, am leichtesten findet man ihn heraus, wenn man die Arduino-IDE startet und unter Werkzeuge -> Port nachschaut.
• Verwendet man das mit der Arduino-IDE installierte avrdude ist die Arguments-Zeile um die Angabe des Pfads zur avrdude.conf-Datei zu ergänzen, z. B.: -C"C:\Program Files (x86)\Arduino\hardware\tools\avr\etc\avrdude.conf"
• Wenn die Release-Dateien verwendet werden sollen, dann ist die Angabe des Hex-File-Pfades in den Arguments anzupassen: -U flash:w:"$(TargetDir)$(TargetName).hex":i

Arduino-ISP mit Arduino-IDE

Im Menüpunkt "Werkzeuge" -> Programmer -> Arduino as ISP (MicroCore) wählen. Danach kann mit Sketch -> Hochladen oder Sketch -> Mit Programmer hochladen (beides bewirkt dasselbe) der ATTiny-13-Sketch kompiliert und via Arduino-ISP auf das Experimentierboard übertragen werden.