Einfach ARDUINO‎ > ‎

RasterDuino

http://sites.prenninger.com/arduino-uno-r3/einfach-arduino/rasterduino

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2018-09-22

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   (Heftrand 15mm / 5mm)     siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_elektronik-arduino.uno.r3-einfach.arduino-rasterduino (xx Seiten)_1a.pdf


Atmel ATmega328P-PU (DIP28) mit Arduino Bootloader

ATMEL ATmega328p-pu (dip28) mit Arduino Bootloader
https://www.watterott.com/de/ATmega328-Arduino-Bootloader


ATmega328-pu mit Arduino Bootloader ATMEL Microcontroller AVR Mega Dip-28

https://www.ebay.de/p/Atmega328-pu-mit-Arduino-Bootloader-Atmel-Microcontroller-AVR-Mega-Dip-28/1004720253?iid=162347096074



A) Minimalschaltung mit Atmega328 mit Bootloader


B) ARDUINO Schaltung mit 8 Bauteilen
C) Handskizze



D) Beispiel für eine Minimalbeschaltung, optional mit Programmieranschluss:



E) Minimal ARDUINO für BreadBoards






F) Arduino Uno Minimalbeschaltung

https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf

Steckbrett Arduino
Dieser Schaltplan  enthält nur die notwendigen Komponenten, um einen ATmega328P mit dem Arduino Uno Bootloader zu betreiben.

Die Verbindungen zu Aref und AVcc werden nur benötigt, wenn Sie beabsichtigen, den Adc des Chips zu verwenden, aber ich habe diese Verbindungen trotzdem eingefügt.
Normalerweise schalte ich den Adc und alle analogen Pins für meine Projekte aus, um Energie zu sparen
Der Pull-up-Widerstand zum RESET-Pin kann einen beliebigen Wert zwischen 1 und 100 kOhm haben.
Der Wert des Strombegrenzungswiderstands, der an die Arduino-Anzeige-LED an Pin D13 angeschlossen ist, sollte entsprechend Ihrer Systemspannung und LED gewählt werden (siehe diesen Beitrag).
http://www.fiz-ix.com/2012/11/schematic-of-a-breadboard-arduino/






ATmega328-Arduino Pin-Mapping



               Rasterduino

Maximale Flexibilität mit Rasterduino
Der Nachbau eines Arduino Uno auf dem Breadboard oder einer Lochrasterplatine gilt unter Arduino-Bastlern fast schon als »die Kür«.
Eigentlich zu Unrecht, denn der Selbstbau ist schnell erledigt, und es hat viele Vorteile, sich mit dem Mikrocontroller ohne Ballast zu beschäftigen:
Der Wegfall unnötiger Bauteile spart Geld und Strom, und Sie können je nach Anforderung festlegen, ob Sie einen externen (bis 20 MHz) oder den internen Taktgeber (1 MHz bis 8 MHz) nutzen wollen.
ATMEL ATmega328P  im bastelfreundlichen DIL-/DIP-Gehäuse (Double Inline Package) sind bereits ab € 2,50 .. € 5,-  erhältlich.
Für den ersten Versuch ist eine gute Stunde anzusetzen, bis der Rasterduino blinkt – mit etwas Routine klappt es dann in 5 Minuten.

Benötigte Bauteile
  1x  Arduino Uno R3 (DIL)                (€ 12,20 China)
        oder Pro Mini als ISP
  1x  USB-zu-seriell-Wandler            (€ 3,- bis € 10,-)
  1x  ATmega328P im DIL-Package  (€ 2,50 bis € 6,- )
  1x  Quarz 16 MHz                           (€ 0,50 bis € 1,-)
  2x  Kondensatoren 22 pF                (€ 0,20)
  1x  Kondensator 10 μF (0,10 Euro)
  1x  Kondensator 0,1 μF (0,20 Euro)

Benötigte Software
   Hardwaredefinitionen Rasterduino Franzis Barebone Atmel 1.5.zip
Download unter www.buch.cd oder www.arduino-hausautomation.de

