AVR In System Programmer

Aus der Mikrocontroller.net Artikelsammlung, mit Beiträgen verschiedener Autoren (siehe Versionsgeschichte)
Wechseln zu: Navigation, Suche

Einführung

In-System-Programming (ISP) bedeutet, einen Mikrocontroller oder anderen programmierbaren Baustein im eingebauten Zustand zu programmieren. Dazu muss der Mikrocontroller entsprechend beschaltet sein. Das bedeutet, die benötigten Anschlüsse am Mikrocontroller müssen zugänglich und nicht ohne weitere Vorkehrungen anderweitig benutzt sein - siehe Atmel Application Note AVR042.

Atmel verwendet für ihre 8-Bit RISC Mikrocontroller zum Teil unterschiedliche ISP-Protokolle. Das bekannteste davon wird einfach als ISP bezeichnet. Insgesamt findet man:

ISP
Der Normalfall. Bei vielen, aber nicht allen AVRs teilen sich SPI- und ISP-Schnittstelle die Pins. Je nach AVR gibt es leichte Unterschiede im Protokoll. Das Protokoll für einen Typ ist im Datenblatt unter Memory Programming -> Serial Downloading beschrieben.
TPI
Tiny Programming Interface. Einige AVRs der Tiny-Serie, besonders die 6-Pin Tinys.
PDI
Programming and Debugging Interface. Die XMEGAs.
JTAG
AVRs mit JTAG Debugging-Schnittstelle lassen sich auch über JTAG in-system-programmieren.
Bootloader
Einige wenige AVRs kommen bereits mit einem einprogrammierten Bootloader. Bei diesen kann man ein zum Bootloader passendes Programm nutzen um den AVR über eine im Bootloader definierte Schnittstelle programmieren. Auf Bootloadern basierende Systeme haben ansonsten ein Henne-Ei Problem. Irgendwie muss der Bootloader einmal konventionell in den AVR programmiert werden, zum Beispiel mit ISP.

Atmels debugWire ist keine Programmierschnittstelle, sondern eine reines Debugging-Interface. Zum Programmieren verwendet man bei AVRs mit debugWire daher normalerweise ISP.

Atmel hat für die AVR 8-Bit RISC Mikrocontroller mehrere Application Notes herausgegeben, auf deren Basis eine Vielzahl von Programmiergeräten (programmer) entwickelt wurden.

Natürlich liefert Atmel auch eigene, fertige Programmiergeräte (AVRISP (mk I), AVRISP mk II, AVR-Dragon, ...), Programmiersoftware (AVRProg, AVR Studio) und Entwicklungsboards mit integriertem Programmiergerät (z. B. STK500).

FAQ/Tipp: "Welchen ISP-Adapter sollte man sich zulegen oder bauen?"

Man sollte sich einen fertigen, original Atmel (keinen Clone) ISP-Adapter kaufen. Zum Beispiel für ISP (und PDI) Programmierung Atmels original AVRISP mkII für rund 36,- Euro.

Das ist eine Investition, die viel Zeit und Ärger spart, denn es geht nichts über zuverlässiges Werkzeug. Beim Umgang mit µCs ist es sehr frustrierend an drei Fronten gleichzeitig zu kämpfen:

  1. Bugs in der Software,
  2. Bugs in der Schaltung und
  3. Bugs/Probleme beim ISP-Adapter-/PC-Gespann.

Wenigstens Probleme mit dem ISP-Adapter lassen sich durch den Kauf eines zuverlässigen ISP-Adapters eliminieren. Siehe auch diverse Forenbeiträge u.a. [1] und [2].

Sehr unzuverlässig sind häufig billige oder selbstgebaute Programmierkabel mit nichts außer ein paar Widerständen. Unzuverlässig sind häufig auch billige oder selbstgebaute Programmierkabel mit einem einfachen Bustreiber. Nur weil sie bei manchen funktionieren heißt das nicht, dass sie überall problemlos funktionieren.

Parallelport- (Druckerport-) ISP-Adapter funktionieren gar nicht, wenn man sie mit einem USB <-> Druckerport Adapter an einen USB-Port am PC anschließt. Einfach (unintelligente) ISP-Adapter für die serielle Schnittstelle funktionieren gar nicht oder extrem langsam, wenn man sie mit einem USB <-> Seriell Adapter am PC anschließt. Gute intelligente serielle Programmieradapter, wie der in Atmels STK500 eingebaute, funktionieren normalerweise mit einem USB-Adapter.

Bei allen Programmieradaptern mit eigener Firmware, einschließlich der Original-Adapter von Atmel, ist man darauf angewiesen, dass der Hersteller wenn nötig Firmware-Updates bereitstellt. Bei Clones ist die Versorgung mit Firmware manchmal fraglich.

