Main /

Tutorial ATTINY 2313 Programmierung

Tutorial ATTINY 2313 Programmierung

/ HomePage / Computerthemen / Hardware / Microcontroller / Tutorial ATTINY 2313 Programmierung

Tutorial: Programmierung eines ATTINY 2313 mit USBTinyISB und Avr Studio 4 und 6

Dies ist eine Schritt für Schritt-Anleitung wie man mit dem Microcontroller ATTINY 2313 eine LED zum blinken bekommt. Dabei geht es natürlich nicht um die blinkende LED, das bekäme man deutlich preiswerter und einfacher hin, es geht darum wie man den ATTINY 2313 anschließt und ihn programmiert. Wer verstanden hat wie es funktioniert, kann dann seiner Kreativität freien Lauf lassen. Als Programmiergerät wird der preiswerte USBTinyISP verwendet, der an vielen Stellen im Internet zu bekommen ist.

Was man braucht

Hardware

Für ca. 20 Euro bekommt man die Grundausstattung:

Einen neuen (=unprogrammierten) ATTINY 2313 (1,95€ Pollin)

Ein Steckbrett (Steckboard, Breadboard) (2,95€ Pollin) und ein paar Steckbrücken, die man sich aus starrer Litze (z.B. Telefondraht) leicht selbst machen kann.

Eine 6-Polige Stiftleiste mit langen Stiften. Ich habe genau so eine wie auf dem Bild dargestellt verwendet, und ein 6-poliges Stück abgebrochen. Das klappt gut, denn diese Stiftleisten haben Sollbruchstellen. (Pollin 0,27€)

Die Stiftleiste biegt man sich mit einer Flachzange so zurecht, dass sie auf das Steckbrett passt. Die einzelnen Stifte muss man vorher etwas weiter durch die schwarze Plastikhalterung drücken, so dass die Stifte ungefähr in der Mitte zusammengehalten werden. Das Ergebnis sieht dann so aus:

Die Stiftleiste ist der Anschluß (genannt ISP) für das Programmiergerät, in unserem einfachen Beispiel wird der Microcontroller auch darüber mit Strom versorgt.

Eine beliebige Leuchtdiode

einen Widerstand zwischen 30 Ohm und 5 KiloOhm. (ich habe nur kein gutes Bild gefunden wo nur einer drauf ist winking smiley)

Einen AVR-ISP-Programmer und ein passendes USB-Kabel. Ich habe den UsbTinyISP, den man überall im Netz zwischen 10€ und 20€ kaufen kann. Meiner kam für 12,50€ incl. Versand direkt aus Hong Kong (per ebay) hat aber eine halbe Ewigkeit gedauert (jaja, der deutsche Zoll...).

Software

Die folgende Software benötigt man unter Windows 7:

  • Treiber für den USBTinyISP
  • AVRDude - ein Programm welches man zum Programmieren des Controllers braucht
  • AVR-Studio ab Version 4 bzw. Microchip Studio 7. Letzteres ist auf der Microchip-Website kostenlos verfügbar und der neue Name von AVR-Studio nach der Übernahme von AVR durch Microchip . AVR-Studio 6 und Microchip Studio 7 basieren auf Visual Studio, sind komfortabler zu bedienen und kommen mit neueren AVR-Typen klar. Dafür belegen sie erheblich mehr Speicherplatz und ist fühlen sich träger an als das alte AVRStudio 4.

Softwareinstallation

  • USBTinyISP Treiber entpacken
  • USBTinyISP über USB anschließen
  • Wenn Windows nach einem Treiber fragt, das Treiberverzeichnis auswählen.
  • Bestätigen dass man den Treiber installieren möchte, auch wenn der Herausgeber unbekannt ist.
  • WinAvr als Administrator installieren.
  • AVRStudio Installation als Administrator ausführen

Testschaltung zusammenbauen