Zeitaufwand:
   etwa 1 Stunde beim ersten Aufbau, mit etwas Routine rund 5 Minuten

Schritt 1: Bootloader brennen
Beenden Sie zunächst die Arduino-IDE und entpacken Sie das Zip-Archiv Franzis
Barebone Atmel 1.5.zip
in den Arduino-Ordner in Ihrem Heimatverzeichnis.
Sie sollten dort nun in derselben Ebene wie libraries den Ordner hardware vorfinden.
Nach dem erneuten Start der Arduino-IDE stellt der Menüeintrag Werkzeuge → Boards neue Menüpunkte für Rasterduino und Rastertiny in verschiedenen Konfigurationen bereit.
Versehen Sie zunächst den als Programmer dienenden Arduino mit dem Sketch Beispiele → Arduino as ISP – dieser Vorgang ist nicht mehr möglich, wenn nach dem Schaltungsaufbau ein 10-μF-Kondensator den Reset-Pin blockiert!

Bild 2.21: Nach Entpacken von Franzis Barebone Atmel 1.5.zip muss ein Ordner
hardware parallel zu libraries entstehen.

Bild 2.22: In der neu gestarteten Arduino-IDE tauchen jetzt die Hardwaredefinitionen für Rasterduino und Rastertiny auf.

Anschließend gilt es, aus Breadboard, Arduino Pro Mini (oder Uno), dem nackten ATmega328P, dem Quarz und den drei Kondensatoren die abgebildete Schaltung aufzubauen.
Ähnlichkeiten zur Schaltskizze zum Anschluss des Arduino Pro Mini fürs Flashen des Bootloaders sind nicht zufällig, sondern Absicht:
Zum Setzen der Grundeinstellungen des Mikrocontrollers und dem anschließenden Flashen des Bootloaders kommen die gleichen Hardwareschnittstellen und die gleichen Werkzeuge zum Einsatz.
Wichtig ist die Verwendung des 16MHz Quarzes (falls nicht zur Hand, gehen auch 8 MHz) und der zwei Kondensatoren am Quarz:
ATmega328P werden in der Regel so ausgeliefert, dass ein externer Taktgeber für die Ersteinrichtung erforderlich ist.
Auf anders lautende Angaben von Versandhändlern sollten Sie sich nicht verlassen:
Zwar liefert Atmel in Tausenderstückzahlen auch anders konfigurierte Mikrocontroller, doch da der Einkauf über Zwischenhändler häufig billiger ist, kaufen die meisten Versender von diesen – ohne auf exakte Einstellungen zu achten.




Bild 2.23: Die Pins D11, D12, D13 und Reset werden wie beim Flashen des Pro-Mini-Klons angeschlossen.
Neu ist der externe Taktgeber.




Als ersten Test lesen Sie die Fusebits aus.
Bei diesen handelt es sich um generelle Einstellungen des Mikrocontrollers, beispielsweise bei Unterschreitung welcher Spannung ein Reset erfolgen soll,
ob ein externer Taktgeber genutzt wird oder ob Programme mittels Bootloader (komfortabler)
oder Programmer hochgeladen werden (spart 512 ... 2.048 Byte Speicher).
Wenn Sie Interesse an der Bedeutung und Berechnung der Fusebits bei Atmel-Mikrocontrollern haben, besuchen Sie
http://www.engbedded.com/fusecalc/
https://www.mikrocontroller.net/wikifiles/4/47/WakeUPLightFuses.pdf

