Einfach ARDUINO‎ > ‎

ARDUINOtoBreadBoard

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

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                            Wels, am 2019-05-10

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_arduino.uno.r3-einfach.arduino-arduinotobreadboard (xx Seiten)_1a.pdf

Das einfachste un billigste war für mich ARDUINO UNO mit Kabel um € 4,99

Der Experte für Mikroelektronik


Kostenlose E-Books
https://www.az-delivery.de/collections/kostenlose-e-books?ls=de
https://bibliothek.az-delivery.de/wp-content/uploads/2018/01/9-AZ-Delivery_UNO-R3_Startertutorial.pdf
https://www.az-delivery.de/collections/arduino-kompatible-boards/products/uno-r3?ls=de



Mikrocontroller-Programmierung mit dem gewissen Dreh

https://www.heise.de/ct/artikel/Shake-rattle-n-roll-292164.html





Ways to Use Arduino as USB to TTL Converter

Wie verwende ich einen Arduino Uno als FTDI-Programmierer
Verwenden Sie einen Arduino als FTDI-Programmierer
ARDUINO-Beispiel #2

Use an Arduino as an FTDI programmer
Arduino Examples #2 Use an Arduino As a FTDI Programmer



Arduino-Beispiele # 2 Verwenden Sie einen Arduino als FTDI-Programmierer


In dieser Anleitung zeige ich Ihnen, wie Sie mit einem Arduino Uno, Duemilanove, Diecimila, Mega 2560, Mega 1280 oder Nano ein Arduino Pro, Pro Mini, Mini, LilyPad oder ein anderes Gerät mit einem ATmaga168, ATmaga328 mit einem Arduino programmieren.
Dies funktioniert jedoch nur auf 5V Karten, NICHT auf 3,3V Karten.
Wenn Sie Fragen, Kommentare oder Vorschläge für andere Arduino-Beispiele haben, können Sie gerne einen Kommentar hinterlassen.
Ich werde mich so schnell wie möglich bei Ihnen melden.

Schritt 1: Holen Sie sich die erforderliche Hardware

Hardware erforderlich
1x Arduino UNO
1x 6-polige Buchsenleiste
6x  Überbrückungsdrähte Dm 0,64mm

Schritt 2: Verdrahten des ARDUINO 5V Boards.
Entfernen Sie zuerst den Mikrocontroller ATmega328P  von der Karte, die Sie nicht programmieren möchten, da Sie sonst beide Mikrocontroller programmieren.
Verbinden Sie als Nächstes die Überbrückungskabel zwischen dem Arduino und dem Header wie auf dem Foto unten gezeigt.
Fahren Sie dann mit dem nächsten Schritt fort, um den Arduino zu programmieren.


Aufgrund der verschiedenen Antworten und Bilder hier habe ich es gerade geschafft, ein (im Grunde genommen -Nano mit einem austauschbaren ATmega328) als Programmierschnittstelle für ein Gateway (v7.2) zu verwenden.

Der FTDI-Anschluss der Nanode ist bei vielen Arduinos verkehrt herum, wobei das Schwarze zur Platinenmitte und das Grüne zur Kante zeigt.

Ich habe die unter http://www.adafruit.com/datasheets/DS_TTL-232R_CABLES_V201.pdf veröffentlichte Farbcodierung nach dem FTDI-Standard verwendet.


               USB-serial TTL
USB-TTL-Kabel    TTL-232R-5V
   FTDI-Kabel          ATmega328P                   
Pin1 = GND sw       pin-8 und pin-22   GND
Pin2 = CTS  br       pin-8 und  pin-22  GND 
Pin3 = Vcc  rt         pin-7 und pin-20  und pin-21  +5V
Pin4 = TxD  or       pin-2  RxD
Pin5 = RxD  ge      pin-3  TxD
Pin6 = RTS  gn      über einen 100nF zu pin-1  RESET  ws


Nanode       ......  Arduino
------------------------------
Black, Pin1  ......  GND
Brown, Pin2  ......  GND
Red,   Pin3  ......  5V Vcc
Orange,Pin4  ......  RxD
Yellow,Pin5  ......  TxD
Green, Pin6  ......  über einen 0,1uF zu pin-1 = RESET

Some tips that I had a hard time working out:

  1. Der Nanode-Bootloader scheint sehr wählerisch in Bezug auf das Reset-Timing zu sein. Grün-> Reset ist ein Lebensretter!
  2. Sie müssen den RX / TX überqueren. RX auf Arduino geht an den FTDI-Header TX (Orange, Pin4), TX auf Arduino geht an den FTDI-Header RX (Gelb, Pin5)
  3. Sie müssen den atmega328 vom Arduino entfernen, sonst wird die Programmierung auf keinem der beiden Geräte gespeichert.
  4. Wählen Sie "Uno" als Karte, wenn "Nicht synchronisiert" -Fehler auftreten.


Schritt 3: Programmieren Sie den Arduino
Öffnen Sie nun mit Ihrem Computer die Arduino-Software.
Verbinden Sie dann Ihre 2 Arduino's miteinander und mit Ihrem Computer.
Gehen Sie dann zu Tools und wählen Sie die Karte aus, die Sie programmieren möchten.
Wenn Sie sie anschließend testen möchten, können Sie den gesamten Text zwischen // kopieren und einfügen.
Laden Sie dann das Programm auf Ihren Arduino hoch und die an Pin 13 angeschlossene LED sollte blinken.


void setup() {  // this sets the output pins

pinMode(13, OUTPUT); // Pin 13 has an LED connected on most Arduino boards:
}

void loop() {
digitalWrite(13, HIGH); // set the LED on
delay(1000); // wait for a second
digitalWrite(13, LOW); // set the LED off
delay(1000); // wait for a second
}


Wenn Sie Fragen, Kommentare oder Vorschläge für andere Arduino-Beispiele haben, können Sie gerne einen Kommentar hinterlassen.
Ich werde mich so schnell wie möglich bei Ihnen melden.

Quelle:
https://www.instructables.com/id/Arduino-Examples-2-Use-an-Arduino-as-a-FTDI-Progr/
https://stackoverflow.com/questions/18362942/how-to-use-an-arduino-uno-as-an-ftdi-programmer





Eigenbau Arduino
Bau eines Arduinos (Aufbauanleitung)

Arduino selber bauen

Barebone-Arduino

Arduino selber bauen mit USB TTL Converter

Arduino im Eigenbau

Selbstbau Arduino Uno

arduino mini selber bauen
arduino selber bauen schaltplan


Barebone-Arduino
https://fhp.incom.org/project/684




Arduino-Kurzeinführung
300_b_ARDUINO-x_Arduino-Kurzeinführung_1a.pdf

ORDNER Arduino-Kurzeinführung_1a.tgz
http://www.netzmafia.de/skripten/hardware/Arduino/

http://www.netzmafia.de/skripten/hardware/Arduino/Intro/index.html#portable
http://www.netzmafia.de/skripten/hardware/Arduino/Servo/index.html

                ARDUINO to BreadBoard

           ARDUINO UNO R3 selbstgebaut auf BreadBoard

How to build an Arduino Uno on a BreadBoard

http://www.instructables.com/id/How-to-Build-an-Arduino-Uno-on-a-BreadBoard/





ATmega328P-PU (DIL28)

Atmel ATmega328P-PU (DIP28) mit Arduino Bootloader € 3,81


ATmega328P mit geflashtem Bootloader
Atmel ATmega328P-PU mit Arduino Uno Bootloader geflasht.
  • Atmel ATmega328P-PU
  • Arduino Uno Bootloader mit Auto-Baudratenerkennung (Optiboot)
  • PDIP 28 Gehäuse
  • 32kb Flash
  • 2kb RAM
  • 1kb EEPROM

watterott.com/de/ATmega328-Arduino-Bootloader
https://www.watterott.com/de/ATmega328-Arduino-Bootloader





ARDUINO UNO R3 Schaltplan  

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





********************************************************I*

From Arduino to a Microcontroller on a BreadBoard

Von Arduino zu einem Mikrocontroller auf einem BreadBoard

Dieses Tutorial erklärt, wie die Migration von einem Arduino-Board zu einem eigenständigen Mikrocontroller auf einem Steckbrett.

Es ist ähnlich wie dieses Tutorial, aber verwendet ein Arduino-Board, um das ATmega328p auf dem Breadboard zu programmieren.


Building an Arduino on a Breadboard

https://www.arduino.cc/en/Main/Standalone



Wenn Sie die am Ende dieses Tutorials beschriebene minimale Konfiguration nicht verwenden, benötigen Sie vier Komponenten (neben dem Arduino, dem ATmega328p und dem Steckbrett):

            16MHz Quarz
           10k Widerstand
2Stk.  22pF  (keramische) Kondensatoren.




Brennen des Bootloaders

Wenn Sie ein neues ATmega328 (oder ATmega168) haben, müssen Sie den Bootloader darauf verbrennen.
Sie können dies mit einem Arduino-Board als in-System-Programm (ISP).

Wenn der Mikrocontroller bereits über den Bootloader verfügt (z. B. weil man ihn aus einem Arduino-Board entnommen hat oder ein bereits geladenes ATmega328p bestellt hat), können Sie diesen Abschnitt überspringen.

Gehen Sie folgendermaßen vor, um den Bootloader zu brennen:
Laden Sie die ArduinoISP-Skizze auf Ihr Arduino-Board. (Sie müssen die Karte und den seriellen Port im Menü Extras auswählen, das Ihrem Board entspricht.)
Verdrahten Sie das Arduino-Board und den Mikrocontroller wie in der Abbildung rechts dargestellt.
Wählen Sie "Arduino Duemilanove oder Nano w / ATmega328" aus dem Menü Extras> Karte. (Oder "ATmega328 auf einem Steckbrett (8MHz interne Uhr)", wenn die minimale Konfiguration unten beschrieben wird.)
Starten Sie Tools> Burn Bootloader> w / Arduino als ISP.

Sie sollten den Bootloader nur einmal brennen.
Nachdem Sie dies getan haben, können Sie die mit den pin-10, pin-11, pin-12 und pin-13 der Arduino-Platine verbundenen Jumperdrähte entfernen.


Mit einem Arduino-Board, um den Bootloader auf ein ATmega auf einem Steckbrett brennen.


ATmega328              ARDUINO UNO
5V       pin-7       auf           5V
GND    pin-8       auf          GND
SCK    pin-19     mit         SCK     Pin-13    (Clock mit Clock)
MISO  pin-18      mit         MISO  Pin-12
MOSI  pin-17      mit         MOSI  Pin-11
RST    pin-1        mit         SS     Pin-10




Hochladen mit einem Arduino-Board


Sobald Ihr ATmega328p über den Arduino-Bootloader verfügt, können Sie Programme mit dem USB-zu-seriellen Konverter (FTDI-Chip) auf einem Arduino-Board hochladen.
Zu entfernen, entfernen Sie den Mikrocontroller von der Arduino-Platine, so dass der FTDI-Chip kann mit dem Mikrocontroller auf dem Steckbrett statt zu sprechen.

Das Diagramm rechts zeigt, wie die RX- und TX-Leitungen vom Arduino-Board zum ATmega auf dem Steckbrett verbunden werden.

Um den Mikrocontroller zu programmieren, wählen Sie "Arduino Duemilanove oder Nano w / ATmega328" im Menü Extras> Karte (oder "ATmega328 auf einem Steckbrett (8MHz interne Uhr)", wenn Sie die unten beschriebene minimale Konfiguration verwenden).

Dann laden Sie wie gewohnt hoch.


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

ARDUINO UNO ohne IC          ATmega328P               
GND sw                              pin-8 und pin-22   GND
Vcc  rt                                pin-7 und pin-20  Vcc + AVcc
TxD  ge                              pin-3  TxD
RxD  gn                              pin-2  RxD   
RESET bl                            pin-1  Reset