Diese einfache Schaltung wird auf dem Steckbrett aufgebaut. Über den 6-Polige Stecker wird das Programmiergerät angeschlossen, gleichzeitig erfolgt darüber die Stromversorgung. Hier muss genau drauf geachtet werden wie herum der Stacker nachher aufgesteckt wird. Die eine Ader des Anschlusskabels (Flachband) ist rot markiert, das ist der Pluspol. Dieser kommt an die rot dargestellte Leitung, die zu VCC am Controller führt

Die LED wird an Pin4 (PA1) angeschlossen. Hier muss man aur richtige Polung achten, das längere Beinchen der LED wird über den Widerstand mit dem Pin4 des Controllers verbunden, das kürzere (Eselsbrücke: Kathode/kurz/Minus) mit Minus/Masse/GND (wie man es auch immer nennt). Hat man die LED falsch herum eingebaut kann aber nichts kaputt gehen, sie leuchtet dann nur nicht.

Der Pin PA1 kann (wie fast alle Pins des Controllers) verschiedene Aufgaben übernehmen, je nach Programmierung. In unserem Beispiel wird er als Ausgang programmiert, d.h. man kann ihn per Programm auf High (=+5V, LED leuchtet) oder Low (0V, LED aus) setzen.

Die LED muss immer über einen Widerstand angeschlossen werden, denn sonst würde ein hoher Strom fließen, der die LED und wenn man Pech hat auch den Controller zerstören würde.

Programmierung

Projekt anlegen:

AVR Studio 4:

  • Starten von AVR Studio 4
  • Neues Projekt anlegen, Projekttyp AVR GCC, Projektname beliebig, ich verwende hier "blinkled"
  • Debug Platform AVR Simulator 2, Device ATTINY2313
  • Es öffnet sich ein leeres Fenster

AVR Studio 6

  • Starten von AVR Studio 6
  • Neues Projekt anlegen (File -> new Project), Projekttyp "GCC Executable Project", Name "blinkled"
  • Controller auswählen: Device Family tinyAVR, 8 bit -> Attiny2313 (oder eben den Controller den man zu Hand hat) -> OK
  • Es öffnet sich ein Fenster mit einem Programmtemplate.

Das C-Programm

// -----------------------------------------
// Blinken einer LED an PIN 4 (PA1)
// für ATTINY 2313
// -----------------------------------------

// 1MHz ist Default-Takt (Fuse-Bits nicht manipuliert
#define F_CPU 1000000UL

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


int main (void)
{
        // Pin 1 von Port A (PA1) als Ausgang schalten
        DDRA = (1 << PA1);

        // Endlosschleife
        for (;;) {
                PORTA |= (1 << PA1);  // bit im Portregister auf 1 setzen => LED leuchtet
                _delay_ms(500);                         // eine halbe Sekunde warten

                PORTA &= ~(1 << PA1); // bit im Portregister auf 0 setzen => LED aus
                _delay_ms(500);                         // eine halbe Sekunde warten
        }
}
 
[$[Get Code]]

Programm Kompilieren

  • F7 drücken oder im Menü Build -> Build klicken.

Wenn das Programm fehlerfrei kompiliert werden konnte sieht die Ausgabe bei Avr-Studio 4 im unteren Fenster in etwa so aus. Bei AVR-Studio 6 ähnlich, zumindest sollte es keine Fehlermeldungen geben.

Build started 9.5.2011 at 10:35:27
avr-gcc -mmcu=attiny2313 -Wall -gdwarf-2 -std=gnu99 -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT blinkled.o -MF dep/blinkled.o.d -c ../blinkled.c
avr-gcc -mmcu=attiny2313 -Wl,-Map=blinkled.map blinkled.o -o blinkled.elf
avr-objcopy -O ihex -R .eeprom -R .fuse -R .lock -R .signature blinkled.elf blinkled.hex
avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 --no-change-warnings -O ihex blinkled.elf blinkled.eep || exit 0
avr-objdump -h -S blinkled.elf > blinkled.lss

AVR Memory Usage
----------------
Device: attiny2313

Program: 98 bytes (4.8% Full)
(.text + .data + .bootloader)

Data: 0 bytes (0.0% Full)
(.data + .bss + .noinit)


