Microcontroller (1-10/10)

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);
  
}

Microchip Studio ist eine integrierte Entwicklungsumgebung mit einem sehr guten Fehlersuchsystem (Debugger) und der Möglichkeit, den Programmablauf zu simulieren.

Das Programmpaket ist kostenlos, aber sehr umfangreich, weshalb für die Installation einige Zeit veranschlagt werden muss.

Es erlaubt die Programmierung von AVR-Prozessoren (zu denen auch der ATTiny 13 gehört) in Assembler (manchmal auch "Maschinensprache" genannt), in C und C++.

Assembler-Beispiel

Ein einfaches Blink-Programm in Assembler kann so aussehen:

/*
 * Das Programm lässt zwei Leuchtdioden abwechselnd blinken
 */

/*
 * Die .INCLUDE-Anweisung importiert die Namen der Register
 */

.INCLUDE "tn13def.inc"

/*
 * Der Befehl legt ganz am Beginn des Programmspeichers einen Sprungbefehl
 * zum eigentlichen Programm. Die ersten zehn Speicheradressen bilden die 
 * sogenanten Interrupt-Vektoren. Das sind Sprungbefehle, die aufgerufen werden,
 * wenn ein Interrupt auftritt. Auf Platz 0x0000 befindet sich der RESET-Vektor,
 * der beim Start oder Neustart des Microcontrollers aufgerufen wird.
 * Streng genommen ist das für das simple Programm hier nicht notwendig, da es
 * keine weiteren Interrupts aufruft. Es könnte also genausogut gleich auf 0x0000
 * beginnen.
 */

rjmp Anfang

/*
 * Die Direktive .ORG teilt dem Assembler mit, dass die nächsten Befehle ab der
 * hier angegeben Adresse abgelegt werden sollen. SRAM_START zeigt auf
 * Speicherplatz 0x0010, gleich hinter die Interrupt-Vektor-Tabelle.
 */

.ORG SRAM_START

/* 
 * Hier beginnt das Programm. Das Label "Anfang" markiert die Einsprungadresse
 * für den Sprungbefehl im RESET-Vektor
 */

Anfang:
      ldi   r16,0b00011000 ; PB3 und PB4 als output
      out   ddrb,r16    ;Datenrichtung

/*
 * Blinkschleife mit zwei LEDs: Die LEDs werden abwechselnd ein und ausgeschaltet, der rcall-Befehl
 * ruft ein Unterprogramm auf, das nichts tut außer einige Zeit zu warten.
 */

Blinken:

      ldi   r16,0x08    ;8 = 0x08
      out   portb,r16   ;PB3 = 1, PB4 = 0
      rcall Warten      ;Unterprogrammaufruf

      ldi   r16,16      ;16 = 0x10
      out   portb,r16   ;PB3 = 0, PB4 = 1
      rcall Warten      ;Unterprogrammaufruf

rjmp  Blinken

/*
 * Warteroutine: normalerweise sollte hier mit Hilfe der eingebauten Timer und Interrupts eine
 * präzisere Pausenfunktion realisiert werden - vor allem aber eine, die den Microcontroller hier
 * nicht mit Nichtstun aufhält.
 */

Warten:
      Ldi   r18,2
Warten1:                ;äußere Schleife1
      Ldi   r17,250
Warten2:                ;äußere Schleife2
      ldi    r16,250
Warten3:                ;innere Schleife
      dec   r16
      brne  Warten3
      dec   r17
      brne  Warten2
      dec    r18
      brne  Warten1
      ret                   ;Rücksprung

C-Beispiel

 /*
 * Auch dieses Beispiel lässt die beiden LEDs der ATTiny-Experimentierboards als "Lauflicht" blinken.
 */ 

/*
 * Die Variable F_CPU wird von einigen Bibliotheken, darunter der hier verwendeten delay-Bibliothek
 * benötigt, um die Wartezeiten zu berechnen. Damit die Resultate stimmig sind, sollte die Variable
 * an die tatsächlich verwendeten Einstellungen angepasst werden.
 * Der ATTiny 13 wird mit einer voreingestellten internen Frequenz von 9,6 MHz und einem Prescaler
 * (teilt die Taktfrequenz herunter) von 8 ausgeliefert, das macht 1,2 MHz. 
 */