Oftmals funktionieren auch die Treiber der Clones unter 64-Bit Betriebssystem nicht richtig oder nur mit Tricks, die leider wichtige Sicherheitsfunktionen des Betriebssystem abschalten. Der AVRISP mkII funktioniert dagegen auch unter Windows 7 (64-Bit).

Application Notes

  • AVR910 (PDF) "Low-cost" In-system programming (AVRISP) beschreibt einen einfachen, kostengünstigen Programmieradapter zur Übertragung von Programmen in den Mikrocontroller. Auf dem Programmer befindet sich ein Mikrocontroller (natürlich von Atmel ;-), der serielle Steuerkommandos und Daten vom PC in Programmiersignale für den Mikrocontroller umsetzt.
  • AVR911 (PDF) Open source serial programmer (AVROSP) beschreibt eine open source Programmiersoftware zur Übertragung von Programmen in den Mikrocontroller.
  • AVR109 (PDF) Self-Programming mit Hilfe eines Bootloaders. Hier wird im Mikrocontroller zunächst ein mikrocontroller-spezifisches Bootloader-Programm abgelegt. Dieses Programm empfängt das eigentliche Benutzerprogramm oder Daten z. B. über einen seriellen Anschluss (UART), legt es ggf. im Speicher (Flash-ROM, EEPROM) ab und führt ggf. anschliessend das Benutzerprogramm aus.

Pinbelegung

ISP

Die Standard-Pinbelegung des ISP-Steckers zum Anschluss des Mikrocontrollers sieht nach obigen Application Notes und der AVR042 (PDF) folgendermaßen aus (Anschluss auf der Platine, Ansicht von oben). Atmel bevorzugt dabei bereits seit Jahren den 6-poligen Anschluss.

Avr-isp-pinout.png
 10-poliger       6-poliger
 Anschluss        Anschluss
 
 1 MOSI           1 MISO
 2 VCC            2 VCC
 3 - (*)          3 SCK
 4,6,8,10 GND     4 MOSI
 5 RESET          5 RESET
 7 SCK            6 GND
 9 MISO

Pin 1 ist am Pfostenstecker mit einem kleinen Pfeil gekennzeichnet.

(*) Einige Programmieradapter (Ponyprog-Adapter nach Lancos-Schaltplan) unterstützen an Pin 3 des 10-poligen Steckers eine LED (Kathode an Pin), die "Programmierzugriff" signalisieren soll. Dies ist aber kaum nützlich, daher wird der Pin auch von Atmel als N/C (not connected) definiert und beim original Atmel AVRISP mit GND verbunden.

Der 10-polige Anschluss wurde von der Firma Kanda beim STK200 verwendet und ist deshalb auch als "Kanda-Standard" bekannt und war zur Zeit der STK200 Programmieradapter relativ weit verbreitet. Die Anschlussbelegung über einen 6-poligen Stecker stammt von Atmel selbst und ist platzsparender auf der Platine.

Am besten kauft oder fertigt man sich einen Adapter 6 <-> 10 (siehe [3], [4], [5]), dann lassen sich praktisch alle Boards mit jedem Programmer programmieren.

Kabeloben.jpg Kabelunten.jpg Isp kab.jpg

Zehnpolige Messerleisten (Wannenstecker) zur Montage auf einer µC Platine zum verpolungssicheren Anschluss des Programmieradapters sind fast "überall" verfügbar, nach den sechspoligen muss man häufig etwas suchen. Mittlerweile sind sie endlich bei Reichelt erhältlich (WSL 6G).
Alternativ bleibt nur der Griff zu den nicht verpolungssicheren 2xN Stiftleisten (z. B. 2x40), wobei man eine Stiftleiste auf 2x6 Pole kürzt.

Sechspolige Federleisten (Pfostenbuchsen) zum Anquetschen an ein Programmierkabel sind dagegen zumindest bei den großen Versendern und Distributoren erhältlich (z. B. von Bürklin Art.53F3500; Conrad Art.701980-62; Farnell Art.1097021; Reichelt PFL 6). Kleine lokale Elektronikläden führen diese jedoch häufig nicht. Zu den sechpoligen Pfostenbuchsen gibt es keine Alternative, wenn man ein sechpoliges Programmierkabel bauen möchte. Zehnpolige Pfostenbuchsen lassen sich nicht auf sechs Pole kürzen.

Je nach Programmieradapter hat der VCC-Anschluss unterschiedliche Funktionen:

1. Versorgung des Programmieradapters mit Strom aus der Schaltung, wie es bei vielen Parallelport-Adaptern der Fall ist.

2. Versorgung der Schaltung mit Strom aus dem Programmieradapter. Dies ist insbesondere beim STK500 möglich und dank dessen programmierbarer Versorgungsspannung manchmal ganz praktisch.