Build succeeded with 0 Warnings...
[$[Get Code]]

Wir haben jetzt ein kompiliertes Programm mit sage und schreibe 98 Bytes länge. Doch wie kriegen wir es in den Controller? Weiterlesen...

Programm in den Flash-Speicher des Controllers übertragen

Zum Programmieren verwenden wir das Programm avrdude das Bestandteil von WinAvr, also dem C-Compiler ist, welcher am Anfang installiert wurde. Theoretisch kann man den Controller auch direkt aus Avr Studio programmieren, jedoch funktioniert das nur mit den Programmiergeräten von Atmel, und die sind teuer.

Der Compiler hat unter anderem eine Datei blinkled.hex erzeugt. Darin befindet sich das binäre Programm welches in den Controller übertragen wird. blinkled.hex liegtin einem Unterverzeichnis des Projektverzeichnisses. In Windows 7 findet man die Datei einfach über die Suche im Startmenü, dann mit der rechten Maustaste das Suchergebnis anklicken und Dateipfad öffnen wählen, schon ist man im richitgen Verzeichnis.

Jetzt öffnet man mit eine Kommando-Shell (cmd), und begibt sich in das Verzeichnis wo sich blinkled.hex befindet (am besten Pfad kopieren).

Spätestens jetzt sollte der USBTinyISP-Programmierer an USB und die Schaltung auf dem Steckbrett angeschlossen werden. Nochmal: Stecker RICHTIG HERUM aufstecken, lieber einmal zu oft prüfen als irgendwas zu verheizen.

Dann kommt der spannende Moment, das Übertragen des Programmes mit avrdude:

avrdude -c usbtiny -p attiny2313 -U flash:w:blinkled.hex
[$[Get Code]]

Erläuterung der verwendeten Parameter:

  • -c usbtiny: Legt fest, dass wir einen USBTinyISP als Programmiergerät verwenden. avrdude unterstützt diverse Programmiergeräte.
  • -p attiny231: Wir wollen einen attiny2313 programmieren
  • -U flash:w:blinkled.hex: Wir wollen die Datei blinkled.hex in den flash Speicher schreiben (w)

Wenn alles glatt läuft sieht die Ausgabe von avrdurde ungefähr so aus:

C:\Users\Elsni\Documents\Daten\projekte\blinkled\default>avrdude -c usbtiny -p attiny2313 -U flash:w:blinkled.hex

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.04s

avrdude: Device signature = 0x1e910a
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "blinkled.hex"
avrdude: input file blinkled.hex auto detected as Intel Hex
avrdude: writing flash (98 bytes):

Writing | ################################################## | 100% 0.14s



avrdude: 98 bytes of flash written
avrdude: verifying flash memory against blinkled.hex:
avrdude: load data flash data from input file blinkled.hex:
avrdude: input file blinkled.hex auto detected as Intel Hex
avrdude: input file blinkled.hex contains 98 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.06s



avrdude: verifying ...
avrdude: 98 bytes of flash verified

avrdude: safemode: Fuses OK

avrdude done. Thank you.
[$[Get Code]]

Nun sollte die LED blinken!!!

Post-Build-Event für automatisches Flashen in AVR-Studio 6

Bei Version 6 kann man sich ein post-Build-Event einrichten (rechte Maustaste auf das Projekt, dann Properties). Das ist ein Kommando, was nach erfolgreichem Compilieren automatisch ausgeführt wird. Dies ist z.B. bestens geeignet um das Kompilat in den Microcontroller zu übertragen.

Hier ein recht universelles Post-Bild Kommando, das so für alle Projekte mit allen Controllertypen funktionieren sollte, sofern sie mit dem UsbTinyISP programmiert werden:

avrdude -c usbtiny -p $(avrdevice) -U flash:w:$(SolutionName).hex
[$[Get Code]]

Weiterführende Informationen

/Elsni

Frische Änderungen | Menü editieren
zuletzt geändert am 26.08.2021 19:12 Uhr von Elsni
Edit Page | Page History