Einfach ARDUINO‎ > ‎

Arduino selbstgebaut

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

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2017-06-28

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

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   siehe
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-einfach.arduino-arduino.selbstgebaut (xx Seiten)_1a.pdf


            ARDUIONO UNO selbstgebaut!
Minimal ARDUINO selbst bauen
ARDUINO selber bauen mit ATmega328P-PU
https://crazy-electronic.de/index.php/arduino-selbst-bauen


Bau eines ARDUINO (Aufbauanleitung)
https://funduino.de/anleitung
https://www.grund-wissen.de/elektronik/arduino/aufbau.html

Der schnelle Einstieg in Arduino
https://www.elv.at/Arduino-verstehen-und-anwenden-Teil-1-Einstieg-in-die-Hardware-Arduino-und-AVR-Mikrocontroller/x.aspx/cid_726/detail_44820

https://crazy-electronic.de/index.php/arduino



elektor BUCH  ARDUINO entdecken  7.10 ARDUIONO selbstgebaut Seite 198
7.10 Ein Arduino selbstgebaut
Arduinos sind nicht besonders teuer, aber wenn Sie für jedes (dauerhafte) Projekt einen kaufen müssen, kann dies schon ins Geld gehen.
Glücklicherweise ist es nicht allzu kompliziert, einen ARDUINO UNO R3 für ein paar Euro selber zu bauen.


7.10.1 Stand-alone-Mikrocontroller
Wir beginnen mit der Hardware. Sie benötigen einen Mikrocontroller ATmega328P im PDIP-Gehäuse, das gut auf das Steckboard passt und auch der Typ ist, der bei den meisten Arduino Uno verwendet wird.

Da wird selber einen Bootloader installieren wollen, kaufen wir ATmega328P-Chips ohne Bootloader für 2...3 Euro pro Stück.
Mit Bootloader sind die Controller etwas teurer und auch schwerer erhältlich.

Die Nummerierung der Pins des ATmega328P beginnt wie bei jedem IC mit der 1 oben links, wenn die Einkerbung nach oben gehalten wird. Pin 1 ist mit einem kleinen Kreis markiert.
Die Nummerierung geht an dieser Seite weiter mit 2 bis 14, dann auf der rechten Seite unten mit 15 und nach oben bis 28. Pin 28 befindet sich also gegenüber Pin 1.
Die Pinnummerierung und die Bedeutung der Pins erfahren Sie aus dem folgenden Bild, das aus dem Datenblatt des Herstellers stammt.


B.2 Anschlussbelegung Microcontroller
Pinbelegung ATmega168 & ATmega328P-PU

ATmega Microcontroller Anschlussbelegung (Gehäuse DIP-28)
Bild 123. Die Anschlüsse des ATmega328P


Digital pin-0 bis pin-13
Analog pinA-0 bis pin-A5

Bild 5.104: Die Pinbelegung des ATmega328P (innen) und die dazugehörigen ARDUINO UNO R3 pin (außen).


Weitere Angaben zum Microcontroller und zu den verschiedenen weiteren Gehäuseformen sind detailliert im Datenblatt beschrieben.
http://atmel.com/dyn/resources/prod_documents/doc8025.pdf


Zuordnung Pin-1 bis Pin-28 zu Anschlüssen auf Arduino Uno R3

ATmega-Pin    Pinbeschreibung    Arduino-Board-Funktion
  1    PCINT14 / Reset           (PC6)    Reset
  2    PCINT16 / RXD             (PD0)    D0 (RX)
  3    PCINT17 / TXD              (PD1)    D1 (TX)

  4    PCINT18 / INTo            (PD2)    D2
  5    PCINT19 / OC2B / INTI (PD3)     D3 (PWM)
  6    PCINT20 / XCK / To      (PD4)    D4
  7    Vcc    Vcc
  8    GND    GND
  9    PCINT 6 / XTAL1 / TOSCI (PB6)    Quarz
10    PCINT 7 / XTAL2 / TOSC2 (PB7)    Quarz
11    PCINT21 / OCoB / TI       (PD5)     D5 (PWM)
12    PCINT22  /0CoA / AIN0   (PD6)     D6 (PWM)

13    PCINT23 /            AIN1   (PD7)    D7
14    PCINT 0 / CLK0 / ICP1   (PB0)     D8
15    OC1A /             PCINT1  (PB1)     D 9 (PWM)
16    SS /     OC1B / PCINT2  (PB2)     D10 (PWM)
17    MOSI / OC2A / PCINT3  (PB3)     D11 (PWM)