Minimaler Schaltkreis (Eliminierung der externen Uhr)

Wenn Sie nicht über die zusätzlichen 16MHz Quarz und 22pF Kondensatoren verfügen, die in den obigen Beispielen verwendet werden,
können Sie den ATmega328p so konfigurieren, dass er seinen internen 8MHz RC-Oszillator als Taktquelle verwendet.

Sie brauchen nicht wirklich die 10k PullUp-Widerstand auf dem Reset-Pin entweder, so dass wir entfernen, um eine wirklich minimale Konfiguration zu erhalten.


Sie müssen die Unterstützung für eine zusätzliche Hardware-Konfiguration installieren:
1) Laden Sie dieses Hardware-Konfigurationsarchiv: 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-Skizzenbuch-Ordner
(dessen Position Sie im Dialogfeld "Arduino-Einstellungen" finden können).

Wenn Sie zuvor Unterstützung für zusätzliche Hardwarekonfiguration installiert haben, verfügen Sie möglicherweise bereits über einen "Hardware" -Ordner in Ihrem Skizzenbuch.
3) Verschieben Sie den Ordner "Broadboard" aus dem Zip-Archiv in den "Hardware" -Ordner Ihres Arduino-Skizzenbuchs.
4) Starten Sie die Arduino-Software neu.
5) Sie sollten sehen,  ATmega328p auf einem Steckbrett (8MHz interne Uhr)  in der Tools> Board-Menü.
Sobald Sie dies getan haben, können Sie den Bootloader brennen und Programme auf Ihren ATmega328p hochladen, wie oben beschrieben.
Achten Sie darauf, "ATmega328p auf einem Steckbrett zu wählen (8MHz interne Uhr)" beim Brennen des Bootloaders.
Wenn Sie das falsche Element auswählen und den Mikrocontroller so konfigurieren, dass er eine externe Uhr verwendet, funktioniert er erst, wenn Sie eine Verbindung herstellen.


ACHTUNG
Dieses Verfahren funktioniert auf Arduino 1.0.x Software.


Mit einem Arduino-Board, um den Bootloader auf ein ATmega328p auf einem Steckbrett (ohne externe Uhr) zu brennen.


ATmega328              ARDUINO UNO
5V       pin-7       auf           5V
GND    pin-8       auf          GND
SCK    pin-19     mit         SCK     Pin-13    (Clock mit Clock)
MISO  pin-18      mit         MISO  Pin-12
MOSI  pin-17      mit         MOSI  Pin-11
RST    pin-1        mit         SS      Pin-10






Hochladen von Skizzen zu einem ATmega auf einem Steckbrett.

ARDUINO UNO ohne IC          ATmega328P               
GND sw                              pin-8 und pin-22   GND
Vcc  rt                                pin-7 und pin-20  Vcc + AVcc
TxD  ge                              pin-3  TxD
RxD  gn                              pin-2  RxD   
RESET bl                            pin-1  Reset


Loswerden des Arduino Boards
Sobald Sie das ATmega auf dem Steckbrett programmiert haben, können Sie das Arduino entfernen.
Dazu müssen Sie eine alternative Stromversorgung für den Mikrocontroller bereitstellen.

Siehe die eigenständige Arduino auf einem BreadBoard Tutorial für Details.



Quelle:
https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard



Building an Arduino on a BreadBoard

Dieses Tutorial zeigt Ihnen, wie Sie ein Arduino-kompatibles Steckbrett mit einem Atmel Atmega8 / 168/328 AVR-Mikrocontroller und einem FTDI FT232-Breakout-Board von SparkFun bauen.
Sie können auch den Arduino USB Mini verwenden.



Teile für die Verdrahtung von Arduino
1x Steckbrett
10x  AWG Draht Dm 0,64mm
1x 7805 Spannungsregler
2x LED 5mm rt
2x 220R  Widerstände
1x 10k Ohm Widerstand
2x 10uF Kondensatoren
1x 16MHz Taktquarz
2x 22pF Kondensatoren
1x Mini-Taster

USB zu serieller Kommunikationskarte
Sie benötigen ein FT232 USB Breakout Board von  SparkFun.
Sie haben zwei Möglichkeiten:

FT232RL USB zu Seriell Breakout Board, SKU BOB-0071
Arduino Serielles USB-Board, SKU DEV-08165

Wenn Sie die Top-Option verwenden möchten und noch keine Header an das Breakout-Board gelötet haben, ist dies jetzt ein guter Zeitpunkt.
Booten Sie Ihre Atmega Chips

Es gibt verschiedene Möglichkeiten zum Booten Ihrer Atmega-Chips, von denen einige in diesem Tutorial behandelt werden.
Wenn Sie Ihre Atmega-Chips mit Ihrem Steckbrett booten möchten, erleichtert ein zusätzliches Teil Ihr Leben erheblich, ist jedoch nicht erforderlich.
AVR-Programmieradapter von Sparkfun, BOB-08508





Quelle:
www.arduino.cc/en/Main/Standallone
https://www.arduino.cc/en/Main/Standalone
https://www.arduino.cc/en/Main/StandaloneAssembly





********************************************************I*

          iXduino - Arduino on a Breadboard

715_d_ARDUINO-x_ iXduino – Arduino on a Breadboard - DIY-ARDUINO auf einem BradBoard_1a.pdf


Im ersten Projekt geht es darum, ein eigenes DiY-Arduino-System ("iXduino") auf einem Breadboard zusammenzubauen.

Wegen des Preises lohnt es sich zwar nicht – kompatible Arduino Uno Boards gibt es bereits für wenige Euro bei eBay oder Amazon –, dafür macht es aber Spaß und vermittelt noch dazu wichtige Kenntnisse.

https://www.amazon.com/gp/product/B00BT0NDB8/ref=as_li_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=B00BT0NDB8&linkCode=as2&tag=notandvol0f-20&linkId=EU3S2VKEDHXKCKBA

Die Konstruktion eines eigenen Arduino-Klons ist nicht weiter schwierig, weil der Microcontroller ATmega328p als SoC (System on a Chip) die wichtigsten Features wie Arbeits- und Flash-Speicher sowie Ein- und Ausgänge bereits mitbringt.

https://www.amazon.com/gp/product/B007SH0D0A/ref=as_li_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=B007SH0D0A&linkCode=as2&tag=notandvol0f-20&linkId=TJHD576HH65GKDQH

Zum Aufbau eines Arduino-Boards fehlen nur noch Stromversorgung, USB-Eingang, Taktgeber, Platine/Steckbrett, ein paar LEDs, Widerstände, Kondensatoren, ein Reset-Taster, und natürlich Verbindungsdrähte.

Benötigt werden also diverse Bauteile, deren Kosten sich im Bereich von € 10..€ 15,- bewegen.