3. Messung der Betriebsspannung der Schaltung, so dass der Programmieradapter sich auf diese Spannung einstellen kann und so ein 3,3 V Board mit 3,3 V und ein 5 V Board mit 5 V programmiert. So wie zum Beispiel beim AVRISP mkII. Daher wird VCC auf neueren Schaltbildern auch als Vtg oder VTref bezeichnet (Atmel kann sich da nicht auf eine Bezeichnung einigen).

Je nach verwendetem Programmer muss man daher sorgfältig auf die Beschaltung von VCC/Vtg/VTref und auf die Stromversorgung von Board und Programmer achten.

TPI

Die TPI-Programmierung setzt sich aus mehreren Schichten zusammen: Hardware (Ansteuerung der IO-Pins), Speicher-Management (stellt Funktionen zum Flashen bereit) und der Speicher selbst.

PDI

Atmel Board-Schnittstelle & AVRISP MkII

Für Mikrocontroller-Boards schlägt Atmel einen 6-Pin Header, 2,54 mm Raster, mit folgender Pinbelegung vor (Ansicht von Oben): 

DATA  1 2  VCC
N.C.  3 4  N.C.
 CLK  5 6  GND

(N.C.: Not Connected, nicht verbunden). Diese Belegung wird auch von Atmels AVRISP MkII im PDI-Modus verwendet.

Bei Atmels eigenem XPlain Eval-Kit und anderen Programmieradaptern geht es zur Zeit jedoch noch fröhlich durcheinander. Folgenden Pinbelegungen lassen sich finden.

Atmel XPlain Eval-Board

Hier hat Atmel die Xmega PDI- und JTAG-Schnittstelle gemeinsam auf den Header J100 gelegt. Die PDI-Belegung ist wie folgt: 

      1  2  GND
      3  4  VCC
      5  6  CLK
 VCC  7  8  DATA
      9 10  GND

Nur jeweils ein VCC- und ein GND-Anschluss muss verwendet werden. Es bieten sich die Pins 2 und 4 an.

Man beachte die Position von DATA auf Pin 8 bei dieser Belegung von PDI auf dem XPlain JTAG-Header.

Atmel JTAGICE MkII

Einige sehr alte JTAGICE MkII unterstützen kein PDI. Alle neueren, in den letzten Jahren hergestellte tun es. Eventuell ist ein Firmware-Upgrade über AVR-Studio nötig.

Laut [6] und der eingebauten Hilfe von AVR Studio 4.18 SP 1 verwendet ein JTAGICE MkII im PDI-Modus folgende Pinbelegung: 

      1  2  GND
      3  4  VTref
      5  6  CLK
      7  8
DATA  9 10  GND

Man beachte, dass DATA hier angeblich auf Pin 9 liegt. (VTref dürfte VCC entsprechen). In der Hilfe zu AVR Studio 4.18 SP 1 ist der Pin CLK mit PDI_CLK, und der Pin DATA mit PDI_DATA bezeichnet.

Atmel AVR Dragon

Erst mit der Dragon-Firmware im SP 1 für AVR Studio 4.18 soll der PDI-Support des AVR Dragon funktionieren. Angekündigt war PDI-Support bereits für AVR Studio 4.18.

Leider hat Atmel es versäumt in der Dragon-Dokumentation die Pinbelegung für PDI auf der Seite des Dragon anzugeben. In der Studio-Dokumentation ist von einem ominösen Dragon PDI Adapter die Rede, der Teil des "Dragon Kit" sein soll. Allerdings wird der Dragon 'nackt' ausgeliefert und bisher gibt es keine Berichte darüber, dass jemand diesen ominösen Adapter gesehen hat. Von neueren Versionen des JTAGICE mkII ist hingegen bekannt, dass sie mit einem XMEGA PDI adapter kit geliefert werden.

Angeblich ist es nötig, beim Dragon jeweils einen 330 Ohm Widerstand in die CLK und DATA Leitung zu legen, um Probleme mit dem Überschwingen der Signale zu vermeiden.

Programmer-Varianten

Mittlerweile existiert eine fast unüberschaubare Zahl von Programmer-Varianten und Untervarianten. Hier sollen nur die wichtigsten Varianten mit Bauanleitungen aufgelistet werden, geordnet nach der Art des Anschlusses an den PC.

Parallelport

STK200-kompatibel

Fast alle erhältlichen Parallelport-Programmieradapter, u.a. auch der hier im Shop angebotene, sind kompatibel zum Programmer des STK200 / STK300.

Paralleles Interface für AVR und PonyProg

Schaltplan und Erläuterungen bei Scott-Falk Hühn

SP12 Programmer

Schaltplan, Erläuterungen und Software für mehrere Plattformen, darunter auch MSDOS, gibt es bei Steven Bolt. Ken's Dongle ist ein spezieller Kabeladapter für SP12 zur Verbesserung der Signalqualität. Anpassung an neue Typen erfolgt durch leicht selbst erstellbare Beschreibungsdateien.

