Matthias Weissers Infopage  Vorträge   Beratung   Kontakt   
eintragen austragen   InterNetWORX
FreeFind
Gästebuch
   Seminare   Bücher   Infoletter  
Infopage | Medizin | Reisen

 Matthias Weisser Logo Matthias Weisser's
Infopage
Schweitzer-Banner
Medizin: Psyche, Statik, Selbstheilung, Regeneration
Prävention: präventologische Beratung | meine Medizin-Bücher
Ökologie | Flohmarkt
meine Reiseberichte | Infopage als Datei | Infopage Historie

Atmega4809-Mikrocontroller-Tutorial
Einführung
Mikrocontroller-Historie
Mikrocontroller Atmega4809
UPDI-Programmer bereitstellen
per UPDI Bootloader programmieren
Test des Bootloaders mit LED-Blinkprogramm
WinAVR einrichten
LED-Beispiel mit WinAVR
siehe auch: Über mich meine Ideen meine Bastelprojekte

lernen an praktischen Beispielen . . .

Es wird gezeigt wie man mit einfachen Mitteln eine Atmega4809-CPU per UPDI programmieren kann.
Ein einfacher UPDI-Programmer dazu und der Umgang damit wird vorgestellt.
Ein einfaches Testprogramm mit LED wird erstellt und über Bootloader geladen.
Es wird gezeigt wie man eine Entwicklungsumgebung für C einrichtet und ein erstes Programm zum Laufen bringt.
Viel Erfolg !

Einführung

In den 70er Jahren waren Computer kein Allgemeingut. Mein erster Taschenrechner - ein Triumph-Adler mit grüner Fluoreszenzanzeige und Sin/Cos/Tan - kostete 260 DM. Die 4 NiCd-Akkus waren rasch leer. Der nächste Taschenrechner hatte eine LCD-Anzeige und lief mit 2 LR44-Knopfzellen mehr als 1 Jahr.

1977 gab es am Asam-Gymnasium einen Computerraum mit einem HP-Rechner der mit 3 Registern X, Y und Z arbeitete deren Inhalt er auf einem roten LED-Display anzeigte. Programme konnte man auf Strich-Karten oder Magnetstreifen speichern. Ein Plotter erlaubte graphische Ausgaben.

Als 1979 das Elektrotechnik-Studium begann war es nicht einfach etwas mit Mikrocontrollern wie 8080, 8085 oder Z80 zu entwickeln, denn preiswerte Computer, Diskettenlaufwerke, Festplatten, Monitore, Drucker und C-Compiler für jedermann gab es nicht. Der klobige PET 2001-Computer mit 1MHz-CPU und Kassettenlaufwerk als Massenspeicher kostete zunächst um 3000 DM.

An der TU München wurde statt "C" noch Fortran gelehrt. Die Programmzeilen stanzte man mit Hilfe großer Stanzgeräte als Code auf Karten und las diese im Leibnitz-Rechenzentrum ein. Bei Programmfehlern lochte man neue Karten und ließ den korrigierten Stapel erneut einlesen. Nur wenige Studenten konnten an einem der Eingabeterminals arbeiten um die zeitraubende Arbeit mit den Karten zu vermeiden.

Die Fa. Intel bot ein Entwicklungssystem für ihre Mikroprozessoren an, das um 50000 DM teuer in Firmen wie Siemens stand. Dabei wurden die Programme mit 2 Laufwerken auf großen 5 1/4"-Disketten gespeichert.

Wer etwas mit Mikrocontrollern machen wollte und wenig Geld hatte musste lernen mit einfachsten Mitteln Ergebnisse zu erzielen. Statt mit C-Compiler oder Assembler konnte man per Bleistift und Papier in Maschinensprache programmieren. Die Adressen für die Sprünge musste man sich dabei ausrechnen.

Statt teurem Bildschirm konnte man eine Hex-Anzeige nutzen für Adresse und Daten. Der Programmablauf ließ sich damit einzelschrittweise verfolgen. Eine Entwicklung von eigenem Code war mit Hilfe eines 2kB Netzteil-gepufferten RAM-Speichers möglich.

Wenn es brauchbar funktionierte brannte man sich ein EPROM. Dazu wurde eine selbstgebaute Zusatzplatine am parallelen Bus der Mikrocontroller-Platine angeschlossen. Ein selbstgebautes Netzteil lieferte die Programmierspannung von 21V.

Statt Laptop mit TFT-Display konnte man als Notlösung ein selbstgebautes Videointerface nutzen, das 40 Zeichen pro Zeile auf einem als Monitor umgebauten kleinen Fernseher darstellen konnte. Eine brauchbare Tastatur zur Eingabe von Zeichen mit paralleler bzw. serieller Schnittstelle kostete mehr als heute ein gebrauchter Laptop. Von Fa. Rafi bekam ich eine solide Tastatur für 30 DM der das Gehäuse und das nötige EPROM fehlte. Durch Messen am Sockel fand ich heraus was programmiert werden musste um die gewünschten Ascii-Codes auf die parallele Schnittstelle zu bekommen. Das Gehäuse klebte ich aus Sperrholz zusammen, rundete die Ecken ab und lackierte es weiß.