Es gibt auf eBay und Amazon fertige Bausätze für € 4 .. 10,- (ohne Breadboard, ohne Drähte und ohne FTDI-USB-Platine

– diese müssen Sie separat erwerben, beispielsweise hier:

http://tinyurl.com/arduinobausatz, oder hier: http://tinyurl.com/arduinobausatz2

https://www.amazon.com/gp/product/B007SH0D0A/ref=as_li_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=B007SH0D0A&linkCode=as2&tag=notandvol0f-20&linkId=TJHD576HH65GKDQH


Die meisten Bausätze liefern einen bereits programmierten ARDUINO ATmega328p  Prozessor aus,

sodass Sie sich das spätere Programmieren des Chips sparen können.

Teileliste

  • Mikrocontroller ATmega328P im 28-DIP Gehäuse
  • optional: DIL-28 Fassung, falls Sie den Mikrocontroller nicht direkt aufs Steckbrett stecken wollen
  • Breadboard (z.B. eines mit 840 Kontakten)
  • Mikrotaster als Reset-Knopf
  • 16MHz Quarz
  • 2 Stk. Keramikkondensatoren mit 22pF
  • LED 5mm low current 2,8V 4mA grün
  • LED 5mm low current 2,1V 2mA rot
  • Stabi-IC LM8705 (Spannungsregulator), um die USB-Spannung auf die benötigten 5,0Vdc für den ARDUINO zu transformieren
  • 2Stk Elektrolytkondensatoren mit je 10uF
  • 10k Ohm Widerstand
  • 2 Stk. 220R Ohm Widerstände
  • diverse Verbindungsdrähte Dm=0,64mm  (Jumper Wires)
  • FTDI-Platine für den USB-Anschluss (Stromversorgung, Datenübertragung)


Arduino on a Breadboard

http://www.notesandvolts.com/2012/12/fun-with-arduino-arduino-on-breadboard.html


Schaltbild für den eigenen ARDUINO UNO

http://www.notesandvolts.com/2012/12/fun-with-arduino-arduino-on-breadboard.html



9Vdc  Power Adapter - 500mA or greater (Wall Wart)
DC Power Socket (Dm= 2.1mm or sized to fit the plug of your power adapter)
          LM7805 - 5 Volt regulator
         1N4001 - rectifier diode
        100uF (Micro-Farad) electrolytic capacitor - rated at 25v or more
          10uF (Micro-Farad) electrolytic capacitor - rated at 25v or more
2 Stk. 22pF ceramic capacitors
ATmega328P microcontroller
16 MHz crystal
Verbindungskabel (22 Gauge - Solid = Dm 0,64mm)

(Optional)
1 - SPST Switch
1 - 220 Ohm resistor
1 - LED

Bauanleitung

Auf arduino.cc findet sich eine genaue Bauanleitung. Trotzdem möchte ich die Schritte kurz erläutern:

https://www.arduino.cc/en/Main/Standalone


Den Mikroprozessor setzen Sie mit der Kerbe nach oben auf das Steckbrett (alle ICs haben dort eine Markierung, wo sich der obere Teil des Bausteins befindet).
Die Zählung der Pins startet dann im Gegenuhrzeigersinn mit dem oberen linken Pin.
Die Versorgungsstränge des Steckbords links und rechts werden später über den Ausgang des Spannungsregulators versorgt und nicht (!!!) durch Batterie oder USB-Eingang.
An Pin09 und Pin10 des ATmega328p muss der 16MHz Quarz anliegen.
Um die Impulse zu glätten, verbinden Sie die beiden Elektroden (Pin09, Pin10) des Oszillators über je einen der 22pF Keramikkondensatoren mit Masse.
Pin-7 muss auf Versorgungsspannung (= Ausgangsspannung des Regulators), Pin-8 auf Masse liegen.
Pin22 liegt auf Masse, Pin20 und Pin21 auf Versorgungsspannung (= Ausgangsspannung des 7805 Stabi-IC).

Den Spannungsregulatoreingang (linker-Pin) verbinden Sie später mit der Versorgungsspannung aus der FTDI-Platine oder einer Batterie.
Die Mitte (= mittlerer-Pin) des Bausteins legen Sie auf Masse.
Die Masse der Eingangsspannung und die Masse der Ausgangsspannung sind daher mit dem mittleren-Pin des Spannungsregulators / Stabi-IC verbunden.
Sowohl zwischen Masse und Eingang als auch zwischen Masse und Ausgang (rechter-Pin des Spannungsreglers) platzieren Sie mit richtiger Polung je einen der Elektrolytkondensatoren.



Schaltungs-Draufsicht


An Pin19 des IC (=  ARDUINO pin-13) legen Sie über einen Verbindungsdraht einen 220 Ohm Widerstand und in Serie dazu die grüne LED.
Deren negativen Pol verbinden Sie mit Masse.
Das Ende des Verbindungsdraht vom Pin-19 sollte außerhalb des Bereichs liegen, wo sich der ATmega befindet.
Auf ARDUINO-Boards befindet sich immer eine LED, die am Digital pin-13 liegt.
Am Ausgang des Stabi-IC platzieren Sie einen weiteren 220 Ohm-Widerstand, danach in Serie die rote LED, die Sie mit Masse verbinden.
Leuchtet diese LED, wissen Sie, dass eine Stromversorgung anliegt.
Den Pin01 des ATmega328p  (=RESET-Eingang) legen Sie über einen 10k Ohm Widerstand an die Versorgungsspannung Ub=5V  (Ausgang des Spannungsregulators).
Dieser Widerstand dient als Pull-Up Widerstand, der ein versehentliches RESET durch Fluktuationen im Stromkreis verhindert.
Achtung:
der RESET-Eingang ist invertiert. Ein Reset erfolgt also bei 0V Spannung.

Zudem verbinden Sie den Pin01 mit einem Taster, dessen andere Verbindung geht auf Masse.
Dadurch können Sie den Prozessor gezielt reseten, indem Sie den Taster betätigen.
Nun verbinden Sie die Spannung des FTDI-Boards mit dem Eingang des Spannungsregulators und führen dessen GND-Ausgang auf das GND des Spannungsregulators.
Den RxD-Pin des FTDI-Boards verbinden Sie mit dem TxD Pin03 (hinein) des ATmega328p.
Den TxD-Pin des FTDI-Boards verbinden Sie mit dem RxD Pin02 (hinaus) des ATMega328p.

Nachdem Sie die Schaltung nochmals eingehend geprüft haben, verbinden Sie den USB-Eingang ihres Computers mit dem USB-Eingang des FTDI.

Oder legen Sie alternativ die Spannung einer Batterie an. Nun sollte die rote LED leuchten.

Oben sehen Sie das Bild des Schaltungsaufbaus ohne Spannungsversorgung.

Diese müsste oben rechts zum Spannungsregulator geführt werden, genau gesagt zum linken und mittleren Standbein.


Programmierung der Firmware
Dummerweise enthält ein "nackter" ATmega328 weder die benötigte Firmware noch einen geeigneten Bootloader.
Dazu könnte man einen Programmer kaufen oder den ATmega328p von einem anderen Arduino Board rausziehen und in der eigenen Schaltung platzieren.
Wenn Sie bereits ein Arduino-Uno-Board ihr Eigen nennen, lässt sich der ARDUINO Uno als Programmer nutzen.



ATmega328              ARDUINO UNO
5V       pin-7       auf           5V
GND    pin-8       auf          GND
SCK    pin-19     mit         SCK     Pin-13    (Clock mit Clock)
MISO  pin-18      mit         MISO  Pin-12
MOSI  pin-17      mit         MOSI  Pin-11
RST    pin-1        mit         SS      Pin-10



Arduino als Programmer
Verbinden Sie einfach pin-13 (SCK), pin-12 (MISO), pin-11 (MOSI) ihres Original-Arduino-Boards mit den Pin19 (SCK), Pin18 (MISO), Pin17 (MOSI) des ATmega328p.
Verwenden Sie die Versorgungsspannung des als Programmer verwendeten Original-Boards zur Speisung des DiY-Boards und verbinden Sie auch das GND des DiY-Boards mit dem des Programmers.
Verbinden Sie pin-10 (SS) des Programmerboards (= ARDUINO UNO Board)  mit dem Pin01 (Reset) des ATmega328p.
Der Programmer muss den RESET steuern, wenn der Programmiervorgang gestartet wird.
Laden Sie in der Arduino-IDE das Beispielprogramm ArduinoISP (Pulldown-Menü Examples) und lassen Sie es ablaufen.
Läuft alles gut, haben Sie die Firmware erfolgreich auf Ihrem eigenen DiY-Board installiert.


Den Bootloader brennen
Sie können zusätzlich auch noch den Bootloader in das neue Board einprogrammieren.
Das ist nur einmal nötig und empfiehlt sich.
Im Tools-Menü müssen Sie neben den Typ Ihres Original-Bords (Uno), MEGA ... auch den richtigen seriellen Port einstellen.
Als Programmer wählen Sie im Menü "Arduino as ISP".
Wählen Sie "Burn bootloader" im Tools-Menü.
Nun laden Sie über Examples/Basics das Blinkbeispiel.
Halten Sie die Hochstelltaste während Sie in der IDE den Run-Knopf drücken (einen gelb umrahmten Pfeil ).
Dadurch wird das Programm nicht auf Ihr Originalboard geladen, sondern auf Ihr DiY-Board ATmega328p.
Ist alles gut gegangen, müsste jetzt die grüne LED im Einsekundentakt blinken.


Sie haben einen eigenen ARDUINO UNO gebaut und erfolgreich getestet.
Sie könnten natürlich das Board um Steckbrücken erweitern, die dieselben physikalischen Anordungen haben wie ein ARDUINO UNO Board.
Dadurch ließen sich sogar Shields betreiben.
Es empfiehlt sich, ein wenig die Schaltung zu studieren, um mit der Funktionsweise Ihres selbstgebauten Arduino-Boards vertraut zu werden.
Und natürlich zu experimentieren.



Quelle:
https://www.heise.de/developer/artikel/Do-it-Yourself-Projekt-iXduino-Arduino-on-a-Breadboard-3198567.html




********************************************************I*
Bau eines Arduino (Aufbauanleitung) UNO Clone  (1A)
In diesem Video möchte ich zeigen, wie man sich selber aus einem ATmega328P-PU einen Arduino bauen kann.
Das ist die beste Erklärung auf deutsch, die ich bisher gesehen habe!
Hab schon ein paar AtMega328p in Schaltungen verbaut und immer den Kondensator am Reset-Pin vergessen.
Mit deiner Erklärung verstehe ich endlich wieso dieser Kondi so wichtig ist.
Am Ende hatte ich auch das Problem, dass ich keinen Arduino Uno Bootloader flashen konnte, sondern nur den des Arduino pro mini.



GND pin-8 mit  Masse verbinden
GND pin-22 mit Masse verbinden



Vcc   pin--7   mit +5V verbinden
AVcc pin-20  mit +5V verbinden  -  analogRead()
Aref  pin-21  nicht verbinden




Arduino AVR Boards (Uno, Mega, etc.)
DEFAULT: the default analog reference of 5 Volts (on 5V Arduino boards) or 3,3 Volts (on 3,3V Arduino boards)
INTERNAL: an built-in reference, equal to 1,1 volts on the ATmega168 or ATmega328P and 2,56 volts on the ATmega8 (not available on the Arduino Mega)
EXTERNAL: the voltage applied to the Aref pin-21 (0 to 5V only) is used as the reference.
htps://www.arduino.cc/en/reference/AnalogReference





100nF Entstorkondensator zwischen Aref und GND  direkt neben den pin-21 und pin-22 einstecken  - analogReference()


100nF Entstorkondensator zwischen Vcc und GND  direkt neben den pin-7 und pin-8 einstecken
100nF Entstorkondensator zwischen AVcc und GND  direkt neben den pin-20 und pin-22 einstecken



10k Ohm Widerstand vom RESET pin-1 zu Vcc pin-7 stecken



16MHz Quarz zwischen pin-9 und pin-10 direkt neben den pins einstecken  (oder Keramikresonator der hat die beiden Kondensatoren schon mit eingebaut)
1M Ohm Widerstand zwischen pin-9 und pin-10  einstecken damit der Quarz sauber schwingt
22pF Kondensator von pin-9 auf GND
22pF Kondensator von pin-10 auf GND


D-Register





B-Register


Auf PB6 & PB7  ist der Quarz angeschlossen




Analoges  C-Register


Auf PC6 ist RESET angeschlossen



Mit Bootloader selbst programmieren


Üblicherweise haben ATmega328P Chips keinen Bootloader schon installiert.

Daher Bootloader selbst flashen mit Hilfe eines vorhandenen ARDUINOS UNO R3 und des Scatches "ArduinoISP"
dieses Programm verwandelt den ARDUINO in einen Programmer



1) ARDUINO IDE öffnen MENUE File > Examples > 11 ArduinoISP > ArduinoISP

Diesen "ArduinoISP" Sketch auf den ARDUINO hochladen

2)  ATmega328P Chip auf BreadBord mit dem nun programmierten ARDUINO UNO Programmer verbinden.


ATmega328              ARDUINO UNO
5V       pin-7       auf           5V
GND    pin-8       auf          GND
SCK    pin-19     mit         SCK     Pin-13    (Clock mit Clock)
MISO  pin-18      mit         MISO  Pin-12
MOSI  pin-17      mit         MOSI  Pin-11
RST    pin-1        mit         SS     Pin-10




stehender ISP  neben dem  ATmega328P    (NICHT den liegenden  ISP1 für den USB-Controller ATmega16U2 neben den RESET-Taster)



3) ARDUINO iDE öffnen MENUE Tools > Board > Arduino  Genuino Uno   (geht nicht)
3) ARDUINO iDE öffnen MENUE Tools > Board > Arduino Pro mini          (geht)




4)  MENUE Tools > Push > COM3   (Port wo der ARDUINO Programmer angeschlossen wurde)




5)  MENUE Tools > Programmer > Arduino and ISP




6)  MENUE Tools > Burn Bootloader
Jetzt enthält der ATMEGA 328P (auf dem BreadBord) den Bootloader eines ARDUINO UNO


7) An pin-19 SCK  Pin-13  Kathode einer LED  Anode an GND (wenn LED in Sekundentakt blinkt ist alles OK)


8)   NICHT   MENUE Sketch > Upload Using Programmer > Blink  Blink Proramm ist am uC aber Bootloader ist weg)



DTR - Data Terminal Ready   (nur der RST  RESET-pin kann bis 12V aushalten - high voltage programming)




ATmega328P mit dem ARDUINO-Bootloader geflasht
Um den ATmega328P-PU Chip mit Bootloader über die serielle Schnittstelle zu programmieren benötigt man einen






                  ATmega328 Bootloader flashen