18    MISO /             PCINT   (PB4)    D12
19    SCK /              PCINT5  (PB5)    D13

20    AVcc    Vcc
21    Aref     Aref

22    GND    GND
23    ADC0 /           PCINT  8 (PC0)    A0
24    ADC1 /           PCINT  9 (PC1)    A1
25    ADC2 /           PCINT10 (PC2)    A2
26    ADC3 /           PCINT11 (PC3)    A3
27    ADC4 / SDA / PCINT12 (PC4)    A4
28    ADC5 / SCL / PCINT13 (PC5)    A5


Tabelle B.2: Zuordnung der ATmega pin1..pin-28 Pins  Anschlüssen auf Arduino Uno  Pin-0 bis Pin-13 UND  Pin-A0 bis Pin-A5





Sie sehen, dass die Namen und Pinnummern nicht mit denen der Arduino-Sketche übereinstimmen.
Darauf kommen wir später noch zurück.

Mikrocontroller sind ziemlich anfällig für statische Elektrizität.
Berühren Sie deshalb etwas Geerdetes, bevor Sie den Mikrocontroller anfassen, und berühren Sie so wenig wie möglich die Anschlüsse.
Achten Sie gut darauf, dass alle Pins gut im Steckboard sitzen.
Manchmal passiert es, dass sich ein Pin verbiegt und dann zwischen IC-Gehäuse und Steckboard und nicht im Kontakt steckt.
Wir verbinden den Controller so wie im folgenden Bild mit dem Arduino Uno.
Bei 7/20 und 8/22 müssen natürlich jeweils beide Pins mit +5 Volt respektive GND verbunden werden.


Bild 124. Anschluss des ATmega328P an den ARDUINO UNO R3

Eigentlich trivial, aber es ist schon oft vorgekommen, dass ein Projekt partout nicht funktionieren will, weil (unerkannt) die Versorgungsspannung fehlt.
Auf einem Steckboard sind die Versorgungsschienen oft nicht durchverbunden.
In folgendem Bild sorgen deshalb kurze Kabel (rot und blau) für die Verbindung der linken und der rechten Hälfte.
Die Kabel, die die oberen und die unteren Schienen miteinander verbinden, sind hier nicht im Bild (aber vorhanden).

    ARDUINO-pin ATmega328P-pin
    10           1
    11          17
    12          18
    13          19
    +5V          7+20
    GND          8+22
Tabelle 41. Kopplung von Arduino und ATmega328P.


Um Störungen zu vermeiden, sollte man an jeder Ecke des Boards einen 100-nF-Konden-sator (Code 104) über die Versorgungsspannung schalten. Diese Kondensatoren sind hier weder im Bild noch in der Schaltung zu sehen.



BILD fehlt
Bild 125. Aufbau auf einem Steckbrett.

Im Download finden Sie die OptiLoader-Dateien.
Sie können auch von der Webseite des "Machers" die neuste Version abholen. Entpacken Sie die Datei und platzieren Sie sie in einem Ordner "optiLoader" (achten Sie auf das große L).

Laden Sie die Datei optiLoader.pde in die Arduino-IDE und senden Sie sie zum Arduino.
Ist die IDE fertig, so ziehen Sie den USB-Stecker, damit die Schaltung stromlos wird.

                Bootloader
7.10.3\flashLEDadjust.ino
          \optiLoader.h
          \optiLoader.pde




BILD 126 fehlt
Bild 126. Der Sketch funktioniert.


Warten Sie einen Augenblick und stecken Sie das USB-Kabel wieder ein. Starten Sie den Serial Monitor auf 19200 Baud, damit Sie verfolgen können, was geschieht. In diesem Moment startet der Sketch von neuem, aber das ist kein Problem. Wenn alles gut geht, erscheint folgender Text. Wenn ein Fehler gemeldet wird, sind die Anschlüsse nicht richtig oder Sie haben ein Problem mit Störungen. Im zweiten Fall: Haben Sie die Kondensatoren an den Versorgungsschienen eingesetzt?

Bootloader
OptiLoader Bootstrap programmer.
2011 by Bill Westfield (WestfW)

Target power on!
Starting Program Mode [OK]

Reading signature:950F
Searching for image...
  Found "optiboot_atmega328.hex" for atmega328P
  Start address at 7E00
  Total bytes read: 502