Die Softwarebasis des Systems war ein kleines Monitorprogramm dessen Funktionen man selbst erweitern konnte. Das Programm las die Tastatur ein, verarbeitete die Eingaben, beschrieb den Speicher oder auch Eproms und gab Daten an das Videointerface aus.

Zur Inbetriebnahme war ein Oszilloskop wichtig. Das 70MHz-Oszilloskop HM705 von Hameg mit 2 Kanälen und Trigger after Delay kostete 1983 2179 DM.

Fazit:
Der Selbstbau eines 8085- und 68000-Systems für Lernzwecke war um 1983 zeitintensiv und teuer, aber lehrreich. Die ICs auf der 68000-Platine und Speicherplatine wurden auswechselbar in Carrierstifte gesteckt und diese auf der Unterseite der Platine mit Fädeldraht verbunden. Trotz Wirrwarr funktionierte das Ganze gut. Mit der Tastspitze konnte man an jedem Pin messen.

Heute ist vieles einfacher geworden, denn es gibt nun preisgünstige hochintegrierte Mikrocontrollerchips mit
+ oft wiederprogrammierbarem Flash-Speicher,
+ SRAM-Schreib-Lese-Speicher,
+ Peripherie wie USART, SPI, I2C

und dazu
+ preisgünstige gebrauchte Laptops,
+ freie C-Compiler und Entwicklungswerkzeuge.

Um zu lernen wie Dinge zusammenhängen und was mit einfachen Mitteln möglich ist dient dieses Tutorial.

Mikrocontroller-Historie

Mikrocontroller bestehen aus vielen Transistorfunktionen. Zunächst verwendete man Einzeltransistoren für den Bau von Rechenanlagen. Leiterplatten konnten diverse solche Transistoren und auch Kernspeicher aufnehmen. Dann wurden Transistoren auf Siliziumscheiben integriert. Durch stetige Verkleinerung ließen sich mehr Transistoren auf kleinerer Fläche unterbringen.

Schauen wir kurz wie sich die Dinge über die Jahre entwickelt haben:

1943 patentierte gedruckte Leiterplatte (Paul Eisler)
1947 funktionsfähiger Germanium-Transistor (Shockley, Bardeen, Brattain)
1953 erster Silizium-Einkristall (Siemens-Verfahren)
1954 erster funktionsfähiger Silizium-Transistor (Gordon Teal), Transitor-Radio
1961 monolitisch integrierte Schaltung (RTL-Patent Bob Noyce)
1966 Standard TTL Quad Nand Gate-Gatter mit 2 Eingängen (Fairchild)
1967 DTL-Logik-Array mit 32 Gattern (Fairchild)
1969 4-Chips für Rechenmaschinen: 4bit Logik-IC CPU, ROM, RAM, Schieberegister (Ted Hoff, Intel)
1970 Entwicklung Intel 4001 (2048bit ROM), 4002 (320bit RAM), 4003 (10bit Schiebereg.), 4004 (4bit CPU)
1971 4bit Mikroprozessor Intel 4004 in Serie (4 Chip-Design von Ted Hoff)
1972 8bit Mikroprozessor Intel 8008 als Nachfolger 4004 mit 2250 Transistoren, 108kHz
1974 erster vollwertiger 8bit-Mikroprozessor Intel 8080 mit 4500 Transistoren, 2MHz
1974 8bit Mikroprozessor Motorola 6808
1975 8bit Mikroprozessor AMD 8080A
1975 8bit Mikroprozessor Zilog Z80 (Federico Faggin)
1976 8bit Mikrocontroller Intel 8748 - Familie MCS-48
1978 Fairchild Advanced Schottky TTL (FAST)-Logik (Fairchild)
1978 16bit Prozessor Intel 8086 mit 29000 Transistoren, 5-10MHz
1979 abgespeckter 16bit Prozessor Intel 8088 mit 8bit-Bus
1979 32bit Prozessor Motorola 68000 mit 68000 Transitoren
1982 16bit Prozessor Intel 80286 mit 134000 Transistoren für AT-Rechner
1984 32bit Prozessor Motorola 68020
1985 32bit Prozessor Intel 386DX mit 275000 Transistoren
1985 Fairchild Advanced CMOS Technologie (FACT)-Logik (Fairchild)
1993 32bit Prozessor Intel Pentium 80586 60-233MHz
1994 32bit Mikrocontroller Motorola 68F333
1995 32bit Prozessor Intel Pentium Pro 150-200MHz
1997 32bit Prozessor Intel Pentium II 80686 233-400MHz
1999 32bit Prozessor Intel Pentium III 450-600MHz
2000 32bit Prozessor Intel Pentium 4 1.3-2GHz
2004 32bit Prozessor Intel Pentium 4 Prescott 3,8GHz usw.