# Name der Gerätedatei /dev/ttyACM0, COM1... ist jeweils dem in der Arduino-
IDE angezeigten anzupassen!
# Linux – Pfadvariable auf Wunsch dauerhaft in $HOME/.bash_profile oder
$HOME/.profile setzen
export PATH=$PATH:/usr/local/arduino-1.5.x/hardware/tools
export AVRCONF=/usr/local/arduino-1.5.x/hardware/tools/avrdude.conf
avrdude -C "$AVRCONF" -p m328p -c arduino -b19200 -P /dev/ttyACM0 -U
lfuse:r:-:h -U hfuse:r:-:h -U efuse:r:-:h -U lock:r:-:h
# Windows – Pfadvariable auf Wunsch dauerhaft setzen:
http://www.java.com/en/download/help/path.xml
set PATH=%PATH%;"C:\Program Files\Arduino\hardware\tools\avr\bin"
set AVRCONF="C:\Program Files\Arduino\hardware\tools\avr\etc\avrdude.conf"
avrdude.exe -C "%AVRCONF%" -p m328p -c arduino -b19200 -P COM1 -U lfuse:r:-
:h -U hfuse:r:-:h -U efuse:r:-:h -U lock:r:-:h
# Mac OS X – Pfadvariable auf Wunsch dauerhaft in $HOME/.bash_profile setzen
export
PATH=$PATH:/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/
avr/bin
export AVRCONF=/Applications/Arduino.app/Contents/Resources/Java/
hardware/tools/avr/etc/avrdude.conf
avrdude -C "$AVRCONF" -p m328p -c arduino -b19200 -P /dev/tty.usbmodem123 -U
lfuse:r:-:h -U hfuse:r:-:h -U efuse:r:-:h -U lock:r:-:h


Die Ausgabe sollte wie folgt aussehen. Wichtig ist die Device signature = 0x1e950f und das fehlerfreie Auslesen.
Die Werte H:07, E:D9, L:62 weisen auf einen ATmega328P im Auslieferungszustand hin.
Tauchen Fehler auf, prüfen Sie Verkabelung und Kondensatoren.
Mir ist es passiert, dass die Schaltung nach permanentem Übertragen auf eine Streifenrasterplatine nur in zwei von drei Fällen korrekt arbeiten wollte:
Beim Verlöten habe ich den 10μF Elektrolytkondensator beschädigt.
Nach dessen Austausch funktionierte alles wieder.


avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.01s
avrdude: Device signature = 0x1e950f
avrdude: reading lfuse memory:
Reading | ################################################## | 100% 0.02s
avrdude: writing output file "<stdout>"
0xff
avrdude: reading hfuse memory:
Reading | ################################################## | 100% 0.02s
avrdude: writing output file "<stdout>"
0xda
avrdude: reading efuse memory:
Reading | ################################################## | 100% 0.02s
avrdude: writing output file "<stdout>"
0x5
avrdude: safemode: Fuses OK (H:07, E:D9, L:62)
avrdude done. Thank you.


Starten Sie nun die Arduino-IDE und vergewissern Sie sich, dass Werkzeuge → Programmer → Arduino as ISP eingestellt ist.
Jetzt können Sie Boards → Rasterduino auswählen und mit einem Klick auf Werkzeuge → Bootloader brennen einen Standardbootloader auf den ATmega328P flashen.
Der Menüpunkt Bootloader brennen ist dabei eigentlich zu kurz gegriffen: Bevor nämlich der Bootloader zum ATmega328P übertragen wird, werden Fusebits geändert.
Sie kontrollieren dies mit einem erneuten Aufruf von avrdude.
Dessen relevante Ausgabe sollte jetzt wie folgt aussehen – und auch nach Abziehen von Quarz und den beiden 22-μF-Kondensatoren noch funktionieren:

avrdude: safemode: Fuses OK (H:05, E:DA, L:E2)
avrdude done. Thank you.


Schritt 2: Minimalkonfiguration aufbauen
Es gilt nun, die auf dem Breadboard aufgebaute Schaltung umzubauen.
Der ATmega328P kann mitsamt der Verkabelung von Versorgungsspannung Vcc und GND (Masse) an seinem Ort verbleiben.
Ziehen Sie alle anderen Anschlüsse ab und stecken Sie den USB-zu-seriell-Wandler oder ein FTDI-Breakout auf das Breadboard.
Verbinden Sie zunächst Masse und Vcc mit den entsprechenden Schienen des Breadboards.
Den Reset-Pin (Pin 1) des Mikrocontrollers verbinden Sie dann über einen 10kΩ Widerstand mit Vcc und zudem über einen 0,1μF Kondensator mit DTR oder EXT RESET des USB-zu-seriell-Wandlers.
Wenn Sie nun eine LED an D13 (Pin 19 des Mikrocontrollers) anschließen und eine USB-Verbindung (als Spannungsversorgung) anschließen, sollten Sie bereits die Blinksignale des Bootloaders zu sehen bekommen.