Manchmal kommt es vor, dass man sich - wie auch immer - den Bootloader des Arduino zerschießt.
Das geht ganz leicht, wenn man den Arduino wie ein ganz gewöhnliches Controllerboard behandelt und die Software nicht über die serielle Schnittstelle in den Flash-Speicher des Prozessors lädt, sondern direkt über den ISP-Anschluss (ISP: (In System Programming).
Die meisten Arduino-Boards haben dafür auch einen eigenen Anschluss, eine zweireihige Stiftleiste mit sechs Pins.
Der Arduino UNO besitzt sogar zwei ISP-Anschlüsse, einen für den eigentlichen Arduino ISP  und einen für den USB-zu-seriell-Konverter ISP1 neben den RESET-Taster.



Der ISP-Port ist bei allen Arduinos gleich belegt.
Die folgende Tabelle zeigt die Zuordnung der Anschlüsse. In der mittleren Spalte stehen die Pins des ISP-Ports, links die Leitungen des Programmers (Arduino oder AVR-Programmer) und rechts die Anschlüsse am zu flashenden Controller.

ISP-Port (6-pin) stehend neben dem ATmega328P

                                                                          stehend rechts   liegend links oben
Arduino as ISP AVR Programmer ISP Header  ATmega328       ATmega32U4
D12 (MISO)        MISO                   Pin-1             D12 (pin-18)       D14
Vcc / 5V            5V                       Pin-2             Vcc (pin-7)        Vcc
D13 (SCK)         SCK                     Pin-3             D13 (pin-19)       D15
D11 (MOSI)        MOSI                   Pin-4             D11 (pin-17)        D16
D10 (Reset)       RESET                 Pin-5            Reset (Pin-1)      RST
GND                 GND                    Pin-6             GND (Pin-8)       GND

Anmerkung:
Falls nicht wie unten beschrieben ein Arduino UNO als Programmierer verwendet wird, sondern der ISP Header eines anderen Systems als Programmierer dient, ist zu beachten, dass der RST-Anschluss immer vom Output D10 (Reset) genommen werden muss.
RST am ISP Header ist die Reset-Leitung des als Programmier dienenden Controllers, während D10 die Restleitung des zu programmierenden Controllers ist.


Bootloader auf einen ARDUINO UNO R3 oder ARDUNO NANO brennen
Um einen neue Bootloader auf einen Arduino zu brennen, wird beispielsweise der Arduino UNO als ISP verwendet. Zum Programmieren des Bootloaders sind folgende Schritte notwendig:

Schritt 1: Den UNO zum ISP-Programmer umfunktionieren
Dazu wird zunächst der UNO mit dem PC verbunden und mit der Programmer-Software geladen. In der Arduino-IDE finden Sie das entsprechende Programm unter Datei → Beispiele → ArduinoISP.
Dieses wird in die IDE geladen. Falls nicht schon geschehen, unter Werkzeuge → Board → Arduino UNO den UNO als aktuelles System festlegen und die richtige COM-Schnittstelle wählen (Werkzeuge → Port → COMxx. Dann das Programm compilieren und in den UNO laden.

Schritt 2: Anschluß des zu flashenden Arduino
Das kann jeder Arduino mit einem ISP-Anschluss sein. Als Beispiel soll hier ein Arduino NANO dienen. Stecken Sie die UNO vom PC ab (stromlos machen) und verbinden Sie den ISP-Port des NANO mit den entsprechenden Pins des UNO gemäß der Tabelle oben.

Also:
D12 (MISO) des ARDUINO UNO  →  Pin 1 des ARDUINO NANO
+5V des UNO  →  Pin 2 des NANO
D13 des UNO  →  Pin 3 des NANO
D11 (MOSI) des ARDUINO UNO → Pin 4 desARDUINO  NANO
D10 des UNO  →  Pin 5 des NANO
GND des UNO  →  Pin 6 des NANO

Für die Verbindung der beiden Board eignen sich die Experimentierlitzen mit Stecker an einem und Buchse am anderen Ende.

Schritt 3: Bootloader programmieren
Stecken Sie den UNO wieder am PC an. Das "ArduinoISP"-Programm ist ja noch gespeichert und startet.
Nun wählen Sie den zu flashenden NANO unter Werkzeuge → Board → Arduino NANO aus und überprüfen Sie, ob die Einstellung des seriellen Ports noch stimmt.
Stellen Sie unter Werkzeuge → Programmer → Ardunino as ISP ein.
Nun starten Sie das Brennen des Bootloaders mittels Werkzeuge → Board → Bootloader brennen.
Machen Sie den UNO wieder stromlos und entfernen Sie die Verbindungen zum NANO.



Bootloader auf einen ATmega328P-PU brennen
Ab und zu verwende ich den Arduino zum Programmieren, aber andere Hardware für das fertige Projekt.
Oft lohnt sich die Anfertigung einer Platine nicht, weil sich nur einige wenige Bauteile rund um den ATMEGA328P tummeln.
Also wird die Schaltung auf einer Lochrasterplatte aufgebaut und der Controller dann aus der DIL-Fassung des Arduino gezogen und in die DIL-Fassung auf der Lochrasterplatte gesteckt. Also wird öfter mal ein ATMEGA328P (genauer ATMEGA328P-PU) mit Bootloader als Ersatz benötigt (manchmal auch, wenn der ATMEGA328P in der Schaltung "gegrillt" wurde).
Hier kann man fast genauso verfahren, wie oben - lediglich der zweite Schritt ist unterschiedlich.

Schritt 1: Den ARDUINO UNO R3 zum ISP-Programmer umfunktionieren
Dazu wird zunächst der UNO mit dem PC verbunden und mit der Programmer-Software geladen.
In der Arduino-IDE finden Sie das entsprechende Programm unter Datei > Beispiele > ArduinoISP.
Dieses wird in die IDE geladen. Falls nicht schon geschehen, unter Werkzeuge > Board > Arduino UNO den UNO als aktuelles System festlegen und die richtige COM-Schnittstelle wählen (Werkzeuge > Port > COMxx.
Dann das Programm compilieren und in den UNO laden.

Schritt 2: ATMEGA328P auf dem Steckbrett vorbereiten
Diesmal wird das Steckbrett mit dem ATMEGA328P bestückt.
Die Pinbelegung des Dual-Inline-Gehäuses zeigt die folgende Grafik.



Neben den ISP-Leitungen werden noch der Quarz mit seinen beiden Kondensatoren und ein Pullup-Widerstad für den Reset-Eingang benötigt.
Die Schaltung des Quarzes ist recht einfach, der Quarz wird zwischen den Pins 9 und 10 angeschlossen, die Kondensatoren sind gegen Masse geschaltet.

1M Ohm Wiederstand muß nicht sein !



Man kann den Controller noch einen 100-nF-Kondensator an der Spannungsversorgung (Pin 7 und Pin 8) gönnen.
Des weiteren wird ein 10-kΩ-Widerstand zwischen Reset (Pin 1) und +5V gelegt. Ihr Steckbrett sollte dan etwa so aussehen:


Nun werden noch die sechs ISP Leitungen vom UNO zum Steckbrett gezogen:


ARDUINO UNO R3   +5V  → ATmega328 pin-7
ARDUINO UNO R3   GND → ATmega328 pin-8
ARDUINO UNO R3  10     → ATmega328 pin-1   Reset
ARDUINO UNO R3  11     → ATmega328 pin-17 MOSI
ARDUINO UNO R3  12     → ATmega328 pin-18 MISO
ARDUINO UNO R3  13     → ATmega328 pin-19 SCK

ODER

ATmega328              ARDUINO UNO R3
5V       pin-7       auf           5V
GND    pin-8       auf          GND
SCK    pin-19     mit         SCK     Pin-13    (Clock mit Clock)
MISO  pin-18      mit         MISO  Pin-12
MOSI  pin-17      mit         MOSI  Pin-11
RST    pin-1        mit         SS     Pin-10

ODER

ARDUINO UNO-Pin            ATrnege328P
   SS         Pin-10               pin-1   RST
   MOSI     Pin-11               pin-17  MOSI
   MISO     Pin-12               pin-18  MISO
   SCK      Pin-13               pin-19  SCK  (eingebaute LED)
   +5V      Pin-Vcc+AVcc    pin-7+20  (Vcc+AVcc)  
   GND    pin-GND+GND     pin-8+22  (GND+GND) 





Wer es ganz komfortabel haben möchte, platziert noch eine LED mit Vorwiderstand (ca. 1k Ohm) auf dem Steckbrett, wobei der Widerstand an Pin-19 des ATMEGA angeschlossen wird.
Die andere Seite des Widerstandes kommt an die Anode der LED (langes Bein) und die Kathode der LED (kurzes Bein) wird mit GND verbunden.
Dann hat man eine Funktionsanzeige.


Schritt 3: Bootloader programmieren
Stecken Sie den UNO wieder am PC an. Das "ArduinoISP"-Programm ist ja noch gespeichert und startet.
Nun wählen Sie diesmal den zu flashenden ATMEGA unter Werkzeuge > Board > Arduino UNO aus und überprüfen Sie, ob die Einstellung des seriellen Ports noch stimmt. Stellen Sie unter Werkzeuge → Programmer → Ardunino as ISP ein.
Nun starten Sie das Brennen des Bootloaders mittels Werkzeuge > Board > Bootloader brennen.
Machen Sie den ARDUINO UNO R3 wieder stromlos und entfernen Sie die Verbindungen zum ATmega328P.


Quelle:
http://www.netzmafia.de/skripten/hardware/Arduino/Bootloader_Flashen/



Microcontroller flashen: Arduino Uno als In-System-Programmer

Atmega programmieren :: Meine Arduino-Projekte

Einen fabrikneuen ATmega328P mit Bootloader für Arduino Uno

Atmega328 auf Breadboard flashen mit Arduino UNO R3 - Arduino Forum

Arduino ATMEGA328 Bootloader flashen - Netzmafia

Arduino-Bootloader auf Atmega328 flashen - Mikrocontroller.net

Arduino: Bootloader neu flashen - so geht's - CHIP





FTDI-USB-Seriell-Wandler (FTDI-Treiber mit Treibersoftware)
FTDI USB Driver  -  FTDI USB Serial Driver 
entweder mit
1) USB-Serial Cable (FTDI-Kabel)  5V FTDI-Programmierkabel = USB-Programmierkabel
ODER mit
2) USB-Serial-Breakout-Board (FTDI-Leiterplatten-Modul)

BUCH: Arduino Praxiseinstieg Seite 444 Abb. 10.1 und Stückliste

https://www.dell.com/support/home/at/de/atbsdt1/drivers/driversdetails?driverid=r5k9d

FTDI Adapter FT232RL USB zu TTL Serial 5V für Arduino
FTDI Adapter FT232RL USB zu TTL Serial für 3,3V und 5V für Arduino PRO Mini


5V FTDI Basic von SparkFun mit IC-FT232Rl
SparkFun FTDI Basic Breakout - 5V     DEV-09716
watterott.com/de/FTDI-Basic-Breakout-5V
https://www.sparkfun.com/products/9716
https://www.watterott.com/index.php?page=product&info=429&x7633b=4d41bd68d0942bafbe8f3955e7fde117

SparkFun FTDI Basic breakout Board  5V

FT232RL FTDI USB zu TTL Seriell Konverter Adapter Modul für Arduino
FTDI Adapter FT232RL USB zu TTL Serial 5V für Arduino

                                           mit FTDI-Chip - USB to Serial-Chip


1k Widerstand von 328-pin-8-GND zu FTDI-DTR
100nF Kondensator von 328-pin-1-RESET zu FTDI-DTR

FTDI-RX zu 328-pin-3-TX
FTDI-TX zu 328-pin-2-RX
FTDI Vcc zu 328 5V
FTDI GND zu 328 0V



Mit diesem Arduino-Shield kann man ATmega328P-PU Chip mit Programmen bespielen.
Dieses Shield wird auf ein ARDUINO UNO R3  gesteckt.

XTAL1 ABRACON CRYSTAL 16.0000MHz 18pF SMD     https://abracon.com/Resonators/abls.pdf
U1 IC ATMEL AVR-microcontroller  ATmega328P-PU
https://aisler.net/EdgarFrog/playground/bootloadershield-platine




FTDI Adapter FT232RL USB zu TTL Serial für 3,3V und 5V mit gratis eBook!



9)  Mit einem FTDI breakout Board einen ARDUINP Pro mini programmieren



Links:
AtMega328 Datenblatt: http://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061A.pdf  
Der keramikresonator des UNO's: https://www.murata.com/~/media/webrenewal/support/library/catalog/products/timingdevice/ceralock/p17e.ashx   ..
Wikipedia - RS232: https://de.wikipedia.org/wiki/RS-232
Arduino-Shield:  https://aisler.net/EdgarFrog/playground/bootloadershield-platine


https://www.youtube.com/watch?v=slezReZBRsE   (1A)




********************************************************I*
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 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.






ATmega328P-PU    DIP-28

Bild 123. Die Anschlüsse des ATmega328P-PU 28-DIP
                                  (NICHT ATmega328P-AU   SMD)





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..



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).


ATmega328              ARDUINO UNO
5V       pin-7       auf           5V
GND    pin-8       auf          GND
SCK    pin-19     mit         SCK     Pin-13    (Clock mit Clock)
MISO  pin-18      mit         MISO  Pin-12
MOSI  pin-17      mit         MOSI  Pin-11
RST    pin-1        mit         SS       Pin-10