Mikrocontroller leben von Basisentwicklungen wie die 4 Chips der 4000-Serie von Intel, deren Integration zum Durchbruch mit den 8bit-Controllern 8080 und 8085 führte. Der Z80 war noch fortschrittlicher. Es folgte der Z8000.

Verbesserung in der Halbleiterindustrie ermöglichten die Integration von mehr Transistoren bei höheren Taktfrequenzen. Die Entwicklung ging von 4bit über 8bit, 16bit, 32bit zu 64bit-Systemen.

Leider setzte sich der deutliche bessere 68000-Kern gegenüber den 8086,80x86 nicht durch weil IBMs PC-System mit den Steckplätzen mangels Patentschutz rasch Nachahmer fand und sich so rasch weltweit verbreitete.

Jeder Mikrocontroller braucht einen Speicher für Programm, Stack und Daten. Anfangs wurden kleine ROM (ReadOnlyMemory) und RAM (RandomAccessMemory)-Speicher eingesetzt. Da ROM nur einmal beschrieben werden konnte musste der Code fehlerfrei sein, bevor man ihn so verewigen konnte. Schreib-Lese-Speicher RAM war vergleichsweise teuer. Beim Abschalten der Spannung verloren sie ihren Inhalt. Batteriegepufferte RAMs waren gut aber sehr teuer.

Paralleler Zugriff erforderte viele Pins und damit viel Platz auf der Leiterplatte. Platzsparende SMD-Bauweise gab es noch nicht.

EPROMs (EraseableProgrammableReadOnlyMemory) waren ein Fortschritt weil man den Speicher mehrmals mit UV-Licht löschen (spezielle Lampe) und dann mit Hilfe einer erhöhten Programmierspannung (z.B. 21V) elektrisch neu beschreiben konnte.

Bequemer waren elektrisch löschbare Speicher EEPROM (ElectricErasableProgrammableReadOnlyMemory) ab 1986 weil die lange Wartezeit für das Löschen per UV-Lampe so entfiel. Weil auf das Quarzfenster verzichtet werden konnte waren die Bausteine billiger. Es folgten Flash-Speicher die anfangs jedoch nicht sehr viele Schreib-/Löschzyklen vertrugen.

1974 UV-Licht löschbarer ErasableProgrammableReadOnlyMemory NMOS-EPROM (George Perlegos)
1986 elektrisch löschbarer nichtflüchtiger Speicher in CMOS-Technologie (Fairchild)


Genauso wichtig wie der Mikrocontroller selbst ist eine dazu brauchbare Entwicklungsumgebung. Auch dies hat sich über die Jahre gewandelt. Auf Rechner mit Relais, Röhren folgten Transistoren und integrierte Schaltkreise. Als Ablaufsteuerung für Rechner kamen schließlich Betriebssysteme wie MS-DOS und Windows:

1623 zahnradgetriebene Rechenmaschine (Wilhelm Schickard, Tübingen)
1937 erster Computer Z1 (Konrad Zuse)
1939 Relais-Computer Z2 (Konrad Zuse)
1941 programmierbarer Computer Z3: 600 Relais für Rechenwerk, 1600 Relais für Speicher (Konrad Zuse)
1944 Relaisrechner Harvard Mark I mit Lochstreifen (Howard H. Aiken)
1946 Electronic Numerical Integrator and Computer ENIAC: 17468 Röhren, 1000 Rechnungen/Sekunde
1951 UNIVersal Automatic Computer UNIVAC I (Eckert-Mauchly Computer Corporation)
1952 Relais-/Röhrenrechner ARRA (Mathematisches Zentrum Amsterdam)
1954 Relais-/Röhrenrechner ARRA II
1955 TRansistorized Airborne DIgital Computer TRADIC (AT&T Bell Labs)
1958 Electrologica X1 mit Germanium-Transistoren, Dioden (Bart Loopstra, Carel Scholten)
1959 IBM 1401 mit Transistoren, Kondensatoren, Dioden auf Platinen
1964 erster Tischrechner mit Transistoren, Kernspeicher IME 84 (Industria Macchine Elettroniche)
1967 erster Taschenrechner (Jack Kilby, Jerry Merryman, James Van Tassel von Texas Instruments)
1968 Demonstration Computermaus (Douglas C. Engelbart)
1970 Betriebssystem für PDP7 in 8kB (Ken Thompson, Dennis Ritchie)
1975 Altair 8800-Computer, programmiert per Kippschalter (Ed Roberts)
1976 Apple I-Rechner der Fa. Apple Computer (Steve Wozniak, Steve Jobs, Ron Wayne)
1977 Apple II-Rechner
1977 Personal Electronic Transactor PET 2001 1MHz MOS6502, 4kB RAM (Chuck Peddle, Commodore)
1981 IBM-PC 5150 mit Intel 8088, 4.77MHz, 48kB RAM, 5 ISA-Slots, Betriebssystem PC-DOS
1983 Apple Lisa mit graphischer Bedienoberfläche, 1MB RAM
1984 Apple Macintosh mit 68000, graphischer Oberfläche, Maus
1984 IBM PC AT mit 80286, 6MHz, bis 16MB RAM, 1.2MB Floppy Disk
1985 Microsoft Windows
1995 Windows 95-Betriebssystem