Serieller Port (RS-232)

Atmel AVRISP, STK500, AVR910

Der original AVRISP von Atmel, das STK500 und der Programmer aus der Application Note AVR910 enthalten einen Mikrocontroller, der die Umsetzung der seriellen Daten auf das ISP- und TPI-Programmierinterface vornimmt. Sie lassen sich direkt mit dem AVR-Studio programmieren und sind auch problemlos mit einem USB-seriell-Adapter verwendbar.

Ein Layout mit Schaltplan und erweitertem Sourcecode findet sich in diesem Thread in der Codesammlung AVR910 Programmer, Schaltplan, Layout, Firmware.

Das AVR910 Design ist u.a. auf der Seite von Serasidis Vasilis im Detail beschrieben.

Eine weitere, auführliche Anleitung zum AVR910 gibt es in deutsch auf der Seite von Klaus Leidinger.

Einen AVR-ISP STK500 Protokoll Programmmer und JTAGICE kompatiblen Programmer/Debugger können Sie auf folgender Homepage bestellen: myevertool

SI-Prog

Daneben gibt es noch weitere Programmieradapter für den seriellen Port, die auf den eigenen Mikrocontroller im Programmieradapter verzichten und das ISP-Programmierprotokoll über die Steuerleitungen des RS-232-Port nachbilden. Das Programmierprogramm auf dem PC sendet jetzt keine Steuerkommandos und Daten mehr, sondern gibt direkt die Programmiersignale an der seriellen Schnittstelle aus ("Pinwackeln an den Statuspins"). Der Nachteil dieser Adapter ist, dass sie meistens relativ langsam sind und nur unter wenigen Betriebssystemen funktionieren. Ein Beispiel dafür ist SI-Prog.

Sercon2

Mit einer etwas anderen Steckerbelegung als der SI-Prog arbeitet die Sercon Familie an Adaptern. Nähere Unterlagen dazu finden sich hier

Selbstbau-Programmer, basierend auf dem FTDI chip (via avrdude)

http://irq5.wordpress.com/2010/07/15/programming-the-attiny10/

USB

Die meisten USB-Programmieradapter verwenden einen USB-seriell-Wandler und ein STK500/AVRPROG-kompatibles Protokoll und können damit direkt aus dem AVR-Studio programmiert werden.

Eine Quick-and-Dirty Programmierlösung bietet der #USB-Hub-ISP, der außer einem USB-Hub nur Standard-Bauteile voraussetzt.

Atmel AVRISP MKII

Nachfolger des Atmel AVRISP "MKI". Mit USB-Schnittstelle, leistungsfähigerem Programmiercontroller und erweitertem Hardwareschutz. Programmiersoftware: AVR-Studio und AVRDUDE. Herstellerinformation bei atmel.com

Dave Jones hat im EEVblog #158 ein Videotutorial erstellt, wie man beim Atmel AVRISP "MKI" mit dem LM317 Spannungsregler 3.3V oder 5V Versorgungsspannungen für das Targetboard nachrüstet. Im Video schlägt Dave als bessere Lösung die Verwendung eines Low-Drop-Spannungsreglers vor. Dafür eignet sich z.B. der LM1117

Weiter unten auf dieser Seite wird auch ein einfacher, kompatibler Nachbau namens usbprog vorgestellt.

Atmel AT90USBKEY

Mit hilfe des AVRISP-MKII Clone Projekts aus dem LUFA Paket wird aus dem AT90USBKEY recht einfach ein Programmer, der mit AVR-Studio und AVRDUDE genutzt werden kann.

Bascom USB ISP

Beliebter USB programmer der speziell für den Bascom Compiler entwickelt wurde. Unterstützt Bascom einen neuen AVR-Controller, so kann dies automatisch auch dieser USB Programmer, eine neue Firmware ist nicht erforderlich. Ein weiterer Vorteil ist, dass er speziell für Bascom entwickelt wurde und in der IDE unterstützt wird. Er unterstützt alle Features von Bascom, auch die automatische Fusebit-Einstellung per Direktive im Quellcode.

Angenehm ist auch, dass er keine 5V benötigt. Im Gegenteil, er kann sogar Boards über das übliche ISP-Programmierkabel mit 5V versorgen, so dass viele Boards auch ohne weitere Spannungsquelle programmiert werden können. Ein wirklich empfehlenswerter Qualitätsprogrammer für alle Programmierer, die ausschließlich mit Bascom arbeiten wollen

Im Online- / Auktionshandel werden auch Alternativen angeboten, teils recht schick im Plexiglasgehäuse für ca. 20 Euro. Angeboten z. B. als "USB 2.0 Full Speed low cost Programmer für ATMEGA Chips" oder "AVR USB ISP Programmer ATMEL ATMEGA STK500". Die Adapter funktionieren auch mit BasCom (aber auch mit AVR Studio), z. B. mit der Einstellung "STK500 native driver".