Zur Programmierung fehlen noch die seriellen Anschlüsse TX des Wandlers auf RX (Pin 2) des Mikrocontrollers und RX auf TX (Pin 3).
Fertig ist der minimale Eigenbau-Arduino:
Schließen Sie den Aufbau an den PC an und laden Sie einen Beispiel-Sketch auf den nackten Mikrocontroller.
Nach dem erfolgreichen Test können Sie den Rasterduino zerlegen und gegebenenfalls auf Streifen- oder Lochrasterplatine dauerhaft neu aufbauen.
Als Stromversorgung können Sie ein geregeltes Netzteil (3 bis 5V), zwei Alkaline-Batterien (~3,2 V) oder drei Akkuzellen (~3,6 V) verwenden.
Erfolg versprechen auch Solarzellen, die je nach Bedarf einen Kondensator oder Akkuzellen aufladen.
Beachten Sie, dass mit dem Aufbau ohne Spannungsregler die Versorgungsspannung nicht über 5,5 V liegen darf (sonst droht Beschädigung) und nicht unter 2,7V fallen sollte, da darunter kein stabiler Betrieb garantiert ist.

FTDI-Breakout   FTDI Basic


Bild 2.25: Tests und Upload von Sketches führen wir mit einem FTDI-Board oder USB-zu-seriell-Wandler durch – im späteren Einsatz wird dieses Teil nicht mehr benötigt.




Bild 2.28: Die Pins des ATmega328P in Arduino-Notation.
Pin 1 (Reset) befindet sich an der Seite mit der Kerbe (links oben)  und ist meist durch einen kleinen Kreis markiert.






Quelle:
Hausautomation mit Arduino Seite 66 bis 70     ISBN: 978-3-645-20279-4
x715_c_FRANZIS-x_60279-2 Hausautomation mit Arduino (254 Seiten)_1a .pdf





Evolution des Rasterduino – Barebone-Arduino für € 5,-

Für viele meiner kleinen Projekte nehme ich nackte Atmega328-Microcontroller, wenn gerade keine billigen Pro Minis zur Hand sind:
Versandhändler wie Reichelt liefern die µCs meist binnen 48 Stunden.
Für die Maker World in Friedrichshafen galt es eine Art “standardisiertes” Design zu finden
– davon habe ich zwei ausgetüftelt, die leicht nachzubauen sind, und den Bau eigener Shields aus Streifen- oder Lochrasterplatinen unterstützen.
Dafür habe ich darauf geachtet, die Buchsenleisten so zu platzieren, dass das Shield immer richtig aufgesteckt wird (wenn die volle Größe verwendet wird).

Benötigt werden die folgenden Bauteile:
  • Atmega328P im DIL28 Package (je nach Quelle 2,50 bis 5€)
  • ggf. Stecksockel
  • Buchsenleiste 34 oder 36 Pins
  • Sockelleiste gewinkelt 6 Pins
  • Streifenrasterplatine
  • Widerstand 10kOhm
  • Keramikkondensator 0,1µF
  • Schaltlitze YV
  • Ich verwende keinen externen Oszillator, der Atmega328P läuft auf 8MHz internem Takt (1MHz bei 2V ist auch möglich).

    Bitte meine Hinweise zu den Hardwaredefinitionen und dem Flashen des Bootloaders lesen!

    Der Ausgangspunkt




Ausgangspunkt ist das etwas aufgeräumte Arduino to Breadboard Modell – hier bereits mit Buchsenleisten.
Die Buchsenpärchen in den Ecken sollen für mechaische Stabilität bei der Verwendung großer Shields sorgen.
Sie erlaichtern es aber auch, Streifenrasterplatinen quer zu verwenden, wenn dies praktischer ist.