Viele Entwicklungshilfsmittel sind heute online zu finden und oft gratis herunterzuladen. Es finden sich Datenblätter, C-Compiler, Schaltpläne und Foren wo man Fragen stellen kann. Das Internet begann in den 70er Jahren und wurde gegen 1998 populär als mehr Menschen einen Zugang dazu hatten - erst per Modem und dann per DSL-Router.

1969 Arpanet als Vorläufer des Internet
1973 Erfindung Ethernet (Robert Metcalfe)


Interessante Mikrocontroller wie die AVR-Serie kamen von der Fa. Atmel die nun von Microchip übernommen wurde.

Obwohl 8bit überholt erscheinen mögen kann man damit auch heute noch gut lernen und arbeiten. Wichtig ist das Verstehen und problemlose Arbeiten. Letztlich waren es 2 Studenten die aus einer eigenen Unzufriedenheit heraus die AVR-Controller erfanden. Eine Erfolgsgeschichte begann.

1984 Gründung Fa. Atmel (George Perlegos)
1992 Erfindung AVR-CPU durch 2 unzufriedene Studenten (Alf-Egil Bogen, Vegard Wollan)
1997 Fa. Atmel stellt den Mikrocontroller Atmel AVR vor
2003 500Mio Mikrocontroller Atmel AVR verschickt
2007 Atmel AVR für Arduino Uno startet Erfolgsgeschichte der Arduino-Produkte
2015 7 Mrd Mikrocontroller Atmel AVR verschickt

Hier soll der Atmega4809 nun näher betrachtet werden.

Mikrocontroller Atmega4809

Der Atmega4809 verfügt über interessante Eigenschaften wie:

+ 48kB Flash-Programmspeicher (10000 Zyklen)
+ 6kB SRAM
+ 256 Bytes EEPROM (100000 Zyklen)
+ Hardware-Multiplizierer
+ 20MHz interner Oszillator
+ 32768Hz interner Oszillator
+ 16bit Timer/Counter mit Compare-Funktion
+ 16bit Timer/Counter mit Input-Capture
+ 16bit RealTimeCounter RTC
+ 4 USART
+ SPI-Interface
+ TWI-Interface für I2C
+ Analog-Komparator
+ 10bit AD-Wandler 150kS/s
+ Referenzspannungen 0.55V, 1.1V, 1.5V, 2.5V, 4.3V
+ Watchdog Timer WDT
+ 41 programmierbare IO-Pins
+ UPDI-Interface zum Programmieren
+ interner Bootloader
+ preisgünstig
+ Arduino-IDE als Unterstützung zur Programmierung verfügbar

Wer meint daß 48kB Programmspeicher "wenig ist" der sei daran erinnert daß mein selbstgebautes 8085-System von 1982 mit ~2kB auskam und daß der erste IBM-PC auch nur 48kB RAM hatte, wo Programme per Diskette hineingeladen werden konnten. Selbst aufwendige Programme für professionelle Kunden passten anfangs in diesen Speicher.

Neben dem 4809 gibt es abgemagerte Varianten wie:
- ATmega3209 32kB Flash, 4kB SRAM
- ATmega1609 16kB Flash, 2kB SRAM
- ATmega809 8kB Flash, 1kB SRAM
- ATmega4808, ATmega3208, ATmega1608 und ATmega808 haben weniger als 40 Pins.

Die abgemagerten Varianten sollen hier bewusst nicht näher betrachtet werden weil es den Rahmen hier sprengen würde. Da die Preisunterschiede zwischen den Typen nicht so groß sind kann man zum Lernen den 4809 nehmen um bei Programmierversuchen mit "C" weniger rasch an Grenzen zu stoßen wie SRAM zu klein.

Das Datenblatt "ATmega4808/4809 Data Sheet DS40002173B" umfasst 554 Seiten. Daher hier ein paar Auszüge.

Der 4809 ist in mehreren Gehäuseformen verfügbar, darunter:
+ 40 Pin Plastik Dual Inline Package PDIP
+ 48 Pin Thin Quad Flatpack TQFP