Man kann die Targetspannungsversorgung per USB zwischen 3,3 und 5V umschalten oder ganz abschalten (per DIP-Schalter). Sie sind per USB an den PC angeschlossen und arbeiten über einen virtuellen COM-Port. Achtung: In BasCom funktioniert das nur bis COM9. Wenn sich das Gerät z. B. auf COM15 installiert, wird es im BasCom evtl. nicht gefunden. Dann in der Systemsteuerung entsprechend umstellen.

Atmel AVR Dragon

Hauptartikel AVR-Dragon

Der AVR Dragon ist ein preiswerter ISP (und ICE) von Atmel, der aufgrund Preis/Leistungs-Verhältnisses schnell populär wurde. Atmel wurde von dieser Popularität überrascht, da der Dragon wohl ursprünglich nur als ein "Gimmick" zur Verbreitung von AVRs in Asien gedacht war.

Die großen Vorteile des Dragons sind, dass er alle Programmiermodi beherrscht, inklusive High-Voltage Parallel Programming ("verfuste" AVRs retten), dass er ein natives USB-Interface hat, von AVR-Studio unterstützt wird, und sogar JTAG und debugWIRE ICE / Debugging unterstützt (bei den AVRs die dies können).

Zu den größten bekannten Nachteilen gehören, dass der Dragon völlig "nackt" kommt. Kein USB-Kabel, kein Gehäuse, nicht einmal Abstandsbolzen unter der Platine, keine Patchkabel und nicht einmal die Fassungen zum Einstecken von AVRs sind bestückt. Eine gedruckte Anleitung gibt es auch nicht. Daneben wird aufgrund des Stromverbrauchs des Dragon ein USB-Hub mit Netzteil benötigt.

Weiter ist der Dragon dafür bekannt, empfindlich auf statische Aufladungen zu reagieren. Ein Spannungsregler und ein Ausgangstreiber gehen dabei besonders gerne kaputt. Ein gerne von Anfängern gemachter Fehler ist es, den Dragon im Betrieb auf dem mitgelieferten "Schaumstoff" aus der Verpackung liegen zu lassen. Das ist jedoch kein Schaumstoff, sondern leitendes Moosgummi.

Weitere Schutzmaßnahmen für gefährdete AVR Dragons findet man auf der Dragonlair-Seite von Nard Awater.

Der Dragon wird unter Linux z. B. von der avrdude-Programmiersoftware unterstützt. Unerklärlicherweise stellt Atmel die Dokumentation und Beschreibung des Dragon nur als Teil der Online-Hilfe der AVR-Studio Software unter Windows zur Verfügung. Weiterhin lassen sich Firmware-Updates auch nur mittels eine proprietären Atmel-Software unter Windows einspielen. Daher ist der Dragon für Linux-Benutzer nur dann zu empfehlen, wenn man zusätzlich noch Zugriff auf eine Windows-Installation hat.

USBisp

AVR Programmierdongle mit USB Anschluss und kompatibel zum STK500-Protokoll. Unter anderem programmierbar mit AVR-Studio, AVRDUDE und uisp. Schaltplan (PDF), Layout (PDF), Erläuterungen und Firmware gibt es vom Entwickler Matthias Weißer.

USB avrisp

USB AVR Programmer auf Basis des AVR 910 Designs. Den Schaltplan, Layout und Erläuterungen (englisch) gibt es von Joakim Arfvidsson.

Evertool

Mit USB-seriell-Wandler. Getestet mit Adapterkabeln/ICs von FTDI, SiLabs und Prolific (Adapterkabel z. B. für ca. 10EUR bei Reichelt).

USBasp

Thomas Fischls USBasp ist ein Openhardware/Openfirmware USB-ISP-Adapter. Er basiert auf einem ATmega8 (oder ATmega88), der mittels einer rein auf Firmware basierenden USB-Implementierung von Objective Development arbeitet. Zum Ansteuern wird AVRDUDE in einem speziellen Modus benötigt, der ab Version 5.2 standardmäßig vorhanden ist (vorher waren Patches nötig). Eine MacOS X Anpassung stammt von Sven Schwiecker.

Der Programmer hat den Nachteil, dass er nicht die Targetspannung zum Programmieren benutzt, sondern immer seine 5V. Deshalb kann es Probleme geben, wenn das Target mit einer niedrigen Spannung versorgt wird, da der USBasp die Target-Highpegel eventuell nicht mehr als High erkennt. Abhilfe kann ein kleiner Hack schaffen, mit dem der µC wahlweise mit 5V oder mit ~3.6V betrieben wird: http://www.mikrocontroller.net/topic/109648?goto=2031524#2031524

Der Optoisolated USBASP 1.8V to 6V ist eine Hardwareänderung mit breitem Targetspannungsbereich und galvanischer Isolation über die Optokoppler 6N317 (schnelle Datenleitungen) und PC817 (langsame Resetleitung).