ARDUINO UNO-Pin            ATrnege328P
   SS         Pin-10               pin-1   RST
   MOSI     Pin-11               pin-17  MOSI
   MISO     Pin-12               pin-18  MISO
   SCK      Pin-13               pin-19  SCK  (eingebaute LED)
   +5V      Pin-Vcc+AVcc    pin-7+20+21  (Vcc+AVcc+Aref)  
   GND    pin-GND+GND     pin-8+22  (GND+GND) 

Tabelle 41. Kopplung von Arduino und ATmega328P.


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



Foto fehlt
Bild 125. Aufbau auf einem Steckbrett.




Im Download finden Sie die OptiLoader-Dateien.77)
77) 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).

Software-Arduino entdecken
software_arduino_entdecken.zip
7.10.3 \flashLEDadjust.ino
          \optiLoader.h
          \optiLoader.pde   (heute *.ino)   Bootloader

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.


Bild optiLoader und COM5  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 0FF!

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 Arduino 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. S
ie 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
RST                          pin-1            Reset
0                                    2            Rx / digital
Pin-1                              3            Tx / digital

Pin-2                             4            digital
3                                    5            digital
4                                    6            digital
+5V              pin-7 und pin-20      Vcc (+5V)    Achtung: Beide Pins müssen angeschlossen werden!
GND             pin-8 und pin-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-13 / digital
Aref                        pin-21           Aref
A0                                23           analog
Al                                 24           analog
A2                                25           analog
A3                                26           analog
A4                                27           analog
Pin-A5                   pin-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.
pin-7 / pin-20 bedeutet, dass immer beide Pins (also pin-7 und pin-20) angeschlossen sein müssen.
Das gleiche gilt natürlich für pin-8 / pin-22.




Bild 127. Die Basisschaltung des ATmega328P


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



BreadBoard Schaltungs 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.



Bild 129. Stabilisierte 5-Volt-Versorgung.


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.78)
78) 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.
/usb-ttl-interface-cable-5V
https://www.ftdichip.com/Products/Cables/USBTTLSerial.htm

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,1-pF-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.


   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET


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


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

Achten Sie darauf, dass Sie die 5 Volt Version verwenden.

TTL-232R  TTL to USB Serial Converter Range of Cables
USB-TTL-Kabel
TTL232R  USB to TTL Serial Converter Cable
FTDI TTL-232R cable

USB cable with 6 way 0.1" pitch single inline connector with +5.0V signalling.    TTL-232R-5V   (6 way, 0.1" pitch single inline connector)
https://www.ftdichip.com/Support/Documents/DataSheets/Cables/DS_TTL-232R_CABLES.pdf
https://www.ftdichip.com/Products/Cables/USBTTLSerial.htm
https://www.digikey.at/product-detail/de/ftdi/TTL-232R-5V/768-1028-ND/2003493?utm_adgroup=Cable+Assemblies&mkwid=s&pcrid=291655443974&pkw=&pmt=&pdv=c&productid=2003493&slid=&gclid=EAIaIQobChMIza3CmemY4gIVRJSyCh1bhwfiEAQYAiABEgLOB_D_BwE
https://www.sparkfun.com/products/9718





USB-serial TTL
USB-TTL-Kabel    TTL-232R-5V

   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET




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-el 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-Seri-al 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,1 pF Kondensator und schließen eine gut stabilisierte Spannungsversorgung von +5Vdc an.
Der 10k Widerstand an pin-1 muss in der Schaltung verbleiben.







   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET


Bild 132. Die Schaltung des einstellbaren Blinklichts.

Drehen Sie am Potentiometer, um die Blinkfrequenz einzustellen.


BILD des BreadBoard mit USB-TTL-Kabel fehlt
Bild 133. Der Aufbau auf dem Steckbrett.


Quelle:
BUCH: Arduino entdecken  Seite 199






********************************************************I*
DIY Boards und Clones

10.1.1 Minimalschaltung Arduino
Abbildung 10.1 zeigt die Minimalschaltung des Arduino.
Der zentrale Baustein ist der Microcontroller (IC1) mit der Typenbezeichnung ATmega328.
Die Kondensatoren C2 und C3 und der Quarz (Q1) erzeugen den Takt für die Microcon-trollerschaltung.
Mit dem Widerstand R1, dem Kondensator C4 und dem Taster T1 ist eine Reset-Schaltung realisiert.
Über den Widerstand R1 ist der Reset-Anschluss des Microcontrollers (pin-1) mit HIGH verbunden.
Durch Druck auf den Taster wird der Reset-Anschluss mit 0V (LOW) verbunden und der Microcontroller wird zurückgesetzt.
Zusätzlich kann über den Kondensator C4 und den DTR-Anschluss des FTDI-Steckers von außen ein Reset erzeugt werden.

Der FTDI-Anschluss dient dabei als Schnittstelle zum angeschlossenen Rechner und liefert gleichzeitig die Spannungsversorgung.
Am FTDI-Anschluss muss ein so genannter USB-Seriell-Wandler angeschlossen werden.
Wie der Name aussagt, ist das das Bindeglied zwischen dem USB-Anschluss des Rechners und der seriellen Schnittstelle der Arduino-Schaltung.


Abb. 10.1: Minimalschaltung Arduino


   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET



Stückliste (Minimalschaltung Arduino):
Microcontroller ATmega328P  28-pol DIL mit Arduino Bootloader (IC1)
Quartz 16 MHz (Q1)
Widerstand 10k Ohm (R1)
2 Kondensator 22pF (C2, C3)
2 Kondensator 100nF (Ci, C4)
Reset-Taster (Si)
Stiftleiste 6-polig (Stecker FTDI)


10.1.2 Bare Bone Breadboard Arduino
Die Minimalschaltung mit den neun Komponenten aus dem vorherigen Abschnitt ist die Basis für den Bare Bone Breadboard Arduino, das Grundgerüst oder Grundschaltung eines Arduino-Boards auf dem Steckbrett.
Die Steckbrett-Variante eignet sich ideal für die Entwicklungsphase eines Projekts.
Die Schaltung ist schnell aufgebaut und kann durch die lötfreie Verbindungstechnik schnell verändert werden.
Für den Upload der Arduino-Sketches wird auch ein USB-Seriell-Wandler verwendet, der am 6-poligen FTDI-Stecker angeschlossen wird.

Abbildung 10.2 zeigt den Schaltungsaufbau auf dem Steckbrett.


Abb. 10.2: Breadboard Arduino


10.1.3 Really Bare Bone Board (RBBB)
Bauteile für Sensor-Anwendungen in Haus und Garten oder andere kleine Anwendungen, die mit Arduino realisiert werden, sind meist in einem festen und stabilen Gehäuse untergebracht.
Oftmals muss die Anwendung dabei so klein wie möglich sein, damit sie in das gewählte Gehäuse passt, oder der Anwender möchte eine kostengüstigere Arduino-Variante verwenden.
Die Steckbrettschaltung aus dem vorherigen Abschnitt ist zwar kostengünstig, aber für Anwendungen im produktiven Einsatz meist zu unstabil.