Setting fuses for programming
  Lock: 3F FFE000 Low: FF FFA000 High: DE FFA800 Ext: 5 FFA400

Programming bootloader: 512 bytes at 0x3F00
  Commit Page: 3F00:3F00
  Commit Page: 3F40:3F40
  Commit Page: 3F80:3F80

  Commit Page: 3FC0:3FC0

Restoring normal fuses
  Lock: 2F FFE000

Target power OFF!

Type `G` or hit RESET for next chip


Die Anmerkung "Target power OFF!" sollte Sie nicht beeindrucken.
Es ist nämlich möglich, den ATmega328P über pin-9 des Arduino zu versorgen. In diesem Fall schaltet der Ardui-no nach dem Programmieren den pin-9 und damit die Versorgung des ATmega328p ab.
Danach kann man den Controller aus dem Steckboard holen, den nächsten ATmega328p einstecken und ihn mit einem Druck auf die Reset-Taste mit einem Bootloader ausstatten.
Das ist möglich, weil der ATmega328p auf dem Steckboard nicht einmal 15mA benötigt.
Ich ziehe es aber vor, den ATmega328p über den normalen +5V Anschluss zu versorgen und dann vor dem Entfernen das USB-Kabel herauszuziehen.

Markieren Sie den ATmega328p mit einem Sticker, so dass Sie wissen, dass der Controller nun einen Bootloader enthält.
Sie können den neuen Bootloader testen, indem Sie den Controller des Arduino (vorsichtig!) aus der Fassung holen und dafür den gerade eben programmierten einsetzen.
Am besten, Sie statten auch den originalen Arduino-Controller mit einem Sticker ("Original") aus.
Achten Sie auch darauf, dass der Chip auf dem Arduino richtig herum eingesteckt ist (pin-1 befindet sich am gekrümmten Platinenrand).

Schließen Sie das USB-Kabel wieder an und probieren Sie die Blink-Demo aus.
Wenn alles richtig gemacht wurde, blinkt die LED an pin-13.
Sie können auf diese Weise einen Sketch entwickeln, den Chip vom Steckboard holen und in die (permanente) Zielapplikation einsetzen.

Wenn Sie einen ATmega328P anstelle eines Arduinos verwenden, vergessen Sie nicht, dass die Anschlüsse auf den Arduino-Headern anders heißen als beim ATmega328P. Natürlich sind trotz der unterschiedlichen Bezeichnungen die gleichen Pins vorhanden.
Die folgende Tabelle zeigt, wie die Anschlüsse von ATmega328 und Arduino-Header übereinstimmen und welche Funktion sie haben.
Wenn sich zum Beispiel beim Arduino ein Schalter an Header-pin-3 befindet, muss er beim ATmega328 an pin-5 angeschlossen werden.

ARDUINO-pin ATmega328P-pin  Funktion
Reset       1               Reset
0           2               Rx/digital
1           3               Tx/digital
2           4               digital
3           5               digital

4           6               digital
+5V         7 und 20        Vcc (+5V)
  Achtung: Beide Pins müssen angeschlossen werden!
GND         8 und 22        GND
        Achtung: Beide Pins müssen angeschlossen werden!
5          11               digital
6          12               digital
7          13               digital
8          14               digital
9          15               digital
10         16               digital
11         17               digital
12         18               digital
13         19           LED/digital
AREF       21               Aref
AO         23               analog
Al         24               analog
A2         25               analog
A3         26               analog
A4         27               analog
A5         28               analog

Tabelle 42. Anschlüsse von Arduino und ATmega328 und ihre Funktionen.

Folgendes Bild zeigt die Basisschaltung eines ATmega328P.
Diese Anschlüsse und Bauteile MÜSSEN immer vorhanden sein.
7/20 bedeutet, dass immer beide Pins (also 7 und 20) angeschlossen sein müssen.
Das gleiche gilt natürlich für 8/22.

Bild 127. Die Basisschaltung des ATmega328P.

Der 10k Ohm Widerstand weist den Farbcode braun-schwarz-orange auf, die 20pF Kondenatoren den Code 22.
Achten Sie darauf, dass die Quarzfrequenz wirklich 16MHz beträgt, eine andere Frequenz funktioniert nicht!


BreadBoard Bild fehlt
Bild 128. Basisschaltung auf dem Steckbrett. Pin 1 ist oben rechts.


