Main /

Tutorial ATTINY 2313 Programmierung

Allgemein

Knowledge Base

Virtualisierung Emulation

Technik und Wissen

Community

Privat

%center%[[http://validator.w3.org/check?uri=referer|http://www.w3.org/Icons/valid-xhtml10.png]]%%

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
  • WinAVR C-Compiler, enthält auch AVRdude, ein Programm welches man zum Programmieren des Controllers braucht
  • AVR-Studio 4 oder AVR-Studio 6. Beide Versionen sind auf der Atmel-Webside kostenlos verfügbar. AVR-Studio 6 basiert auf Visual Studio, ist komfortabler zu bedienen und kommt mit neueren AVR-Typen klar. Dafür belegt es erheblich mehr Speicherplatz und ist fühlt sich träger an.

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, gleichzeit erfolgt darüber die Stromversorgung. Hier muss genau drauf geachtet werden wie herum der Stacker nachher aufgesteckt wird. Die eine Ader des Anschlußkabels (Flachband) ist rot markiert, das ist der Pluspol. Dieser kommt an die rot dargestelle 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
        }
}
 

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...

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

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.

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

Weiterführende Informationen

/Elsni

Frische Änderungen (All) | Edit SideBar Zuletzt geändert am 01.12.2013 23:22 Uhr Seite Bearbeiten | Seitenhistorie
Powered by PmWiki