#define F_CPU 1200000UL

/*
 * Die Standardbibliotheken werden eingebunden
 */

#include <avr/io.h>
#include "avr/iotn13.h"
#include "util/delay.h"

/*
 * Das Hauptprogramm: Nach der Setup-phase, in der das Port-Richtungs-Register für PB3 und PB4
 * gesetzt werden geht das Programm in eine Endlosschleife (while(1)).
 */

int main(void)
{
    unsigned int i;
    
    // PORTB als Ausgang
    DDRB = 0b00011000; 
    
    while(1)
    {
        // Led sukzessive einschalten
        for (i=3;i<5;i++) {
            PORTB = (1<<i);
            _delay_ms(500);
        }

        // alle wieder ausschalten
       PORTB = 0b00000000;
       _delay_ms(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.

Die mit dem Platinenlayoutprogramm entworfene Platine kann auf mehrere Arten hergestellt werden:

Variante 1, Auftragserteilung an Firma: Das ist die einfachste, aber sicherstes Variante. Es gibt eine Reihe von Anbietern in Europa und v. a. in China, die Platinen sehr kostengünstig in Kleinserien herstellen. In der Regel sind einige Tage bis zur Lieferung einzukalkulieren. Für fritzing ist das besonders einfach, es ist schon ein Anbieter fest verdrahtet.

Die Platinenhersteller verlangen in der Regel ein spezielles Exportformat, das Gerber heißt. Jedes Layoutprogramm kann die nötigen Dateien erzeugen. Manchmal ist es auch möglich, die Originaldatei des Layoutprogramms hochzuladen (z. B. bei fritzing).

Variante 2: Man kann die Platine auch mit einer CNC-Fräsmaschine herstellen. Dazu werden die Umrisse der Leiterbahnen frei gefräst. Für die Ansteuerung sind verschiedene Arbeitsschritte und eine eigene "Toolchain" notwendig, abhängig auch von der Fräsapparatur.

Variante 3: Die Leiterbahnen werden mit einem geeigneten Ätzmittel frei geätzt. Dazu müssen die Leiterbahnen auf die rohe Kupferplatine übertragen werden und selber ätzfest sein. Als Ätzmittel eignen sich u. a. Eisen-III-Chlorid, Salzsäure oder Natriumpersulfat. Bei allen drei Chemikalien sind besonders im schulischen Einsatz die nötigen Sicherheitsmaßnahmen (Brille, Handschuhe und Laborschürze) zu beachten. Da Salzsäure etwas gefährlicher ist und Eisen-III-Chlorid unangenehm riecht und nicht transparent ist, so dass der Ätzfortschritt nicht gut mitverfolgt werden kann, ist Natriumpersulfat das Mittel der Wahl.

Im ersten Schritt müssen die Leiterbahnen des Layouts auf die Platine gebracht werden.

Die simpelste Methode und bei einfachen Platinen auch durchaus möglich, ist das Nachzeichnen der Leiterbahnen mit säurefesten Stiften (Nagellack tut's übrigens auch). Dazu am besten den ausgedruckten Entwurf als Bohrschablone nutzen und zuerst die Löcher in die Rohplatine bohren. Diese dienen dann als Ankerpunkte für die Zeichnung.

Vielfach wird die sogenannte Thermo-Transfer-Methode vorgeschlagen. Dabei wird der Entwurf mit einem Laserdrucker auf ein leicht wasserlösliches Papier ausgedruckt (es werden häufig Katalogseiten von Elektronikversandhäusern empfohlen). Der Ausdruck wird dann z. B. mittels Bügeleisen (ca. 150 Grad) auf die sauber geputzte Platine aufgebügelt. Das Papier dann im warmen Reinigungsmittelbad langsam auf- und abgelöst.

Für anspruchsvollere Aufgaben kann auch eine photopositiv beschichtete Platine verwendet werden. Das Platinenlayout wird dabei auf eine transparente Folie oder dünnes Papier ausgedruckt und auf die belichtungsempfindliche Platinenschicht aufgelegt. Zur Belichtung wird UV-Licht benötigt. Die Belichtungszeiten sind je nach verwendeten Materialien und Lichtquellen am besten experimentell zu ermitteln. Sonnenlicht funktioniert auch, es ist allerdings schwierig hier konstante Bedingungen zu schaffen. Diese Methode wird im Folgenden näher beschrieben.

Platine belichten und entwickeln

Das auf Folie gedruckte Platinemlayout wird mit der bedruckten Seite auf die Platine gelegt, damit das Licht nicht unter die gedruckte Leiterbahn kommt. Mit einer Glasscheibe wird dafür gesorgt, dass die Folie plan anliegt.

[Folienausdruck mit UV-LEDs bestrahlt]

Positivlacke bestehen meist aus Harz (Novolak), einer fotoaktiven Komponente (z. B polymere Diazoverbindungen) und einem Lösungsmittel. Beim Belichten bricht die fotoaktive Komponente auf und kann mit einem Bad in Entwicklerflüssigkeit, Ätznatron (Natriumhydroxid, NaOH), entfernt werden. Die bei der Belichtung abgedeckten Teile bleiben stehen. Beim Ausdruck mit Laserdrucker auf Klarsichtfolien (Overhead-Folie) ist die Deckkraft des Toners oft zu gering für gute Ergebnisse, es empfiehlt sich die Folie in doppelter Ausführung übereinandergelegt zu verwenden.

Folgende Zahlen dienen als Richtwerte:

• 10-15 g Entwickler pro 1 Liter Wasser
• Arbeitstemperatur ca. 20 °C
• ca. 60 Sekunden Entwicklungszeit

[Fertig entwickeltes ATTiny 13 Experimentierboard]

Platine ätzen mit Natriumpersulfat

Nach dem Entwickeln empfiehlt sich eine Sichtkontrolle der Platine, man kann hier Brücken zwischen Leiterbahnen noch mit einem geeigneten Werkzeug (Messerchen) auftrennen und fehlerhafte Verbindungen mit einem säurefesten Stift (Permanentstift) ausbessern.

Die Platine gut abwaschen, bevor sie in das Ätzbad kommt, damit die verwendeten Chemikalien nicht miteinander reagieren.

Richtwerte für die Arbeit mit Natriumpersulfat:

• 200-250 g Ätzmittel auf 1 Liter Wasser
• 40-50 °C Arbeitstemperatur
• 10-20 Minuten Ätzzeit, abhängig von der Schichtdicke des Kupfers

Das Ätzbad sollte etwas in Bewegung gehalten werden, was die Gleichmäßigkeit beschleunigt. Das Kupfer löst sich gemeinhin vom Rand her, zentrale Bereiche brauchen länger.

Die chemischen Vorgänge beim Ätzen mit Natriumpersulfat sind hier im Detail beschrieben.

[Platine im Atzbad, die freien Kupferstellen färben sich rosa]

Bohren und Bestücken

Die meisten Bohrlöcher auf THT-Platinen (Through Hole Technology), wie die des ATTiny 13 Experimentierboards haben den Durchmesser von 0,8 mm, einige von 1,2 mm. Es gibt die entsprechenden Bohrer mit dickerem Schaft, so dass sie auch in normale Bohrmaschinen eingespannt werden könnten. Am besten eignet sich natürlich eine Miniaturbohrmaschine mit Bohrständer.

Vor dem Löten empfiehlt es sich, die Platine z. B. mit Aceton von Lackresten zu befreien, um sie besser lötbar zu machen.

Kleinere Fehler auf der Platine können jetzt noch ausgebessert werden, unterbrochene Leiterbahnen können mit Lötzinn oder dünnen Drähtchen überbrückt werden. Unbeabsichtigte Brücken zwischen den Leiterbahnen können mit einem scharfen Messer aufgetrennt werden.

[Ein verirrter Fingerabdruck mit Folgen]

Beim Bestücken fängt man am besten mit den flachen Bauteilen an, insbesondere den Drahtbrücken, und arbeitet sich dann in der Bauhöhe voran. Es wird oft empfohlen die Beinchen der Bauteile vor dem Löten auf das richtige Maß zu bringen, um mechnische Belastungen durch Abzwicken zu vermeiden. Die Praxis zeigt, dass das selten ein Problem ist.

[Fertig bestückte Platine]

Für das Projekt kann auf verschiedene frei verfügbare Layoutprogramme zurückgegriffen werden, die sich in Komplexität und Aufwand deutlich unterscheiden. Allen gemeinsam ist, dass sie die Möglichkeit bieten, den Schaltplan mit Elementen aus Bauteilebibliotheken zu zeichnen. Diese Bauteile mit den entsprechenden Maßen und Verbindungen untereinander werden dann zu einer funktionierenden Platine "entflochten". Professionelle Programme machen das halb- oder bei entsprechenden Einstellungen auch vollautomatisch ("Autorouter").

Durch die Verknüpfung von Schaltplan und Platinenlayout werden Fehler vermieden, z. B. vergessene Verbindungen.

Schaltplaneditoren

Wer quasiprofessionelles Layouten mit gutem Autorouter haben möchte, kann auf "Eagle" der Firma Autodesk zurückgreifen. Die Lizenz ist Teil der "Fusion 360-Lizenz" und als Educational-Variante gratis, muss aber jedes Jahr per Nachweis, dass man einer Bildungseinrichtung angehört, erneuert werden. Das lohnt sich wohl nur, wenn auch andere Software des Fusion-360-Pakets benutzt werden, z. B. der CAD-Editor für 3D-Drucke.

KiCad ist ebenfalls für gehobene Ansprüche eine gute Wahl und ist als Open-Source-Software kostenfrei downloadbar.

Die einfachste Variante ist fritzing. Ursprünglich von der Fachhochschule Potsdam entwickelt, ist die Weiterentwicklung nach längerer Pause jetzt wieder im Gange. Die aktuelle Version kann gegen einen einmaligen Obulus heruntergeladen werden, der Quellcode ist aber Open Source. Allerdings sind ältere Versionen weiterhin verfügbar und können im Gegensatz zur aktuellen Version uner Windows nach einfachem Entpacken z. B. auch vom USB-Stick gestartet werden. fritzing bietet zusätzlich eine für den Unterricht gut nutzbare "Steckbrettansicht" der Schaltung.

Hier ein Schnelleinstieg in fritzing:

[Eine Einführung in fritzing von StartHardware]

ATTiny-Experimentierboard

Der folgende Schaltplantvorschlag für ein ATTiny 13 Experimentierboard bietet Folgendes:

• 10pin ISP-Anschluss
• Schraubklemme für Stromanschluss
• 2 LEDs für Statusanzeigen
• 1 Taster für Eingabe
• 1 aushängbares Potentiometer für analoge Messungen
• Steckleiste für die Ausgänge PB0 - PB4, VCC und GND, um exteren Bauteile zu verbinden

 Stückliste:

• R1, R3: 220Ω 1/4 Watt
• R2: Trimmer 10kΩ 1/4 Watt, 0,6 mm
• R4, R5: 10KΩ 1/4 Watt
• C1: 100nF 16V
• U1: ATTiny 13 PDIP
• LED1, LED2: 3mm
• S1: Taster mit 4 pins 5mm
• J1: Stiftleister 7pins
• J2: Stiftleister 2 pins
• J3: Schraubklemme lötbar 5 mm
• ISP-10: Wannstecker 2x5 pins
• Einseitige Platine (top view)

 Bei der Bestückung der einseitigen Platine die sieben Drahtbrücken (gelb) nicht vergessen:

[Bestückungsplan Experimentierboard]

Das Projekt beschränkt sich auf wenige fix verdrahtete Zusatzbauteile, kann aber als Grundlage für spezifischere Anwendungsfälle (vgl. Projektideen) verwendet werden.

LEDs erzeugen mit wenig Strom viel Licht und eignen sich daher für die direkte Ansteuerung durch die Ausgänge des Microcontrollers. Für stromhungrigere Ansteuerelemente wie z. B. Motoren oder Glühlampen muss ein sogenannter Treibertransistor vorgeschaltet werden.

[LED Schaltplansymbol und Abbildung]

Der Strom durch die LEDs muss durch einen Widerstand begrenzt werden, damit sie nicht durchbrennen bzw. der Microcontroller nicht zu viel Strom zieht, was den Ausgang beschädigen könnte. Für eine sichere positive Polung des Reset-Eingangs im Betrieb ist ebenfalls ein Widerstand vorgesehen (vgl. hier). Die Widerstandswerte von Widerständen in Steckausführung sind als Farbringe codiert.

[Widerstandswerte sind mit Farbcodes angegeben]

Tasten dienen der Eingabe von digitalen Signalen und können ebenfalls direkt mit einem Microcontrolleranschluss verbunden werden.

[Taster - Achtung: je zwei Pins sind kurzgeschlossen!]

Ein Potentiometer oder Trimmer ist ein einstellbarer Widerstand und kann für Experimente mit den analogen Eingängen benutzt werden oder als Eingabe dienen.

[Trimmer oder Potentiometer sind regelbare Widerstände]

Eine 2x5-polige Pfostenleiste dient als Programmieranschluss für den In-System-Programmer (ISP).

[Pfosten- oder Wannenstecker]

Eine 1x5-polige Stiftleiste dient als Anschlusstelle für ein Steckbrett für weitere Komponenten.

Mit einer 2-poligen Stiftleiste, auch Jumper genannt, können bestimmte Teile der Schaltung gekoppelt oder entkoppelt werden.

[Stiftleisten gibt es als lange Reihen zum Selberkürzen in beliebiger Länge]

Und schließlich noch eine Schraubklemme für den Anschluss eines Batteriebehälters für den autonomen Betrieb des Microcontrollers.

[2er Schraubklemme]

Microcontroller sind Miniatur-Prozessoren, die mit geringem Aufwand in eigene Schaltungen eingebaut werden können. Es gibt verschiedene Anbieter mit jeweils großem Produktumfang.

Für das hier vorgestellte Projekt kommt ein Microcontroller der Firma Microchip (ehemals ATMEL) zum Einsatz, der "ATTiny 13" (Datenblatt).

Eigenschaften

Den ATTiny 13 gibt es in verschiedenen Bauvarianten und mit verschiedenen elektrischen Eigenschaften.

Für Eigenbauprojekte eignet sich die sogenannte 8-PDIP/SOIC Variante, die auch in einem Steckbrett benutzt werden kann:

[Abbildung: 8-PDIP ATTiny 13]

Alle Varianten arbeiten mit einer Spannung von 3 - 5,5 Volt und können mit mindestens 10 MHz internem Takt betrieben werden.

Der ATTiny 13 hat:

• einen 8-Bit-Timer für u. a. zwei PWM-Kanäle
• 4 ADC-Wandler mit 10-bit Auflösung
• einen Watchdog-Timer mit separatem Oszillator
• einen Analog-Comparator

Speicher (Memory)

Der ATTiny 13 arbeitet mit 8-Bit Daten und mit 16-Bit Adressdaten für den Flash-Programmspeicher.

Er hat gerade mal

• 1 KByte Programmspeicher in FLASH-Technik, entspricht in der Funktion einer Festplatte, wird allerdings normalerweise nicht zum Abspeichern von Daten verwendet,
• 64 Byte EEPROM, das ist ein Speicher, der von einem Anwendungsprogramm genutzt werden kann um Daten abzulegen, die auch nach einem Stromausfall erhalten bleiben,
• 64 Byte SRAM, das entspricht dem normalen RAM eines PCs, der Speicherinhalt geht beim Neustart verloren.

Dazu kommen noch 32 Byte sogenannte Arbeitsregister (zum "Rechnen") und 64 Byte Input/Output-Register zur Ansteuerung der diversen Funktion, z. B. um auszuwählen, ob ein Anschlusspin als digitaler Eingang oder Ausgang verwendet werden soll.

Der Programmspeicher wird mit 16 Bit adressiert und belegt die Adressbereiche 0x0000 bis 0x01FF.

Die Register, I/O-Register und das interne SRAM werden mit 8 Bit adressiert und sind in vom Programmspeicher getrennten Speicherbereichen von 0x00 bis 0x9F abgelegt:

[Abbildung: Register und SRAM]

Das EEPROM wird ebenfalls separat mit 8-Bit-adressiert und geht on 0x00 bis 0x40.

Anschlüsse

Der ATTiny 13 ist ein Winzling unter den Microcontrollern und hat gerade mal 8 Anschlussbeinchen (Pins), weil er aber auch ein echter Allerkönner ist, sind diese gleich mit mehreren Funktionen belegt.

Welche Funktion ein Anschluss ausübt, entscheidet das darauf laufende Programm und natürlich der Einsatzzweck:

POWER oder VCC (Pin 8) und GROUND oder GND (Pin 4) dienen exklusiv der Spannungsversorgung.

RESET (Pin 1) dient dazu, das Programm auf dem Microcontroller neu zu starten und wird auch für die Programmierung benötigt. Pin 1 kann für andere Funktionen permanent umgestellt werden, dabei gehen aber die Reset-Funktion und die Programmierbarkeit über die ISP-Schnittstelle verloren, das ist nur etwas für finale Versionen und nichts für unsere Projekte.

Bleiben also 5 verwendbare Pins übrig:

ADC1 - ADC3: Analoge Eingänge zum Messen von Spannungen, z. B. bei bestimmten Sensoren notwendig.

INT0, PCINT0 - PCINT4: Hardware Interrupteingänge, die  eine sofortige Programmunterbrechung (Interrupt) auslösen und einen speziellen Programmteil anspringen. Das ist für sogenannte Echtzeitanwendungen wichtig, wo der Microcontroller (fast) sofort reagieren muss.

PB0 - PB4: Digitale Ein- oder Ausgänge, die je nach Programmierung z. B. einen Tastendruck erkennen (Eingang) oder LEDs ansteuern (Ausgang).

0 - 4: Bezeichnungen für die Digitaleingänge und -ausgänge in der Arduino-IDE

A1 - A3: Bezeichnungen für die Analogfunktionen in der Arduino-IDE

SCK, MISO und MOSI werden für die Programmübertragung verwendet.

OC0A und OC0B: Timergesteuere Ausgänge, die vor allem für Pulsweitenmodulation (PWM) verwendet werden.

CLKI: Kann für einen externen Zeitgeber (Quarz) verwendet werden, falls die internen Oszillatoren für eine Anwendung zu ungenau sind.

[QR-Code zu dieser Webseite: htts://s.blikk.it/tiny13]

Computer und besonders Prozessoren werden von uns vor allem als "magische" Black-Boxes wahrgenommen, deren Innenleben undurchschaubar und nur etwas für Spezialist:innen ist.

Das hier vorgestellte Projekt soll als Anregung dienen, in der Schule einen Blick hinter die Kulissen dieser Technologie zu werfen und durch Entmystifizierung der Technik einen gleicherweisen kreativen wie medienkritischen Zugang zu finden.

Es werden die einzelnen Schritte bei der Konzipierung, dem Entwurf, dem Bau und schließlich der Programmierung einer Microcontrollerschaltung beschrieben.

Zum Abschluss werden noch einige Projektideen zum Einsatz des Microcomputers skizziert.

• Vom Transistor zum Prozessor
• Der Microcontroller ATTiny 13
• Periferiebausteine
• Schaltplan und Platinenlayout
• Platinenherstellung
• ISP-Programmer
• Programmierung mit Microchip-Studio (Assembler und C, C++)
• Programmierung mit Arduino (C++)
• Projektideen