Die Luxusversion

Modul Bus stellt ein PCB her, das exakt dem Aufbau eines Breadboards mit 270 Löchern entspricht.
Diese Platine ist mit 2,40€ nicht ganz billig, aber aufgrund der durchgeösten Lötaugen von beiden Seiten einfach zu bearbeiten.
Die Beschriftung erleichter die Navigation und Schraubenlöcher ermöglichen gegebenenfalls mechanisch sehr stabile Konfigurationen, wenn der “Barebone Arduino mit ein oder zwei Shields versehen werden soll.


Die Platine von Modul Bus bildet das Breadboard exakt nach.


Die Verbindungen von RX des FTDI zu pin-3 des Atmega 328, sowie die beiden gekreuzten Masse- und Vcc Verbindungen und die Brücke von GND des FTDI auf die Masseschiene Y habe ich auf der Unterseite der Platine verlötet.
Im Bild ist A nach wie vor oben, gezählt wird aber von rechts:





Im Gegensatz zum Breadboard können bei der Platine von Modul Bus auf beiden Seiten Strippen gezogen werden.




Die Billigvariante

Eine Billigversion habe ich auf Streifenrasterplatine aufgebaut.
Benötigt wird lediglich ein Stück Platine 8×20 Löcher, also ca. 23x53mm².
Die unterschiedliche Länge der Buchsenleisten sorgt für Sicherheit gegen verkehrtes Aufstecken eigener Shields und erleichtert die Stromversorgung durchs Shield selbst.
Das Ergebnis sieht so aus.


Erst lesen, dann löten – hier wurde getrickst!


Zunächst müssen Leiterbahnen aufgetrennt werden, zu erkennen an den weissen Balken.
Hier habe ich schon einige Lötstellen gesetzt, beispielsweise ist die sechspolige Sockelleiste für den FTDI bereits verlötet:

Die Oberseite vor Einsetzen des Microcontrollers:
Das Kabel zu Pin 2, Vcc und Masse sowie den Widerstand zwischen Pin 1 und Vcc führe ich unter dem µC nach draußen.
Zu beachten ist, dass der Kondensator an Pin 1 und die Drahtbrücke an Pin 2 sich die Löcher mit dem Microcontroller teilen – zu erkennen an der grauen Fläche!
Diese dürfen demnach erst verlötet werden, wenn der Controller an seinem Platz ist.
Sitzt dieser, können die Buchsenleisten folgen.



Drei Kabel und ein Widerstand werden unter dem µC nach außen geführt.

Diskussionsbedarf

Diese Variante nutzt den internen Oszillator des ATmega328P.
Ist mehr Rechenpower oder eine präzisere Uhr gewünscht, müssen ein Quartz und zwei Kondensatoren ergänzt werden.
Beim Aufbau auf der Modul Bus Platine ist im Rechteck A-E x 15-24 genügend Platz.
Auf der Streifenrasterversion ist es eng aber sicher machbar, wenn die gekreuzten Kabel für Masse und VCC von der Oberseite des µC darunter, resp. auf die Unterseite der Platine wandern.
Denkbar wäre es auch, die Streifenrastervariante weitere zwei Pinreihen schmaler zu machen.
Und führt man GND und VCC des FTDI per Kabel auf die entsprechenden Pins des 328, ist eine Größe von 6×17 Löchern möglich…

https://www.arduino-hausautomation.de/2014/evolution-des-rasterduino-barebone-arduino-fuer-5euro/



FRANZIS-BUCH  Sensoren am ARDUINO  Seite ?? = Rasterduino

ISBN 978-3-645-20279-4



Hardware: “Pure” Atmega328P mit Arduino 1.5