Das Netzteil muss eine gut stabilisierte +5 Volt Gleichspannung liefern.
Sie können einen USB-Adapter verwenden und dort den Stecker abknipsen oder alternativ einen kleinen Netztrafo, an dessen Sekundärseite Sie die Schaltung aus Bild 130 anschließen.




7.10.2 Mit USB-Anschluss

Wir verfügen nun über einen funktionsfähigen Arduino-Bootloader in einem ATmega328, haben aber keine Möglichkeit, um über den USB Verbindung aufzunehmen.
Eine gute Option ist ein USB-TTL-Kabel für 5 Volt. So etwas ist nicht billig, aber man kann es für alle selbstgemachten Arduinos verwenden. Insofern scheint es nicht nur die praktischste, sondern auch die preiswerteste Lösung zu sein.

Wir setzen in diesem Projekt ein "TTL232R USB to TTL Serial Converter Cable" ein.

Das "TTL-232R USB to 5 Volt TTL Serial Converter Cable" ist von Future Technology Devices International Ltd.
Achten Sie darauf, dass Sie die 5-Volt-Version verwenden.
Sie können dieses Kabel im Elektor-Shop (http://www.elektor.de/usb-ttl-interface-cable-5v) erwerben.

USB-TTL-Kabel  TTL232R USB to TTL Serial Converter Cable

Der Anschluss des Kabels an die Hardware ist einfach, Sie dürfen aber nicht vergessen, die CTS-Leitung auf Masse zu legen.
Dies ist für den PC der Hinweis, dass Daten gesendet werden dürfen.
Die Anschlüsse 1 und 2 des USB-TTL-Kabels werden miteinander verbunden.

Die Arduino-IDE will selbstständig den ATmega328P zurücksetzen können und benutzt dazu den RTS-Anschluss.
Dieser ist mit einem 0,1pF Kondensator mit dem Reset-Anschluss des Atmega328P verbunden.
Der TTL-Stecker des Kabels ist nicht markiert, pin-1 (Erde) ist bei der schwarzen Ader.
Wir schließen noch eine LED an pin-19 (Arduino pin-13) an und können die Funktion der Schaltung mit dem Blink-Sketch aus dem Ordner Examples überprüfen.



Bild 130. Die Schaltung mit dem USB-TTL-Kabel am ATmega328P.

Der Kondensator weist den Code 104 auf, der 10k Ohm Widerstand (die Farben braun-schwarz-orange), der 220 Ohm Widerstand (rot-rot-braun) und die kleinen 20pF Kondensatoren (die Nummer 22).
Achten Sie darauf, dass Sie einen 16MHz mQuarz verwenden, sonst funktioniert es nicht.
Die kleinen Patchkabelstecker passen genau in den Stecker des USB-TTL-Kabels.



Steckbrett Bild fehlt
Bild 131. Der Aufbau auf dem Steckbrett.




Wir können nun in der Arduino-IDE einen Sketch erstellen und auf gewohnte Manier im selbstgemachten Arduino unterbringen.
Der einzige Unterschied ist, dass das USB-TTL-Ka-bel seinen eigenen COM-Port hat, der sich vom COM-Port des alten Arduinos unterscheidet.
Bei mir befindet sich der normale Arduino an COM 5, der über das USB-TTL-Kabel verbundene an COM 6. Das kann bei Ihnen aber anders aussehen.
Sie können über Tools-Serial Port den Port wie gewünscht einstellen. COM-Ports von USB-Konvertern sind übrigens nur sichtbar, wenn das Kabel auch tatsächlich angeschlossen ist.


7.10.3 Demoprojekt mit selbstgebautem Arduino: einstellbares Blinklicht
Wir wiederholen Projekt 5.1, aber verwenden dieses Mal unseren selbstgebauten Arduino.
Wir belassen die LED an pin-13 (pin-19 des ATmega382P) und schließen an pin-A5 (pin-28 des ATmega382P) ein Potentiometer an.
Der Sketch zeigt keine Besonderheiten.

int pot = A5;
int led = 13;
int state = false;

void setup()
  pinMode(led, OUTPUT);

void loop() {
  digitalWrite(led, state);
  state=!state;
  delay(analogRead(pot)+20);
}


Ziehen Sie den USB-Stecker aus dem PC, so dass die Schaltung stromlos wird, bevor Sie daran arbeiten.
Das USB-TTL-Kabel ist nur für die Programmierung erforderlich.
Wenn Sie die Arbeit beendet haben, entfernen Sie das Kabel und den 0,1pF Kondensator und schließen eine gut stabilisierte Spannungsversorgung von +5V an.
Der 10k OhmWiderstand an pin-1 muss in der Schaltung verbleiben.






Bild 132. Hie Schaltung des einstellbaren Blinklichts.



Drehen Sie am Potentiometer, um die Blinkfrequenz einzustellen.


BreadBoard Bilf fehlt
Bild 133. Der Aufbau auf dem Steckbrett.



8.1 Einstellbare Spannungsversorgung (1,2...13 Volt)

Eine einfache einstellbare Spannungsquelle für Spannungen von 1,2...13 Volt ist schnell gebaut und ideal für alle Projekte in diesem Buch, die eine externe Versorgung erfordern. Ich habe sie auch beim Ausprobieren der Projekte in diesem Buch verwendet.
Wenn der Regler mit einem Kühlkörper von etwa 10 cm2 ausgestattet wird, kann die  Spannungsquelle maximal 1,5 A liefern, mehr als genug für unsere Zwecke.


Bild 134. Schaltung der einstellbaren Spannungsquelle.

TO-220    1-2-3
Bild 135. Anschlussbelegung des LM317.


Sie müssen natürlich mit einem Multimeter überprüfen, welche Spannung zu welcher Potistellung gehört.
Wenn Sie die Schaltung in ein Gehäuse mit einer Skala am Potentiometer einbauen, ist diese Kalibrierung nur einmal erforderlich.
Die Spannungsquelle wird selbst von einem Steckernetzteil versorgt, das 15V Gleichspannung liefert.
Wenn Sie ein anderes Steckernetzteil mit anderen Werten verwenden, sollten Sie die nachstehende Erläuterung genau studieren und unter Umständen andere Bauteile verwenden. Liefert das Stecker-netzteil eine Wechselspannung, muss dem Spannungsregler ein Gleichrichter vorgesetzt werden.



Netzteil-Foto fehlt
Bild 136. Das Netzgerät im Gehäuse.

Der LM317 ist ein 1,2-Volt-Spannungsregler.
Der Spannungsabfall über Ausgang und ADJ-Anschluss beträgt stets 1,2 Volt.
Für eine maximale Ausgangsspannung von 13 Volt ist ein 15V Steckernetzteil (oder Trafo) deshalb ausreichend.
Die Spannung wird mit einem linearen 5k Ohm Potentiometer eingestellt.
Der Spannungsabfall über dem Potentiometer beträgt 11,8 Volt (13V - 1,2V) und der Strom hindurch 2,36 Milliampere.

Umax = 13                                   [Formel 38]
Uvar = 13 - 1,2 = 11,8 Volt              [Formel 39]
Ivar = U/R = 11,8 / 5 k = 2,36 mA    [Formel 40]

Dieser Strom fließt nicht durch den LM317, sondern durch den Bypass-Widerstand, der angesichts der Spannung über dem LM317 von 1,2 Volt leicht berechnet werden kann:

Rfix = U/I = 1,2 / 0,00236 = 508 Q.    [Formel 41]

Dieser Wert existiert nicht, man muss entweder 470 Ohm oder 560 Ohm einsetzen.
Für eine höhere maximale Spannung nehmen wir 470 Ohm (gelb-lila-braun).
Wenn Sie eine LED als Einschaltkontrolle einbauen wollen, schließen Sie diese direkt an der 15V Eingangsspannung mit einem Vorwiderstand von 1k Ohm (braun-schwarz-rot) an.
















       BreadBoard ARDUIONO UNO selbstgebaut!

Arduino Handbuch:    € 34,95


Breadboard-Arduino
5.21_Ohne Inhalt_1a.zip

Breadboard-Arduino

Ganz ohne Arduino bauen wir uns einen Arduin0  Seite 370


5.21 Breadboard-Arduino™
Kommen wir zu den hohen Weihen der Arduino-Kunst: Arduino ohne Arduino.

{ GND: Die Massen von ISP und Zielprozessor.
{ Vcc: Die Versorgungsspannung, die der ISP für die zu programmierende Schaltung
bereitstellt.
{ MOSI: Die Datenleitung, die Daten vom ISP zum Zielprozessor transportiert.
{ MISO: Die Datenleitung, die Daten vom Zielprozessor zum ISP transportiert.
{ SCK: Der ISP stellt auf dieser Leitung einen gemeinsamen Takt bereit, der zur Kommunikation
benötigt wird.
{ RST: Diese Leitung versetzt den Zielprozessor bei Bedarf in den Reset-Modus, in
dem dieser programmiert werden kann.
Damit man einen Mikrocontroller schnell programmieren kann, sind diese sechs Leitungen auf einer genormten Stecker-/Buchsenleiste angeordnet.


Verwendung eines Arduino Uno als ISP
Benötigte Bauteile
1x Arduino ISP oder Arduino Uno, Leonardo oder Mega
1x Mikrocontroller ATmega328P-PU
1x Breadboard
8x Steckbrücken / Drahtbrücken
1x grüne LED
1x Widerstand 120R
2x Kondensatoren 22pF (optional)
1x Quartzoszillator 8MHz (QM016 optional

a


5.21.4 Schaltplan


Bild 5.103: Falls der ATmega328P nur mit 1 MHz betrieben werden soll, kann auf den Quarz und die zwei Kondensatoren verzichtet werden.

Programmierung des ATmega328P
Um einen Mikrocontroller mithilfe des Arduino ISP zu programmieren, muss dieser in der Arduino-Entwicklungsumgebung unter dem Menüpunkt Werkzeuge/Programmer ausgewählt werden.
Zudem muss unter Werkzeuge/Board der Arduino Uno ausgewählt werden, der ja ebenfalls mit einem ATmega328P bestückt ist.
 Um zu testen, ob alles funktioniert, kann mit Datei/Beispiele/01.

http://sites.prenninger.com/arduino-uno-r3/arduino-handbuch





Arduino Selbstbau auf Lochraster

Arduino selbst bauen

Lochrasterplatine
1 Quarz 16Mhz
2 Keramikkondensatoren 22pf 50V
1 10k Ohm 1/4 Watt
2 Kondensatoren 100nf 63V (0,1µf)
1 Pinheader female 40pol.
1 IC Sockel 24pol.
1 ATmega328P-PU
1 Kleinsttaster

1 DC Einbaubuchse
4 Dioden 1N4007
1 Spannungsregler 5V
1 LM317K für 3,3V
1 Elko 22 - 100µf
1 Widerstand 330R Ohm
1 Widerstand 470R  Ohm
1 Widerstand 150R  Ohm
1 LED 5mm grün
1 Wannenstecker 10pol.




Der  von der  Fa. FTDI produzierte FTDI232RL wandelt die USB Pegel in ein RS232 Signal um. Es werden die Pins TX RX DTR und DSR unterstützt.  Für das Programmieren des Arduino ist das DTR Signal wichtig, das den zum Programmiervorgang  benötigte Reset am Ende erzeugt.


https://crazy-electronic.de/index.php/ftdi-bastelarduino-an-usb




Quelle:
https://crazy-electronic.de/index.php/arduino-selbst-bauen





*******************************************************************************I**
AZ-Delivery

Aus Buch ARDUINO KOMPENDIUM
16.2 Minimaler Arduino Seite 431 bis 440

16.2 Minimaler Arduino
In dieser E-Mail wollen wir die Frage beantworten, ob man auch selbst eine Arduino-Platine nachbauen kann.
Tatsächlich spricht nichts dagegen. Möchte man ein Projekt aus dem Experimentierstatus in den Praxiseinsatz überführen, bietet diese Taktik sogar Kosten- und Platzvorteile.

DIP-Bauform

Der ATMega328P ist für unter 2€ verfügbar.

Alles, was Sie dafür benötigen, ist der Arduino-Mikrocontroller (ATmega328 oder ATmega328P), welcher im Handel für deutlich unter 5 Euro pro Stück erhältlich ist.
Der Zusatz P weist lediglich darauf hin, dass die überarbeitete Version des Mikrocontrollers effektivere Stromsparfunktionen (Power-Management) besitzt. In der Anwendung gibt es keine Unterschiede.
Es gibt mehrere Bauformen, für Bastel-Einsteiger eignet sich die große DIP-Bauweise (Dual Inline Package) mit zwei Anschlussreihen am besten, da sie sowohl für BreadBoards als auch für die Platinenmontage geeignet ist.

SMD-Bauform

ATmega328P – die deutlich kleinerer SMD-Ausführung.

In der Serienherstellung werden häufig die kleineren SMD-Bauformen
(Surface Mounted Device – Bei dieser Form werden die Pins nicht durch die Platinen hindurch gesteckt, sondern direkt auf die Oberfläche gelötet.) verwendet, welche sich jedoch nur schwer manuell verlöten lassen.
Das Innenleben ist unabhängig von der Bauform jeweils gleich.

Mikrocontroller ATMEL ATmega328P
Mikrocontroller Microchip AVR (vormals Atmel)  ATmega328P

Pinbelegung des ATmega328P in DIP-Bauform.

Zur Abgrenzung von den Bauteil-Pinnummern wurde den digitalen Ein- und Ausgangspins ein D vorangestellt.

Der Mikrocontroller verfügt über 28-Pins, von denen die meisten bereits aus unseren Arduino-Versuchen bekannt sind.
Die Arduino-Platine verbindet die Ein- und Ausgangspins einfach direkt mit denen des Mikrocontrollers.

Der RESET-Pin funktioniert wie ein digitaler Eingang mit internem Pull-Up-Widerstand.
Nur wenn er mit Masse verbunden wird, löst dies einen Neustart aus.
Für die Betriebsspannung (Vcc – Voltage at the Common Collector) sind gleich zwei Pins vorgesehen.
Zur Vermeidung von gegenseitigen Störungen werden in der Signalverarbeitung traditionell getrennte Betriebsspannungen für digitale (Vcc) und analoge Schaltungsteile (AVcc) verwendet.
In unseren Anwendungsfällen (ohne hochfrequente oder hochpräzise Signale) ist dies nicht relevant, deshalb sind auch auf der originalen Arduino-Platine einfach beide Pins mit dem gleichen 5V Spannungsregler verbunden.

Der Aref-Pin bietet die Möglichkeit, eine abweichende Referenzspannung für die analogen Eingänge zu verwenden, wenn die Betriebsspannung nicht dafür genutzt werden soll (siehe Kapitel 5.3).

Die Bezeichnung der Crystal-Pins weist auf den 16MHz Quarzkristall hin, welche hier als Taktgeber anzuschließen ist.
Wie ein Metronom bestimmt er die Arbeitsgeschwindigkeit des Mikrocontrollers und muss gemäß Spezifikation des Chipherstellers mit zwei 22pF Kondensatoren zur Masse hin stabilisiert werden.



Zwei 22pF Kondensatoren und ein 16MHz Quarzkristall


Minimale Beschaltung des ATMega328P

Daraus ergibt sich auch schon die minimale Beschaltung de Mikrocontrollers – tatsächlich reichen die Spannungsversorgung sowie der Schwingquarz samt Kondensatoren.
Genau genommen könnte dieser Taktgeber sogar entfallen, da der ATmega328P auch über einen internen 8MHz Taktgeber verfügt.
Allerdings muss dafür die Konfiguration des Bootloaders geändert werden.
Dieser Eingriff ist nicht über die Arduino IDE möglich und sollte nur von Profis durchgeführt werden, da ein Fehler dazu führen kann, dass der Chip dauerhaft unbenutzbar wird.
Wir bleiben also im Folgenden beim externen Takt, welcher zudem nicht nur doppelt so schnell, sondern auch genauer ist.

Minimale Beschaltung des ATmega328P


16.3 In-System-Programmer

Die minimale Beschaltung sorgt zwar dafür, dass der Microkontroller läuft – jedoch ist er noch nicht programmiert.
Handelt es sich um einen fabrikneuen Chip, müssen wir zudem davon ausgehen, dass auch der Bootloader (“Startprogramm”, siehe Kapitel 3.1.3) noch nicht vorhanden ist.
Dieser kann ebenfalls über die Arduino IDE auf den Mikrocontroller geladen werden, allerdings nicht mit dem bisherigen Weg über die serielle Schnittstelle.

Stattdessen benötigt man einen ISP (In-System-Programmer), manchmal auch ICSP (In-Circuit-Serial-Programmer) genannt.
Diese Module sind üblicherweise als USB-Adapter (für den 6-Pin-ICSP-Steckplatz) erhältlich und ermöglichen das unmittelbare Schreiben auf den Programmspeicher des Chips.
Bei unserer bisher üblichen seriellen Programmierweise hatte uns unbemerkt immer der vorinstallierte Bootloader geholfen.

USB-ISP mit dem typischen 6-Pin-Stecker

Verfügt man nicht über einen solchen Adapter, kann man aber auch einfach einen weiteren Arduino benutzen.
Im Idealfall besitzt man sogar zwei Arduino-UNO-Platinen:
Dann kann man den original-Chip vorübergehend aus einer der Platinen entfernen und durch den fabrikneuen ersetzen:

ARDUINO UNO R3 (Revision 3)
Mit einem Schraubendreher kann der Mikrocontroller vorsichtig aus seiner Halterung gelöst werden.


Anschließend verbindet man beide wie folgt:

Links der (mit dem Computer verbundene) Arduino, welcher als ISP fungiert - rechts die Platine mit dem fabrikneuen Chip, auf welchen nun auch der Bootloader gespielt werden soll




Die Datenübertragung erfolgt über  Pin-11 bis Pin-13.
Die Reset-Verbindung ist wichtig, weil das Aufspielen von Daten nur direkt nach einem Neustart möglich ist.
Verfügen Sie über nur einen ARDUINO UNO R3, kann die Programmierung natürlich auch am Breadboard erfolgen.
Die folgende Verdrahtung ist identisch mit der aus der vorhergehenden Abbildung:

Oben der mit dem Computer verbundene Arduino UNO, welcher als ISP fungiert.

Mit der Arduino IDE muss nun im ersten Schritt ein spezieller Sketch auf den Arduino geladen werden, welcher als ISP dienen soll.
Sie finden diesen unter Datei -> Beispiele -> 11.ArduinoISP -> ArduinoISP.

Der für die ISP-Funktion benötigte Sketch befindet sich im Beispiele-Menü.

Laden Sie diesen Sketch ohne Änderungen auf den Arduino hoch. Nun ist der Arduino-ISP einsatzbereit.
Im nächsten Schritt stellen Sie noch einmal sicher, dass unter Werkzeuge -> Board: “Arduino/Genuino Uno” eingestellt und unter Werkzeuge -> Programmer: “Arduino as ISP” ausgewählt ist.
(Würden Sie stattdessen einen USB-ISP nutzen, müsste dieser hier entsprechend angewählt werden.)
Die Wahl des korrekten Boards ist sehr wichtig, da die Software daraus auf einen bestimmten Mikrocontroller-Typ schließt (in unserem Fall ATMEL ATmega328).
Für jeden Typ ist ein zugehöriger Standard-Bootloader hinterlegt.
Kommt es hier zu einer Verwechslung, wird womöglich der falsche Bootloader genutzt und der Chip könnte dauerhaft unbrauchbar werden.


Prüfen Sie die korrekten Einstellungen für “Board” und “Programmer”.

Sind alle Einstellungen korrekt, kann über Werkzeuge -> Bootloader brennen der Vorgang gestartet werden.
Die Wortwahl “brennen” hat sich eingebürgert, weil der Bootloader bei älteren Mikrocontrollern nach einmaligem Schreiben nicht mehr geändert werden konnte, er war also quasi “eingebrannt”.
Auch heute wird er meist während der gesamten Lebensdauer eines Mikrocontrollers nicht mehr geändert, obwohl es rein technisch möglich ist.

Nun ist der neue Mikrocontroller einsatzbereit. Wenn Sie möchten, können Sie direkt den ersten Sketch hochladen.
Nutzen Sie dazu allerdings nicht die normale Hochladen-Funktion, sonst landet das Programm auf dem Hilfs-Arduino, welchen wir als ISP genutzt haben.
Klicken Sie stattdessen auf Sketch -> Hochladen mit Programmer, um der Arduino IDE mitzuteilen, dass sie den ISP nutzen soll, um das Programm zu übertragen.


Das Hochladen muss bei der aktuellen Verbindung via Arduino-ISP über diesen Menübefehl erfolgen.

Da der Bootloader nun aufgespielt ist, können wir unseren minimal-Arduino künftig auch wie üblich über die serielle Verbindung mit einem neuen Sketch bespielen.
Auch dazu sind spezielle USB-Adapter erhältlich.
Es gibt aber auch wieder einen Weg ohne Adapter, indem der USB-zu-seriell-Wandler eines Arduino-Boards genutzt wird.
Dafür muss allerdings der ATmega328 des entsprechenden Boards komplett entfernt werden, die Fassung muss leer bleiben – sonst fühlt sich dieser Chip ebenfalls angesprochen und reagiert.


Das Arduino-Board kann als USB-zu-seriell-Wandler verwendet werden, wenn der Mikrocontroller entfernt wurde.

Nun können beliebige Programme auf unseren “alleinstehenden” Mikrocontroller geladen werden.
Danach führt er das gewünschte Programm aus, ohne dafür ein Arduino-Board zu benötigen.
Die Ein- und Ausgabepins können ohne Einschränkungen genauso genutzt werden wie bei einem originalen Arduino UNO.


















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









Comments