AvrUsb500

  • AvrUsb500 - an open source Atmel AVR Programmer, stk500 V2 compatible, with USB interface
  • meCHAOS - Nachbau mit neuem Platinenlayout und weiteren Funktionen.

usbprog

usbprog von Benedikt Sauter ist ein USB Programmieradapter, der fast alle Atmel Mikrocontroller unterstützt (ATiny, ATMega, AT89, AT90, ...) und daneben auch für ARM7/9 und MSP universell einsetzbar ist. Unterstützung für Xmega gibt es nicht.

Der Programmer wurde so entwickelt, dass man die Firmware auf dem Adapter über die USB-Verbindung austauschen kann. Dadurch sollte der Adapter lange attraktiv bleiben, da alles rund um das Projekt als open Source veröffentlicht ist und daher neue Controller einfach in die usbprog-Firmware integriert werden können. Es ensteht gerade eine Firmware für einen einfachen JTAG Adapter. Damit kann man dann ganz einfach debuggen (voraussichtlich auch aus dem AVR Studio aus).

Man kann den Adapter auch als 1:1 AVRISP mkII kompatibles Gerät betreiben. Dafür muss man eine andere Firmware einspielen, die ebenfalls Teil des Projektes ist. Der Vorteil ist der, dass man so auf jede bestehende Programmiersoftware zurückgreifen kann, die das originale AVRISP mkII unterstützt. Getestet wurde usbprog bis jetzt mit avrdude (Linux und Windows) und dem AVR Studio 4 (Windows).

Derzeit kann man bei Benedikt Sauter Platinen und Bauteile im Set für 22 EUR (neue v3 für 34 EUR) bestellen. Näheres auf der Projektseite.

AVR-Doper

AVR-Doper kann neben ISP auch im High-Voltage Serial Mode als AVR HV-Programmer programmieren. Rein auf Firmware basierende USB-Implementierung. BUS-Powered. Einseitige Platine und damit auch für Selbstbauer geeignet. Verwendet einen Mega8 zur Steuerung des Programmers. Ist kompatibel zu AVR-Studio durch STK500-Protokoll.

USB AVR-Lab

USB AVR-Lab besteht aus einer sehr einfachen Hardware, usb wird in Software gemacht. Mit einem Bootloader nebst Applikation kann die Funktion des Lab´s zwischen

  • AVRISPmkII kompatiblem Programmer (AVR Studio, Linux, MacOS)
  • JTAGICEmkII kompatibler AVR Programmer (AVR Studio, Linux, MacOS) (keine AVR32, kein Xmega)
  • OpenOCD Interface (sehr viel ARM Controller, PLD´s, FPGA´s)
  • STK500v2 kompatiblem Programmer (AVR Studio)
  • USBasp kompatiblem Programmer (Linux, MacOS)
  • JTAG Boundary Scan Interface + Software
  • RS232/RS485 Wandler
  • I2C Logger
  • I2C Interface (zur benutzung aus eigenen Programmen)
  • Oszi
  • 6-Kanal Logik Analyzer (in Entwicklung)
  • Labornetzteil (in Entwicklung)

getauscht werden. Mit der STK500v2 kompatiblen Firmware kann der Programmer direkt aus dem AVR Studio heraus voll kompatibel zum AVR-ISP mkII arbeiten. Zusätzlich bietet der Programmer den virtuellen Com Port als Debug Port an solange nicht geflasht wird. Man kann also direkt mit dem Terminalprogramm auf seinen AVR zugreifen über den ISP Adapter. Dieser Modus wird von jeder ISP Firmware unterstützt. Statusanzeige des Targets (angeschlossen, falsch angeschlossen, nicht angeschlossen), max. 3 Mhz ISP Freq. Das Ganze ist sehr günstig in der Beschaffung (10 Eur Bauteile bei Reichelt + 3,5 Eur Platine von ullihome.de, oder 15 Eur bestückt von ullihome.de)

USBtinyISP

USBtinyISP ist ein preiswerter (ca. 16$ für die Bauteile) AVR ISP Programmer und SPI Interface auf open-source Basis. Als Software kann z.B. AVRDUDE oder AVRStudio verwendet werden. Der Programmer wurde auf Windows, MacOS X und Ubuntu (ab 9.04) getestet. Bei Adafruit sind auch Selbstbaukits erhältlich. Eine miniaturisierte Version findet sich hier www.mikrocontroller.net/articles/AVR-ISP-Stick.

UCOM-IR

Der UCOM-IR Programmieradapter ist ein kommerzieller Bausatz (ca. 25 €), der auf einem AT90USB162 basiert. Durch die Verwendung des STK500v2 Protokolls kann zur Programmierung sowohl das AVR-Studio wie auch AVRDUDE verwendet werden. Zusätzlich hat der Adapter einen IR-Empfänger und zwei Sendedioden, die zur Kommunikation und zur Fernsteuerung verwendet werden können.

