lernen an praktischen Beispielen . . .
Es wird gezeigt wie man mit einfachen Mitteln eine Atmega4809-CPU per UPDI programmieren kann.
Ein einfacher UPDI-Programmer 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 !
| Video: "UPDI Programming an ATmega4808" | |
| es ist mit einfachen Mitteln möglich einen Atmega4808 mit einem kleinen Programm zu versehen. Das Video zeigt wie es geht.. der Atmega4809 hat mehr Pins und damit mehr Möglichkeiten. Der Umgang damit ist jedoch ebenso einfach.. siehe unten.. | |
| Einführung |
In den 70er Jahren waren Computer kein Allgemeingut. Mein erster Taschenrechner am Gymnasium - ein Triumph-Adler 88T mit grüner Fluoreszenzanzeige und Sin/Cos/Tan - kostete 260 DM. Die 4 NiCd-Akkuzellen waren rasch leer. Der Brother 738SR für das Mathe/Physik-Abitur lief mit seiner stromsparenden LCD-Anzeige mit 2 LR44-Knopfzellen mehr als 1 Jahr.
1977 gab es am Asam-Gymnasium einen Computerraum mit HP9810A-Rechner. Ein rotes LED-Display zeigte die Rechenregister X, Y, Z an. Programme wurden auf Magnetstreifenkarten (eingebaute Lese-/Schreib-Einheit) oder Loch-/Strichkarten (Lesegerät HP98603A) gespeichert. Der Plotter (HP98623A) erlaubte hochauflösende graphische Ausgaben. Die US-Preise lagen bei $2475 Rechner, $675 Drucker, $485 Plotter, $500 500 weitere mögliche Programmschritte, $485 Mathe-Modul Sin/Cos + Plotten, $485 Statistik-Modul. Das System wurde 1971 von HP als Nachfolger des HP9100A eingeführt.
Im Elektrotechnik-Studium ab 1979 war es nicht einfach privat etwas mit Mikroprozessoren wie 8080, 8085, Z80 oder 68000 zu entwickeln, denn preiswerte PCs, Laptops, Monitore, Drucker, C-Compiler gab es nicht. Ein PET 2001-Computer mit 1MHz-CPU und Kassettenlaufwerk als Massenspeicher kostete anfangs um 3000 DM.
An der TU München wurde von uns Studenten statt "C" Umgang mit Fortran gefordert. Die Zeilen des Programms konnte man mit großen Stanzgeräten codiert auf Karten lochen und diese im Leibnitz-Rechenzentrum einlesen lassen. Bei Fehlern im Programm lochte man neue Karten. Für wenige Studenten gab es Platz an einen Eingabeterminal um die Arbeit mit den Lochkarten zu vermeiden.
Fa. Intel hatte ein Entwicklungssystem für MCS80-Mikroprozessoren, das um 50000 DM teuer in Firmen wie Siemens stand. Betriebssystem und Programme wurden auf großen 5 1/4"-Disketten gespeichert. RAM-Speicher mit 1MB oder mehr - Fehlanzeige.
Wer als Student ohne viel Geld etwas mit Mikroprozessoren machen wollte musste lernen mit einfachsten Mitteln Ergebnisse zu erzielen. Ein einfaches Entwicklungsboard mit 8085 ließ sich als doppelseitige Leiterplatte auflösen, mit Höhensonne belichten und ätzen. Als Durchkontaktierung diente abisolierter Kupferdraht. Platinen rasch mal per Internet in China billig machen lassen - Fehlanzeige. Leiterplattenerstellung per PC - Fehlanzeige. Das Layout wurde 1:1 auf Transparentpapier erstellt. Die Lochreihen und Durchkontaktierungen wurden aufgeklebt/aufgerubbelt und die Leiterbahnen kamen von einer schmalen Rolle. Nach dem Ätzen wurde von Hand jedes Loch gebohrt. Lötstopplack - Fehlanzeige.
Statt C-Compiler oder Assembler war Maschinensprache nutzbar. Programme ließen sich mit Bleistift auf Papier schreiben. Die Adressen für die Sprünge konnte man von Hand ausrechnen. Programme ausdrucken - Fehlanzeige. Kopierer oder Scanner Fehlanzeige.
Statt einem teurem Monitor als Ausgabe konnte man sich eine Hexadezimal-Anzeige zusammenbauen zur Anzeige von Adresse und Daten. Der Programmablauf ließ sich einzelschrittweise verfolgen. Es war möglich Programmcode in einem 2kB-RAM-Speicher abzulegen und ihn dort zu entwickeln. Um den Code beim Abschalten des Netzteils nicht zu verlieren ließ sich das RAM per Batterie puffern.
Erst wenn das Programm brauchbar funktionierte brannte man sich ein EPROM. Da Programmiergeräte teuer waren konnte man sich selbst etwas bauen mit ein paar Tasten, 7-Segment-Anzeigen, Dekodern, Treibern, Timern und Logik.
Komfortabler wurde das Programmieren von EPROMs durch eine Zusatzplatine für Anschluss am parallelen Bus der Mikrocontroller-Platine. Ein extra Netzteil lieferte die für EPROMs nötige Programmierspannung von 21V.
Für das Löschen der EPROMs gab es teure UV-Löschgeräte. Billiger war es eine UV-Lampe als Sonderangebot zu erwerben und ein Gehäuse darum zu bauen.
Wenn man eine Ausgabe auf Bildschirm wollte war dazu ein alter Schwarzweiß-Fernseher nutzbar in den man eine Buchse hinten einbaute. Etwa 40 Zeichen pro Zeile ließen sich brauchbar lesbar darstellen. Das nötige Videointerface dazu konnte man auf einer Leiterplatte aufbauen. Die Punkte für die Zeichen wurden aus einem Character-ROM ausgelesen. Eine Logik mit Zählerbausteinen erzeugte das Video-Signal für die Darstellung auf dem Fernseher.
Für Studenten bezahlbare Laptops mit Tastatur und hochauflösendem TFT-Display gab es zur Ein- und Ausgabe noch lange nicht. Man konnte sich ein Video-Terminal zusammenzubauen mit Z80. Nur kostete das eine Menge Geld für Gehäuse, Netzteil, Platine, CPU, Speicher, Videochip.
Eine Tastatur zur Eingabe von Zeichen über parallele bzw. serielle Schnittstelle kostete 1981 mehr als heute ein gebrauchter Laptop. Von Fa. Rafi bekam ich eine hochwertige Tastatur ohne Gehäuse und das nötige EPROM für 30 DM. Durch Messen am Sockel fand ich heraus was programmiert werden muss um bei Tastendruck den gewünschten ASCII-Code auf die parallele Schnittstelle zu bekommen. Ein Gehäuse dazu klebte ich aus Sperrholzteilen zusammen, rundete die Ecken ab und lackierte es weiß.
Die Softwarebasis des selbstgebauten 8085-Systems war ein kleines Monitorprogramm dessen Funktionen man selbst erweitern konnte. Das Programm las die Zeichen von der Tastatur ein, verarbeitete diese Eingaben, beschrieb den RAM-Speicher, programmierte EPROMs und gab Zeichen über das Videointerface aus.
Um Erfahrungen mit 16bit-Mikroprozessoren zu sammeln wurde ein 68000-System aufgebaut. Die ICs wurden auswechselbar in Carrierstifte gesteckt. Diese wurden auf der Unterseite der Doppeleuropakarte mit Fädeldraht verbunden. Auf eine zweite solche Leiterplatte kam batteriegepufferter SRAM-Speicher. Die Teile waren teuer, aber das Ergebnis zufriedenstellend. Am Ende lief auf dem Board ein 68000-Assembler.
Zur Inbetriebnahme der Systeme war ein gutes 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- oder 68000-Mikroprozessorsystems für Lernzwecke war um 1983 zeitintensiv, teuer, aber lehrreich. Trotz Draht-Wirrwarr mit Lackdraht auf der Platinenunterseite funktionierte das 68000-System gut. Per Tastspitze konnte man an jedem Pin leicht messen.
Heute ist vieles einfacher, denn es gibt preisgünstige Mikrocontrollerchips mit
+ integriertem, elektrisch wiederprogrammierbarem Flash-Speicher,
+ integriertem SRAM-Schreib-Lese-Speicher,
+ integrierter Peripherie wie USART, SPI, I2C.
Dazu gibt es
+ 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 einzelne Transistoren für den Bau von Rechenanlagen. Leiterplatten konnten diverse Transistoren und auch Kernspeicher aufnehmen. Dann wurden Transistoren auf Siliziumscheiben integriert. Durch stetige Verkleinerung ließen sich immer mehr Transistoren auf kleinerer Fläche unterbringen.
Transistorfunktionen
Schauen wir kurz wie sich Transistorschaltungen ü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), Transistor-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 Transistoren
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 auf Basis 68000
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.
Mikroprozessoren und Mikrocontroller lebten 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 16bit-Prozessor Z8000.
Kleinere Strukturen in der Halbleiterindustrie ermöglichten die Integration von immer mehr Transistoren bei steigenden Taktfrequenzen und fallender Spannung. Die Entwicklung ging von 4bit über 8bit, 16bit, 32bit zu 64bit-Systemen.
Speicher
Mikrocontroller brauchen Speicher für Programm, Stack und Daten. Anfangs wurden recht kleine Lesespeicher ROM (ReadOnlyMemory) und Schreib-Lese-Speicher RAM (RandomAccessMemory)-Speicher eingesetzt.
Da ROM-Speicher nicht mehrmals beschrieben werden kann musste der Code fehlerfrei sein, bevor man ihn so verewigen konnte. Schreib-Lese-Speicher RAM war vergleichsweise teuer. Beim Abschalten der Spannung verlieren RAMs ihren Inhalt. Parallel angesteuerte batteriegepufferte RAMs (z.B. 8kB) waren gut aber teuer.
Ein paralleler Zugriff auf Speicher erforderte viele Pins und damit viel Platz auf der Leiterplatte. Platzsparende SMD-Bauweise mit kleinen Balls unter dem Chip gab es damals nicht. Dafür war der parallele Zugriff schnell weil Daten und Adressen rasch übertragen werden konnten.
EPROM-Speicher (EraseableProgrammableReadOnlyMemory) waren ein Fortschritt weil man solche Speicher mehrmals mit UV-Licht löschen (spezielle Lampe) und mit Hilfe einer erhöhten Programmierspannung (z.B. 21V) elektrisch neu beschreiben konnte.
Bequemer handhabbar waren elektrisch löschbare Speicher EEPROM (ElectricErasableProgrammableReadOnlyMemory) ab 1986 weil die lange Wartezeit für das Löschen per UV-Lampe so entfiel. Da bei EEPROM auf das Quarzfenster verzichtet werden konnte waren die Bausteine billiger.
Es folgten Flash-Speicher die anfangs jedoch nicht sehr viele Schreib-/Löschzyklen vertragen konnten.
1974 UV-Licht löschbarer ErasableProgrammableReadOnlyMemory NMOS-EPROM (George Perlegos)
1986 elektrisch löschbarer nichtflüchtiger Speicher in CMOS-Technologie (Fairchild)
Rechner-Architekturen
Hard- und Software von Rechnern und Controllern wandelten sich über die Zeit.
Auf Rechner mit Mechanik, Relais, Röhren folgten Transistoren und integrierte Schaltkreise ICs.
1623 zahnradgetriebene Rechenmaschine (Wilhelm Schickard, Tübingen)
1937 Rechenmaschine (Binärziffernmaschine) Z1 (Konrad Zuse)
1939 Relais-Rechenmaschine Z2 (Konrad Zuse)
1941 frei programmierbarer Rechner 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
1950 mechanische Rechenmaschinen mit Handkurbel bei Fa. Moll
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
1962 mechanische Rechenmaschine Walther für Addition/Subtraktion
1963 mechanische Rechenmaschine Walther Admulta für Addition/Subtraktion/Multiplikation/Division
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)
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, flimmerfreiem Schwarzweißbildschirm
1984 IBM PC AT mit 80286, 6MHz, bis 16MB RAM, 1.2MB Floppy Disk
1994 32bit Mikrocontroller Motorola 68F333 auf Basis 68000
2023 64bit Mikroprozessor Intel Core i9 mit 16 CPU, 5.5GHz bis 128GB RAM
Leider setzte sich die bessere 68000-Architektur gegenüber 8086/80x86 bei PCs nicht durch. IBMs PC-Design mit Steckplätzen die eine Erweiterung erlaubten fand Nachahmer und verbreitete sich durch billigere kompatible Rechner aus Fernost rasch. Es folgten Entwicklungen wie PowerPC, ARM und RISC-V.
Betriebssysteme
Als Ablaufsteuerung für PCs kamen Betriebssysteme wie PC-DOS, MS-DOS und Windows:
1970 Betriebssystem für PDP7 in 8kB (Ken Thompson, Dennis Ritchie)
1981 IBM-PC mit Betriebssystem PC-DOS
1985 Microsoft Windows
1995 Windows 95-Betriebssystem
Entwicklungshilfsmittel
Mindestens genauso wichtig wie der Mikrocontroller-Chip selbst sind dazu passende Entwicklungshilfsmittel für Hard- und Software.
Vieles zum Thema Mikrocontroller ist heute online im Internet zu finden und oft gratis herunterzuladen. Das Internet begann in den 70er Jahren und wurde gegen 1998 populär als mehr Menschen einen Zugang dazu hatten - erst per Modem z.B. Call by Call und dann per DSL-Router, Kabel-Router oder Glasfaser.
1969 Arpanet als Vorläufer des Internet
1973 Erfindung Ethernet (Robert Metcalfe)
Für die Entwicklung von Hardware finden sich auf den Seiten der Hersteller Datenblätter der Chips und dazu Applikationshinweise, Schaltpläne, Bauteile und Entwicklungsboards.
Auf der Softwareseite gibt es Hilfsmittel wie Assembler, C-Compiler, BASIC-Interpreter, Microphython und Treiber für Bauteile wie Feuchtesensoren, Temperatursensoren, AD-Wandler, DA-Wandler, Displays. Wer mag kann sich Treiber auch selbst schreiben. Dabei lernt man eine ganze Menge.
Es gibt auch Projekte wie Arduino wo unterschiedliche Mikrocontroller programmiert und getestet auf Leiterplatten angeboten werden. Dazu gibt es eine kostenlose integrierte Entwicklungsumgebung IDE, wo C-Code eingegeben, kompiliert, auf das Board geladen und getestet werden kann. Es ist auch möglich bei Bedarf einen passenden Bootloader zu installieren, der genutzt werden kann um Code aufzuspielen.
Bücher vermitteln Basiswissen oder fortgeschrittenes Wissen zu Mikrocontrollern. Zu manchen Büchern gehören auch Bauteilsätze um die Beispielprogramme aus dem Internet gleich auszuprobieren. Es ist viel einfacher auf solche Art und Weise mit Fertighardware an Beispielen und deren Änderungen zu lernen als von Null mit einem unprogrammierten Einzelchip anzufangen.
Falls Probleme auftreten gibt es im Internet Foren wo man Fragen stellen kann.
AVR-Mikrocontroller
Interessante Mikrocontroller wie die AVR-Serie wurden von der Fa. Atmel entwickelt die mittlerweile von Fa. Microchip übernommen wurde. Atmel startete die Entwicklung mit einer 8bit CPU und bot dann auch eine größere Variante an die hier nicht betrachtet werden soll.
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
Das Besondere an den Atmel AVR ist die RISC-Architektur. RISC bedeutet "Reduced Instruction Set Computer". Im Gegensatz zu CISC "Complex Instruction Set Computer" wird ein reduzierter Befehlssatz verwendet. Der Rechnerkern kann daher kleiner ausfallen und die meisten Befehle schneller abarbeiten. Viele Befehle werden beim AVR in einem Zyklus abgearbeitet.
Mit AVR-GCC steht für die AVR-Chips ein leistungsfähiger kostenloser C-Compiler zur Verfügung. Es gibt auch den BASIC-Compiler BASCOM.
Obwohl 8bit Busbreite im Zeitalter von 32 oder 64bit-Anwendungen überholt erscheinen mag kann man damit gut lernen und arbeiten. Wichtig ist es zu verstehen was man tut.
Es waren 2 Studenten die 1992 aus Unzufriedenheit die AVR-Controller erfanden. Eine Erfolgsgeschichte begann die unter Fa. Microchip fortgesetzt werden soll.
Hier soll der Atmega4809 näher betrachtet werden.
| Mikrocontroller Atmega4809 |
Der Atmega4809-Mikrocontroller verfügt über Eigenschaften wie:
+ 48kB Flash-Programmspeicher (10000 Programmierzyklen)
+ 6kB SRAM (Schreib-Lese-Speicher)
+ 256 Bytes EEPROM (elektrisch löschbarer Speicher, 100000 Programmierzyklen)
+ 32 8bit-Register R0-R31
+ Hardware-Multiplizierer (für Multiplikation 8bits auf 16bit in 2 Zyklen)
+ 20MHz interner Oszillator (bei 5V, 105°C)
+ 32768Hz interner Oszillator
+ 16bit Timer/Counter mit Compare-Funktion
+ 16bit Timer/Counter mit Input-Capture-Funktion
+ 16bit RealTimeCounter RTC
+ 4 USART für serielle Ein-/Ausgabe
+ SPI-Interface für schnelle Ein-/Ausgabe über SPI-Bus
+ TWI-Interface für Ein-/Ausgabe über I2C-Bus
+ Analog-Komparator
+ 10bit AD-Wandler 150kS/s für Erfassung analoger Spannungen
+ Referenzspannungen 0.55V, 1.1V, 1.5V, 2.5V, 4.3V
+ Watchdog Timer WDT
+ 41 programmierbare IO-Pins für Ein- und Ausgabe
+ UPDI-Interface zum Programmieren per 1 Pin
+ interner Bootloader zum Laden von Programmen
+ 40 Pins PDIP oder 48 Pins VQFN/TQFP verfügbar
Wer meint daß 48kB Programmspeicher "wenig ist" der sei daran erinnert daß ein selbstgebautes 8085-System mit ~2kB auskam. Der erste IBM-PC hatte 48kB RAM, wo Programme per Diskette hineingeladen werden konnten. Professionelle Programme waren so möglich.
Neben dem 4809 gibt es kleinere Chip-Varianten wie:
- ATmega3209 32kB Flash, 4kB SRAM
- ATmega1609 16kB Flash, 2kB SRAM
- ATmega809 8kB Flash, 1kB SRAM
- ATmega4808, ATmega3208, ATmega1608 und ATmega808 haben 32 bzw. 28 Pins.
Die kleineren Varianten sollen hier aus Platzgründen nicht betrachtet werden.
Beim Lernen wird man mit dem 4809 weniger rasch an Grenzen zu stoßen wie z.B. SRAM zu klein.
Das Datenblatt "ATmega4808/4809 Data Sheet DS40002173C" von 2021 hat 560 Seiten.
Der 4809 ist in Gehäuseformen verfügbar wie:
+ 40 Pin Plastik Dual Inline Package PDIP
+ 48 Pin Thin Quad FlatPack TQFP
Bei PDIP fehlen 8 Pins. Dafür lässt sich DIL40 für Versuche auf ein Steckbrett stecken. Bei Defekt kann rasch getauscht werden.
Wer mehr als 40 Pins braucht kann das TQFP-Teil auf eine Platine löten und diese auf ein Steckbrett stecken.
Platine mit Atmega4809 an 5V, wo alle CPU-Pins an Anschlüssen liegen. Auf der Rückseite sitzt ein FT232RL-Baustein für USB.
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 werden keine 20MHz garantiert. Bei 2.7V sollen 8MHz gehen bzw. 10MHz bis 105°C (Table 32-3 Datenblatt S.461).
Damit 20MHz genutzt werden können wird der Chip über einen Spannungsregler (links bei der USB-Buchse) mit 5V versorgt.
LEDs zeigen Datenverkehr (Receive RX, Transmit TX) der seriellen Schnittstelle an. Eine weitere LED hängt für Testzwecke an PF5.
Als C-Compiler für 4809 sind denkbar:
+ AVR-GCC-Compiler z.B. aus Arduino-IDE
+ MPLAB® XC8 Compiler
+ BASCOM BASIC-Compiler
Als Entwicklungsumgebung für den Atmega4809 ist möglich:
+ Atmel Studio 6.2/7 für Entwicklung C/C++ und Assembler-Code
+ Microchip MPLAB X IDE für Entwicklung Code für Microchip Mikrocontroller und DSPs
+ IAR Embedded Workbench für AVR
+ Keil µVision für AVR
+ Arduino-IDE mit AVR-GCC-Compiler für AVR -> dazu MegaCoreX
+ WinAVR mit AVR-GCC-Compiler, Makefile, AVRDUDE
+ BASCOM BASIC-Compiler und IDE für AVR
Hinweise zur Nutzung der oberen 4 Umgebungen finden sich im "Atmel START User's Guide".
"Atmel START" kann genutzt werden um Code für AVR-Controller zu erzeugen (Users Guide S.90 7.2).
Bei "Atmel START" gibt es auch Beispiel-Projekte und einen "example browser".
Hinweise zur Programmierung in C finden sich in "AVR1000b: Getting Started with Writing C-Code for AVR MCUs".
+ Beispiele zum Umgang mit Bit Masken _bm, Bit Group Masken _gm, Group Configuration Masken_gc.
+ Beispiele zur Nutzung von Bitpositionen wie z.B. ADC_ENABLE_bp.
Es wird gezeigt wie man bits in Registern setzen/rücksetzen kann ohne die anderen bits zu beeinflussen.
Es gibt Kurzbeschreibungen mit Beispielen zur Nutzung von Peripherie-Einheiten:
+ TB3209 - Getting Started with ADC (Analog Digital Converter)
+ TB3211 - Getting Started with AC (Analog Comparator)
+ TB3213 - Getting Started with RTC (Real Time Counter)
+ TB3214 - Getting Started with TCB (TimerCounter B)
+ TB3215 - Getting Started with SPI (Seriell Parallel Interface)
+ TB3216 - Getting Started with USART (serielle Schnittstelle)
+ TB3217 - Getting Started with TCA (TimerCounter A)
+ TB3218 - Getting Started with CCL (Configurable Custom Logic)
+ TB3229 - Getting Started with GPIO (General Purpose Input Output)
Der 4809 hat PORTMUX zur flexiblen Verbindung von internen Einheiten zu IO-Pins:
+ EVSYSROUTEA -> EVOUTA, EVOUTC, EVOUTD an PA2/PA7, PC2/PC7, PD2/PD7
+ CCLROUTEA -> LUT0, LUT1, LUT2, LUT3 an PA3/PA6, PC3/PC6, PD3/PD6, PF3/PF6
+ USARTROUTEA -> USART0[1:0], USART1[1:0] , USART2[1:0], USART3[1:0] an PA[3:0]/PA[7:4], PC[3:0]/PC[7:4], PF[3:0]/PF[6:4], PB[3:0]/PB[5:4]
+ TWISPIROUTEA -> TWI0[1:0], SPI0[1:0] an PA[3:2]/PC[3:2], PA[7:4]/PC[3:0]/PE[3:0]
+ TCAROUTEA -> TCA0[2:0] an PA[5:0], PB[5:0], PC[5:0], PD[5:0], PE[5:0], PF[5:0]
+ TCBROUTEA -> TCB0, TCB1, TCB2, TCB3-Output an PA2/PF4, PA3/PF5, PC0/PB4, PB5/PC1 (Datenblatt S.140f).
Der 4809 kann Pins weniger steil schalten zur Reduzierung von Störstrahlung:
+ PORTCTRL-> Slew Rate Limit Enable (SLR) bit ggf. setzen (Datenblatt S.149,153,164).
Die Anstiegszeit lässt sich so erhöhen 2.5 -> 19ns bei 3V, 1.5 -> 9ns bei 5V
und die Abfallzeit 2 -> 21ns bei 3V, 1.3 -> 11ns bei 5V (Datenblatt S.470f)
Der 4809 kann Pullup-Widerstände an Pins schalten:
+ PINnCTRL -> PULLUPEN Pull-up Enable (Datenblatt S.165).
Der 4809 kann IO-Pins invertieren:
+ PINnCTRL -> INVEN Inverted I/O Enable (Datenblatt S.165).
Der 4809 kann IO-Pins als Interrupt nutzen und abschalten:
+ PINnCTRL -> ISC[2:0] Input/Sense Configuration (Datenblatt S.165).
Dabei gibt es folgende Möglichkeiten:
+ INTDISABLE -> kein Interrupt, Input buffer enabled
+ RISING -> Interrupt auf steigender Flanke
+ FALLING -> Interrupt auf fallender Flanke
+ BOTHEDGES -> Interrupt auf steigender und fallender Flanke
+ LEVEL -> Interrupt bei Low Pegel
+ INPUT_DISABLE -> kein Interrupt, Input buffer disabled (Pin abgeschaltet).
Der 4809 hat konfigurierbare Logik CCL mit
+ Logikfunktionen
+ kombinatorische Logik mit bis zu 3 Eingängen
+ D-Flip Flop, JK-Flip Flop, D-Latch, RS-Latch
+ 4 programmierbare Look-up Tabellen LUT0-LUT3 (Datenblatt S.372).
Der 4809 hat einen Real Time Counter RTC der mit 32768Hz-Quarz laufen kann:
+ als Echtzeituhr oder Wecker nutzbar
+ Genauigkeit der Uhr einstellbar (Datenblatt S.261).
Der 4809 hat einen analogen Komparator AC der 2 Eingänge vergleichen kann.
Ein DACREF kann die Vergleichsspannung erzeugen.
Hysterese ist einstell-/abschaltbar. Invertieren schaltbar (Datenblatt S.392).
Der 4809 hat programmierbare "Fuses" zur Konfiguration 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 (Datenblatt S.54 7.8.1)
Wichtig ist dass sinnvolle Werte für die Fuses eingestellt werden:
+ Fuse BODCFG -> BODLEVEL0, BODLEVEL2, BODLEVEL7 bei 1.8V, 2.6V, 4.3V
+ Fuse OSCCFG -> OSCLOCK, FREQSEL[1:0]
+ Fuse SYSCFG1 -> SUT[2:0] Start-Up Time Setting 0ms-64ms
+ Fuse APPEND -> APPEND[7:0] Application Code Section End
+ Fuse BOOTEND -> BOOTEND[7:0] Boot Section End
Fuses können nur per UPDI-Schnittstelle verändert werden.
Erst nach Reset werden Änderungen der Fuses wirksam (Datenblatt S.53 7.8).
Als "Main Clock" sind über CLKSEL[1:0] im Register MCLKCTRLA wählbar:
+ interner 16/20MHz-Oszillator OSC20M
+ interner 32.768kHz-Oszillator OSCULP32K
+ externer 32.768kHz-Oszillator XOSC32K
+ externer Clock EXTCLK (Datenblatt S.94 10.5.1).
Der interne RC-Oszillator 16/20MHz hat Register zur Frequenzkorrektur bei 3V, 5V:
+ OSC16ERR3V Oszillatorfrequenz-Fehler bei 16MHz, 3V
+ OSC16ERR5V Oszillatorfrequenz-Fehler bei 16MHz, 5V
+ OSC20ERR3V Oszillatorfrequenz-Fehler bei 20MHz, 3V
+ OSC20ERR5V Oszillatorfrequenz-Fehler bei 20MHz, 5V (Datenblatt S.50f 7.7.2.8f).
Über das oberste bit in MCLKCTRLA wird der "Main Clock" CLK_MAIN zum CLKOUT-Pin geleitet.
Über das Register MCLKCTRLB ist ein Prescaler wählbar und aktivierbar:
+ PEN schaltet den Prescaler ein/aus
+ DIV2 -> teilt CLK_MAIN durch 2
+ DIV4 -> teilt CLK_MAIN durch 4
+ DIV6 -> teilt CLK_MAIN durch 6
+ DIV8 -> teilt CLK_MAIN durch 8
+ DIV10 -> teilt CLK_MAIN durch 10
+ DIV12 -> teilt CLK_MAIN durch 12
+ DIV16 -> teilt CLK_MAIN durch 16
+ DIV24 -> teilt CLK_MAIN durch 24
+ DIV32 -> teilt CLK_MAIN durch 32
+ DIV48 -> teilt CLK_MAIN durch 48
+ DIV64 -> teilt CLK_MAIN durch 64 (Datenblatt S.95 10.5.2).
Über das Register XOSC32KCTRLA ist der externe 32.768kHz-Oszillator konfigurierbar:
Über CSUT[1:0] und SEL wird die Startzeit für das Anschwingen des Quarz ausgewählt.
SEL schaltet um zwischen externem Quarz und externem Takt am TOSC1-Pin.
RUNSTDBY schaltet den Quarzoszillator aktiv falls ENABLE=1 (Datenblatt S.102 10.5.9).
Es erscheint sinnvoll einen Programmieradapter für UPDI zu kaufen oder zu bauen.
Programmierung per UPDI ist auch möglich mit dem Onboard-Debugger des "ATmega4809 Curiosity Nano"-Boards.
| UPDI-Programmer bereitstellen |
UPDI bedeutet "Unified Program and Debug Interface". Man kann damit Chips wie den Atmega4809 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 "Atmel Studio 7" unterstützt das viel Rechenleistung (moderne Hardware) und Win10 erfordert.
Hier soll ein Weg ohne das Studio gezeigt werden.
Auf Platinen "Arduino nano 3" ist üblicherweise ein Bootloader installiert, mit dessen Hilfe eine Software aufgespielt werden kann um die Platine zu einem UPDI-Programmer zu machen.
Im Internet findet sich ein Beitrag "UPDI programmer software for Arduino (targets ATtiny 417 / 814 / 816 / 817 / 1614 / 1616 / 1617 and similar MCUs) – ElTangas/jtag2updi" und dazu die Datei jtag2updi-master.zip.
In dieser zip-Datei ist die Datei JTAG2UPDI.hex zu finden. Diese kann auf den Arduino nano 3 installiert werden. Dazu gibt es mehrere Möglichkeiten:
+ per Arduino IDE (diese nutzt eine Kommandozeile für AVRDUDE)
+ direkt mit AVRDUDE, z.B. über eine batch-Datei oder ein Eingabefenster.
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 hier 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. Mit 5V betriebene Atmega4809-Chips sollten sich damit programmieren lassen.
| per UPDI Bootloader programmieren |
Mit Hilfe des UPDI-Programmers kann man einen Bootloader auf den Atmega4809 flashen, wenn man dies möchte.
Der Vorteil eines Bootloaders ist dass man damit auch ohne UPDI-Programmer per USB Programme in den Atmega4809 laden kann.
Von Nachteil ist dass der Bootloader einige Byte Speicherplatz kostet.
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.18 genutzt (arduino-1.8.18-windows.exe).
Installieren Arduino IDE:
+ arduino-1.8.18-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.
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 Entwicklungsumgebungen aufwendig einrichten zu müssen. Programme für AVR-Controller wie Atmega328, Atmega2560 oder Atmega32u4 sind damit problemlos erstellbar.
Mit WinAVR 2010 sind jedoch neuere Chips wie Atmega4809 nicht ohne weiteres nutzbar. Der GCC 4.3.3-Compiler aus WinAVR 2010 ist veraltet. Neuere Versionen erzeugen jedoch 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 mit WinAVR ist eine Datei main.c wo die Befehle stehen die die LED zum Blinken bringen sollen.
int main(void)
{
// Initalisierung Clock, Pins in/out
initialization();
while(1)
{
PORTF.OUT |= PIN5_bm; // LED ein - LED gg. GND
delay_ms(1000); // warte 1s
PORTF.OUT &= ~PIN5_bm; // LED aus
delay_ms(1000); // warte 1s
}
}
Schauen wir die Teile nacheinander an.
Ganz oben in der main.c stehen z.B. Anweisungen wie:
#include <stdint.h> // Integer-Datentypen 8-64bit
#include <avr/io.h> // Pins und Interrupt-Tabelle -> siehe auch iom4809.h
#include <avr/interrupt.h> // Interrupts
#include "main.h" // CPU-Frequenz
#include "delay.h" // Delay-Funktionen us, ms
Zunächst sind Systemeinstellungen zu machen. Dazu dient die Funktion initialization().
In initialization()
+ wird die gewünschte Taktfrequenz eingestellt
+ werden Pins des 4809 als Eingang oder Ausgang definiert.
CLKCTRL_MCLKCTRLA und CLKCTRL_MCLKCTRLB kontrollieren den Takt.
um diese Register ansprechen zu können dient CPU_CCP als Freigabe.
PORTF.DIR bestimmt die Richtung der Pins an Port F.
Die LED an Pin F5 soll Ausgang sein. Daher wird dieses bit gesetzt.
void initialization(void)
{
// Main Clock Control A MCLKCTRLA S.83 9.5.1
// CLKSEL Clock Select, CLKOUT System Clock Out
CPU_CCP = CCP_IOREG_gc; // write access for 4 CPU instruct. - noetig !
CLKCTRL_MCLKCTRLA = 0x80; // 16/20MHz + CLKOUT aktiv -> mit Oszi Takt 16MHz an Clockout-Pin
// Main Clock Control B MCLKCTRLB S.84 9.5.2
// PDIV Prescaler Division, PEN Prescaler Enable default 1 -> Teiler durch 6 aktiv
CPU_CCP = CCP_IOREG_gc; // write access for 4 CPU instruct. - noetig !
CLKCTRL_MCLKCTRLB = 0; // kein Prescaler
// PORTF nur 1 Pin auf Ausgabe, kein PF7
PORTF.DIR = (0<<6) | (1<<5) | (0<<4) | (0<<3) |
(0<<2) | (0<<1) | (0<<0);
// PF6 = RESET - in
// PF5 = AIN15, RX2, TCA5 LED3 - out
// PF4 = AIN14, TX2, TCA4 - in
// PF3 = AIN13, SCL, TCA3 - in
// PF2 = AIN12, SDA, TCA2 - in
// PF1 = TOSC2, RX2, TCA1 - in
// PF0 = TOSC1, TX2, TCA0 - in
}
Zur Aktivierung der LED wird Pin F5 eingeschaltet. PIN5_bm ist die Bitmaske
für Pin5.
PORTF.OUT |= PIN5_bm; // LED ein - LED gg. GND. Veroderung schaltet Pin
ein.
Zur Deaktivierung der LED wird Pin F5 ausgeschaltet. PIN5_bm ist die Bitmaske
für Pin5.
PORTF.OUT &= ~PIN5_bm; // LED aus. Verundung mit invertierter Bitmaske
schaltet Pin 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.
delay_ms(1000); // warte 1s
Zu main.c gehört eine Header-Datei main.h die ggf. weitere Hinweise
für den Compiler enthält wie z.B. Taktfrequenz:
#define F_CPU 16000000UL
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 in den Speicher laden soll
Im Makefile stehen Zeilen wie:
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 Makefile 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 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 Erfolgserlebnisse hatten
oder noch haben werden wenn etwas klemmen sollte. Viel Erfolg !
| © 2000-2024 Weisser |
| Impressum |
 |