Beim PDIP-Gehäuse fehlen 8 Pins, so daß diese nicht genutzt werden können. Der Vorteil von PDIP ist daß man den Controller in einen DIL40-Sockel stecken und somit leicht wechseln kann.

Wenn man alle Pins nutzen möchte muss man den TQFP-Chip auf eine Platine löten, die dann z.B. auf ein Steckbrett gesteckt werden kann.

Atmega4809
Platine mit Atmega4809, wo alle CPU-Pins an externen Anschlüsse liegen. Hinten sitzt ein FT232RL.

Atmega4809 Schaltplan
Der 4809 erhält ~5V per USB oder Spannungsregler IC3. FT232RL erlaubt Anschluss an USB.

Die maximal mögliche Taktfrequenz des Atmega4809 hängt von Betriebsspannung und Temperatur ab. Bei 125°C sind 16MHz möglich. Unter 4.5V sind keine 20MHz zu erwarten. Bei 2.7V sollen 8MHz gehen bzw. 10MHz bis 105°C.

Damit auch 20MHz für Tests genutzt werden können wird das Chip hier über einen Spannungsregler (links bei der USB-Buchse) mit 5V versorgt. Leuchtdioden zeigen Datenverkehr (Receive RX, Transmit TX) auf der seriellen Schnittstelle an. Eine weitere LED hängt für Testzwecke an PF5.

Der Chip verfügt über "Fuses" mit denen Eigenschaften vorgegeben werden können wie:
+ Watchdogverhalten -> WDTCFG
+ BrownOutDetect -> BODCFG
+ Oszillator-Konfiguration -> OSCCFG (16 oder 20MHz: FREQSEL=0, =1)
+ Systemkonfiguration 0 -> SYSCFG0 (CRC, Reset-Pin)
+ Systemkonfiguration 1 -> SYSCFG1 (Startup-Timing)
+ Code-Ende -> APPEND
+ Ende Bootblock -> BOOTEND

Die Fuses können nur per UPDI-Schnittstelle ausgelesen und verändert werden (Datenblatt S.51f 7.8).

Es erscheint daher sinnvoll sich einen Programmieradapter für UPDI zu bauen oder zu kaufen.

UPDI-Programmer bereitstellen

UPDI bedeutet "Unified Program and Debug Interface". Man kann damit das 4809-Chip programmieren, die Fuses verändern und ggf. auch den Programmablauf verfolgen.

Es gibt Programmer für UPDI in unterschiedlicher Ausführung und Preislage. Manche werden von der Entwicklungsumgebung "Atmel Studio 7" unterstützt das viel Rechenleistung (moderne Hardware) fordert.

Hier soll ein preisgünstiger Weg ohne das Studio gezeigt werden.

Im Internet sind Platinen "Arduino nano 3" preisgünstig zu erhalten. Ein Bootloader ist dabei üblicherweise installiert, so daß mit dessen Hilfe eine Software aufgespielt werden kann um die Platine zu einem UPDI-Programmer zu machen.

Dazu wird im Internet nach dem Titel "UPDI programmer software for Arduino (targets ATtiny 417 / 814 / 816 / 817 / 1614 / 1616 / 1617 and similar MCUs) – ElTangas/jtag2updi" gesucht und die Datei jtag2updi-master.zip auf den Rechner heruntergeladen. Darin findet sich die Datei JTAG2UPDI.hex.

Diese Datei kann z.B. mit einer Arduino IDE oder mittels AVRDUDE auf den Arduino nano 3 installiert werden.

Im Netz sind unterschiedliche Versionen von AVRDUDE.exe zu finden. Wichtig ist eine dazu passende AVRDUDE.conf-Datei. Wenn diese beiden Dateien vorhanden sind lässt sich avrdude aufrufen und der chip auf der Arduino nano 3-Platine programmieren mit einer Zeile wie:

avrdude -v -v -p atmega328p -c arduino -P COM7 -b 57600 -U flash:w:JTAG2UPDI.hex

wobei mit COM7 der serielle Port gemeint ist der sich im Windows-Gerätemanager meldet wenn die Arduino nano 3-Platine angesteckt wird. Wenn beim Anstecken ein gelbes Rufzeichen im Gerätemanager erscheint fehlt der passende Treiber. Auf der Arduino nano-Platine kann ein FTDI-Baustein verbaut sein oder ein CH340-Chip. Nach Installation des passenden Treibers sollte das gelbe Rufzeichen verschwinden. Der Port der dann angezeigt wird kann dann oben an Stelle von COM7 eingetragen werden.

