Hallo zur Webseite von
DL1DMW
DL1DMW
<- Bild 1: Vorschlag für eine AVR-Platine mit ATMega1284P im DIL40-Gehäuse. Mit einem Bootloader wird daraus ein zu Arduino kompatibles Entwicklungsboard.
Arduino selbst gemacht:
Prozessorplatine mit ATMega1284P
Features:
- Atmel AVR mit 128 KByte Flash RAM
- kompatibel zu Arduino
- einfache Installation
- Atmel mit 40-pol. DIP-Gehäuse
- Betrieb mit 3,3 oder 5 Volt
- Eigene Wünsche integrierbar
Wird Ihr Arduino UNO zu „klein“, weil der Speicher nicht ausreicht? Für diesen Fall stehen größere Arduinos wie der Arduino Mega2560 mit 256 KB Speicher bereit. Doch wozu kaufen? Mit etwas Zeit und Muße lötet man eine Platine selbst und realisiert nebenbei eigene Ideen und Wünsche! Lesen Sie, wie ein neuer Arduino „geboren“ wurde.
Zielsetzung ist es, einen Arduino zu kreieren, der mehr Speicher aufweist als der Arduino UNO, ebenso vielseitig einsetzbar ist und – wichtig – komplett auf SMD-Bauelemente verzichtet. Der leistungsstärkste AVR im DIL-Gehäuse ist der ATMega1284P mit 128 KB RAM, 16KB Flash und 4KB EEPROM. Mit dieser satten Ausstattung lässt sich eine Menge anfangen: Während der Arduino UNO mit seinen 32 KB Speicher bei Nutzung mehrerer Bibliotheken zur Ansteuerung von LCD, Sensoren oder ähnlichem bald an seine Speichergrenzen stößt, ist das beim ATMega1284P lange nicht zu erwarten. Der Prozessor ist pinkompatibel zu seinen kleineren Brüdern ATMega16/32 und kann diese in älteren Schaltungen ersetzen. Ein weiterer Vorteil sind die zwei Hardware-UARTS: Einer dient in der Regel zur Programmierung und zur Fehlerbeseitigung (debugging), der zweite übernimmt allerlei Kommunikationsarbeit. Natürlich verfügt der ATMega1284P über die vom ATMega328P bekannten Leistungsmerkmale wie Analog-Digitalwandler, PWM-Ausgänge und vieles mehr.
Schaltung und Aufbau
Die Entscheidung für eine eigene Arduino-Kreation gibt freie Hand zur Anordnung aller Bauteile, Stecker und Buchsen auf der Platine. Die strikte Anordnung der Anschlüsse eines Arduino UNO mit der Möglichkeit, Shields (Erweiterungsplatinen) aufzustecken, wurde hier bewusst fallen gelassen. Die Idee war, möglichst viel Peripherie anschließen zu können. So wurde jeder Prozessorpin über Stecker und Buchsen mehrfach zugänglich gestaltet. Hinzu kommt, dass die Spannungsversorgung zwischen 5 und 3,3 Volt umschaltbar sein sollte. Dies geschieht simpel durch einen Jumper. Viele LCD, Gyroskope und anderes nützliche Sensoren werden heute bei 3,3 Volt Betriebsspannung betrieben – es ist praktisch, wenn sich der Prozessor dem anpasst. Die obligatorischen Pullup-Widerstände an den I2C-Pins befinden sich bereits auf der Platine und sind per Jumper zuschaltbar. Der Takt wurde auf 16 MHz festgelegt und der Quarz fest verlötet. Hier könnte man mehr Flexibilität mit einer Quarzfassung erreichen – sofern man sie vorrätig hat. Zur Info: Der maximale Takt beträgt bei 5 Volt 20 MHz, bei den hier gewählten 16 MHz ist noch „Luft“ nach oben. Bei 3,3 Volt Spannung nennt das Datenblatt des ATMega1284P einen maximalen Takt von 10 MHz. Bei 3,3 Volt Spannung sollte man die Prozessor-FUSES auf den internen 8-MHz-Takt umschalten. Der vorhandene Quarz stört in diesem Fall nicht.
Der Referenzspannungseingang des AD-Wandlers ist bei den Arduinos meist mit einem 100nF-Kondensator beschaltet. Dies ist hier ebenso, doch ein Anschluss ermöglicht für spezielle Anwendungen die Einspeisung einer externen Referenzspannung. Einige Anschlüsse wurden mit einem grünen Steckverbinder ausgestattet, weil dieser gerade verfügbar war. Er kennzeichnet acht analogen Eingänge farblich.
Der Spannungseingang wird von einer Diode in Durchlassrichtung gegen Verpolung geschützt. Nach einem Elko teilt sich die Eingangsspannung auf zwei Spannungsregler auf: Der eine für 5 Volt (7805), der andere für 3,3 Volt (LM3940-3.3), jeweils versehen mit einem 100-nF-Kondensator. Am Ausgang der Regler führt ein Jumper – je nach Stellung - eine der beiden Spannungen dem Prozessor zu. Auf der Lochrasterplatine befinden sich weiterhin ein Reset-Taster und ein ISP-Anschluss zur Programmierung des Prozessors via SPI.
Nehmen wir an, die Lochrasterplatine ist aufgebaut und mit dem Multimeter auf Kurzschlüsse und korrekte Spannungen getestet. Nun kann der Prozessor in die Fassung gedrückt und das erste Mal ein Programm übertragen werden. Dazu benötigt man normalerweise ein Programmiergerät. Das Geld dafür kann man sich sparen, wenn man bereits einen Arduino UNO besitzt. Mit dem richtigen Programm wird er zu einem Programmiergerät für AVR-Prozessoren. Das Stichwort ist hier „Arduino as ISP“. Auf [1] und vielen Webseiten wird erklärt, mit man das mit nur wenigen Kabelverbindungen zwischen Arduino UNO und dem zu programmierenden ATMega1284P bewerkstelligt. Als Beispielprogramm könnten Sie ein Programm (Sketch) erstellen, das PortB.0 zum blinken anregt (LED mit Vorwiderstand).
Aus Platine wird Arduino
Was macht einen Arduino aus? Ein Arduino ist (etwas) mehr als eine ordinäre Platine mit einem Atmel ATMega darauf. Sie muss zur Arduino IDE (Editor und Entwicklungsumgebung) kompatibel sein, um all die bequemen Annehmlichkeiten nutzen zu können. Da ist ganz vorn zu nennen die Übertragung eines Sketches (Programms) auf den Prozessor über ein USB-Kabel. Ohne Kabel an- oder abzuklemmen programmiert sich der ATMega mit einem Mausklick fast von selbst. Dazu benötigt die Platine die Signale des UART und das Reset-Signal. Da es das Ziel war, keine SMD-Bauelemente zu löten, greifen wir zu einem der zahlreichen fertigen USB-zu-TTL-Module. Letzteres muss mindestens Anschlüsse für Masse, TX, RX und DTR aufweisen und für 5 Volt sowie 3,3 Volt geeignet sein – die Sendeleitung wird dann mit 3,3 Volt Daten ausgeben.
Bild 2: Das Schaltbild mit Spannungsversorgung, Prozessor und Arduino-kompatibler Minimalbeschaltung. Eine größere und bessere Abbildung finden Sie im Downloadfile (siehe unten) zu diesem Projekt.
Die Verbindungen zwischen Platine und USB-Modul wird wie im Schaltplan abgegeben, gefertigt. Zur Kompatibilität gehört der 100nF-Kondensator zwischen dem Reset-Signal und DTR des USB-Moduls, damit der PC den Prozessor starten (RESETten) kann. Und schließlich: damit sich der Prozessor über die serielle Schnittstelle (UART) programmieren lässt, benötigt unser ATMega einen Bootloader. Das ist ein Programm, das die vom PC kommenden Bytes über den UART empfängt und in den Flash-Speicher des Prozessors schreibt. Glücklicherweise muss man es nicht mehr programmieren, das haben andere fleißige Leute bereits erledigt.
Bild 3: Um die Arduino IDE auf neue Boards vorzubereiten, trägt man hier – blau markiert - die MightyCore-Internet-Adresse (URL) ein.
Eine Internet-Recherche bot einige Ansatzpunkte sowie eine hervorragende Quelle: MightyCore [2]. In diesem Programmpaket sind angepasste Libraries für SPI, Wire etc., mehrere Bootloader und allerlei Nützliches mehr vorhanden – und das Beste: es lässt sich recht einfach über den Boardmanager der Arduino IDE installieren! Dazu gibt man im Fenster Voreinstellungen unter Weitere Boardverwalter-URLs die folgende Zeile ein:
https://mcudude.github.io/MightyCore/package_MCUdude_MightyCore_index.json
Bild 4: Das Bild zeigt den Boardverwalter nach der Installation der MightyCore-Platinen (z. B. mit ATMega1284P).
<- Bild 5: Ist alles richtig installiert, stehen u. a. der ATMega1284 und ATMega1284P sowie weitere Optionen zur Auswahl.
Diese Angabe findet man auch in der Beschreibung auf [2]. Sind bereits eine oder mehrere URLs eingetragen, trennt man diese jeweils mit einem Komma und fügt die neue hinten an. Danach öffnet man im Menü Werkzeuge / Board den Bordverwalter, rollt ganz nach unten und installiert MightyCore. Läuft es perfekt, stehen nach wenigen Minuten im Menü Werkzeuge / Boards die neuen Prozessoren, darunter auch unser AtMega1284P zur Auswahl bereit (Bild 5).
Bild 6: Bootloader manuell: Diese Datei wird auf den Prozessor übertragen, danach Fuse-Bits setzen.
Was dem Prozessor bisher fehlt, ist der Bootloader. Den kann man nach der Anleitung in [2] installieren, also mit einem Arduino UNO als ISP-Programmer und wenigen Kabeln zum Prozessor. Ich habe das manuell erledigt und zwar so: Es wurde ein kleines LED-Blink-Programm erstellt und für den AtMega1284P kompiliert. Heraus kommen zwei Hex-Dateien (siehe Bild). Die eine ohne, die andere mit Bootloader. Die habe ich mit Atmel Studio 7 und meinem Programmer AVR-Dragon auf den Prozessor „gebrannt“ und anschließend die Fuse-Bits wie folgt eingestellt:
Diese Einstellung schützt den Bootloader vor dem Überschreiben durch andere Sketche und der Prozessor kann über das USB-Kabel vom PC aus programmiert werden wie jeder andere Arduino. Befindet sich allein der Bootloader auf dem Prozessor und ist an PortB.0 eine LED angeschlossen, so blinkt diese im Sekundentakt. Wird nun mit der Arduino IDE ein Sketch auf den Prozessor übertragen, sollte das einwandfrei funktionieren. Wer einen Blick auf die Liste der Bootloader tun möchte, findet sie bei Windows-PCs im Pfad
Benutzername\AppData\Local\¬Arduino15\packages\MightyCore\¬hardware\avr\2.0.0\bootloaders.
Auf meinem PC mit der Arduino IDE 1.8.3 trat jedoch einen unangenehmer Fehler auf: Der Compiler beendete fehlerlos, der Linker brach leider ab, weil er die zuvor erzeugte Datei nicht finden konnte. Die Prüfung ergab: sie ist entgegen der Fehlermeldung doch vorhanden, jedoch mit einem sehr langen Pfad – vielleicht für Windows zu lang? Der Effekt: Nach jedem Starten der Arduino IDE konnte genau ein Mal fehlerfrei kompiliert, gelinkt und das Programm auf den ATMega übertragen werden. Jeder zweite und weitere Durchlauf ergab dieselbe Fehlermeldung.
Abhilfe:
unter LW:Benutzername\AppData\Local\Arduino15 die Datei preferences.txt laden und den Eintrag
build.path=D:\Arduino_Out
auf einen möglichst kurzen Pfad setzen, wie hier das Verzeichnis Arduino_Out. Dazu eignet sich gut Notepad++, der Windows-Texteditor ist nicht empfehlenswert, weil er die für Windows ungewöhnliche Zeilenumschaltung nicht erkennt. Nach der Änderung blieben fortan die Pfade unter 255 Zeichen Länge, Windows verarbeitete sie nunmehr klaglos, folglich traten keine derartigen Fehler mehr auf. Seitdem ist die Platine ohne Einschränkung in Betrieb.
Bild 7: Das Bild zeigt die Zuordnung der Arduino-Pinnummern zu den Portpins des Prozessors. PortB.0 hat also die Nummer 0, PortB1 die Nummer 1 usw.. Eine besser lesbare Abb. finden Sie in der Downlöoad-Datei (siehe Button unten) zu diesem Projekt.
Bei Arduino-Befehlen wie digitalWrite(), analoRead() und weiteren gibt man der Einfachheit halber die auf den Arduino-Platinen aufgedruckten Pinnummern an. Beispiel: analoRead(A0).Welche Arduino-Nummern sind den Portpins unseres Prozessors nun zugewiesen? MightyCore bietet drei zur Auswahl: Standard, Bobuino und Sanguino. Was bedeutet das? Der Entwickler erklärt:
Standard: Das ist die Stand-Nummerierung der Arduino-Pins, basierend auf dem Original-Pinout des Prozessors. Die Pins sind der Reihe nach durchnummeriert (Bild oben).
Bobuino: Diese Nummerierung orientiert sich an die des Arduino UNO. Sie passt gut zu Sketches und Shields, die für den Arduino UNO erstellt wurden, die Pinnummern ist dieselben wie beim UNO (MOSI auf D11, MISO auf D12, SCK auf D13 etc.).
Sanguino: Dieses Pinout orientiert sich an eine ältere Konvention, die meist bei 3D-Druckern wie Sanguino, RepRap Sanguinololu, und RepRap Gen7 verwendet wurden.
Persönlich verwende ich Standard, habe ich ein bestehendes Programm für den Arduino UNO vorliegen und möchte es unverändert auf dem ATMega1284P laufen lassen, stelle ich als Pinout Bobuino ein und erspare mir etwas Arbeit. Die Standard-Pinzuordnung zeigt Bild 7.
Erweiterungen im MightyCore
Wie viele Leser vermutlich wissen, basiert die Arduino-Programmiersprache auf Wiring [4], einer einfacheren Version der Programmiersprache "C". Wiring entwickelt sich weiter und so hat der Entwickler des MightyCore einige neue Befehle eingeführt:
portMode()
portRead()
portWrite()
sleepMode()
sleep()
noSleep()
enablePower()
disablePower()
Die Bezeichnungen sprechen für sich, mögliche Parameter listet [3] auf.
Wie bei den Einstellungen der Boards (Bild 5) zu sehen ist, bietet MightyCore die Wahl neben der Auswahl des Prozessors (ATMega1284 oder ATMega1284P) weitere Optionen:
BOD
Brown out detection, oder kurz BOD überwacht die Betriebsspannung des Prozessors und schaltet ab, wenn die Spannung zu gering wird. Dies wird üblicherweise separat über die Fuse-Bits geregelt, hier ist es sehr bequem im Menu einstellbar. Um die BOD zu verändern, müssen Sie einen ISP-Programmer anschließen und auf Burn bootloader klicken.
LTO
Link time optimization (kurz: LTO) wird seit der Arduino IDE 1.6.11 unterstützt. LTO optimiert den Code zur Linkzeit und lässt ihn signifikant kürzer werden, ohne dass er langsamer wird. Seit Arduino IDE 1.6.11 und den neueren Versionen ist LTO immer eingeschaltet. Im Menü Werkzeuge besteht die Möglichkeit, LTO auszuschalten, um eine Source-Kompatibilität für Versionen vor 1.6.11 zu erreichen. Für neue Sketches ist das nicht nötig, daher LTO einschalten.
Nun, dann viel Spaß beim Löten des eigenen Arduino. Scheuen Sie sich nicht, den Schaltplan Ihren Wünschen anzupassen: Hätten Sie beispielsweise gern einen Stecker für ein OLED- oder LC-Display, für ein GPS- oder Funkmodul oder einigen Tastern? Integrieren Sie diese auf ihre individuelle Platine!
Literatur/Verweise:
[1] Arduino-Homepage: arduino.cc
[2] MightyCore für ATMega1284P: https://github.com/MCUdude/MightyCore
[3] Wiring reference: https://github.com/MCUdude/MightyCore/blob/master/Wiring_reference.md
[4] Wiring: http://wiring.org.co
Mehr Zeugs
- Schaun mer mal
- Moin
- Bast scho
Hier gibt es was zu lesen
- dl1dmw.darc.de
- dl1dmw.wordpress.com
- qsl.net/dg5dbz
Adresse etc.
- Op: Michael, DL1DMW
- ITU Region 1, Zone 14, DL, JO41CO
- Bad Sassendorf
- NRW / Germany