Bareduino, Arduino on a Breadboard oder Rasterduino (so nenne ich quasi pure Atmega328p im Buch) sind bei Bastlern recht beliebt, wenn Schaltungen dauerhaft mit wenig Kosten aufgebaut werden sollen:
Während Uno und Co mit mehr als 25€ zu Buche schlagen, liegt der Preis für einen nackten Atmega328P bei weniger als fünf Euro – sogar, wenn man ihn schnell mal beim blauen C in der Fußgängerzone holt.
Dazu kommt, dass der Breadboard-Arduino mit niedrigerem Takt (und damit niedrigerer Versorgungsspannung) versehen werden kann als es bei einem Pro Mini 16 MHz oder Uno der Fall ist.
Die Arduino-Entwicklungsumgebung macht gerade den Sprung auf Version 1.5.
Optisch unterscheidet sich diese kaum von 1.0, doch im Hintergrund hat sich viel getan: Waren die alten Entwicklungsumgebungen hinsichtlich der Macros und Kommandos für Compiler, Bootloader, Fuse-Settings auf die AVR-Familie von Atmega fixiert, besteht nun Hardware-Wahlfreiheit.
Die wird erstmal durch Arduino Zero und Co auf Basis eines ARM-Kerns vollzogen.
Längerfristig heisst dies aber auch, dass so ziemlich jeder Hersteller von Microcontrollern durch die Bereitstellung eigener “Plug-Ins” eine vollständige Integration in die Arduino-Familie erreichen kann:
Dazu muss er Bibliotheken portieren, Compiler als Drop-In bereitstellen und Tools für Bootloader und Fuses.
Der Aufwand ist größer, wenn es um eine komplett neue Controller-Familie geht, kleiner wenn es um Verwandtschaft geht.
So ist es durchaus denkbar, dass Infineon, die bereits Entwicklerkits im Arduino-Formfaktor bereitstellen, den nächsten Schritt zur vollständigen Arduino-Integration gehen:
Angesichts des ARM-Cortex-Cores wären am Compiler wohl keine Änderungen erforderlich.
Zurück zum Thema: Ich habe für Arduino 1.5 Hardware-Definitionen für nackte Atmega-328P erstellt – mit verschiedenen Fuse- und Takt-Einstellungen von 1MHz bis 16MHz, mal mit und mal ohne Brown-Out-Detection.
Die Abschaltung des Brown-Out ist mir wichtig, weil diese es auch mal erlaubt, Sensorknoten, die geringe Datenmengen loggen, auf einer einzigen AAA-Zelle mit 1MHz laufen zu lassen.
Ich habe dabei Gebrauch gemacht von der neuen einfachen Möglichkeit, Submenüs zu definieren und habe ein Auswahlmenü für “Clock” eingefügt, mit dem Sie bestimmen, welcher Takt verwendet wird und ob BOD aktiviert ist (siehe Einstiegesbild).

Hier gibt es die Hardware-Definitionen Atmega328P on Breadboard for Arduino 1.5 zum Download.

Zur Installation einfach im Ordner hardware/ im Arduino-Ordner der Heimatverzeichnisses entpacken.
Unter 1.5 sollte kein Neustart notwendig sein – besser trotzdem die IDE beenden und erneut aufrufen.
ATtinys sind übrigens auch integriert und zumindest mit dem 1€ “teuren” ATtiny85 getestet, aber bei diesen müssen die Fuses noch manuell gesetzt werden – dazu mehr in einem separaten Artikel.

Atmega328P_Attiny_Bare1.5_20140401.zip


Bare Atmega328P und Attiny tauchen nach Entpacken des Zips als “Rasterduino” und “Rastertiny” in der Hardwareliste auf.


https://www.arduino-hausautomation.de/2014/hardware-pure-atmega328p-mit-arduino-1-5/







Vom ARDUINO zu einem Mikrocontroller ATmega328P auf einem Steckbrett  (Breadboard)
In diesem Lernprogramm wird erläutert, wie Sie von einem Arduino-Board zu einem eigenständigen Mikrocontroller auf einem Steckbrett migrieren können.
Es ähnelt diesem Lernprogramm, this tutorial, verwendet jedoch ein Arduino-Board, um den ATmega auf dem Steckbrett zu programmieren.
Sofern Sie nicht die am Ende dieses Tutorials beschriebene Minimalkonfiguration verwenden, benötigen Sie vier Komponenten (neben dem Arduino, ATmega328P und dem BreadBoard):

    ein 16 MHz Quarz,
    ein 10k Widerstand
    zwei 18pF bis 22 Picofarad Keramik-Kondensatoren.