Die obige Zeile kann in eine Batchdatei eingetragen werden wie z.B. program.bat. Dies ruft man dann auf.
Es ist auch möglich ein Fenster "Eingabeaufforderung" aufzurufen und die obige Zeile dort einzugeben.
Die Dateien avrdude.exe, avrdude.conf und JTAG2UPDI.hex sollten sich dann im angezeigten Ordner befinden.

Auf diese Weise sollte sich die Arduino nano 3-Platine erfolgreich mit JTAG2UPDI.hex über den Bootloader programmieren lassen. Der neue UPDI-Programmer ist nun betriebsbereit.

per UPDI Bootloader programmieren

Da der Programmer nun gehen sollte kann man damit den Bootloader auf den Atmega4809 brennen, wenn man dies möchte.

Mit Hilfe des Bootloaders ist es dann möglich weitere Programme auf den Atmega4809 zu bringen ohne den UPDI-Programmer erneut nutzen zu müssen, so wie man es vom Arduino nano 3 bereits kennt..

Zum Brennen des Bootloaders kann die Arduino IDE vorteilhaft verwendet werden. Daher soll die Vorgehensweise hier kurz beschrieben werden. Als Beispiel wird Arduino 1.8.9 genutzt (arduino-1.8.9-windows.exe).

Installieren Arduino IDE:
+ arduino-1.8.9-windows.exe aufrufen
+ alles installieren lassen incl. USB-Treiber in Programme (x86)/Arduino