Alle Anforderungen, kleine Abmessungen, kostengünstig und ein stabiler Aufbau, bietet das Really Bare Bone Board (RBBB) von Modern Device (http://moderndevice.com).
Der RBBB ist als Minimalboard realisiert und hat sehr geringe Abmessungen.
Die schmale Leiterplatte ist 15mm breit und 80mm lang.



Abb. 10.3: Really Bare Bone Board (Bild: moderndevice.com)


Alle digitalen und analogen Ports des Arduino sind beim RBBB seitlich auf Stiftleisten geführt.
Das RBBB-Board kann so auch in ein Steckbrett oder eine Prototy-penplatine gesteckt oder gelötet werden.
Der 6-polige Anschluss für den FTDI-Stecker ist an der schmalen Seite positioniert und erlaubt ein einfaches Anschließen des Programmierkabels.
Für eigenständige Anwendungen kann eine Versorgungsspannung von einer Batterie oder einem Netzteil an der Jack-Buchse angeschlossen werden.
Bei der Auswahl eines RBBB als Arduino-Board ist immer zu beachten, dass diese Aufbauvariante mechanisch nicht kompatibel ist mit den Arduino Shields.
In der Praxis heißt das konkret, dass man, falls man Shields verwenden möchte, einen zusätzlichen Adapter verwenden muss.
Dieser Adapter, in Form einer Leiterplatte, verbindet die Anschlussstifte des RBBB mit dem Shield.
Einen passenden Adapter liefert Wicked Device:
http://wickeddevice.com/index.php?main_page=product_info&cPath=2&products id=86


10.1.4 Nanode
Das Nanode-Board (Network Application Node) ist ein weiterer erfolgreicher Arduino-Clone.
Der Nanode (http://nanode.eu) wurde von Entwicklern des London Hackspace (http://wiki.london.hackspace.org.uk/view/Project:Nanode) entwickelt
und hat denselben mechanischen Aufbau wie ein Standard-Arduino-Board. Zusätzlich besitzt das Nanode-Board, wie der Name aussagt, einen Netzanschluss in Form einer Ethernet Schnittstelle.
Nanode benötigt für die Verbindung zum Internet kein zusätzliches Ethernet Shield.
Die gesamte Funktionalität ist auf der Grundplatine aufgebaut und somit eignet sich Nanode ideal für webbasierte Arduino-Anwendungen wie
Sensor-Interface, Webdatenlogger, Wetterstation oder Twitter-Tools (Abbildung 104).




Abb. 10.4: Arduino-Clone mit Ethernet: Nanode

Das Projekt Nanode hat sich aus einer Idee für ein kostengünstiges Arduino-Board mit Webconnectivity zu einem preisgekrönten Projekt entwickelt.
Die Internet-Community hat das Projekt Nanode mit dem INTERNET OF THINGS AWARD 2011 in der Kategorie OPEN SOURCE PROJECT (http://postscapes.com/ best-iot-open-source-project-2011) ausgezeichnet.
Nanode hat dabei sogar das Quasi-Mutterprojekt ARDUINO übertrumpft.

Zwischenzeitlich ist das Nanode-Board bei verschiedenen Arduino-Produkte-Lieferanten im Angebot und es wurden bereits über 1.000 Boards verkauft.

Der Nanode ist Arduino-kompatibel und wird über einen USB-Seriell-Wandler mit dem Rechner verbunden.
Aus Kosten- und Platzgründen wurde die Ethernet-Schnittstelle nicht mit einem Wiznet-Controller, der auf den Standard-Ethernet Shields integriert ist, realisiert, sondern mit einem Ethernet-Controller vom Typ ENC28J60.
Diese unterschiedliche Hardware-Konfiguration hat zur Folge, dass die Standard-Ethernet-Library nicht verwendet werden kann.
Die Ethernet-Funktionalität wird mit der ETHERCARD-Library (https://github.com/jcw/ether-card) umgesetzt.
Neben dem klassischen Nanode-Board gibt es in der Zwischenzeit weitere Nanode-Varianten und Erweiterungen.
Dazu gehören der Nanode RF, ein Nanode mit integriertem RF-Modul für drahtlose Datenübertragung im 433MHz und 868MHz Bereich sowie Shields für drahtlose Datenübertragung.
Alle verfügbaren Modelle sind im Nanode-Shop aufgelistet (http://shop.nanode.eu).

Hinweis
Neben der genannten ETHERCARD-Library gibt es für den Ethernet-Controller ENC28J60 noch die ETHERSHIELD-Library.
Die Weiterentwicklung dieser Bibliothek wurde aber kürzlich vom Entwickler beendet.
In verschiedenen Anwendungen ist aber weiterhin diese Library im Einsatz.





10.2 Programmieradapter (USB-Wandler)
Die in diesem Kapitel beschriebenen Arduino Clones haben alle keine USB-Schnittstelle integriert.
Diese fehlende USB-Schnittstelle wird durch ein externes Modul, den so genannten USB-Seriell-Wandler, ergänzt.
Dieser Wandler ist das Bindeglied zwischen dem USB-Port des Rechners und dem seriellen Anschluss des Arduino-Microcontrollers.
Der USB-Seriell-Wandler wird rechnerseitig über ein USB-Kabel am USB-Port des Rechners angeschlossen.
Am Arduino-Board wird der Wandler an der 6-poligen Stiftleiste, meistens mit FTDI bezeichnet, angeschlossen.
Die Bezeichnung FTDI stammt vom Hardware-Hersteller, der den Logikbaustein herstellt, der auf dem USB-Seriell-Wandler die Signalumsetzung vornimmt.
Der USB-Seriell-Wandler ist in zwei Varianten verfügbar:
1. USB-Serial-Breakout-Board (kleines Leiterplatten-Modul, Abbildung 10.5)
2. USB-Serial Cable (FTDI-Kabel, Abbildung 10.6)
Das USB-Serial-Breakout-Board ist eine kleine Leiterplatte mit USB-Anschluss und der 6-poligen Buchsenleiste.



Abb. 10.5: USB-Seriell-Wandler an RBBB (Really Bare Bone Board)


Das USB-Serial- oder FTDI-Kabel besitzt auf der einen Seite einen USB-Stecker (Typ A) und auf der anderen Seite eine 6-polige Buchsenleiste.



RBBB Compatible with ARDUINO UNO

RBBB (Really Bare Bones Board)  -  Really Bare Bones Board (BBB) Kit

    2,1 mm 7V..9V Stromanschluss
    Optiboot Bootloader (Uno-Einstellung)
    ATmega328P-PU  Chip
    L4931CZ50-AP TO-92 Low-Dropout-Regler (300 mA)
300_b_ARDUINO-x_RBBB Really Bare Bones (Arduino) RBBB-Instructions_1a.pdf
Es ist eines der derzeit kleinsten und kostengünstigsten Arduino-kompatiblen Boards.


   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET



Abb. 10.6: RBBB mit FTDI-Kabel
http://community.medion.com/
https://www.arduino-board.com/boards/rbbb
https://moderndevice.com/product/rbbb-kit/




Beide Varianten des USB-Seriell-Wandlers sind bei vielen Anbietern von Arduino-Produkten erhältlich.

Hinweis
Beim Kauf eines USB-Seriell-Wandlers, Breakout-Boards oder Kabels, muss die Betriebsspannung beachtet werden.
Meist ist in der Beschreibung erwähnt, ob das Produkt für 3,3 V oder 5 V ausgelegt ist.
Bei einigen Produkten kann Betriebs- und Signalspannung mittels Steckverbinder oder Lötverbindung ausgewählt werden.

10.2.1 Anschlussbelegung FTDI
In Tabelle 10.1 sind die Anschlussbelegungen, die Bezeichnungen und die Kabelfarben aufgelistet.

Pin-Nr.    Kabelfarbe    Bezeichnung    Beschreibung
1             Schwarz         GND                   GND
2             Braun             CTS
                 GND
3             Rot                 Vcc                     +5,0V
4             Orange          TxD                   TX
5             Gelb               RXD                   RX
6             Grün              DTR                   Reset


ODER

   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET


Programming cable connections between a RBBB and a FTDI TTL-232R USB to TTL serial cable.

Tabelle 10.1: USB-Seriell-Wandler/FTDI-Kabel



Quelle:
BUCH: Arduino Praxiseinstieg   Seite 443






********************************************************I*
11  Gestatten, Familie Arduino!
In diesem Kapitel lernen Sie Folgendes:
•    Bau einer eigenen Arduino-Schaltung auf einer Steckplatine
•    Funktionsumfang und Vorteile der verschiedenen Arduino-kompatiblen Platinen
•    Open-Source-Hardware

Wir reduzieren hier den Arduino auf eine Handvoll Teile, die Sie auf einer Steckplatine anbringen.
Mit einer eigenen Arduino-Schaltung können Sie Geld sparen, vor allem wenn Sie viele neue Projekte und Prototypen in Angriff nehmen.
Außerdem erfahren Sie hier etwas über neue Bauteile und Schaltungen und lernen, wie Sie Sketche ohne zusätzliche Hardware auf Ihren Arduino Marke Eigenbau hochladen.
Am Ende sehen wir uns die am weitesten verbreiteten Alternativen zum Arduino Uno und die Unterschiede zwischen ihnen an.

Projekt Nr. 37: Einen eigenen Steckplatinen-Arduino bauen
Wenn Sie immer mehr oder immer kompliziertere Projekte und Experimente durchführen, können die Kosten für die Arduino-Platinen schnell ' aus dem Ruder laufen, vor allem sobald Sie an mehreren Basteleien gleichzeitig arbeiten.
Dann ist es billiger und einfacher, wie in diesem Projekt die Schaltung der Arduino-Platine auf einer Steckplatine nachzubauen und dann je nach vorliegender Aufgabe zu erweitern.
Die erforderlichen Teile für die Grundschaltung des Arduino kosten keine 10 €.
Dies ist auch die einfachere Vorgehensweise, wenn in einem Projekt viele externe Verbindungen benötigt werden, da Sie es sich dann sparen können, viele Drähte vom Arduino zur Steckplatine zu verlegen.

Die Hardware
Um eine minimalistische Version des Arduino zu bauen, benötigen Sie folgende Teile:
•    1x linearen Spannungsregler vom Typ LM7805
•    1x 16MHz Quarzoszillator (z.B. den Newark 16C8140)
•    1x ATmega328P-PU-Mikrocontroller mit geflashtem Arduino-Bootloader
•    1x 1uF Elko = Elektrolytkondensator für 25V (C1)
•    1x 100µF Elko   für 25 V (C2)
•    2x 22pF Keramikkondensatoren für 50 V (C3 und C4)
•    1x 100nF Keramikkondensator für 50 V (C5)
•    2x 560R Widerstände (R1 und R2)
•    1x 10k Widerstand (R3)
•    2x  LED 5mm rt und gn (LED1 und LED2)
•    1x Micro-Drucktaste (S1)
•    1x 6-er-Pfostenleiste
•    1x  Clip für 9-Volt Blockbatterie
•    1x  9-Volt Blockbatterie (PP3)
•    Verbindungsdrähte alle Grundfarben  Dm 0,64mm
•    1x BreadBoard = Steckplatine

Mit einigen dieser Teile sind Sie vielleicht noch nicht vertraut.
In den folgenden Abschnitten erklären wir die einzelnen Elemente und zeigen jeweils ein Beispielmodell und das Schaltplansymbol.

Linearer Spannungsregler 7805
Ein linearer Spannungsregler enthält eine einfache Schaltung, die eine Spannung in eine andere umwandelt.
Der in der Teileliste aufgeführte Regler 7805 konvertiert Spannungen zwischen 7V bis 30V in konstante 5,0V
mit einer Stromstärke von maximal 1,0 Amp, was für den Betrieb unseres Steckplatinen-Arduino ideal ist.
Abbildung 11-1 zeigt ein Beispiel des 7805 in der Bauform mit der Bezeichnung TO-220.

    1  2  3 
Abb. 11-1 Linearer Spannungsregler 7805

In Abbildung 11-2 sehen Sie das Schaltplansymbol für den 7805.
Wenn Sie das Bauteil aufrecht halten und auf seine beschriftete Seite blicken, dann ist der linke Kontakt für die Eingangsspannung 7,0 bis 30V zuständig, der rechte für den 5 Volt-Ausgang und der mittlere für den Masseanschluss GND.
Die Metalllasche am oberen Rand weist eine Bohrung auf, um den Regler mit einem größeren Metallstück zu verbinden, das als Wärmeableiter dient.
Wenn sich die Stromstärke dem Maximum von 1 A nähert, wird der 7805 ziemlich warm, weshalb wir unbedingt eine Möglichkeit brauchen, um diese Wärme abzuführen.
Auch die Lasche ist mit Masse Pin-2 verbunden.


Abb. 11-2 Das Schaltplansymbol für den 7805


16MHz Quarzoszillator
Ein Quarzoszillator ruft ein elektrisches Signal mit sehr genauer Frequenz hervor. Bei diesem Bauteil beträgt sie 16MHz.
Den Oszillator, den wir verwenden, sehen Sie in Abbildung 11-3.


Abb. 11-3 Quarzoszillator

Vergleichen Sie diese Abbildung mit dem Quarzoszillator auf einem Arduino.
Die beiden Bauteile sollten die gleiche Form und Größe aufweisen. Quarzoszillatoren sind nicht gepolt.
Das Schaltplansymbol sehen Sie in Abbildung 11-4.


Abb. 11-4 Das Schaltplansymbol für einen Quarzoszillator


Der Oszillator bestimmt die Arbeitsgeschwindigkeit des Mikrocontrollers.
Unser Mikrocontrollerschaltkreis läuft mit 16MHz, kann also 16 Millionen Prozessoranweisungen pro Sekunde verarbeiten.
Das sind jedoch keine 16 Millionen Zeilen oder Funktionen, da zur Interpretation einer einzigen Codezeile viele Prozessoranweisungen erforderlich sind.

Mikrocontroller-IC Atmel ATmega328P-PU
Ein Mikrocontroller ist ein winziger Computer, der einen Prozessor zur Verarbeitung von Anweisungen, verschiedene Arten von Arbeitsspeicher zum Festhalten von Daten und Anweisungen sowie Einrichtungen zum Senden und Empfangen von Daten enthält.
Wie bereits in Kapitel 2 erwähnt, stellt der Mikrocontroller das Gehirn des Arduino dar.
Was wir brauchen, ist der ATmega328P, den Sie in Abbildung 11-5 sehen.
pin-1  befindet sich unten links an dem IC und ist mit einem kleinen Punkt gekennzeichnet.

Abb. 11-5 Der ATmega328P-PU  28-DIL  28-DIP



Das Schaltplansymbol für den Mikrocontroller sehen Sie in Abbildung 11-6.


Abb. 11-6 Das Schaltplansymbol für einen Mikrocontroller

Nicht alle Mikrocontroller enthalten den Arduino-Bootloader, also das Programm, das die für den Arduino geschriebenen Sketche interpretieren kann.
Für einen Eigenbau-Arduino müssen Sie einen Mikrocontroller ATmega4328P-PU auswählen, der diesen Bootloader bereits enthält.
Zu erwerben gibt es sie im Allgemeinen bei den gleichen Händlern, die auch Arduino-Platinen verkaufen,
z.B. Adafruit, Freetronics und SparkFun.


Der Schaltplan


Abbildung 11-7a zeigt Ausschnitt aus den ORIGINAL-Schaltplan.

                                                                               Pin-RX

                                                              Pin-A5


   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET

Abb. 11-7b Schaltplan für den einfachen Steckplatinen-Arduino


Der Schaltplan besteht aus zwei Teilen. Links sehen Sie den Bereich der Stromversorgung, in dem die Spannung von 9V auf 5V verringert wird.
Außerdem befindet sich dort eine LED, die bei eingeschaltetem Strom leuchtet.
Der Abschnitt auf der rechten Seite besteht aus dem Mikrocontroller ATmega328P, der Reset-Taste, den Pins und einer weiteren LED.
Diese ist mit dem pin des ATmega328 verbunden, der als Arduino-Pin 13 dient.
Stellen Sie die Anschlüsse nach dem Schaltplan her.
Vergessen Sie dabei nicht die Verkabelung der 6er Pfostenleiste (siehe Abb. 11-8), die am unteren Rand des Schaltplans als eine Reihe aus sechs Kreisen dargestellt ist.
Diese Verbindung werden wir später verwenden, um einen Sketch auf unseren Eigenbau-Arduino hochzuladen.


Abb. 11-8 Sechser-Pfostenleiste  mit C5 = 100nF

Die Schaltung wird über eine handelsübliche 9 Volt Batterie mit passendem Clip mit Strom versorgt (siehe Abb. 11-9).
Schließen Sie den roten Draht des Batterieclips an Vcc = 5V an,  und den schwarzen an das Minus-Ende.

fehlt
Abb. 11-9 9-Volt-Batterie mit Clip


Die Arduino-Pins
Wo aber sind an unserem Eigenbau-Arduino die Pins geblieben?
Die analogen, digitalen und sonstigen Anschlüsse der normalen Arduino-Platine stehen uns auch bei unserer Steckplatinen-Version zur Verfügung, befinden sich aber direkt am Mikrocontroller.
Bei unserem Eigenbau-Arduino liegen der Widerstand R2 und die Leuchtdiode LED2 am Digitalpin 13.
Tabelle 11-1 stellt die Arduino-Pins und die entsprechenden Pins am ATmega328 gegenüber.

ARDUINO UNO Pin                       ATmega328 pin
Pin-Reset pin-1   Pin-A5       pin-28
Pin-RX/D0 pin-2   Pin-A4       pin-27
    TX/D1     3       A3           26
    D2        4       A2           25
    D3(pwm)   5       A1           24
    D4        6       A0           23
    Vcc       7      GND           22
   
GND       8     Aref           21
    X1(quarz) 9      Vcc           20
    X2
(quarz)10      D13      SCK  19
    D5
(pwm)  11      D12      MISO 18
    D6
(pwm)  12      D11(pwm) MOSI 17
    D7       13      D10
(pwm) SS   16
Pin-D8   pin-14   Pin-D9(pwm)  pin-15

Tab. 11-1 Pinbelegung des ATmega328P



Um Verwechslungen zu vermeiden, bieten Händler wie Adafruit und Freetronics auch Aufkleber mit einer Pinbeschriftung für den Mikrocontroller an
siehe Abb. 11-10; zu beziehen über
http://www.freetronics.com.au/mculabel/

Abb. 11-10 Aufkleber mit Pinbeschriftung


Einen Testsketch ausführen
Nun ist es an der Zeit, einen ersten Sketch hochzuladen.
Als Beispiel nehmen wir einen einfachen Sketch, der die LED blinken lässt:

// Projekt 37: Einen eigenen Steckplatinen-Arduino bauen

void setup()
{
pinMode(13, OUTPUT);
}


void loop()
{
    digitalWrite(13, HIGH);
   delay(1000);
   digitalWrite(13, LOW);
   delay(1000);
}

Zum Hochladen des Sketches haben Sie drei Möglichkeiten:





Austausch des Mikrocontrollers
Die preisgünstigste Möglichkeit, einen Sketch hochzuladen, besteht darin, den Mikrocontroller eines anderen Arduino auszubauen, an dessen Stelle den Mikrocontroller der Steckplatinenversion einzusetzen, den Sketch hoch-zuladen und die Controller dann abermals auszutauschen.
Um einen Mikrocontroller gefahrlos von einem Arduino zu lösen, verwenden Sie einen IC-Abzieher (siehe Abb. 11-11).


IC-Abzieher Foto fehlt
Abb. 11-11 Ausbau eines Mikrocontrollers mit einem IC-Abzieher

Achten Sie beim Ausbau des Mikrocontrollers darauf, langsam und gleichmäßig an beiden Enden zugleich zu ziehen.
Es kann ein bisschen schwierig sein, das Bauteil zu lösen, aber schließlich wird es sich von seinem Sockel entfernen lassen.

Wenn Sie den Mikrocontroller auf der Steckplatine oder einem Arduino einsetzen, müssen Sie möglicherweise die Anschlussstifte ein wenig biegen, sodass sie im rechten Winkel zum IC-Gehäuse stehen und glatt in die Öffnungen rutschen können.
Legen Sie das Bauteil dazu seitlich auf eine ebene Oberfläche und drücken Sie es leicht nach unten (siehe Abb. 11-12).
Wiederholen Sie den Vorgang dann für die andere Seite.



Beim Wiedereinbau des ursprünglichen Mikrocontrollers auf der Arduino-Platine müssen Sie darauf achten, dass das Ende mit der Einkerbung nach rechts zeigt, wie Sie in Abbildung 11-13 sehen.

FOTO fehlt
Abb. 11-12 Die Pins am Mikrocontroller zurechtbiegen  


FOTO fehlt
Abb. 11-13 Richtige Ausrichtung des Mikrocontrollers auf einem Arduino

Anschluss an eine handelsübliche Arduino-Platine
Über die USB-Schnittstelle eines Arduino Uno können Sie Sketche auf den Mikrocontroller des Steckplatinen-Arduino hochladen.
Diese Methode verringert die Abnutzung des Mikrocontroller-Sockels auf der Platine und kommt ohne das besondere USB-Kabel aus, das Sie für die dritte Methode brauchen.

Um einen Sketch hochzuladen, gehen Sie wie folgt vor:
1. Ziehen Sie den Mikrocontroller vom Arduino Uno ab und lösen Sie das USB-Kabel.
2. Unterbrechen Sie die Stromversorgung des Steckplatinen-Arduino.
3. Verbinden Sie Digitalpin 0 des Arduino mit Pin 2 des ATmega328P auf der Steckplatine sowie Digitalpin 1 mit Mikrocontroller-Pin 3.
4. Verbinden Sie den 5-Volt- und den GND-Anschluss des Uno mit den entsprechenden Stellen der Steckplatine.
5. Verbinden Sie den RST-Anschluss des Arduino mit Pin 1 des ATmega328P.
6. Schließen Sie das USB-Kabel wieder an den Arduino Uno an.
Jetzt verhält sich das System wie ein normaler Arduino Uno, sodass Sie Sketche auf die übliche Weise zum Mikrocontroller der Steckplatinenschaltung hochladen und bei Bedarf auch dem seriellen Monitor verwenden können.

Verwendung eines FTDI-Programmierkabels
Die letzte Methode ist die einfachste, doch dafür müssen Sie ein USB-Programmierkabel erwerben, das als FTDI-Kabel bezeichnet wird (weil die USB-Schaltung darin von einer Firma namens FTDI stammt).

Achten Sie darauf, dass Sie das 5-Volt Modell kaufen, da die 3,3-Volt-Version nicht ordnungsgemäß funktioniert.
Das Kabel weist an einer Seite einen USB-Stecker und auf der anderen einen sechsadrigen Anschluss auf. Das USB-Ende enthält eine Schaltung, die der USB-Schnittstelle am Arduino Uno entspricht.
Das andere wird mit der Pfostenleiste verbunden, die Sie in den Abbildungen 11-7 und 11-8 sehen.



Abb. 11-14 FTDI-Kabel

Achten Sie beim Einstecken des Kabels darauf, dass Sie die Seite mit dem schwarzen Draht mit dem GND-Pin der Pfostenleiste verbinden.
Wie bei einem normalen Arduino versorgt das Kabel die Schaltung auch mit Strom.

Bevor sie einen Sketch hochladen oder den seriellen Monitor verwenden, müssen Sie den Platinentyp in Arduino Duemilanove or Nano w/ ATmega328 ändern.
Rufen Sie dazu Tools > Board auf und wählen Sie die entsprechende Option aus (siehe Abb. 11-15).



Abb. 11-15 Den Platinentyp in der IDE ändern


Entscheiden Sie sich für eine Methode und laden Sie als Testlauf den Sketch für Projekt 37 hoch.
Jetzt können Sie auch kompliziertere Schaltungen einzig und allein auf der Steckplatine aufbauen, was mehr Projekte für weniger Geld ermöglicht.
Wenn Sie wissen, wie Sie eigene gedruckte Schaltungen herstellen, können Sie damit auch von Grund auf dauerhafte Projekte bauen.


Quelle:
BUCH: Arduino Workshops   Seite 229





  FTDI-Treiber - USB-Kabel - FTDIUSBSerialDriver
Damit die Arduino-Entwicklungsumgebung mit dem Board kommunizieren kann, müssen Sie Treiber installieren.
Unter Windows, verbinden Sie Ihren PC und das Arduino-Board über ein USB-Kabel und  warten, dass der »Neue Hardware«-Assistent erscheint.
Wenn Sie ein ARDUINO UNO R3 Board verwenden, lassen Sie den Assistenten versuchen, die Treiber zu suchen und installieren.
Der Versuch schlägt fehl (keine Sorge, das ist das erwartete Verhalten).
Um das zu beheben, wechseln Sie nun nach Startmenü-±Systemsteuerung—>System und Sicherheit. 
Klicken Sie auf  System und öffnen Sie den Gerätemanager.
In der dargestellten Liste wählen Sie dann den Eintrag in  COM und LPT namens Arduino UNO (COM nn). nn ist die Nummer, die Windows dem für das Board erzeugten Port zugewiesen hat.
Daneben sehen Sie eine Warnung, da die richtigen Treiber noch nicht zugewiesen wurden.
Klicken Sie den Eintrag mit der rechten Maustaste an und wählen Sie Treibersoftware aktualisieren.
Wählen Sie dann die Option »Brpwse my computer for driver software« und bewegen Sie sich in den Drivers-Ordner im eben entpackten Arduino-Ordner.
Wählen Sie die Datei Arduino-UNO.inf, und Windows sollte den Installationsprozess abschließen.
Wenn Sie ein älteres Board (das FTDI-Treiber verwendet) mit Windows Vista oder Windows 7 nutzen und online sind, können Sie den Assistenten nach Treibern suchen lassen, und sie sollten automatisch installiert werden.
Unter Windows XP (oder wenn Sie keinen Internetzugang haben) müssen Sie die Lage des Treibers angeben.
Bewegen Sie sich in der Dateiauswahl ins Verzeichnis FTDI USB Drivers.
Sie finden es in dem Verzeichnis, in dem Sie die Arduino-Dateien entpackt haben.
Sobald der Treiber installiert ist, erscheint wieder der »Neue Hardware«-Assistent mit der Meldung, eine neue serielle Schnittstelle sei gefunden worden.
Folgen Sie nun den Anweisungen von vorhin.

•    Es ist wichtig, dass Sie diese Schritte zur Installation des Treibers zweimal durchgehen, da die Software anderenfalls nicht mit dem Board kommunizieren kann.

Auf dem Mac sollten neuere Arduino-Boards wie das Uno ohne zusätzliche Treiber genutzt werden können.
Wenn' Sie das Board zum ersten Mal anschließen, erscheint ein Hinweis, dass eine neue Netzwerkschnittstelle gefunden wurde.
Bei älteren Boards (die FTDI-Treiber benötigen), müssen Sie Treibersoftware installieren.
Im Disk-Image finden Sie ein Paket namens FTDIUSBSerialDriver mit einer Reihe von Zahlen dahinter.
Klicken Sie das Paket an und der Installer führt Sie durch den Prozess. Sie müssen das Administrationspasswort kennen, um den Vorgang abschließen zu können.
Unter Linux ist der Treiber bei den meisten Distributionen bereits installiert. Informationen zu Ihrer Distribution finden Sie unter dem Linux-Link, der in der Kapiteleinführung genannt wurde.




Serielle Hardware
Die serielle Hardware sendet und empfängt Daten in Form elektrischer Impulse, die eine sequentielle Folge von Bits darstellen.
Die Nullen und Einsen, die die Informationen enthalten, aus denen ein Byte besteht, können auf verschiedene Art repräsentiert werden.
Das von Arduino verwendete Schema ist 0 Volt für den Bitwert 0 und 5,0V (oder 3,3V)  für den bitwert 1.

Die Verwendung von 0 Volt (für 0) und 5 Volt (für 1) ist weit verbreitet.
Man spricht hier vom TTL-Level (Pegel), weil Signale in einer der ersten Implementierungen digitaler Logik, der sog. Transistor-Transistor Logik (TTL), in dieser Form repräsentiert wurden.

Boards wie das Uno, Duemilanove, Diecimila, Nano und Mega besitzen einen Chip, der den seriellen Hardware-Part des Arduino-Chips in Universal Serial Bus (USB) umwandelt, um die Verbindung mit dem seriellen Port herzustellen.
Andere Boards wie das Mini, Pro, Pro Mini, Boarduino, Sanguino und Modern Device Bare Bones Board unterstützen USB nicht und benötigen für die Verbindung zum Computer einen Adapter, der TTL in USB umwandelt.
Weitere Details zu diesen Boards finden Sie unter http://www.arduino.cc/en/ Main/Hardware

Einige beliebte USB-Adapter sind:
•    Mini USB Adapter                     (http://arduino.cc/en/Main/MiniUSB)
•    USB Serial Light Adapter           (http://arduino.cc/en/Main/USBSerial)
•    FTDI USB TTL Adapter             (http://www.ftdichip.com/Products/FT232R.htm)
•    Modern Device USB BUB-Board (http://shop.moderndevice.com/products/usb-bub)
•    Seeedstudio UartSBee              (http://www.seeedstudio.com/depot/uartsbee-v31-p-688.html)


Einige serielle Geräte verwenden den RS-232-Standard für die serielle Verbindung.
Sie haben üblicherweise einen Neun-Pin-Stecker, und ein Adapter wird benötigt, um sie mit dem Arduino verwenden zu können.
RS-232 ist ein altehrwürdiges Kommunikationsprotokoll, dessen Spannungspegel mit den Digitalpins des Arduino nicht kompatibel sind.

Sie können Arduino-Boards kaufen, die für die RS-232-Signalpegel gebaut sind, etwa das Freeduino Serial v2.0
http://www.nkcelectronics.com/freeduino-serial-v20-board-kit-ar-duino-diecimila-compatib20.html

Hier einige RS-232-Adapter, die RS-232-Signale mit den 5 (oder 3,3) Volt der Arduino-Pins verbinden:
•    RS-232 nach TTL 3V-5.5V Adapter          (http://www.nkcelectronics.comIrs232-to-ttl-converter-board-33v232335.html)
•    P4 RS232 nach TTL Serial Adapter Kits   (http://shop.moderndevice.com/products/p4)
•    RS232 Shifter SMD                              (http://www.sparkfun.com/commerce/product_info.php?products_ id=449)


Ein Standard-Arduino verfügt über einen einzigen seriellen Hardware-Port, doch die serielle Kommunikation ist auch über Software-Bibliotheken möglich, die zusätzliche Ports (Kommunikationskanäle) emulieren, um mehr als ein Gerät anschließen zu können. Serielle Software-Parts benötigen sehr viel Hilfe vom Arduino-Controller, um Daten senden und empfangen zu können, weshalb sie nicht so schnell und effizient sind wie serielle Hardware-Ports.

Das Arduino Mega besitzt vier serielle Hardware-Ports, die mit bis zu 4 verschiedenen seriellen Geräten kommunizieren können.
Nur bei einem ist ein USB-Adapter integriert (alle anderen seriellen Ports können mit einem USB/TTL-Adapter verbunden werden).
Tabelle 4-1 zeigt die Portnamen und -Pins aller seriellen Ports des Mega.

Portname    Sendepin         Empfangspin
Serial            1 (auch USB)    0 (auch USB)
Serial 1       18                     19
Serial 2       16                     17
Serial 3       14                     15

Serielle Software
Sie werden üblicherweise die in Arduino integrierte Serial-Bibliothek verwenden, um mit den seriellen Hardware-Ports zu kommunizieren.
Serielle Bibliotheken vereinfachen die Verwendung serieller Ports, indem sie die Komplexität der Hardware vor Ihnen verbergen.
Manchmal benötigen Sie mehr serielle Ports, als Hardware-Ports zur Verfügung stehen.
In diesem Fall können Sie eine zusätzliche Bibliothek nutzen, die serielle Hardware in Software emuliert.
Die Sketche 4.13 und 4.14 zeigen, wie man eine serielle Bibliothek nutzt, um mit mehreren Geräten zu kommunizieren.



Quelle:
BUCH: Arduino Kochbuch   Seite 7  /90




********************************************************I*
Using the Arduino Pro Mini & FTDI  FT232RL

Getting Started with the Arduino Pro Mini


https://learn.sparkfun.com/tutorials/using-the-arduino-pro-mini-33v/all
https://www.sparkfun.com/products/9716

The Arduino Pro Mini connected to (and powered by) a SparkFun FTDI Basic Breakout Board and USB Mini-B cable.
Note that on earlier Pro Mini boards the orientation of the 6-pin header may be reversed; check that the words GRN and BLK align on the Pro Mini and FTDI Basic Breakout.



   FTDI-Kabel          ATmega328P                   
1 = GND sw       pin-8 und pin-22   GND
2 = CTS  br       pin-8 und  pin-22  GND 
3 = Vcc  rt         pin-7 und pin-20  und pin-21
4 = TxD  or       pin-2  RxD
5 = RxD  ge      pin-3  TxD
6 = RTS  gn     über 100nF auf  pin-1  RESET





https://www.arduino.cc/en/Guide/ArduinoProMini



********************************************************I*
                      USB zu UART
                         USB-zu-seriell Umsetzer

                          Umsetzer USB-UART

Wenn der PC keine serielle Schnittstelle hat dann kann man auf einen USB-zu-seriell Umsetzer zurückgreifen.
Dieser wird oft mit einem FT232R von FTDI realisiert.



Ein derartiger Umsetzer USB-UART kann selbst gebaut werden oder als Fertiggerät gekaut werden.
Teilweise ist ein derartiger Umsetzer bereits in die Programmer-Hardware integriert (z.B. bei den USB-Boards von myAVR).
Auf dem PC wird ein entsprechender Treiber installiert und dadurch eine virtuelle COM-Schnittstelle definiert, die vom Mikrocontroller wie eine traditionelle serielle Schnittstelle (COM1, COM2 usw.) angesprochen werden kann.



25. Kapitel: I2C = TWI
I2C (Inter Integrated Circuit ) oder TWI (Two-Wire Interface) Schnittstelle

Als I2C (Inter Integrated Circuit ) oder TWI (Two-Wire Interface) Schnittstelle wird ein serieller Datenbus bezeichnet, der ursprünglich von der Fa. PHILIPS für die geräteinterne Kommunikation von Schaltungsteilen entwickelt wurde.
Es handelt sich um eine BUS-Verbindung, bei der außer einer gemeinsamen Gnd-Leitung zwei Leitungen (SDA und SCL) benötigt werden.
Mit nur 3 Drähten können viele Komponenten verbunden werden.
Es gibt eine sehr große Anzahl verschiedener Bauteile bzw. Baugruppen, die sich über I2C ansprechen lassen.
Beispiele sind Temperatursensoren, Speichererweiterungen, Uhrenbausteine, Portexpander und vieles mehr.

I2C ist ein Master-Slave-Bus System.
Das heißt, dass es immer einen Master (den Mikrocontroller) und einen oder mehrere Slaves (zum Beispiel Sensoren) gibt.
An einem BUS können über 100 Slaves adressiert werden.
Dabei werden (außer einer GND-Verbindung) nur 2 Pins des Mikrocontrollers benötigt!
Das Ansprechen bestimmter Slaves erfolgt über Adressen.
Ein Teil der Adressen ist fest vorgegeben (für eine bestimmte Slave-Art) und ein Teil ist frei wählbar.
So sind beispielsweise von den 8-bits einer Adresse die ersten bits mit 1001 fest für DS1621 Temperatursensoren vorgegeben, über drei variable Bits lassen sich bis zu 8 dieser Sensoren an einem BUS ansprechen und das achte-bit zeigt an, ob lesend oder schreibend zugegriffen werden soll.
Die Adressierung im Programm muss der Beschaltung der Adresspins (A0, A1, A2) entsprechen!
Es werden üblicherweise Entfernungen bis zu ca. 1 Meter überbrückt.

Wichtig:
Jede der beiden I2C-Leitungen (SDA und SCL) benötigt jeweils einen Pullup-Widerstand von 4,7k Ohm bis 10k Ohm (nach +5V).
1x pro I2C-Bus.



Quelle:
BUCH: Einfacher Einstieg in die Elektronik mit AVR-Mikrocontroller und BASCOM  Seite 407
www.bascom-buch.de 






********************************************************I*
Einführung: Serial Peripheral Interface (SPI)

Der Ethernet-Shield und der Arduino Ethernet kommunizieren mit ihren Ethernet-Controllern über eine Methode zur synchron-seriellen Übertragung namens
Serial Peripheral Interface, kurz SPI. SPI sowie ein anderes synchronserielles Protokoll, Inter-Integrated Circuit oder I2C
(auch manchmal als Two-Wire Interface, oder TWI bezeichnet), sind die zwei am weitesten verbreiteten synchron-seriellen Protokolle, die dir begegnen werden.

Bei allen synchron-seriellen Protokollen gibt es ein Steuergerät, bei dem ein gleichmäßiger Impuls, das Taktsignal, an einem Pin generiert wird.
Bei jedem Taktimpuls werden Daten über einen anderen Pin ausgetauscht (siehe Kapitel 2).
Der Vorteil eines synchron-seriellen Protokolls ist, dass es sich um einen Bus handelt:
Mehrere Geräte können sich dieselbe physische Verbindung mit einem Hauptcontroller teilen.
Jedes Protokoll implementiert den Bus etwas anders.

SPI-Verbindungen bestehen aus drei oder vier Leitungen zwischen dem Steuergerät (dem Master) und den Zusatzgeräten (oder Slaves), und zwar denen hier:

Clock:
Der Pin, an dem der regelmäßige Impuls vom Master anliegt.
Master Out, Slave In (MOSI):
Das Master-Gerät sendet bei jedem Taktimpuls ein Datenbit auf dieser Leitung an den Slave.
Master In, Slave Out (MISO):
Das Slave-Gerät sendet bei jedem Taktimpuls ein Datenbit auf dieser Leitung an den Master.
Slave Select (SS) oder Chip Select (CS):
Weil sich mehrere Slave-Geräte denselben Bus teilen können, hat jedes eine eigene Verbindung zum Master. D
er Master setzt diesen Pin auf low, um genau dieses Gerät anzusprechen.
Wenn der Master nicht mit einem bestimmten Slave spricht, setzt er diesen Pin auf high.

Wenn der Slave keine Daten an den Master senden muss, gibt es keinen MISO-Pin.

Die Arduino-SPI-Library benutzt Pin 11 für MOSI, Pin 12 für MISO und Pin 13 für Clock (Takt).
Pin 10 ist standardmäßig der Pin für Chip Select, aber wie du noch sehen wirst, kannst du das auch ändern.
Der Arduino Ethernet und der Ethernet-Shield haben
z.B. zwei Slave-Geräte an ihrem SPI-Bus: Den WizNet-Chip und die SD-Karte.
Beide sind mit den Pins 11, 12 und 13 für MISO, MOSI und Clock verbunden.
The WizNet-Modul benutzt Pin 10 für Chip Select, die SD-Karte nutzt dagegen Pin 4 für Chip Select.

 
Quelle:
BUCH: Einfacher Einstieg in die Elektronik mit AVR-Mikrocontroller und BASCOM  Seite ???






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











 
Comments