Verwenden einer Arduino-Platine, um den Bootloader auf einen ATmega auf einem Steckbrett zu brennen.



Den Bootloader brennen

Wenn Sie einen neuen ATmega328 (oder ATmega168) haben, müssen Sie den Bootloader darauf brennen.
Sie können dies mit einem Arduino-Board als In-System-Programm (ISP) tun. Wenn der Mikrocontroller bereits über den Bootloader verfügt (z. B. weil Sie ihn aus einem Arduino-Board genommen oder einen bereits gebootetem ATmega bestellt haben), können Sie diesen Abschnitt überspringen.

Gehen Sie folgendermaßen vor um den Bootloader zu brennen:

1. Laden Sie die ArduinoISP-Skizze auf Ihr Arduino-Board hoch. (Sie müssen die Karte und die serielle Schnittstelle aus dem Menü Tools auswählen, das Ihrer Karte entspricht.)
2. Verdrahten Sie die Arduino-Platine und den Mikrocontroller wie in der Abbildung rechts dargestellt.
3. Wählen Sie "Arduino Duemilanove oder Nano w / ATmega328" aus dem Menü Tools > Board.
    (Oder "ATmega328 auf einem Steckbrett (8 MHz interne Uhr)", wenn die unten beschriebene minimale Konfiguration verwendet wird.)
4. Wählen Sie "Arduino als ISP" aus Tools > Programmer
5. Führen Sie Tools> Bootloader brennen aus

Sie sollten den Bootloader nur einmal brennen müssen. Nachdem Sie dies getan haben, können Sie die an die Pins 10, 11, 12 und 13 der Arduino-Platine angeschlossenen Drahtbrücken entfernen.



Hochladen mit einem Arduino Board
Sobald Ihr ATmega328p über den Arduino-Bootloader verfügt, können Sie Programme mit dem USB-zu-Seriell-Konverter (FTDI-Chip) auf einem Arduino-Board hochladen.
Um dies zu tun, entfernen Sie den Mikrocontroller vom Arduino-Board, damit der FTDI-Chip stattdessen mit dem Mikrocontroller auf dem Steckbrett sprechen kann.
Das Diagramm auf der rechten Seite zeigt, wie die RX- und TX-Leitungen von der Arduino-Platine mit dem ATmega auf dem Steckbrett verbunden werden.
Um den Mikrocontroller zu programmieren, wählen Sie "Arduino Duemilanove oder Nano w / ATmega328" aus dem Menü Tools> Board (oder "ATmega328 auf einem Steckbrett (8 MHz interne Uhr)", wenn Sie die unten beschriebene Minimalkonfiguration verwenden).
Laden Sie dann wie gewohnt hoch.



Hochladen von Skizzen zu einem ATmega auf einem Steckbrett.
Denken Sie daran, den Mikrocontroller vom Arduino Board zu entfernen!



Minimalschaltung (Eliminierung der externen Uhr)

Wenn Sie nicht den zusätzlichen 16-MHz-Quarz und die 18-22-Picofarad-Kondensatoren in den obigen Beispielen verwenden, können Sie den ATmega328 so konfigurieren, dass er seinen internen 8-MHz-RC-Oszillator als Taktquelle verwendet. (Sie brauchen den 10K-Pullup-Widerstand auch nicht wirklich auf dem Reset-Pin, also entfernen wir ihn, um eine wirklich minimale Konfiguration zu erhalten.)

Sie müssen Unterstützung für eine zusätzliche Hardwarekonfiguration installieren:

1. Laden Sie dieses Hardware-Konfigurationsarchiv herunter: breadboard-1-6-x.zip, Breadboard1-5-x.zip oder Breadboard1-0-x.zip, je nachdem, welche IDE Sie verwenden.
2. Erstellen Sie einen "Hardware" -Unterordner in Ihrem Arduino-Skizzenbuchordner (dessen Speicherort Sie im Dialogfeld "Arduino-Voreinstellungen" finden). Wenn Sie bereits Unterstützung für eine zusätzliche Hardwarekonfiguration installiert haben, haben Sie möglicherweise bereits einen Ordner "Hardware" in Ihrem Skizzenbuch.
3. Verschieben Sie den Breadboard-Ordner aus dem Zip-Archiv in den Ordner "Hardware" Ihres Arduino-Skizzenbuchs.
4. Starten Sie die Arduino-Software neu.
5. Sie sollten "ATmega328 auf einem Steckbrett (8 MHz interne Uhr)" im Menü Extras> Karte sehen.

Sobald Sie dies getan haben, können Sie den Bootloader brennen und Programme wie oben beschrieben auf Ihren ATmega328 hochladen.
Wählen Sie "ATmega328 auf einem Steckbrett (8 MHz interne Uhr)", wenn Sie den Bootloader brennen.
(Wenn Sie das falsche Element auswählen und den Mikrocontroller so konfigurieren, dass er eine externe Uhr verwendet, funktioniert er nur, wenn Sie eine Verbindung herstellen.)

Achtung:
Diese Prozedur funktioniert mit der Arduino 1.0.x-Software.


Verwenden einer Arduino-Platine zum Brennen des Bootloaders auf einen ATmega auf einem Steckbrett
(w/o an external clock).

Hochladen vom Sketch zu einem ATmega auf einem Steckbrett.

Getting Rid of the Arduino Board

Sobald Sie den ATmega auf dem Steckbrett programmiert haben, können Sie den Arduino beseitigen.
Dazu müssen Sie eine alternative Stromversorgung für den Mikrocontroller bereitstellen.
Weitere Informationen finden Sie im eigenständigen Arduino in einem Lernprogramm mit Steckbrettern.


https://github.com/mschlenker/Arduino-Hausautomation/blob/master/Buch/Hardware/hardware/barebone/avr/boards.txt
https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard



Barebones-Arduino

Arduino als Stand Alone Version


Um ein Arduino auf dem Breadboard zu bauen, benötigt man

z.B. einen ATmega328P  IC, auf dem sich der Arduino Bootloader befinden (Siehe Arduino Bootloader).

Dann fängt man am besten mit der bekannten Spannungsregler-Schaltung an.

Nun wird der IC platziert.

Jetzt kommen die Stromanschlüsse und Federleisten dazu. Die Federleisten sind optional und nicht unbedingt nötig.

Als nächstes wird die Schaltung für den Reset-Button hinzugefügt. Ein 1kOhm Widerstand entstört das Signal.

Nun wird noch der Taktgeber für den IC angeschlossen. Es handelt sich um einen 16 MHz Quarz und zwei Keramikkondensatoren á 22pF (Piko-Farad).

Nun ist das Setup für das Barebones-Arduino fertig und kann z.B. mit einem anderen Arduino-Board programmiert werden.

Die Belegung der Pins sieht folgender Maßen aus:

Ist die Programmierung abgeschlossen, kann man das Arduino-Board entfernen und das Barebones-Arduino mit einem Netzteil betreiben.



Den IC Atmega328P  gibt es vorprogrammiert für ein paar Euro im Elektronikversand

Wenn man nur einen Chip (ohne Boot-Software) kauft und nicht ein fertiges Arduino-Board, muss eine Bootloader-Software auf den Chip, sofern man die Arduino-Software benutzen will.


Um nochmal auf die Verkabelung hinzuweisen wie man einen Bootloader mit einen Arduino auf einen Atmega-IC brennt siehe :
http://arduino.cc/en/Tutorial/ArduinoToBreadboard



Um den Chip so komfortabel zu programmieren, wie es mit der Arduino-Software geht, muss der so genannte Arduino-Bootloader auf den Chip geladen werden. Das passiert z.B. via AVR-Programmer.



https://www.arduino-tutorial.de/barebones-arduino/


DIN A4  ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE













Comments