Selbstbau-Programmer, basierend auf dem vUSB stack

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=90498

USB-Hub-ISP

HUB ISP - Solving the USB-Only "Chicken or Egg" Problem:
HUB ISP can write an AVR chip using only a USB hub, one cheap/common logic chip, and a few resistors.
http://www.pjrc.com/hub_isp/

mySmartUSB

Der mySmartUSB Programmer von myAVR ist ein kompakter ISP Programmer mit USB Anschluss (der Preis liegt bei 28€). Lt. Hersteller kann er auch für die Kommunikation via UART, TWI, SPI verwendet werden (hab ich noch nicht probiert).

ich aber: Beim Schreiben der Fuse Bits musste ich das Tool myAVR_ProgTool.exe verwenden - siehe http://www.opencharge.de/wiki/Mysmartusb

Mit avrdude ist das Schreiben der Fuse-Bits mit dem AVR910-Modus möglich.

avrdude-Kommandozeile : avrdude -c avr910 -P PORT -p PART -U lfuse:w:0xFF:m -U hfuse:w:0xD9:m


Achtung: Die neuere Version (mySmartUSB MK3) scheint mit der aktuellen Firmwareversion noch große Probleme mit ISP zu haben (siehe Postings im Supportforum: http://myavr.info/myForum/viewforum.php?f=8). Solange diese Probleme nicht ausgemerzt sind, sollte man auf die ältere Version (mySmartUSB MK2) oder ein anderes Produkt ausweichen.

mySmartUSB light

Preiswerter (ca. 15 €) Programmer im USB-Stick Design von myAVR. Der mySmartUSB light verfügt über eine Auto-Speed Funktion die die Frequenz des Programmers automatisch an die Taktfrequenz des Controllers anpasst. Allerdings kann diese nur bis ca. 211kHz herunter geregelt werden. Der Programmer kann 5V und 3.3V Systeme programmieren, Treiber gibt es für Windows, Linux und MacOS X und unterstützt wird je nach Firmware-Version das STK500v2 oder AVR910/911 Protokoll.

Amadeus-USB

Amadeus-USB ist ein ISP-Programmer zum Selberbauen. Er unterstützt eine Vielzahl von AVRs und verfügt über ein eigenes User-Interface. Der Programmer enthält einen einfach zu bedienenden Fuse-Editor. Sollte man einmal die falschen Clock-Einstellungen vorgenommen haben, ist das kein Problem, da der Programmer über eine Takterzeugung verfügt, mit der man den AVR wiederbeleben kann. Auch wer mit niedrigen Taktraten arbeitet (z. B. 32kHz), kann einen ATmega64 in ca. 4,8 Sekunden programmieren und vergleichen. Darüber hinaus kann mit geeigneten Makros die Programmausführung getracet werden. Die maximale Programmierdauer beträgt bei einem ATmega64 mit 16MHz Quarz 3,1 Sekunden, wenn der gesamte Speicher geschrieben und verglichen werden muss. Ist das Programm kleiner, geht es natürlich schneller ;-) Für einen ATTiny2313 oder ATTiny24 braucht er weniger als eine Sekunde.


Standalone

Die folgenden Geräte verfügen über interne Speicher, auf denen der zu programmierende Maschinencode abgelegt werden kann. Zum "flashen" selbst ist keine Verbindung zwischen Arbeitsplatzrechner bzw. Notebook und Programmiergerät erforderlich.

TheCableAVR-SD (kommerziell)

TheCableAVR-SD works by saving the "ISP", "HEX" and "EEP" files required for part programming from the PC application onto an SD-Card and inserting it into TheCableAVR-SD. This programmer is stand alone, making it very handy for field software updates and production programming.

ButtLoad

ButtLoad is based on the Atmel AVR Butterfly development board. ButtLoad is specially written firmware which converts a low-cost official Atmel Butterfly evaluation board into a smart ISP programmer for other members of the Atmel AVR family. It supports the entire AVR range, and allows for a complete program (including EEP, HEX, Fuse and Lock Bytes) to be stored and later programmed into a device from the Butterfly's on board non-volatile memory.

ButtLoad basiert auf dem Atmel-AVR Butterfly-development board und ist eine spezielle Firmware, die ein (billiges) Atmel-Butterfly-Board in einen vollwertigen ISP-Programmierer für andere Controller der Atmel-AVR-Familie verwandelt. Es unterstützt den gesamten AVR-Bereich und erlaubt, ein Programm komplett mit EEP, HEX, Sicherungs- und Lock-Bytes im nichtflüchtigen on-board-Speicher des Butterflys abzulegen und dann von dort heraus die Controller zu programmieren.