Es fehlt nun noch die Unterstützung für die Atmega4809-CPU. Dazu kann man "MegaCoreX" von github herunterladen (https://github.com/MCUdude/MegaCoreX). Die Datei "MegaCoreX-master.zip" auf der Festplatte speichern.

Arduino-Umgebung mit MegaCoreX erweitern:
+ MegaCoreX-master.zip auf der Festplatte auspacken
+ verschieben des Ordners nach "C:\Programme (x86)\Arduino\hardware)"
+ den Ordner "hardware" erzeugen falls nicht existent

Die Arduino IDE aufrufen. Unter "Werkzeuge", "Board" sollte unter "MegaCoreX" nun eine Liste mit Atmega4809 und anderen CPUs dieser Serie angezeigt werden.

Die Arduino IDE kennt nun den Atmega4809 und einen kleinen Bootloader (512 byte) dazu.

Zum Programmieren des Bootloaders in den 4809 muss der UPDI-Programmer (rechts) mit dem UPDI-Pin des 4809 (links) verbunden werden.

+ Arduino nano (mit UPDI-Programm im Flash) Pin D6 über 4.7k mit UPDI-Pin Atmega4809 verbinden
+ Arduino nano RST über 470nF mit 5V verbinden
+ GND der beiden Controller verbinden
+ 5V der beiden Controller verbinden

Das Bild zeigt wie es gemacht wird. Links der 4809 und rechts der UPDI-Programmer.

Atmega4809 Programmer
Anschluß UPDI-Programmer Pin D6 über 4.7k an UPDI-Pin 4809. 470nF zwischen RST und VCC.

Zum Programmieren des 4809 wird der Programmer (rechts) über USB mit dem Laptop verbunden. Beide Platinen werden so mit 5V versorgt (kleiner Verlust über Diode und Kabel). Der USB-Chip des Programmers meldet sich im Gerätemanager z.B. mit USB-SERIAL CH340 (COM4). Falls eine gelbe Warnung erscheint muss der nötige Treiber noch installiert werden.

Der Bootloader kann nun über die Arduino IDE programmiert werden:

+ unter "Werkzeuge", "Board", "MegaCoreX" Atmega4809 wählen
+ folgende Einstellungen prüfen und ggf. ändern (andere Optionen ignorieren)
+ Bootloader: "Optiboot (UART3 default pins)"
+ Clock: "Internal 16 MHz"
+ Pinout: "48 pin standard"
+ Reset pin: "Reset"
+ Programmer: "JTAG2UPDI"

Den Programmer (rechts) über USB verbinden, z.B. COM4 meldet sich.

+ in der Arduino IDE den Port für UPDI-Programmer wählen (hier COM4).
+ unter "Werkzeuge" Bootloader brennen wählen -> Bootloader in Atmega4809 brennen.

Es sollte eine Meldung erscheinen wie: "Der Bootoader wurde gebrannt". 512Byte.

Nun sollte der serielle Bootloader des Atmega4809 arbeiten.

Falls eine Fehlermeldung erscheint wie "Fehler beim Brennen des Bootloaders" kann dies ein Hinweis auf eine unbrauchbare Datei avrdude.conf sein. Eine passende Datei sollte dann im Netz gesucht werden. Mit der avrdude.conf von "ElTangas" gab es keine Probleme.

Ein Nachteil des Bootloaders ist daß dieser die unteren 512byte im Flash belegt und damit Programme die für Betrieb ab Adresse 0 gelinkt wurden nicht ladbar sind. AVRDUDE verweigert dann das Laden.

Test des Bootloaders mit LED-Blinkprogramm

Zum Test soll nun ein einfaches LED-Blinkprogramm erstellt und über den Bootloader auf den 4809 heruntergeladen werden. Dazu gibt es Beispiele in der Arduino IDE die man aufrufen kann.

+ entferne das USB-Kabel zum Programmer (Nano-Board) falls noch nicht getan
+ wähle in der Arduino-IDE das LED-Blinkprogramm aus unter "Datei" "Beispiele" "Basics" "Blink"
+ ändere Programm ledPin=39 pinMode(ledPin,OUTPUT), digitalWrite(ledPin,HIGH) etc.
+ stecke das Atmega4809-Board über USB an -> es meldet sich z.B. mit USB Serial Port (COM5)
+ wähle "Werkzeuge" "Board" Atmega4809 unter MegaCoreX
+ prüfe folgende Einstellungen, ggf. ändern (andere Optionen ignorieren)
+ Bootloader: "Optiboot (UART3 default pins)"
+ Clock: "Internal 16 MHz"
+ Pinout: "48 pin standard"
+ Reset pin: "Reset"
+ diesmal ist die Programmer-Option egal
+ per USB angestecktes Atmega4809-Board: Port "COM5"
+ mit "Sketch" "Hochladen" den Arduino-Sketch in den ATmega4809 laden.

Das Programm sollte nun laufen und die untere LED am 4809 blinken.
Es erscheint "Hochladen abgeschlossen" 790 bytes Flash, 4 bytes RAM

In der Arduino IDE können nun C-Programme geschrieben, compiliert und auf den 4809 per Bootloader geladen werden.
Serielle Ausgaben des 4809 über TX3 können über USB verfolgt werden.

Eine weitere Möglichkeit C-Programme zu schreiben und zu übersetzen ist die Nutzung von AVRGCC unter WinAVR.

WinAVR einrichten

WinAVR ist eine kompakte Entwicklungsumgebung mit AVRGCC für AVR-Controller. Sie umfasst Entwicklungswerkzeuge wie:

+ AVR GNU Binutils
+ AVR GNU Compiler Collection (GCC)
+ avr-libc
+ AVRDUDE (Programmiertool)
+ AVR GNU Debugger (GDB) / Insight
+ Splint (braucht cygwin1.dll)
+ MFile (Makefilegenerator)
+ Cygwin DLLs
+ GNU programs/utilities incl. Make (make.exe), bash (sh.exe)

Der Vorteil ist daß mit WinAVR recht brauchbar und rasch einfache Programme entwickelt werden können ohne große Entwicklungsumgebungen aufwendig einrichten zu müssen. Programme für AVR-Controller wie Atmega328, Atmega2560 oder Atmega32u4 sind damit problemlos erstellbar. Neuere Chips wie Atmega4809 sind mit WinAVR 2010 aus dem Netz jedoch nicht ohne weiteres nutzbar.

Der GCC 4.3.3-Compiler aus WinAVR 2010 ist veraltet. Neuere Versionen erzeugen ggf. größeren Code.

Es ist möglich WinAVR 2010 mit neueren Paketen aufzufrischen um Atmega4809 nutzten zu können. Dies ist jedoch nicht so einfach. Daher hat Veit ein avr-gcc-8.4.0_mingw64_binutils2.34.zip zusammengebaut das die Arbeit erleichtert.

+ avr-gcc-8.4.0_mingw64_binutils2.34.zip in Verzeichnis C:\WINAVR kopieren, dort auspacken
+ avr-gcc-8.4.0_mingw64_binutils2.34.zip löschen
+ alle Ordner aus avr-gcc-9.1.0-x86-mingw herauskopieren, den leeren Ordner dann löschen

Fehlende aktuelle Dateien nach C:\WINAVR\bin kopieren wie:
+ avrdude.exe (27.6.2019 455kB)
+ avrdude.conf (25.5.2020 497kB)
+ libusb0.dll (27.6.2019 67kB)
+ make.exe (27.6.2019 255kB)

Dateien aus WinAVR2010 (WinAVR-20100110-install.exe) nach C:\WINAVR\utils kopieren wie:
+ cp.exe
+ diff.exe
+ echo.exe
+ msys-1.0.dll (für rm.exe, sed.exe, cp.exe, sh.exe)
+ rm.exe
+ sed.exe
+ sh.exe
+ msys-1.dll usw.

Den Pfad anpassen mit Start, Computer re Maustaste, Eigenschaften, Erweiterte Systemeinstellungen, Erweitert, Umgebungsvariablen, Systemvariablen, Path, Bearbeiten, Pfad ändern (C:\WINAVR\bin;C:\WINAVR\utils\bin;...), ok.

Wenn alles gutgegangen ist sollte ein einfaches Projekt wie "LED blinken" mit Hilfe eines Makefiles rasch zum Laufen zu bringen sein.

Auch die Fuses sollten nun auslesbar und schreibbar sein mit Hilfe von AVRDUDE.

Beispiele für Auslesebefehle der Fuses sind:
avrdude -c jtag2updi -P com9 -p m4809 -U fuse0:r:FUSE_0.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U fuse1:r:FUSE_1.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U fuse2:r:FUSE_2.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U fuse4:r:FUSE_4.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U fuse5:r:FUSE_5.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U fuse6:r:FUSE_6.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U fuse7:r:FUSE_7.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U fuse8:r:FUSE_8.txt:d
avrdude -c jtag2updi -P com9 -p m4809 -U lock:r:FUSE_LOCK.txt:d

Jede Fuse wird dabei in eine Textdatei eingelesen.

LED-Beispiel mit WinAVR

Wichtig für das LED-Beispiel ist eine Datei main.c wo die Befehle stehen die die LED zum Blinken bringen sollen.

Zu main.c gehört eine Header-Datei main.h die ggf. weitere Hinweise für den Compiler enthält.

Das Makefile enthält Anweisungen
+ welche Dateien zum Projekt gehören
+ welche CPU verwendet wird - hier Atmega4809
+ welche Taktfrequenz verwendet wird
+ wie AVRDUDE das Programm dann in den Speicher laden soll

Schauen wir main.c näher an:

Es gibt eine Funktion initialization(); wo die Pins des 4809 als Eingang oder Ausgang definiert werden.
PORTF.DIR bestimmt die Richtung der Pins an Port F. Die LED an Pin F5 soll Ausgang sein. Daher wird dieses bit gesetzt.

Die Zeile PORTF.OUT |= PIN5_bm; verodert die Bitmaske für Pin F5 - der Pin wird also gesetzt, die LED geht an.
Die Zeile PORTF.OUT &= ~PIN5_bm; verundet die negierte Bitmaske für Pin F5 - der Pin wird also rückgesetzt, die LED geht aus.

Diese Zeilen werden in einer Schleife durchlaufen, die LED geht also ständig an und aus.

Damit das Blinken gut sichtbar ist wird nach dem Einschalten und Ausschalten der LED jeweils 1s gewartet.
Der Befehl dazu lautet delay_ms(1000);

Im Makefile werden festgelegt:
MCU = atmega4809 (verwendete CPU)
F_CPU = 16000000 (Taktfrequenz für delay)
TARGET = main (main.c als Hauptdatei)
avrdude -v -v -p atmega4809 -c arduino -P COM11 -U flash:w:main.hex (Programmierung per Bootloader ins Flash)

Um das Ganze nun zu starten wird eine Eingabeaufforderung geöffnet.
Mit cd-Befehlen wird das Verzeichnis gewechselt zum Ort des Beispielcodes.
Im Ordner des Beispielcodes müssen alle Projektdateien und das Makefile liegen.

Zum Starten gibt man auf der Kommandozeile ein:
make all ENTER -> damit startet die Übersetzung des Programms und der Linker.
Wenn alles gut geht steht am Ende: Errors: none = keine Fehler.
Ansonsten muss man suchen was man falsch gemacht hat.
Eine Hilfe ist die Fehlermeldung und die Zeile wo der Fehler bemerkt wurde.

make clean ENTER löscht die ganzen erzeugten Dateien wieder.

make program ENTER erstellt das hex-file und versucht es über AVRDUDE zu programmieren.
Dazu muss die USB-Verbindung zum 4809 hergestellt sein.
Der im Gerätemanager angezeigte COM-Port darf kein gelbes Rufzeichen zeigen (Treiber fehlt).
Und die angezeigte Nummer des COM-Ports muss zum Eintrag im Makefile bei AVRDUDE passen.

Wenn alles stimmt erscheint keine Fehlermeldung von AVRDUDE.
Stattdessen meldet AVRDUDE 2xxx bytes of flash written, 2xxx bytes of flash verified.
avrdude done. Thank you.

Die LED fängt wie erwartet an zu blinken.

Es ist nun leicht das Programm zu verändern wie z.B. mehr oder weniger Delay einzufügen.
make program ENTER übersetzt jedes mal rasch, linkt und lädt.

Wenn man einen alten Stand nicht verlieren möchte kann man eine Kopie des Datei-Ordners anlegen.
Ein neuer Stand kann so ausgiebig getestet werden ohne zu verlieren was man zuvor hatte.

Damit ist dieser Ausflug in die Welt der Mikrocontroller beendet und ich hoffe daß Sie Ihr Erfolgserlebnis hatten
oder es noch haben werden wenn noch etwas klemmen sollte. Viel Erfolg !

© 2000-2021 Weisser
Impressum
email www.mweisser.50g.com