PalmAVR

AVR-ISP500, AVR-ISP500 tiny

von Olimex, siehe


Geschwindigkeitsvergleich

Im Rahmen einer Forendiskussion entstand die folgende Messung, die einige der möglichen Programmer in ihrer Geschwindigkeit vergleicht. Mit einbezogen in den Vergleich wurde neben originalen Atmel-ISP-Werkzeugen noch Werkzeuge für JTAG.

Die Testdatei war 29704 Bytes groß. Target ist ein ATmega6490, der mit 8 MHz vom RC-Oszillator getaktet wird. Das alles wurde mit einem AVRDUDE 5.5 getestet. 

Programmer     Parameter         Zeit fürs
                              Schreiben  Lesen
-----------------------------------------------
JTAG ICE mkII  default        2,58 s     3,27 s
JTAG           (4 MHz)
-----------------------------------------------
JTAG ICE mkII  1 MHz          8,34 s     8,51 s   (**)
ISP
-----------------------------------------------
AVRISP mkII    250 kHz        5,37 s     5,46 s
               1 MHz          2,45 s     2,45 s
               2 MHz          1,89 s     1,99 s
-----------------------------------------------
STK500         900 kHz        5,84 s     3,49 s
               (schnellstes)
-----------------------------------------------
AVR Dragon     default        2,81 s     3,49 s
JTAG           (4 MHz)
-----------------------------------------------
AVR Dragon     1 MHz          8,34 s     8,64 s
ISP            2 MHz          -          -        (*)
-----------------------------------------------
Parallelport-  keine Delay   13,20 s    12,45 s   (**)
Dongle "alf"   CPU 900 MHz
-----------------------------------------------

(*) Benutzung unmöglich, weder Fuses noch Signature zuverlässig lesbar.

(**) Fuses und Signature OK, aber das programmierte Ergebnis ist fehlerhaft (verify errors)

Software

  • yaap (Windows, diverse Parallelport-Programmer, GUI)
  • PonyProg (Linux, Windows, diverse Programmer für den parallelen und seriellen Port, GUI, am seriellen Port nur "Statuspinwackler" nach dem Schaltplan auf der lancos-Seite)
  • AVRBurner Ponyprog ähnliche Oberfläche für AVRDUDE.
  • AVRDUDE (Unix, Linux, Windows, praktisch alle Programmer, leicht erweiterbar auf andere Parallelportadapter-Anschlussbelegungen, Kommandozeile, auch für AVR Butterfly über dessen vorinstallierten Bootloader/Firmware-Uploader) siehe im Wiki AVRDUDE
  • uisp (Unix, Linux, Windows, praktisch alle Programmer, Kommandozeile, nicht mehr gepflegt).
  • AVR-Studio (nur Programmieradapter mit integriertem Controller für den seriellen Port, z. B. AVR910, ATMEL AVRISP und STK500)
  • Eingebauter Programmer im Bascom-Basic Compiler
  • AvrOspII - GUI Open Source programmer based on Atmels Application note AVR911.
  • Forumsbeitrag - Wie man Ponyprog aus dem AVR-Studio heraus nutzt
  • Kontrollerlab - (Linux), Grafische Oberfläche zu avr-gcc, uisp, avrdude und kate mit built-in debugger und serial terminal. Einfach verständlich und aufgeräumt (im KDE-Stil)
  • myAVRProgTool - Freies Programmiertool und zusätzlich auch als DUDE-GUI geeignet, einfach zu bedienen
  • ISP Programmer von Adam Dybkowski (Opensource, Windows 95, 98, Me, NT 4.0, 2000, XP, 2003, Vista and Windows 7 (32-bit and 64-bit versions))

ISP-Pins am AVR auch für andere Zwecke nutzen

Bei einem Programmer mit eingebautem Tristate-Treiber (z. B. 74HC(T)244) werden die Leitungen MISO, MOSI und SCK hochohmig geschaltet wenn die Programmierung beendet ist, d.h. sie beeinflussen die Schaltung nicht. Man kann die betreffenden Pins am AVR also relativ problemlos als Ausgänge verwenden, wenn man darauf achtet, dass die daran angeschlossene Peripherie durch die Programmierimpulse keinen Schaden nehmen kann. Als Eingänge sollte man die Pins allerdings nicht verwenden, da ein angeschlossener Taster zum Beispiel die Programmierimpulse kurzschließen würde, wenn er gedrückt ist.

Atmel empfiehlt in der Application Note AVR042: AVR Hardware Design Considerations (PDF) Peripherie an der SPI-Schnittstelle, bei gleichzeitiger Verwendung der Schnittstelle als In-System-Programmieranschluss, über Widerstände anzuschliessen.

siehe auch AVR HV-Programmer

Abgerufen von „https://www.mikrocontroller.net/index.php?title=AVR_In_System_Programmer&oldid=57628“