RN-Wissen.de - Benutzerbeiträge [de]

Programmer

2010-03-05T11:05:24Z

Andun: /* USB Programmer */

== Einführung ==
Als '''Programmer''' wird die Hardwarekomponente bezeichnet, mit der das ausführbare Mikrocontrollerprogramm (Firmware, HEX-File) auf den Controller übertragen wird. Es gibt verschiedene Konzepte der Programmübertragung. Neben dem Konzept des Bootloaders, der Parallelprogrammierung und des [[JTAG]]-Interfaces, spielt bei [[Atmel]] Mikrocontrollern das Verfahren des "serial Download" eine große Rolle. Bekannt ist diese Variante der Programmierung als ISP (In System Programmierung). Dabei wird das [[SPI]] (Serial Processor Interface) genutzt, welches bei fast allen [[AVR]]-Controllern zu finden ist. ISP-Programmer zeichnen sich dadurch aus, dass der Hardwareaufwand für diese sehr gering ist. Das hat natürlich Auswirkungen auf den Preis. Für einen "Standard" [[ISP]] Parallel-Programmer liegen die Materialkosten im Cent-Bereich. Bei solchen "billig" Programmern werden die eigentlichen Programmierprotokolle (siehe Abschnitt Memory Programing in AVR Datenblättern) durch ein entsprechendes Programm auf dem PC erzeugt ([[AVR]]-Prog, PonyProg, YAAP, AVRDUDE, [[Bascom]] usw.) und die Programmerhardware ist bestenfalls zur Pegelanpassung da. Letztlich gibt es sogar derartige Programmer, die nur aus drei Schutzwiderständen bestehen. Meist wird aber ein kleiner preiswerter Treiberbaustein eingebaut, der für eine sichere Datenübertragung auch bei längeren Programmierkabeln sorgt. Damit ist ein extrem günstiger Einstieg in die Programmierung von [[Atmel]] AVR-Controllern möglich. Aufwendiger werden dann Programmer, die tatsächlich über eigene "Intelligenz" verfügen. Dabei handelt es sich in der Regel um so genannte Serial-Programmer. Hier erfolgt die Datenübertragung an den Programmer per serieller Schnittstelle oder über [[USB]]. Der Programmer selbst besitzt einen Controller, der die Daten empfängt und das Programmierprotokoll ausführt. Der weit verbreitete SI-Prog (siehe PonyProg) wird zwar an die Serielle Schnittstelle angeschlossen, ist dem Wesen nach aber den Parallelprogrammern äquivalent (einfache Pegelanpassung, keine eigene Intelligenz). Darin liegt auch die Ursache, warum der SI-Prog nie an einem handelsüblichen [[USB]] zu Serial-Adapter laufen wird.

== Parallelport ISP Programmer ==

=== STK 200 kompatible Programmer ===
Bei den Parallelportprogrammern handelt es sich oft um Nachbauten von Programmierintrefaces der ersten Starterkits von ATMEL dem STK200 oder STK300. Damit wird auch geworben in dem man diese als STK200 kompatibel oder als sogenannte Standard-ISP-Programmer bezeichnet. Der Vorteil dieser Programmer liegt tatsächlich darin, dass so ziemlich jede Programmersoftware diese unterstützt.
Die Kompatibilität bezieht sich hier auf die Belegung der Leitungen am LPT-Port. Es hat nichts mit der Verwendung eines Treiberschaltkreises bei den meisten dieser Programmer zu tun.

LPT-Pinning des STK200
SCK = 6;
MOSI = 7;
RESET = 9;
MISO = 10;

=== SP12 kompatible Programmer ===
Bei dem SP12 (von Steve Bolt) Programmer handelt es sich ursprünglich um eine extrem einfache Lösung, bei der nur drei Schutzwiderstände und keine weitere Pegelanpassung benutzt wurde. Dieser Programmer, zum fast Nulltarif, erfreut sich großer Beliebtheit. Der Hauptgrund dafür liegt aber in seiner Schaltungslösung, die es erlaubt, das Zielsystem über den LPT-Port mit Spannung zu versorgen. Bei der STK200 Schaltung muss der Programmer vom Zielsystem versorgt werden. Es wird beim SP12 also zum Programieren kein zusätzliches Netzteil benötigt. Inzwischen werden ernsthafte SP12 Programmer auch mit einem Bustreiber versehen.

LPT-Pinning des SP12
VCC = 4,5,6,7,8;
RESET = 3;
SCK = 2;
MOSI = 9;
MISO = 11;

== Pseudo serielle Programmer (SI-Prog) ==
Ein Programmer, der vor allem wegen seiner guten Unterstützung durch das beliebte PonyProg eine weite Verbreitung erfahren hat, ist der SI-Prog. Dieser wird oft als serieller Programmer bezeichnet. Richtig ist, dass er an den COM-Port des PCs angeschlossen wird. Aber die Schaltung verrät, daß hier die Steuerleitungen wie DTR, RTS und CTS des COM-Ports verwendet werden, um ein [[SPI]]-Protokoll zu fahren. Die eigentlichen Signalleitungen TxD und RxD sind bei diesem Adapter gar nicht angeschlossen. Damit ist es auch beim besten USB-RS232-Adapter nicht möglich, diesen Programmer an einem modernen Notebook anzuschließen, der nur noch über USB verfügt. Deshalb kann PonyProg dann nicht mehr als Programmiertool verwendet werden.

== Echte serielle Programmer ==
Echte serielle Programmer basieren oft entweder auf dem Atmel Application-Note AN910 oder sind STK500 kompatible Programmer. Allen gemeinsam ist das Vorhandensein eines Controllers mit entsprechender AVR910 oder STK500 kompatibler Firmware. Diese kann meist über einen Bootloader aktualisiert werden. Da ein Controller und eine reguläre RS232 Pegelanpassung (z.B. mit einem MAX232) kostenintensiver als das Material für einen Parallelprogrammer ist, sind diese in der Regel auch teurer. Dafür ist aber eine kompatible Lösung erhältlich, die, wie der STK200, durch die meisten Flash-Tools unterstützt wird und auch mit handelsüblichen USB-Serial-Adaptern betrieben werden kann.

Das alte Protokoll nach AN910 ist problematisch bei der Unterstützung neuer Controller, denn hier muß der Programmer die ID des Controllers kennen. Für neue Controller braucht man also ein Update der Software im Programmer. Wichtige Weiterentwicklungen bei den Serialprogrammern ist das AVR911 und das STK500v2 Protokoll. Es sollte beim Neuerwerb darauf geachtet, dass eines dieser aktuellen Protokolle unterstützt wird.

== USB Programmer ==
Bei USB-Programmern handelt es sich eigentlich nicht um eine eigenständige Gruppe von Programmern, sondern um AVR910 oder STK500 kompatible Lösungen. Das besondere ist hier, dass der Programmer selbst über einen USB-Controller verfügt. Dabei muss ein Treiber für diesen Controller installiert werden, der im System einen virtuellen COM-Port zur Verfügung stellt. Beim Betrieb dieser Programmer gibt es keine Unterschiede zu den seriellen Programmern. Leider sind USB Programmer dadurch, dass die USB Controller recht teuer und ausschließlich in SMD verfügbar sind, als Selbstbauprojekte für Anfänger ungeeignet.

Für die langsamste USB-Geschwindigkeit kann ein AVR Controller das USB Interface auch emulieren. Es gibt Baupläne für günstige Programmierer, die so auf den extra USB Controller verzichten (z.B. USB AVR-Lab, AVR-Doper, siehe Weblinks). Das USB-Protokoll ist meistens nur minimalistisch und nicht vollständig umgesetzt, wodurch es zu Inkompatibilitäten kommen kann.

Nichts desto trotz hat die Nutzung der AVR-Controller den großen Vorteil, dass sich nun ohne SMD-Bauteile auch USB-Programmierer bauen lassen, die an modernen Laptops, ohne serielle Schnittstelle funktionieren.

== ISP-Anschluss ==

=== 10poliger ISP Anschluss ===
Die am meisten verwendete Steckerbelegung, nicht nur Im Roboternetz. Genauere Beschreibung unter [[RN-Definitionen]]. Nahezu alle RN-Bauanleitungen nutzen diese Belegung.

1 - MOSI
2 - VCC
3 - LED (oft auch unbelegt)
4 - GND
5 - RST
6 - GND
7 - SCK
8 - GND
9 - MISO
10 - GND

=== 6poliger ISP Anschluss ===
Nur in wenigen Roboternetz-Projekten gebräuchlich. Dieser Stecker spart etwas Platz, ist aber deutlich schwieriger (und teurer) zu bekommen als die zehnpolige Variante.
1 - MISO
2 - VCC
3 - SCK
4 - MOSI
5 - RST
6 - GND

== Autor ==
*[[Benutzer:Martin Fiedler|Martin Fiedler]]
*Kleinere Änderungen Frank

==Siehe auch==
* [[AVR-ISP Programmierkabel]]- Bauanleitung Bauanleitung Parallel Programmer ISP
* [[ISP]]
* [[RN-Definitionen]]

==Weblinks==
* [http://www.rowalt.de/mc/avr/progd.htm Rowalt Bauanleitung Parallel Programmer]
* [http://www.atmel.com/dyn/resources/prod_documents/DOC0943.PDF Atmel Serialprogrammer ]
* [http://www.klaus-leidinger.de/mp/Mikrocontroller/AVR-Prog/AVR-Programmer.html Klaus-Leidinger Serialprogrammer Bauanleitung ]
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/evertool/ Bauanleitung Serialprogrammer Englisch Evertool]
* [http://www.fischl.de/usbasp/ USBasp von fischl.de: USB-Programmer für Atmel AVR Controller] - Bauanleitung, Weblinks zu Schaltplänen und Layouts (Eagle, PDF), Linux und Win32, Firmware mit Quelldateien, Win32-Treiber.
* [http://www.avr-projekte.de/isp.htm USB-Programmer Bauanleitung]
* [http://www.matwei.de/doku.php?id=de:elektronik:usbisp USB-Programmer Bauanleitung]
* [http://www.obdev.at/products/avrusb/avrdoper.html USB-Programmer Bauanleitung] - AVR Doper - High Voltage Programmierung
* [http://www.ullihome.de/index.php/Hauptseite#USB_AVR-Lab USB AVR Lab]
* [http://shop.embedit.de/browse_030001002_66__.php embedit.de] Bezugsquelle für sechspoligen Stecker

[[Kategorie:Microcontroller]]

Wunschthemen

2010-02-26T13:30:56Z

Andun: Wunsch im Ansatz erfüllt.

Auf dieser Seite kann '''jeder''' Themen nennen, die er sich in diesem Wiki wünschen würde. Die Seite dient Usern, die gerne was schreiben möchten, als Anregung. Hat jemand ein entsprechendes Thema erstellt, kann er es auch aus dieser Liste wieder streichen.

==Meine Wunschthemen==

'''Allgemeines'''
* Spracherkennung
* [[Schaltung AVR-Digitizer]] um Videobild mit AVR zu digitalisieren und auszuwerten oder per Funk zu übertragen - etwas zu viel verlangt, das geht kaum.
* Ausführliche Bedienhinweise für Euroflex-Saugroboter Monster Intelligente F1
* Künstliche Neuronale Netze
* [[Formula Flowcode Buggy]]
* Wie ist eine Grundschaltung für einen Roboter aufgebaut, dh. wie werden Motoren mit AVR's angesteuert, wie Sensoren ausgelesen? etc.
* Ausführliche Eagle Tutorials
* Roboterarm ( Allgemeines, Aufbau, Dimensionierung, Berechnung, Beispiele, usw.)

'''Programmierung'''
*Wie programmiere ich meinen Atmelxx mit meinem Lieblingstool Eclipse? (gcc läuft bereits via cygwin)>>>>Woher bekomme ich die Header des Atmelxx und was muss noch beachtet werden?
*Funktionen(Unterprogramme) und Tasks(parallele Prozesse) in Bascom
* Enwickeln eines universellen Programms, das ein Programmablaufdiagram (PDA) direkt in ausführbaren Code für ein bestimmter Prozessor (Maschinensprache) wandelt
* [[Network_Controller/PC_Praxis#Network_Controller.2FPC_RS232_mit_Windows|Ansprechen der RS232 Schnittstelle mit gängigen Programmiersprachen]]
* Pda und PPC steuerung über CF und MMC slot
* [[GCC]] Einführung mit Beispielen (welche Beispiele? Benutzung von GCC? (Optionen, ...)?, Programmbeispiele (also [[C-Tutorial]])?), für spezielle Maschinen oder Derivate? ANSI-C? Was fehlt in den [[:Kategorie:Quellcode C|C-Beispielen]]?)
* Mehr C Tutorials wie bei Bascom für LCDs,....
* C-Control 2 Tutorial
* PIC16F... Programmierung mit dem Go Embedded Pascal-Compiler
* PIC18F... Einführung
* [(ATMega128 mit eingelötetem Uhrenquarz)] Einstellung/Abfrage/Speichern von Zeit und Datum - Code für AVR Dude
* Ein Komplettes kleines Projekt: Kommunikation von einem Atmel µC(z.B.: AtMegaX) zum PC über USB
* Eine Anleitung zu Programmern wie z.b. Ponyprog und [[avrdude]]

'''Hardware'''
* Serielles AVR-ISP Programmierkabel
* USB-ISP Programmieradaper
* JTAG mit AVRs
* Shift-/Schieberegister - Einiges schon unter Portexpander am AVR
* Sensorschaltung Windrichtung
* Sensorschaltung Luftfeuchte
* Schaltungssicherheitsvorkehrungen (wenns nicht nur auf dem Basteltisch funktionieren soll)
** EMV
*** ESD-Sicherheit
*** ESD-Bauteile (Supressor Dioden, etc.)
*** EMV-konformes Routing
*** Abschirmung bei Leitungen, Gehäuseauswahl, etc.
* Bluetooth Support (senden/empfangen) nach dem Vorbild des Lego NXT
* Microcontroller Entwicklungsboards
* Oszilloskop bedienung und Einstellung für Anfänger

==Folgende erscheinen noch unvollständig und sollten von Usern die in dem Bereich kundig sind, ergänzt werden==
Findet man jetzt durch folgenden Link: [[:Kategorie:Artikelausbau]]
Artikel die unvollständig sind sollte man jetzt also nicht mehr hier aufgelistet werden, sondern die Artikel sollten am unteren Ende durch folgendes Kommando ergänzen werden:

<pre><nowiki>
{{Ausbauwunsch|Mehr Grundlagen und vor allem Programmbeispiele etc.}}
</nowiki></pre>

Im Artikel wird dann ein Hinweis eingeblendet, ähnlich wie diesem:

[[Bild:artikelausbau.gif]]

Also hier klicken um ausbaufähige Artikel zu finden:
* [[:Kategorie:Artikelausbau]]

----

Hier noch ein paar Artikel wo der Hinweis noch nicht drin steht:

* [[GNU Assembler|AVR Assembler (GNU) Einführung]]:
* [[Zahnrad]]
* [[Flipflop]]
* [[C-Tutorial]]
* [[Navigation]]
* [[Transistor]] (noch ein paar Bilder und vielleicht Grundschaltungen mit Beschreibung wären toll
* [[Avr-gcc|Dokumentation zu avr-gcc]]
* [[Arm]] Microcontroller
* [[GPS]] - Aufbau und Anwendung
* [[SPI]] - Vielleicht noch Beispiele
* [[Portexpander am AVR]] könnte nen BASCOM-Teil vertragen
* [[Manchester- Codierung]] - noch ein Programmbeispiel wäre toll
* [[JTAG]]

== Bereits erfüllte Wünsche ==
* stellenanzeigen-forum ->Gibt es bereits hier http://www.roboternetz.de/phpBB2/viewforum.php?f=29
* Filter (Hardware/Software) -> Wurde hier angelegt [[Filter (Elektronik)]]
* [[Roboterwettbewerbe]]
* Motortreiber (Einsteigerguide) -> [[Getriebemotoren Ansteuerung]]
* Kondensator (Grundlagen) -> [[Kondensator]]
* Quarz-Bausteine -> [[Schwingquarz]] oder [[Quarzoszillator]]
* [[Roboter-Filme]]
* Kurzschlußsicherheit, Überspannungsschutz und Verpolungsschutz in [[Schutzschaltungen]]
* Schnittstellen Übersicht (Es sollten alle gängigen Schnittstellen mit Vorteilen, Nachteilen etc. aufgelistet werden, damit man für jede zu bewältigende Aufgabe die am besten geeignete Schnittstelle wählen kann) -> siehe unter [[RS232]] oder [[RS485]] oder [[USB]], Bussysteme unter [[I2C]] oder [[TWI]] oder [[CAN]] <- was fehlt noch?
* [[CNY70]] als Liniensensor (analoge / digitale Auswertung)

[[Kategorie:RN-Wissen]]

Avrdude

2010-02-26T13:29:15Z

Andun: Erstellung des Artikels

AVRDUDE ist ein Kommandozeilen-Programm zur Programmierung von Mikrocontrollern.

Das Tool dient sowohl zum lesen und schreiben des [[Flash]], des [[EEPROM]]s als auch den [[Avr#Die_Fusebits|Fuse-Bits]] und den sonstigen Speicherbereichen aktueller Mikrocontroller.

Da schon sehr viele Tutorials im Netz dafür existieren, schaffe ich hier erstmal nur eine ausführliche Linksammlung:

==Siehe auch==
*[[AVR]]

==Offizielle Webseiten==
*[http://www.nongnu.org/avrdude/ Projekt Homepage von AVRDUDE]
*[http://www.nongnu.org/avrdude/user-manual/avrdude.html Dokumentation von AVRDUDE mit allen Befehlen]

==Tutorials==
*[http://www.mikrocontroller.net/articles/AVRDUDE AVRDUDE-Tutorial bei mikrocontroller.net mit hilfreichen Tipps und Tricks]
*[http://www.mikrocontroller.net/articles/AVR_Fuses#AVRDUDE Tipps zum setzten und finden von Fusebits]

==Weitere Links==
*[http://www.engbedded.com/fusecalc/ Online Fuse-Bit Calculator]

Benutzer:Andun

2010-01-31T12:33:16Z

Andun:

==Über mich==

Nick: Andun

Wohnort: Hamburg

==Bisherige Großprojekte==
*Staubsauger Roboter für Jugend Forscht 2005
*Roboter AG für jüngere Schüler an meiner Schule

==Basteileien==
*96x32 LCD Display
*Asuro Roboter
*Ein 20 Jahre alten Videorecorder auseinander genommen :D
*Alte Handys auseinander nehmen
*AVR Evaluation Board -> Wird verarbeitet

Bei Frage schreibt mir im Forum ne PN. Andun

Feststellung der zur Verfügung stehenden COM-Ports auf dem Computer

2010-01-25T21:13:33Z

Andun: Quell-Code-Darstellung geändert

== '''Warum dieses Tutorial?''' ==

Immer wieder stelle ich fest, dass in einer entwickelten Software, die die seriellen Schnittstellen unterstützt, einfach alle erdenklichen COM-Ports angegeben werden. Vor allem auch Ports, die auf dem Computer gar nicht zur Verfügung stehen. Wird ein solcher Port dann ausgesucht, kommt es entweder innerhalb des Programms zu einer Meldung, dass es den ausgewählten Port nicht gibt oder es kommt sogar zum Absturz des Programms. Das muss alles nicht sein. Auf eine einfache Art und Weise ist es möglich, nur die COM-Ports innerhalb eines Programms anzugeben, die auf dem jeweiligen Computer zur Verfügung stehen.

== '''Entwicklungsumgebung''' ==

Für das hier zu beschreibende Beispiel benutze ich Visual C# 2008. Da dieses Beispiel sehr einfach gehalten ist, kann es schnell auf eine andere Programmiersprache portiert werden. Außerdem ist C# 2008 unter der folgenden Adresse kostenlos zu beziehen.
[http://www.microsoft.com/germany/Express/]

== '''Grundgedanke''' ==

Um alle 255 möglichen COM-Schnittstellen zu finden, soll eine Schnittstelle nach der anderen geöffnet werden. Lässt sie sich öffnen, dann schreibe sie in eine Liste, ansonsten mache nichts und nehme die nächste Schnittstelle. Das ganze muss beim Programmstart durch geführt werden. Natürlich könnten auch die installierten Schnittstellen aus der Regetry ausgelesen werden. Meine Erfahrung zeigt aber, dass dieses Vorgehen oft scheitert, da in der Regestry Ports noch eingetragen sind, die in Wirklichkeit nicht mehr vorhanden sind (es wird Software nicht deinstalliert, sondern nur von Hand gelöscht und somit werden die Regestry-Einträge auch nicht gelöscht).

== '''Das Programm''' ==

Beim Programmstart wird über eine FOR-Schleife versucht, alle 255 möglichen COM-Ports zu öffnen. Dieses geschieht in der try-Anweisung. Gibt es auf dem Computer die jeweilige Schnittstelle nicht, läuft es auf einen Fehler, der in der catch-Anweisung abgefangen wird. Da aber bei einem Fehler nichts gemacht werden soll, ist die catch-Anweisung leer und es wird versucht, den nächsten COM-Port zu öffnen. Beim Öffnen eines COM-Ports gibt es aber etwas zu beachten. Der jeweilige Port besteht nicht nur aus einer Ziffer (1-255), sondern aus COM1 –COM255. Aus diesem Grunde muss der Portname aus dem String COM und der jeweiligen Nummer zusammen gesetzt werden. Dieses wird mit der Zeile
Port = „COM“ + i;
gemacht. Der so definierte Portname wird zugeordnet und anschließend wird dieser COM-Port geöffnet. Gibt es nun diesen Port nicht, tritt ein Fehler auf und es wird gleich in die catch-Anweisung gesprungen. Da dort aber nichts durchgeführt werden soll, wird i um 1 erhöht und somit wird versucht, den nächsten COM-Port zu öffnen. Ließ sich nun aber der Port öffnen, wird vor dem Schließen des Ports dieser in die ComboBox cmdPortName hinzugefügt.
Die Variable Port muss als String deklariert werden.

for (int i = 1; i < 256; i++)
{
try
{// Öffne den jeweiligen COM-Port und trage den Gefundenen in die ComboBox ein
Port = "COM" + i; // Zusammensetzung des Ports aus COM und der Ziffer
ComPort.PortName = (Port); // Zuordnung des Ports
ComPort.Open(); // Öffnen des Ports
cmdPortName.Items.Add(Port); // Gefundener Port in ComboBox hinzufügen
ComPort.Close(); // Schließen des Ports
}
catch
{
// Der Com-Port kann nicht geöffnet werden
//MessageBox.Show("COM-Port kann nicht geöffnet werden!");
}
}
Das ist schon das ganze Prinzip, um nur die zur Verfügung stehenden COM-Ports des Computers zu finden.

== '''Zur Vollständigkeit hier das ganze Programm''' ==

<pre>
using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace WindowsFormsApplication1

{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
//******************************************************************
//* Programm beenden *
//******************************************************************
private void button3_Click(object sender, EventArgs e)
{
Application.Exit(); /* Komplette Programm beenden */
}
//******************************************************************
//* Hauptprogramm *
//******************************************************************
private void Form1_Load(object sender, EventArgs e)
{
String Port;
for (int i = 1; i < 256; i++)
{
try
{// Öffne den jeweiligen COM-Port und trage den Gefundenen in die ComboBox ein
Port = "COM" + i;
ComPort.PortName = (Port);
ComPort.Open();
cmdPortName.Items.Add(Port);
ComPort.Close();
}
catch
{
// Der Com-Port kann nicht geöffnet werden
//MessageBox.Show("COM-Port kann nicht geöffnet werden!");
}
}
// Button setzen
Exit.Enabled = true;
Connect.Enabled = true;
Disconnect.Enabled = false;
// Zur Verfügung stehende COM-Ports suchen
/* Voreinstellungen für den zu öffnenden COM-Port */
cmdPortName.Items.Add("No COM-Port haved available");
cmdPortName.SelectedIndex = 0;
cmdBaudrate.Items.Add("4800"); /* Baudrate */
cmdBaudrate.Items.Add("9600");
cmdBaudrate.Items.Add("19200");
cmdBaudrate.Items.Add("38400");
cmdBaudrate.Items.Add("57600");
cmdBaudrate.Items.Add("115200");
cmdBaudrate.SelectedIndex = 1; /* Setzen auf 9600 Baud */
cmdDataBits.Items.Add("4"); /* Anzahl der Datenbits*/
cmdDataBits.Items.Add("5");
cmdDataBits.Items.Add("6");
cmdDataBits.Items.Add("7");
cmdDataBits.Items.Add("8");
cmdDataBits.SelectedIndex = 4; /* Setzen auf 8 Datenbits */
cmdParity.Items.Add("Even"); /* Parity */
cmdParity.Items.Add("Odd");
cmdParity.Items.Add("None");
cmdParity.Items.Add("Marquage");
cmdParity.Items.Add("Plaque");
cmdParity.SelectedIndex = 2; /* Setzen auf None */
cmdStopBits.Items.Add("1"); /* Anzahl der Stopbits */
cmdStopBits.Items.Add("1.5");
cmdStopBits.Items.Add("2");
cmdStopBits.SelectedIndex = 0; /* Setzen auf 1 Stopbit */
}
//******************************************************************
//* COM-Port öffnen *
//******************************************************************
private void button2_Click(object sender, EventArgs e)
{
// Button setzen
Connect.Enabled = false;
Disconnect.Enabled = true;
Exit.Enabled = false;
// Setzen der Parameter des COM-Ports gemäss gewählten Einstellungen
if (ComPort.IsOpen)
{
ComPort.Close(); // COM-Port ist geöffnet ==> schließen
}
else
{ // COM-Port kann nun geöffnet werden
ComPort.BaudRate = int.Parse(cmdBaudrate.Text);
ComPort.DataBits = int.Parse(cmdDataBits.Text);
ComPort.StopBits = (System.IO.Ports.StopBits)Enum.Parse(typeof(System.IO.Ports.StopBits), cmdStopBits.Text);
ComPort.Parity = (System.IO.Ports.Parity)Enum.Parse(typeof(System.IO.Ports.Parity), cmdParity.Text);
ComPort.PortName = cmdPortName.Text;
ComPort.ReceivedBytesThreshold = 1;
ComPort.NewLine = "\0x13";
ComPort.WriteTimeout = 1000;
ComPort.ReadTimeout = 5000;
ComPort.DtrEnable = true;
ComPort.RtsEnable = false;
//ComPort.Open();
}
}
//***************************************************************************
//* COM-Port schließen *
//***************************************************************************
private void button1_Click(object sender, EventArgs e)
{
ComPort.Close();
// Button setzen
Disconnect.Enabled = false;
Connect.Enabled = true;
Exit.Enabled = true;
}
private void textBox2_TextChanged(object sender, EventArgs e)
{
}
}
}
</pre>

== '''Screenshots des Programms''' ==
[[bild:111.jpg|111.jpg]]
Nach dem Programmstart stehen in der ComboBox alle zur Verfügung stehenden COM-Ports.

[[Bild:222.jpg]]
COM-Port ist ausgewählt. Alle anderen Parameter sind eingestellt.

[[Bild:333.jpg]]
COM-Port ist geöffnet. Die Button sind inaktiv und werden erst wieder aktiv, wenn die Verbindung getrennt wurde.
== Das Programm samt Sourcecode kann hier [http://www.inter-save.com] im Downloadbereich herunter geladen werden ==

== Lizenz-Bedingung ==

Dieses Programm steht unter der folgenden CC BY-NC-SA-Lizenz .Dieser Quelltext einschließlich
der darin verlinkten Inhalte steht unter der CC by-nc-sa Lizenz
http://creativecommons.org/licenses/by-nc-sa/3.0/de/

Das bedeutet: Es ist gestattet: das Werk vervielfältigen, verbreiten und öffentlich
zugänglich machen, Abwandlungen bzw. Bearbeitungen des Inhaltes anfertigen zu den folgenden
Bedingungen:
Namensnennung. Sie müssen den Namen des Autors/Rechteinhabers in der von ihm festgelegten
Weise nennen. Keine kommerzielle Nutzung. Dieses Werk darf nicht für kommerzielle Zwecke
verwendet werden. Weitergabe unter gleichen Bedingungen. Wenn Sie den lizenzierten Inhalt
bearbeiten oder in anderer Weise umgestalten, verändern oder als Grundlage für einen anderen
Inhalt verwenden, dürfen Sie den neu entstandenen Inhalt nur unter Verwendung von
Lizenzbedingungen weitergeben, die mit denen dieses Lizenzvertrages identisch oder
vergleichbar sind.

HDD44780

2009-10-10T16:44:52Z

Andun:

#REDIRECT [[hd44780]]

HDD44780

2009-10-10T16:42:51Z

Andun: Artikel in eine Weiterleitung umgebaut

#WEITERLEITUNG [[hd44780]]

Hd44780

2009-10-10T16:41:40Z

Andun: Artikel erstellt, als Linksammlung

Dieser Artikel behandelt den Display-Controller HD44780 von Hitachi und seine Ansteuerung.

==Siehe auch==
*[[LCD-Modul am AVR]]
*[[Bascom und LCD's]]
*[[LCD an C-Control M-Unit 2]]

==Weblinks==
*[http://www.sprut.de/electronic/lcd/index.htm Ausführliche Einführung in LCD-Displays]

HDD44780

2009-10-10T10:49:08Z

Andun: /* Siehe auch */

Der HDD44780 ist ein oft verwendeter Steuer-IC für Text-Displays.

Meistens wird er jedoch HD44780 geschrieben und unter diesem Suchbegriff sind deutlich mehr Informationen im Internet zu finden.

==Siehe auch==
*[[LCD-Modul am AVR]]
*[[Bascom und LCD's]]
*[http://www.sprut.de/electronic/lcd/index.htm Allgemeine Einführung in LCD-Displays]

LCD-Modul am AVR

2009-10-02T06:59:59Z

Andun: /* 8-Bit Ansteuerung (Busmode) */

[[Bild:lcdmodul_2.jpg|right|thumb|350px|LCD-Modul]]

==Einleitung==

LCD ist eine Abkürzung und bedeutet '''''L'''iquid '''C'''rystal '''D'''isplay''. Übersetzt bedeutet dies Flüssigkristall-Anzeige. Flüssigkristalle sind organische Verbindungen, die Eigenschaften von Flüssigkeiten und Festkörpern besitzen. Zwischen zwei Glasplatten mit Polarisationsfiltern schwimmen die Flüssigkristalle. Durch Anlegen einer Wechselspannung ändert sich die Polarisationsebene der Flüssigkristalle und damit, ob das einfallende Licht reflektiert oder absorbiert wird.

Bei einem LCD-Modul befindet sich neben dem LCD auch ein Controller zur Ansteuerung des LCDs.

==Text-Displays==

Text-Displays kommen wegen der problemlosen Anbindung in Mikrocontroller Projekten wie Robotern am häufigsten zum Einsatz. Bei Text-LCDs kommen meistens der HD44780 von Hitachi oder ein kompatibler Controller zum Einsatz. Dieser Controller unterstützt Displays mit bis zu 80 Zeichen. Gängige Displaygrößen sind: 8 × 1, 8 × 2, 16 × 1, 16 × 2, 20 × 2, 20 × 4, 40 × 2 Zeichen Displays (Spalten × Zeilen). Hat das Display mehr als 80 Zeichen, dann benötigt das Display 2 Controller und verhält sich nach außen zur Ansteuerung, wie 2 Displays (zusätzliche Enable Leitung)

===Anschlußbelegung für ≤80 Zeichen Displays===

Text-Displays verfügen über genormte 14 Anschluss Pins (LCD-Module mit Backlight über 16 Pins). Lediglich bei der Backlight Versorgungsspannung und Polung kann es Unterschiede geben. Im Zweifelsfall hilft hier der Blick ins Datenblatt. Entweder sind die Anschlüsse in einer Reihe (1 × 14(16)) oder zweireihig (2 × 7(8)) herausgeführt.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Pin'''
|'''Bezeichnung'''
|'''Beschreibung'''
|-
|1
|GND
|Masse
|---
|2
|VCC
|Spannungsversorgung +5V
|---
|3
|VEE
|Kontrast Poti 0..0,5V
|---
|4
|RS
|Register Select, 1=Daten schreiben / 0=Kommando senden.
|---
|5
|R/W
|1=Read / 0=Write zum lesen / schreiben in das Display RAM
|---
|6
|Enable
|Fallende Flanke -> Übertragen des Kommandos oder der Daten, H-Pegel -> Lesen von Daten aus dem Display
|---
|7
|DB0
|Datenbus Bit0 LSB
|---
|8
|DB1
|Datenbus Bit1
|---
|9
|DB2
|Datenbus Bit2
|---
|10
|DB3
|Datenbus Bit3
|---
|11
|DB4
|Datenbus Bit4
|---
|12
|DB5
|Datenbus Bit5
|---
|13
|DB6
|Datenbus Bit6
|---
|14
|DB7
|Datenbus Bit7 MSB
|}

===HD44780 kompatibler LCD Controller===

Der HD44780 LCD Controller besitzt 3 Speicher. Den DDRAM (Display Data RAM) Darin werden die anzuzeigenden Daten geschrieben.
Der CGROM (Character Generator ROM) enthält die Zeichen in Form von 5x8 oder 5x10 Punktmatrizen.
Im CGRAM (Character Generator RAM) können acht benutzerdefinierte Zeichen 5x8 Pixel oder vier 5x10 Pixel abgelegt werden.

====Befehlsübersicht====

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Befehl'''
| '''RS'''
| '''R/W'''
| '''DB7'''
| '''DB6'''
| '''DB5'''
| '''DB4'''
| '''DB3'''
| '''DB2'''
| '''DB1'''
| '''DB0'''
| '''Beschreibung'''
| '''Ausführungszeit bei fosc=250kHz'''
|-
|Clear Display
|0
|0
|0
|0
|0
|0
|0
|0
|0
|1
|Löscht das Display und setzt den Cursor auf den Anfang der 1. Zeile (Addresse 0).
|1.64mS
|-
|Cursor Home
|0
|0
|0
|0
|0
|0
|0
|0
|1
|*
|setzt den Cursor auf den Anfang der 1. Zeile (Addresse 0)
|1.64mS
|-
|Entry mode set
|0
|0
|0
|0
|0
|0
|0
|1
|I/D
|S
|Setzt die Cursor Bewegungsrichtung (I/D), spezifiziert das Display zu schieben (S). Diese Operationen werden während des Daten lesen/schreiben durchgeführt.
|40uS
|-
|Display on/off Control
|0
|0
|0
|0
|0
|0
|1
|D
|C
|B
|Schaltet an/aus: das gesamte Display (D), Den Cursor (C) Cursor blinken (B).
|40uS
|-
|Cursor/Display shift
|0
|0
|0
|0
|0
|1
|S/C
|R/L
|*
|*
|Setzt Cursor Bewegung oder Display Bewegung (S/C), Bewegungsrichtung (R/L)
|40uS
|-
|Function set
|0
|0
|0
|0
|1
|DL
|N
|F
|*
|*
|Einstellen der Schnittstellen Datenlänge (DL), Anzahl Display Zeilen (N) und Zeichen Font (F).
|40uS
|-
|Set CGRAM Address
|0
|0
|0
|1
|colspan=6 |CGRAM Adresse
|Setzen der CGRAM Adresse. CGRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Set DDRAM Address
|0
|0
|1
|colspan=7 |DDRAM Adresse
|Setzen der DDRAM Adresse. DDRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Read busy-flag and address counter
|0
|1
|BF
|colspan=7 |CGRAM / DDRAM Adresse
|Liest das Busy-flag (BF), welches anzeigt das interne Operationen ausgeführt werden, und liest den CGRAM oder DDRAM Adress Zeiger Inhalt.
|0uS
|-
|Write to CGRAM or DDRAM
|1
|0
|colspan=8 |Schreib Daten
|Schreibt Daten zum CGRAM oder DDRAM.
|40uS
|-
|read from CGRAM or DDRAM
|1
|1
|colspan=8 |Lese Daten
|Liest Daten vom CGRAM oder DDRAM.
|40uS
|}

Anmerkungen:
* DDRAM = Display Data RAM.
* CGRAM = Character Generator RAM.
* DDRAM Adresse entspricht der Cursor Position.
* * = egal.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Bit Name'''
|'''Einstellung / Status'''
|
|-
|I/D
|0 = Erniedrige Cursor Position
|1 = Erhöhe Cursor Position
|-
|S
|0 = Display nicht schieben
|1 = Display schieben
|-
|D
|0 = Display aus
|1 = Display an
|-
|C
|0 = Cursor aus
|1 = Cursor an
|-
|B
|0 = Cursor blinken aus
|1 = Cursor blinken an
|-
|S/C
|0 = Bewege Cursor
|1 = Schiebe Display
|-
|R/L
|0 = Schiebe nach links
|1 = Schiebe nach rechts
|-
|DL
|0 = 4-bit Interface
|1 = 8-bit Interface
|-
|N
|0 = 1/8 oder 1/11 Duty (1 Zeile)
|1 = 1/16 Duty (2 Zeilen)
|-
|F
|0 = 5x7 Punkte
|1 = 5x10 Punkte
|-
|BF
|0 = Befehle werden akzeptiert
|1 = Interne Operation wird ausgeführt
|}

===8-Bit Ansteuerung (Busmode)===

Die "8-Bit Busmode"-Ansteuerung funktioniert nur bei AVR Prozessoren mit externem Bus Interface. Diesen Mode unterstützen allerdings nur die wenigsten Atmel AVR Prozessoren, z.B. der AT90S8515 und ATmega128. Der Busmode empfiehlt sich, wenn man in der Applikation auch externen Speicher verwendet.

[[Bild:lcdmodul_8bit_schem.png|center|thumb|600px|8-Bit Ansteuerung. Quelle: Peter Fleury]]

====BASCOM-AVR Programm====
Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode.
<pre>
$regfile = "8515def.dat"
$crystal = 4000000
$lcd = &HC000 'Adresse LCD Daten
$lcdrs = &H8000 'Adresse LCD Register select

Config Lcdbus = 8 'LCD im 8-Bit Bus Mode
Config Lcd = 16 * 2 'wir verwenden ein 16 x 2 Zeichen Display

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 4000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 2 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 16 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 0 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
...
#elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || defined(__AVR_ATmega64__) || \
defined(__AVR_ATmega8515__)|| defined(__AVR_ATmega103__) || defined(__AVR_ATmega128__) || \
defined(__AVR_ATmega161__) || defined(__AVR_ATmega162__)
/*
* memory mapped mode is only supported when the device has an external data memory interface
*/
#define LCD_IO_DATA 0xC000 /* A15=E=1, A14=RS=1 */
#define LCD_IO_FUNCTION 0x8000 /* A15=E=1, A14=RS=0 */
#define LCD_IO_READ 0x0100 /* A8 =R/W=1 (R/W: 1=Read, 0=Write */
#else
#error "external data memory interface not available for this device, use 4-bit IO port mode"

#endif

...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung mit Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 7 Prozessor Ports benötigt. Die Abfrage des Busy Flags ist durch die Verdrahtung des R/W Pins möglich.

[[Bild:lcdmodul_4bitbusy_schem.png|center|thumb|600px|4-Bit Ansteuerung mit Busy]]
Anmerkung: Unbenutzte Pins des Datenports vom LCD sollten auf GND gelegt werden, da sie ansonsten auf keinen definierten Pegel liegen und Störsignale empfangen.

Hier ein [http://picasaweb.google.de/lh/photo/7xU12-9CwCJUXh5XCC7LsQ?authkey=Gv1sRgCI3H2aul1-TmNg&feat=directlink Beispielaufbau] auf einem Steckboard.

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode benötigt einer spezielle LCD Bibliothek, die 'lcd4busy.lib'. Leider müssen bei der Verwendung dieser Bibliothek alle Pins des LCD Modul an den selben Prozessor Port angeschlossen werden.
<pre>
$lib "lcd4busy.lib" 'ersetzt die Standard LCD Bibliothek
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
Const _lcdport = Portc
Const _lcdddr = Ddrc
Const _lcdin = Pinc
Const _lcd_e = 1
Const _lcd_rw = 2
Const _lcd_rs = 3

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
/**
* @name Definitions for 4-bit IO mode
* Change LCD_PORT if you want to use a different port for the LCD pins.
*
* The four LCD data lines and the three control lines RS, RW, E can be on the
* same port or on different ports.
* Change LCD_RS_PORT, LCD_RW_PORT, LCD_E_PORT if you want the control lines on
* different ports.
*
* Normally the four data lines should be mapped to bit 0..3 on one port, but it
* is possible to connect these data lines in different order or even on different
* ports by adapting the LCD_DATAx_PORT and LCD_DATAx_PIN definitions.
*
*/
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 4 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 5 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 6 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 7 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 3 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 2 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 1 /**< pin for Enable line */
...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung ohne Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 6 Prozessor Ports benötigt. Die R/W Leitung des Displays kann man dabei einfach auf GND legen, dann ist aber keine Busy-Bit Abfrage möglich.

[[Bild:lcdmodul_4bit_schem.png|center|thumb|600px|4-Bit Ansteuerung]]

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode.
<pre>
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
' Im I/O Mode wird jeder Prozessor Pin einzeln angegeben
Config Lcdpin = Pin , Db4 = Portc.0 , Db5 = Portc.1 , Db6 = Portc.2 , Db7 = Portc.3 , E = Portc.5 , Rs = Portc.4

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über Porterweiterung===

Mit einem Porterweiterungs Baustein wie dem 74HC595 lassen sich weitere Prozessor-Ports einsparen. Diese Lösung kommt mit 4 Prozessor Ports aus, läßt man die Abfrage des Busy-Bits (PC5) weg, sogar nur mit 3 Prozessor Ports. Trotzdem wird das Display im 8-Bit Mode betrieben.

[[Bild:lcdmodul_portexp_schem.png|center|thumb|600px|Ansteuerung über Porterweiterung]]

====BASCOM-AVR Programm====

Das BASCOM Programm für diese Ansteuerung ist nicht ganz so einfach, da es nicht von der BASCOM Library unterstützt wird. Die Routinen zum Ansprechen des Displays muß man selbst coden.

<pre>

TODO....

</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über I²C===

Nur 2 Prozessor Ports benötigt man bei der I²C-Ansteuerung. Dazu wird als I²C Porterweiterungs IC der PCF8574P benötigt.

[[Bild:lcdmodul_i2c_schem.png|center|thumb|600px|I²C-Ansteuerung]]

====BASCOM-AVR Programm====
Diese Ansteuerung basiert auf der Application Note AN#118 von MCS electronics. Dazu gibt es auch eine fertige Library zu BASCOM-AVR, die die Standard LCD Library ersetzt. Dadurch können die gleichen Befehle zur Ansteuerung verwendet werden wie bei der Standard LCD Library. Das BASCOM-AVR Programm, um das LCD-Modul über I²C anzusprechen, sieht dann so aus.
<pre>
$lib "Lcd_i2c.lib" 'ersetzt die Standard LCD Library
$regfile = "m32def.dat"
$crystal = 16000000

Const Pcf8574_lcd = &H40 'I2C Adresse
Config Scl = Portc.0 'I2C SCL Pin
Config Sda = Portc.1 'I2C SDA Pin
Dim _lcd_e As Byte
_lcd_e = 128 'LCD im 4-Bit Mode betreiben

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über RS232===

Ebenfalls nur 2 Pins zur Ansteuerung benötigt die Lösung. Allerdings ist die serielle Schnittstelle bei Mikrocontrollern oft schon mit anderen Aufgaben belegt. Deshalb befindet sich meistens noch zusätzlich eine I²C-Bus Schnittstelle zur Ansteuerung auf dem Modul.

==Graphik-Displays==

In Mikrocontroller-Anwendungen werden seit neuestem, einhergehend mit der größeren Verbreitung von Controllern mit mehr Speicherplatz, auch immer öfter Grafik-Displays und Farb-TFTs eingesetzt. Der Aufwand an Software und Hardware ist hier allerdings um einiges höher (jedes Pixel ist einzeln anzusteuern).

==LCD über RN LCD Adapter Std an RN-Control==

Hierbei handelt es sich um eine Beispielansteuerung eines LCD über RN LCD Adapter Std an RN-Control in C.

Komfortabel lässt sich ein LCD in C mit der LCD Library von Peter Fleury ansteuern (LCD Controller HD44780 & KS0073).
Die Library selbst sowie deren Online Dokumentation und weiterführende informationen sind von [http://jump.to/fleury Peter Fleury's Home Page]zu entnehmen.

Im hier aufgeführten Beispiel wird ein Crystalfontz 20x4 LCD verwendet (CFAH2004A-YYH-JPE).

Pinbelegung nach [http://www.crystalfontz.com/product/CFAH2004AYYHJPE.html Datenblatt]
<pre>
Pin No. Symbol Level Description
1 VSS 0V Ground
2 VDD 5.0V Supply Voltage for logic
3 VO (Variable) Operating voltage for LCD
4 RS H/L H: DATA, L: Instruction code
5 R/W H/L H: Read(MPU?Module) L: Write(MPU?Module)
6 E H,H?L Chip enable signal
7 DB0 H/L Data bit 0
8 DB1 H/L Data bit 1
9 DB2 H/L Data bit 2
10 DB3 H/L Data bit 3
11 DB4 H/L Data bit 4
12 DB5 H/L Data bit 5
13 DB6 H/L Data bit 6
14 DB7 H/L Data bit 7
15 A - LED +
16 K - LED -
</pre>

Pinbelegung des LCD Adapters nach [http://www.robotikhardware.de/download/rn_LCD_adapter_std.pdf Datenblatt]
<pre>
Pin 1 LCD DB7
Pin 2 LCD DB6
Pin 3 LCD DB5
Pin 4 LCD DB4
Pin 5 Licht ein/aus per Port (da EN2 hier nicht benötigt wird)
Pin 6 LCD EN
Pin 7 LCD R/W
Pin 8 LCD RS
Pin 9 GND LCD GND und Licht Kathode
Pin 10 +5V LCD VCC und Licht Anode
</pre>

Berücksichtigt man die folgenden Tatsachen:
* ATMega32 auf dem RN-Control stellt kein "external memory interface" zur Verfügung, daher ist ohne Weiteres keine 8-Bit Ansteuerung des LCD möglich. Es wird 4-Bit I/O verwendet
* die Zählweise der Pins beginnt in lcd.h bei 0, nicht bei 1
* der LCD Adapter ist mit PORTC des RN Control verbunden (Vorteil: an den LEDs von PORTC kann erkannt werden, ob überhaupt Daten an das LCD gesendet werden)
* der Controler im LCD ist ein SPLC780D, welcher mit dem in lcd.h genutzten HD44780 kompatibel ist
müssen die nachfolgenden Zeilen in lcd.h entsprechend angepasst werden.

<pre>
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */
</pre>
Die DDRAM Adressen der einzelnen Zeilen sind im Datenblatt hinterlegt. Zeile 1 und 3 sowie 2 und 4 bilden intern je eine Zeile.
Der manuelle Zeilenumbruch am Ende des Codeblocks bleibt Geschmacksache.
<pre>
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 1 /**< 0: no wrap, 1: wrap at end of visibile line */
</pre>
4-Bit I/O Mode wird verwendet.
<pre>
#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
</pre>
Wie oben angedeutet werden die Pins von 0 an gezählt. "LCD_DATA3_PIN 0" ist somit Pin 1 des LCD Adapters.
<pre>
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 3 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 2 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 1 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 0 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 7 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 6 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 5 /**< pin for Enable line */
</pre>

Testprogramm:
<pre>
#include <stdlib.h>
#include <avr/io.h>
#include <lcd.c>

int main(void)
{

lcd_init(LCD_DISP_ON_CURSOR_BLINK);
lcd_clrscr();
lcd_puts("test");

return 0;
}
</pre>

==Siehe auch==

* [[Bascom_und_LCD%27s|BASCOM und LCD's]]
* [[Portexpander_am_AVR|Portexpander am AVR]]
* [[AVR]]
* [[I2C|I²C-Bus]]

==Weblinks==

* [http://www.mcselec.com/index.php?option=com_content&task=view&id=82&Itemid=57 MCS electronics AN #118] - I²C LCD and Keyboard library
* [http://jump.to/fleury Peter Fleury's Homepage] - Interfacing a HD44780 Based LCD to an AVR, LCD library for HD44870 based LCD's
* [http://www.display3000.com Display3000 Homepage] - Verkaufen Farb-TFTs und TFT-Komplettlösungen inkl. Bascom und GCC (WinAVR) Ansteuerung und div. Utilities

==Autore(en)==

[[Benutzer:m_a_r_v_i_n|m a r v i n]]

[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Quellcode_Bascom]]
[[Kategorie:Quellcode_C]]

LCD-Modul am AVR

2009-10-02T06:57:47Z

Andun: /* Befehlsübersicht */

[[Bild:lcdmodul_2.jpg|right|thumb|350px|LCD-Modul]]

==Einleitung==

LCD ist eine Abkürzung und bedeutet '''''L'''iquid '''C'''rystal '''D'''isplay''. Übersetzt bedeutet dies Flüssigkristall-Anzeige. Flüssigkristalle sind organische Verbindungen, die Eigenschaften von Flüssigkeiten und Festkörpern besitzen. Zwischen zwei Glasplatten mit Polarisationsfiltern schwimmen die Flüssigkristalle. Durch Anlegen einer Wechselspannung ändert sich die Polarisationsebene der Flüssigkristalle und damit, ob das einfallende Licht reflektiert oder absorbiert wird.

Bei einem LCD-Modul befindet sich neben dem LCD auch ein Controller zur Ansteuerung des LCDs.

==Text-Displays==

Text-Displays kommen wegen der problemlosen Anbindung in Mikrocontroller Projekten wie Robotern am häufigsten zum Einsatz. Bei Text-LCDs kommen meistens der HD44780 von Hitachi oder ein kompatibler Controller zum Einsatz. Dieser Controller unterstützt Displays mit bis zu 80 Zeichen. Gängige Displaygrößen sind: 8 × 1, 8 × 2, 16 × 1, 16 × 2, 20 × 2, 20 × 4, 40 × 2 Zeichen Displays (Spalten × Zeilen). Hat das Display mehr als 80 Zeichen, dann benötigt das Display 2 Controller und verhält sich nach außen zur Ansteuerung, wie 2 Displays (zusätzliche Enable Leitung)

===Anschlußbelegung für ≤80 Zeichen Displays===

Text-Displays verfügen über genormte 14 Anschluss Pins (LCD-Module mit Backlight über 16 Pins). Lediglich bei der Backlight Versorgungsspannung und Polung kann es Unterschiede geben. Im Zweifelsfall hilft hier der Blick ins Datenblatt. Entweder sind die Anschlüsse in einer Reihe (1 × 14(16)) oder zweireihig (2 × 7(8)) herausgeführt.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Pin'''
|'''Bezeichnung'''
|'''Beschreibung'''
|-
|1
|GND
|Masse
|---
|2
|VCC
|Spannungsversorgung +5V
|---
|3
|VEE
|Kontrast Poti 0..0,5V
|---
|4
|RS
|Register Select, 1=Daten schreiben / 0=Kommando senden.
|---
|5
|R/W
|1=Read / 0=Write zum lesen / schreiben in das Display RAM
|---
|6
|Enable
|Fallende Flanke -> Übertragen des Kommandos oder der Daten, H-Pegel -> Lesen von Daten aus dem Display
|---
|7
|DB0
|Datenbus Bit0 LSB
|---
|8
|DB1
|Datenbus Bit1
|---
|9
|DB2
|Datenbus Bit2
|---
|10
|DB3
|Datenbus Bit3
|---
|11
|DB4
|Datenbus Bit4
|---
|12
|DB5
|Datenbus Bit5
|---
|13
|DB6
|Datenbus Bit6
|---
|14
|DB7
|Datenbus Bit7 MSB
|}

===HD44780 kompatibler LCD Controller===

Der HD44780 LCD Controller besitzt 3 Speicher. Den DDRAM (Display Data RAM) Darin werden die anzuzeigenden Daten geschrieben.
Der CGROM (Character Generator ROM) enthält die Zeichen in Form von 5x8 oder 5x10 Punktmatrizen.
Im CGRAM (Character Generator RAM) können acht benutzerdefinierte Zeichen 5x8 Pixel oder vier 5x10 Pixel abgelegt werden.

====Befehlsübersicht====

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Befehl'''
| '''RS'''
| '''R/W'''
| '''DB7'''
| '''DB6'''
| '''DB5'''
| '''DB4'''
| '''DB3'''
| '''DB2'''
| '''DB1'''
| '''DB0'''
| '''Beschreibung'''
| '''Ausführungszeit bei fosc=250kHz'''
|-
|Clear Display
|0
|0
|0
|0
|0
|0
|0
|0
|0
|1
|Löscht das Display und setzt den Cursor auf den Anfang der 1. Zeile (Addresse 0).
|1.64mS
|-
|Cursor Home
|0
|0
|0
|0
|0
|0
|0
|0
|1
|*
|setzt den Cursor auf den Anfang der 1. Zeile (Addresse 0)
|1.64mS
|-
|Entry mode set
|0
|0
|0
|0
|0
|0
|0
|1
|I/D
|S
|Setzt die Cursor Bewegungsrichtung (I/D), spezifiziert das Display zu schieben (S). Diese Operationen werden während des Daten lesen/schreiben durchgeführt.
|40uS
|-
|Display on/off Control
|0
|0
|0
|0
|0
|0
|1
|D
|C
|B
|Schaltet an/aus: das gesamte Display (D), Den Cursor (C) Cursor blinken (B).
|40uS
|-
|Cursor/Display shift
|0
|0
|0
|0
|0
|1
|S/C
|R/L
|*
|*
|Setzt Cursor Bewegung oder Display Bewegung (S/C), Bewegungsrichtung (R/L)
|40uS
|-
|Function set
|0
|0
|0
|0
|1
|DL
|N
|F
|*
|*
|Einstellen der Schnittstellen Datenlänge (DL), Anzahl Display Zeilen (N) und Zeichen Font (F).
|40uS
|-
|Set CGRAM Address
|0
|0
|0
|1
|colspan=6 |CGRAM Adresse
|Setzen der CGRAM Adresse. CGRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Set DDRAM Address
|0
|0
|1
|colspan=7 |DDRAM Adresse
|Setzen der DDRAM Adresse. DDRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Read busy-flag and address counter
|0
|1
|BF
|colspan=7 |CGRAM / DDRAM Adresse
|Liest das Busy-flag (BF), welches anzeigt das interne Operationen ausgeführt werden, und liest den CGRAM oder DDRAM Adress Zeiger Inhalt.
|0uS
|-
|Write to CGRAM or DDRAM
|1
|0
|colspan=8 |Schreib Daten
|Schreibt Daten zum CGRAM oder DDRAM.
|40uS
|-
|read from CGRAM or DDRAM
|1
|1
|colspan=8 |Lese Daten
|Liest Daten vom CGRAM oder DDRAM.
|40uS
|}

Anmerkungen:
* DDRAM = Display Data RAM.
* CGRAM = Character Generator RAM.
* DDRAM Adresse entspricht der Cursor Position.
* * = egal.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Bit Name'''
|'''Einstellung / Status'''
|
|-
|I/D
|0 = Erniedrige Cursor Position
|1 = Erhöhe Cursor Position
|-
|S
|0 = Display nicht schieben
|1 = Display schieben
|-
|D
|0 = Display aus
|1 = Display an
|-
|C
|0 = Cursor aus
|1 = Cursor an
|-
|B
|0 = Cursor blinken aus
|1 = Cursor blinken an
|-
|S/C
|0 = Bewege Cursor
|1 = Schiebe Display
|-
|R/L
|0 = Schiebe nach links
|1 = Schiebe nach rechts
|-
|DL
|0 = 4-bit Interface
|1 = 8-bit Interface
|-
|N
|0 = 1/8 oder 1/11 Duty (1 Zeile)
|1 = 1/16 Duty (2 Zeilen)
|-
|F
|0 = 5x7 Punkte
|1 = 5x10 Punkte
|-
|BF
|0 = Befehle werden akzeptiert
|1 = Interne Operation wird ausgeführt
|}

===8-Bit Ansteuerung (Busmode)===

Für die 8-Bit Busmode Ansteuerung funktioniert nur bei AVR Prozessoren mit externem Bus Interface. Diesen Mode unterstützen allerdings nur die wenigsten Atmel AVR Prozessoren, z.B. der AT90S8515 und ATmega128. Der Busmode empfiehlt sich, wenn man in der Applikation auch externen Speicher verwendet.

[[Bild:lcdmodul_8bit_schem.png|center|thumb|600px|8-Bit Ansteuerung. Quelle: Peter Fleury]]

====BASCOM-AVR Programm====
Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode.
<pre>
$regfile = "8515def.dat"
$crystal = 4000000
$lcd = &HC000 'Adresse LCD Daten
$lcdrs = &H8000 'Adresse LCD Register select

Config Lcdbus = 8 'LCD im 8-Bit Bus Mode
Config Lcd = 16 * 2 'wir verwenden ein 16 x 2 Zeichen Display

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 4000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 2 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 16 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 0 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
...
#elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || defined(__AVR_ATmega64__) || \
defined(__AVR_ATmega8515__)|| defined(__AVR_ATmega103__) || defined(__AVR_ATmega128__) || \
defined(__AVR_ATmega161__) || defined(__AVR_ATmega162__)
/*
* memory mapped mode is only supported when the device has an external data memory interface
*/
#define LCD_IO_DATA 0xC000 /* A15=E=1, A14=RS=1 */
#define LCD_IO_FUNCTION 0x8000 /* A15=E=1, A14=RS=0 */
#define LCD_IO_READ 0x0100 /* A8 =R/W=1 (R/W: 1=Read, 0=Write */
#else
#error "external data memory interface not available for this device, use 4-bit IO port mode"

#endif

...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung mit Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 7 Prozessor Ports benötigt. Die Abfrage des Busy Flags ist durch die Verdrahtung des R/W Pins möglich.

[[Bild:lcdmodul_4bitbusy_schem.png|center|thumb|600px|4-Bit Ansteuerung mit Busy]]
Anmerkung: Unbenutzte Pins des Datenports vom LCD sollten auf GND gelegt werden, da sie ansonsten auf keinen definierten Pegel liegen und Störsignale empfangen.

Hier ein [http://picasaweb.google.de/lh/photo/7xU12-9CwCJUXh5XCC7LsQ?authkey=Gv1sRgCI3H2aul1-TmNg&feat=directlink Beispielaufbau] auf einem Steckboard.

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode benötigt einer spezielle LCD Bibliothek, die 'lcd4busy.lib'. Leider müssen bei der Verwendung dieser Bibliothek alle Pins des LCD Modul an den selben Prozessor Port angeschlossen werden.
<pre>
$lib "lcd4busy.lib" 'ersetzt die Standard LCD Bibliothek
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
Const _lcdport = Portc
Const _lcdddr = Ddrc
Const _lcdin = Pinc
Const _lcd_e = 1
Const _lcd_rw = 2
Const _lcd_rs = 3

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
/**
* @name Definitions for 4-bit IO mode
* Change LCD_PORT if you want to use a different port for the LCD pins.
*
* The four LCD data lines and the three control lines RS, RW, E can be on the
* same port or on different ports.
* Change LCD_RS_PORT, LCD_RW_PORT, LCD_E_PORT if you want the control lines on
* different ports.
*
* Normally the four data lines should be mapped to bit 0..3 on one port, but it
* is possible to connect these data lines in different order or even on different
* ports by adapting the LCD_DATAx_PORT and LCD_DATAx_PIN definitions.
*
*/
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 4 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 5 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 6 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 7 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 3 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 2 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 1 /**< pin for Enable line */
...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung ohne Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 6 Prozessor Ports benötigt. Die R/W Leitung des Displays kann man dabei einfach auf GND legen, dann ist aber keine Busy-Bit Abfrage möglich.

[[Bild:lcdmodul_4bit_schem.png|center|thumb|600px|4-Bit Ansteuerung]]

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode.
<pre>
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
' Im I/O Mode wird jeder Prozessor Pin einzeln angegeben
Config Lcdpin = Pin , Db4 = Portc.0 , Db5 = Portc.1 , Db6 = Portc.2 , Db7 = Portc.3 , E = Portc.5 , Rs = Portc.4

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über Porterweiterung===

Mit einem Porterweiterungs Baustein wie dem 74HC595 lassen sich weitere Prozessor-Ports einsparen. Diese Lösung kommt mit 4 Prozessor Ports aus, läßt man die Abfrage des Busy-Bits (PC5) weg, sogar nur mit 3 Prozessor Ports. Trotzdem wird das Display im 8-Bit Mode betrieben.

[[Bild:lcdmodul_portexp_schem.png|center|thumb|600px|Ansteuerung über Porterweiterung]]

====BASCOM-AVR Programm====

Das BASCOM Programm für diese Ansteuerung ist nicht ganz so einfach, da es nicht von der BASCOM Library unterstützt wird. Die Routinen zum Ansprechen des Displays muß man selbst coden.

<pre>

TODO....

</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über I²C===

Nur 2 Prozessor Ports benötigt man bei der I²C-Ansteuerung. Dazu wird als I²C Porterweiterungs IC der PCF8574P benötigt.

[[Bild:lcdmodul_i2c_schem.png|center|thumb|600px|I²C-Ansteuerung]]

====BASCOM-AVR Programm====
Diese Ansteuerung basiert auf der Application Note AN#118 von MCS electronics. Dazu gibt es auch eine fertige Library zu BASCOM-AVR, die die Standard LCD Library ersetzt. Dadurch können die gleichen Befehle zur Ansteuerung verwendet werden wie bei der Standard LCD Library. Das BASCOM-AVR Programm, um das LCD-Modul über I²C anzusprechen, sieht dann so aus.
<pre>
$lib "Lcd_i2c.lib" 'ersetzt die Standard LCD Library
$regfile = "m32def.dat"
$crystal = 16000000

Const Pcf8574_lcd = &H40 'I2C Adresse
Config Scl = Portc.0 'I2C SCL Pin
Config Sda = Portc.1 'I2C SDA Pin
Dim _lcd_e As Byte
_lcd_e = 128 'LCD im 4-Bit Mode betreiben

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über RS232===

Ebenfalls nur 2 Pins zur Ansteuerung benötigt die Lösung. Allerdings ist die serielle Schnittstelle bei Mikrocontrollern oft schon mit anderen Aufgaben belegt. Deshalb befindet sich meistens noch zusätzlich eine I²C-Bus Schnittstelle zur Ansteuerung auf dem Modul.

==Graphik-Displays==

In Mikrocontroller-Anwendungen werden seit neuestem, einhergehend mit der größeren Verbreitung von Controllern mit mehr Speicherplatz, auch immer öfter Grafik-Displays und Farb-TFTs eingesetzt. Der Aufwand an Software und Hardware ist hier allerdings um einiges höher (jedes Pixel ist einzeln anzusteuern).

==LCD über RN LCD Adapter Std an RN-Control==

Hierbei handelt es sich um eine Beispielansteuerung eines LCD über RN LCD Adapter Std an RN-Control in C.

Komfortabel lässt sich ein LCD in C mit der LCD Library von Peter Fleury ansteuern (LCD Controller HD44780 & KS0073).
Die Library selbst sowie deren Online Dokumentation und weiterführende informationen sind von [http://jump.to/fleury Peter Fleury's Home Page]zu entnehmen.

Im hier aufgeführten Beispiel wird ein Crystalfontz 20x4 LCD verwendet (CFAH2004A-YYH-JPE).

Pinbelegung nach [http://www.crystalfontz.com/product/CFAH2004AYYHJPE.html Datenblatt]
<pre>
Pin No. Symbol Level Description
1 VSS 0V Ground
2 VDD 5.0V Supply Voltage for logic
3 VO (Variable) Operating voltage for LCD
4 RS H/L H: DATA, L: Instruction code
5 R/W H/L H: Read(MPU?Module) L: Write(MPU?Module)
6 E H,H?L Chip enable signal
7 DB0 H/L Data bit 0
8 DB1 H/L Data bit 1
9 DB2 H/L Data bit 2
10 DB3 H/L Data bit 3
11 DB4 H/L Data bit 4
12 DB5 H/L Data bit 5
13 DB6 H/L Data bit 6
14 DB7 H/L Data bit 7
15 A - LED +
16 K - LED -
</pre>

Pinbelegung des LCD Adapters nach [http://www.robotikhardware.de/download/rn_LCD_adapter_std.pdf Datenblatt]
<pre>
Pin 1 LCD DB7
Pin 2 LCD DB6
Pin 3 LCD DB5
Pin 4 LCD DB4
Pin 5 Licht ein/aus per Port (da EN2 hier nicht benötigt wird)
Pin 6 LCD EN
Pin 7 LCD R/W
Pin 8 LCD RS
Pin 9 GND LCD GND und Licht Kathode
Pin 10 +5V LCD VCC und Licht Anode
</pre>

Berücksichtigt man die folgenden Tatsachen:
* ATMega32 auf dem RN-Control stellt kein "external memory interface" zur Verfügung, daher ist ohne Weiteres keine 8-Bit Ansteuerung des LCD möglich. Es wird 4-Bit I/O verwendet
* die Zählweise der Pins beginnt in lcd.h bei 0, nicht bei 1
* der LCD Adapter ist mit PORTC des RN Control verbunden (Vorteil: an den LEDs von PORTC kann erkannt werden, ob überhaupt Daten an das LCD gesendet werden)
* der Controler im LCD ist ein SPLC780D, welcher mit dem in lcd.h genutzten HD44780 kompatibel ist
müssen die nachfolgenden Zeilen in lcd.h entsprechend angepasst werden.

<pre>
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */
</pre>
Die DDRAM Adressen der einzelnen Zeilen sind im Datenblatt hinterlegt. Zeile 1 und 3 sowie 2 und 4 bilden intern je eine Zeile.
Der manuelle Zeilenumbruch am Ende des Codeblocks bleibt Geschmacksache.
<pre>
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 1 /**< 0: no wrap, 1: wrap at end of visibile line */
</pre>
4-Bit I/O Mode wird verwendet.
<pre>
#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
</pre>
Wie oben angedeutet werden die Pins von 0 an gezählt. "LCD_DATA3_PIN 0" ist somit Pin 1 des LCD Adapters.
<pre>
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 3 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 2 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 1 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 0 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 7 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 6 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 5 /**< pin for Enable line */
</pre>

Testprogramm:
<pre>
#include <stdlib.h>
#include <avr/io.h>
#include <lcd.c>

int main(void)
{

lcd_init(LCD_DISP_ON_CURSOR_BLINK);
lcd_clrscr();
lcd_puts("test");

return 0;
}
</pre>

==Siehe auch==

* [[Bascom_und_LCD%27s|BASCOM und LCD's]]
* [[Portexpander_am_AVR|Portexpander am AVR]]
* [[AVR]]
* [[I2C|I²C-Bus]]

==Weblinks==

* [http://www.mcselec.com/index.php?option=com_content&task=view&id=82&Itemid=57 MCS electronics AN #118] - I²C LCD and Keyboard library
* [http://jump.to/fleury Peter Fleury's Homepage] - Interfacing a HD44780 Based LCD to an AVR, LCD library for HD44870 based LCD's
* [http://www.display3000.com Display3000 Homepage] - Verkaufen Farb-TFTs und TFT-Komplettlösungen inkl. Bascom und GCC (WinAVR) Ansteuerung und div. Utilities

==Autore(en)==

[[Benutzer:m_a_r_v_i_n|m a r v i n]]

[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Quellcode_Bascom]]
[[Kategorie:Quellcode_C]]

HDD44780

2009-10-02T06:51:34Z

Andun: Artikel erstellt, damit Suchbegriffe Ergebnisse liefern.

Rc5

2009-09-23T14:26:08Z

Andun: Artikel erstellt, damit die Suche nach RC5 ein Ergebnis liefert, dass zum Decoder führt.

RC-5 ist die Bezeichnung für einen Fernbedienungscode (vorrangig Infrarot-Fernbedienungen) der Firma Philipps, der inzwischen weite Verbreitung gefunden hat.

==Siehe auch==
* [[RC5-Decoder_für_ATMega]]

==Weblinks==
* [http://www.sprut.de/electronic/ir/rc5.htm IR-Fernbedienung - der RC-5 Code]

Digitaltechnik take it easy Part1

2009-08-07T12:05:17Z

Andun: /* Vorwort */

= Digitaltechnik take it easy Part1 =

== Vorwort ==
Digitaltechnik ist einfacher, als so mancher denkt.
Diese Reihe führt euch in die Grundlagen der Digitaltechnik ein bis hin zu komplexen Schaltungen.
Begleitet werden die Beiträge durch praktische Experimente die weitgehend ohne Lötkolben auskommen.
Dies wird der Einsteiger als auch der Analog Elektroniker Schritt für Schritt gehen können und am Ende in der Lage sein Problemlösungen der Praxis selbst zu entwerfen.

=== Theorie was ist das? ===
Diese Reiche soll allen etwas bieten die an der digitaltechnik interessiert sind. wir werden nahe zu das gesamte Gebiet der Digitaltechnik erforschen und uns im praktischen Experimenten erarbeiten. Gleich greifen wir in die Praxiskiste, ohne viel Theorie ;),nichts ist anschaulicher als das praktische Experiment. So ergibt sich auch ohne viel Mate die grundfunktionen der Digitaltechnik die wir auch in größeren Schaltungen anwenden werden mit praktischen Anwendungen.

=== Die Reiseroute ===

Flip-Flop; Tohrschaltung; Schwingungserzeugung; Teiler; Zähler; Speicher; und Decoder lernen wir kennen und bauen praktische Schaltungen vom Pägelprüfer über eine Zähler bis hin zu einer Digitahluhr. (keine Angst an dieser stelle "take it easy") am ende solte jeder in der lage sein, fast jedes digitale Schaltunsproblem zu lösen wenn nicht wir haben auch ein gutes Forum

=== Versprochen ist Versprochen ===
Für unsere Expriment möchten wir viele kleine Schaltunen aufbauen ohne immer wieder neu löten zu müssen. Es bietet sich dafür ein Steck-Experimentierboard an, das es ermöglicht nur durch Stecken viele Schaltungslösunegn zu erarbeiten. Da die Schaltungen in den späteren Part's immer größer werden wählt man (fals noch kein Experimentierboard vorhanden oder schon die entscheidung zum löten gefallen ist) am besten ein mitelgroßes mit Anschlusklemmen für die Versorgungsspannung.

=== Scotty Energy ===
Schrieb ich Versorgungsspanung was braucht eigentlich so ein Digitalbaustein an Spannnung? aber dazu später mehr eine 9V Batterie oder Akumolator solte ausreichen, da diese Serie vorwiegend mit Sparsamen C-MOS Bauteilen aufgebaut wird. Beim späteren vergleich der Schaltkreissysteme erfahren wir noch mehr

Wer ein Netzteil benutzen möchte benötigt eine stabilisierte Spannung. '''''Schliest auf keinen fall auf keinen Fall ein unstabilisierte Steckernetzteil an die Digialschaltkreise an''''' da diese fast keine Last darstellen für ein solches Netzteil und euch nur die IC's brutzelt. Abhilfe schaft ein Festspannungsregler mit Peripherie der auf 5V ausgelegt sein solte (da unterschiedliche Schaltkreissysteme unter schiedliche Versorgungsspanungen haben wir komen noch drauf zu sprechen) Die schalung dafür seht ihr unten

[[Image:Festspannungsregler.jpg]]

Bei den Elkos ist auf die richtige Polung zu achten an Pin 1 des Reglers kommt die posietive Spannung des Steckernetzteils (mit Mulitimeter heraus messbar)an den Mitlerenpin (Pin2) wird Ground/OV Angeschlossen dies wird auch mit der Masseschiene des Experimentierboard's verbunden und schon kann an Pin 3 die 5V Spannung entnommen werden die direkt an die Schaltkreis geführt wird

= 1 oder 0 oder 1 =
ja das ist Digitaltechnik. Sie beruht tatsächlich auf einem Zahlensystem, das aus zwei Ziffern besteht, richtig geraten ,der 1 und der 0. Es ist das Binärsyste, das nur auf diesen Zahlen, Dualzahlen genannt berut. Der Begriff Digitahltechnik kommt übrigens aus dem Englischen Wort für Zahl "digit" den die digitahltächnik tut nichts anderes als zählen , zählen

Der Vorteil eines Dualsystems ist die Eindeutigkeit der Zuordnung zweier Pegelständezustände, entweder die logische 1, auch High-Pegel oder kurz H genannt oder die logische 0, Low-Pegel genannt oder L.

Veifacht gesagt
# High = Spannung liegt an
# Low = Spannung liegt nicht an

Was unter einer Spannung und keiner Spannung zu verstehen istshen wir gleich

= Die Tabelle der Wahrheit =

Avr

2009-03-31T12:39:49Z

Andun: /* Entwicklungsumgebungen */

[[Bild:AtmelController.jpg|thumb|Beispiel eines AVR Controllers]]
'''AVR''' ist eine 8-Bit [[Microcontroller]]-Familie mit RISC-Architektur.
Im Gegensatz zu vielen anderen Microcontroller-Architekturen hat die AVR-Architektur keine Vorgänger. Sie ist ein komplettes Neudesign, das Anfang der 90-Jahre an der Universität von Trondheim/Norwegen entwickelt und vom (bis heute einzigen) Hersteller [[Atmel]] aufgekauft wurde. Es gibt eine ganze Serie von AVR-Controllern. Sie alle werden ähnlich programmiert, haben vergleichbaren Befehlssatz und physikalische Eigenschaften, bieten jedoch unterschiedliche Features und Peripherie.

Es gibt zahlreiche und kostenlose Entwicklungssysteme in den Sprachen Basic, C/C++, Pascal und Assembler für diese Controller-Familie.

== Wofür steht AVR? ==
"AVR" steht angeblich für ''Advanced Virtual RISC'' (in einem Paper der Entwickler des AVR-Kerns Alf Egin Bogen und Vegard Wollan). Laut [[Atmel]] bedeutet es nichts.

== Hardware ==
AVR-Controller besitzen eine zweistufige Pipeline (fetch and execute), die es ermöglicht, die meisten Befehle innerhalb eines einzigen Prozessortaktes auszuführen. Dadurch ist ein AVR wesentlich schneller als etwa 8051-Controller, bei denen der Prozessortakt intern noch durch 12 geteilt wird.

*AVR-Kern
** Harvard-Architektur (getrennter Befehls- und Datenspeicher)
** 32 Register, kein Akkumulator, 3 Pointerregister
** EEPROM-Datenspeicher
** [[Watchdog]], [[Bootloader]]-Support, verschiedene Stromspar-Modi, Brownout-Erkennung, Interner Oszillator
** Lineares Speichermodell (keine Segmentierung)
** 8-Bit Architektur ist für Hochsprachen (C) optimiert
* In-System programmierbar: die Controller können sehr einfach über ein Programmierkabel (oft ISP-Kabel genannt), das mit dem PC verbunden wird, programmiert werden – auch dann, wenn sie sich nicht in einer Schaltung befindet.
* umfangreiche Peripherie
** 8- und 16-Bit-Timer/Counter mit [[PWM]], Capture/Compare, externe Betaktung, asynchrone Operation
** Kommunikation: [[UART|USART]], [[SPI]], [[I2C]] ([[TWI]])
** Analog-Comparator, Analog-Digital-Wandler
** unterschiedlichste externe und interne Interrupt-Quellen (UART, SPI, Timer, A/D-Wandler, Analog-Comparator, ...)
** JTAG (Debugerinterface)
* AVR Typen (AT90 "Classic AVR", ATtiny, ATmega)
* erhältlich in unterschiedlichen Gehäusen, idR Durchsteck und als [[SMD]]
* Viele Entwicklungsboards erhältlich, z.B. das Roboternetzboard [[RN-Control]]

==Einige Pinbelegungen der populärsten AVR-Controller==
(in etwa nach Leistungsfähigkeit sortiert)

* [[AT90S2313]]

[[Bild:at90s2313tiny.png|center]]

* [[Atmel Controller Mega8]]
* [[Atmel Controller Mega48 Mega88 Mega168]]

[[Bild:mega8kompatibel.png|center]]

* [[Atmel Controller Mega16 und Mega32]]

[[Bild:Mega1632.gif|center]]

* [[Atmel Controller Mega128]] ([[SMD]]-Chip)

[[Bild:mega128pin.gif|center]]

----

=== Die AVR-Pin-Bezeichnungen und deren Funktion ===
Die meisten Ports sind doppelt belegt und besitzen neben der normalen Port-Funktion noch eine Sonderfunktion. Die verschiedenen Pinbezeichnungen und Sonderfunktionen werden hier beschrieben:

{| {{Blauetabelle}}
|+ '''Tabelle: Die AVR-Pin-Bezeichnungen und deren Funktion'''

|- {{Hintergrund1}}
! colspan="2"| Versorgungs- und Referenzpins, Reset
|-
|'''[[VCC]]'''
| Versorgungsspannung von 2,7 V bis 5,5 V bei den L-Varianten (low power), ansonsten 4,5V bis 5,5 V. Neuere AVR ab 2,7 V und ab 1,8 V in V-Variante.
|-
|'''[[GND]]'''
|Masse
|-
|'''AREF'''
|Referenzspannung für den Analog-Digital-Wandler. Auch die interne Bandgap-Referenzspannung kann über diesen Pin entstört werden (dann KEINE externe Spannung an diesen Pin geben (Kurzschluss)!).
|-
|'''AGND'''
|Analoge Masse für AD Wandler und dazugehörige Ports. Sollte in aller Regel mit GND verbunden werden.
|-
|'''AVCC'''
|
Die Betriebsspannung für den Analog-Digital-Wandler (und einiges mehr) (siehe Beschaltungsskizze). Die Pins AVCC und AGND müssen immer beschaltet werden, selbst wenn man den AD-Wandler und Port A nicht benutzt.
|-
|'''RESET'''
|Rücksetz-Eingang, intern über einen [[Pullup]] mit VCC verbunden. Ein LOW–Pegel an diesem Pin für die Dauer von mindestens zwei Zyklen des Systemtaktes bei aktivem Oszillator setzt den Controller zurück. Rücksetzen der Ports erfolgt unabhängig von einem evtl. anliegenden Systemtakt.
|-
|'''PEN'''
|Programming Enable - Diesen Pin gibt es nur beim Mega128/64 u.ä. Wird dieser Pin beim Power-On Reset nach Masse gezogen, geht der Controller in den [[ISP]] Programmiermodus. Man kann ihn also alternativ zu Reset verwenden. In der Regel verwendet man aber die Reset-Leitung und PEN sollte man direkt mit VCC verbinden.

|- {{Hintergrund1}}
! colspan="2"| System-Takt
|-
|'''XTAL1'''
|Eingang des internen Oszillators zur Erzeugung des Systemtaktes bzw. Eingang für ein externes Taktsignal, wenn der interne Oszillator nicht verwendet werden soll bzw. Anschluss von Quarz/Keramik-Resonator/RC-Glied.
|-
|'''XTAL2'''
|Anschluss von Quarz oder Keramik-Resonator oder Ausgang des integrierten Oszillators zur Nutzung als Systemtakt (Je nach Fuse-Einstellungen).

|- {{Hintergrund1}}
! colspan="2"| Digitale bidirektionale I/O-Ports
|-
| colspan="2"| Jeder Pin der Ports kann individuell als Eingang oder Ausgang konfiguriert werden. Die I/O-Ports sind maximal 8 Bit breit und verfügen ja nach AVR-Typ über eine unterschiedliche Anzahl von Pins. An jedem als Eingang (Input) geschalteten Pin gibt es zuschaltbare [[Pullup]]-Widerstände, die teilweise auch bei aktivierter Sonderfunkton verfügbar sind.

Bei eingeschalteten Sonderfunktionen wie UART, SPI, ADC, etc. sind die entsprechenden Pins nicht als "normale" digitale I/O verwendbar, sondern dienen der Sonderfunktion. Die Anzahl der als I/O verwendbaren Pins ist auch abhängig von den Fuse-Einstellungen (Vorsicht beim Umstellen, Handbuch GENAU lesen!).
|-
|'''PA 0 – 7''' || Port A
|-
|'''PB 0 – 7''' || Port B
|-
|'''PC 0 – 7''' || Port C
|-
|'''PD 0 – 7''' || Port D
|-
|'''PE 0 – 7''' || Port E
|-
|'''PF 0 – 7''' || Port F
|-
|'''PG 0 – 7''' || Port G

|- {{Hintergrund1}}
! colspan="2"| Externe Interrupts
|-
| colspan="2"| Die PCINT-Interrupts gibt es nur für neuere AVRs wie den [[ATmega88]]. Falls die Anzahl an externen Interrupts nicht ausreicht, kann evtl. auch andere Hardware dafür eingesetzt werden, etwa der Analog-Comparator mit interner Bandgap-Referenz, falls er anderwärtig nicht gebraucht wird.
|-
|'''INT0''' ||Externer Interrupt 0
|-
|'''INT1''' ||Externer Interrupt 1
|-
|'''INT2''' ||Externer Interrupt 2
|-
|'''PCINTx''' ||Pin-Change Interrupt

|- {{Hintergrund1}}
! colspan="2"| [[Timer]] und [[PWM]]
|-
|'''T0'''
|Timer 0: externer Takteingang.
|-
|'''T1'''
|Timer 1: externer Takteingang.
|-
|'''OC0'''
|PWM bzw. Output Compare Ausgang des Timers 0
|-
|'''OC1A'''
|Ausgang für die Compare-Funktion des integrierten Zeitgeber- / Zählerbausteines
Der erste PWM-Ausgang des Timers1. Er kann zum Regeln der Bot-Motorgeschwindigkeit benutzt werden.
|-
|'''OC1B'''
|Ausgang für die Compare-Funktion des integrierten Zeitgeber- / Zählerbausteines
Der zweite PWM-Ausgang des Timers1. Er kann zum Regeln der Bot-Motorgeschwindigkeit benutzt werden.
|-
|'''ICP1'''
|Eingang für die [[Timer/Counter_(Avr)#Input_Capture|Capture-Funktion]] des integrierten Zeitgebers / Zählerbausteines

|-
|'''OC2'''
|[[Pwm]] bzw. Output Compare Ausgang des Timers2. Er kann zum Regeln der Bot-Motorgeschwindigkeit benutzt werden.
|-
|'''TOSC1, TOSC2'''
|TOSC1 und TOSC2 sind Eingänge für den asynchronen Modus von Timer2. Sie sind vorgesehen für den Anschluss eines externen Uhrenquarzes ( 32.768 kHz ). Damit lassen sich zum Beispiel sehr genaue Ein-Sekunden-Impulse für eine Uhr generien.

|- {{Hintergrund1}}
! colspan="2"| Analog-Digital-Wandler
|-
|'''ADC0''' bis '''ADC7'''
|Eingänge des AD-Wandlers. Spannungen können hier gemessen werden oder an den Analog-Komparator weiter geleitet werden.

|- {{Hintergrund1}}
! colspan="2"| Analog-Komparator
|-
|'''AIN0, AIN1'''
|Die beiden externen Eingänge des Analog-Komparators.
Mit AIN0(+) und AIN1(-) kann man zwei Spannungen miteinander vergleichen. Wenn die Spannung an AIN0 höher als bei AIN1 ist, liefert der Komparator "High", ansonsten ein "Low". Als interne Eingänge des Komparators können die Interne Bandgap-Referenzspannung oder Ausgänge des ADC-Multiplexers dienen.

|- {{Hintergrund1}}
! colspan="2"| Serielle Schnittstelle ([[UART|USART]])
|-
|'''RXD'''
|Eingang der Seriellen Schnittstelle (Receive Data), TTL-Pegel
|-
|'''TXD'''
|Ausgang Serielle Schnittstelle (Transmit Data), TTL-Pegel
|-
|'''XCK'''
|Externe Takt für den USART. Wird nur in Sonderfällen für den Takt benötigt.
USART ("Universal Synchronous/Asynchronous Receiver and Transmitter"). Das ist die serielle Schnittstelle, die zur Datenübertragung zwischen Mikrocontroller und PC genutzt wird. Zur bidirektionalen Übertragung werden zwei Pins am Controller benötigt: TXD und RXD. Über TXD ("Transmit Data") werden Daten gesendet, RXD ("Receive Data") dient zum Empfang.

|- {{Hintergrund1}}
! colspan="2"| [[SPI]]-Schnittstelle
|-
|'''SS'''
|SPI-Interface – wird benötigt, um den µC als aktiven Slave auszuwählen
|-
|'''MOSI'''
|SPI-Interface – Datenausgang (als Master) oder Dateneingang (als Slave), verwendet bei ISP (In-System-Programmierung)
|-
|'''MISO'''
|SPI-Interface – Dateneingang (als Master) oder Datenausgang (als Slave), verwendet bei ISP (In-System-Programmierung)
|-
|'''SCK'''
|SPI-Interface – Bustakt vom Master, verwendet bei ISP (In-System-Programmierung)

|- {{Hintergrund1}}
! colspan="2"| [[I2C|I2C]]-Schnittstelle ([[TWI]])
|-
|'''SDA'''
|I2C-Schnittstelle (Bus aus 2 Leitungen) Datenleitung
|-
|'''SCL'''
|I2C-Schnittstelle (Bus aus 2 Leitungen) Clockleitung

|- {{Hintergrund1}}
! colspan="2"| [[JTAG]]-Interface
|-
|'''TDI'''
|JTAG-Debug Interface - Über dieses Interface kann man den AVR programmieren und debuggen. Die Schnittstelle ist ähnlich wie die SPI Schnittstelle und hat getrennte Dateneingangs- und Datenausgangsleitungen sowie eine Taktleitung. TDI ist die Dateneingangsleitung
|-
|'''TDO'''
|JTAG-Debug Interface - TDO ist die Datenausgangsleitung des JTAG Interface
|-
|'''TMS'''
|JTAG-Debug Interface
|-
|'''TCK'''
|JTAG-Debug Interface
|}

== Timer/Counter ==
Für Infos zu Timer und Counter siehe Artikel [[Timer/Counter (Avr)]].

== Analog-Digital-Wandler ==
Für Infos zu Analog-Digital-Wandler siehe Artikel [[ADC (Avr)]].

== Analog-Komparator ==
Für Infos zu Analog-Komparator siehe Artikel [[Analog Komparator (Avr)]].

== TWI/I2C ==
Für Details über das Two-wire Serial Interface (kurz [[TWI]]) siehe Artikel [[TWI]].

== UART/USART ==
Für Details über den UART/USART siehe Artikel [[UART]].

== SPI - Serial Peripheral Interface ==
Für Details über SPI siehe Artikel [[SPI]].

Näheres zu SPI beim AVR siehe [[SPI (AVR)]].

== USI - Universal Serial Interface ==
Für Infos zu USI (Universal Serial Interface) siehe Artikel [[USI (Avr)]].

== Die Fusebits ==
Zur Konfigurierung eines AVR-Controllers werden Fusebits benutzt. Bei der Auslieferung neuer AVR Controller sind die Fusebits bereits vorkonfiguriert, in der Regel auf den internen RC Oszillator und etwa 1 MHz Frequenz. In vielen Fällen kann die Konfiguration unverändert bleiben. Bei den Typen Mega xxx bestimmen einige Fusebits beispielsweise, dass der interne Taktgeber aktiviert ist. Soll z.B. dagegen ein externer Quarz anschlossen oder die Taktfrequenz geändert werden, so müssen auch die Fusebits geändert werden. Auch das Deaktivieren des "[[On Chip Debugging]]" Modus ist oft notwendig, wenn alle Ports genutzt werden sollen.

Die Fusebits werden in der Regel über die Software eingestellt, welche auch für das Übertragen des Programmcodes zuständig ist. Besonders einfach geht dies beispielsweise mit der Entwicklungsumgebung [[Bascom]]. Aber auch andere Programme wie [[PonyProg]] können für die Umstellung der Fusebits genutzt werden. Einmal eingestellte Fusebits bleiben bis zur erneuten Fusebit-Änderung erhalten. Der normale Programmiermodus verändert die Fusebits nicht.

Je nach AVR Controllertyp sind unterschiedliche Fusebits (Einstellungen) vorhanden. Die genaue Beschreibung findet man im jeweiligen Datenblatt. Da aber falsch gesetzte Fusebit-Einstellungen zu den häufigsten Problemen gehören, liste ich hier die Funktion der üblichen Fusebits nochmals genauer auf:

{| {{Blauetabelle}}
|'''CKSEL0, CKSEL1, CKSEL2, CKSEL3'''
|Die Kombination dieser 4 Fusebits bestimmt die Taktquelle des Controllers. Das kann eine interner Taktgenerator, ein Quarz, Quarzoszillator, RC-Glied und ähnliches sein.
|-
|'''JTAGEN'''
|Hiermit wird die "[[On Chip Debugging]]" Schnittstelle aktiviert bzw. deaktiviert. Das sind die Bits mit den Bezeichnungen TDI, TDO, TMS und TCK. Möchte man diese Pins als normalen Port nutzen, so muss diese Schnittstelle immer deaktiviert werden. Alternativ kann man das JTAG aber auch per Software deaktivieren.
|-
|'''SUT0, SUT1'''
|Die sogenannte StartUp-Zeit (PowerOn delay). Diese Einstellung muss abhängig von der Art des Taktgenerators eingestellt werden, genaueres im jeweiligen Datenblatt.
|-
|'''SPIEN'''
|Hiermit kann die serielle [[AVR-ISP Programmierkabel|ISP-Programmierung]], welche die meisten Programmierkabel nutzen, deaktiviert werden. Dies sollte man lieber vermeiden, denn wenn dieser Programmiermodus deaktiviert wurde, kann nur noch der Parallel-Programmiermodus genutzt werden. Der Parallel-Programmiermodus benötigt jedoch ein spezielles Programmiergerät, das die wenigsten Bastler besitzen. ''Also Vorsicht!''
|-
|'''BODEN'''
|Über dieses Bit wird der '''Brown-out Detector''' aktiviert bzw. deaktiviert. Dies ist eine Überwachung der Betriebsspannung, die dafür sorgt, dass bei Spannungseinbrüchen ein ordentlicher RESET durchgeführt wird. Dadurch wird verhindert, dass der Controller in einen undefinierten Zustand gerät (hängen bleibt) oder versehentlich das EEPROM / Flash verändert. In der Regel sollte man daher den '''Brown-out Detector''' aktivieren.
|-
|'''BOOTLEVEL'''
|Über dieses Bit kann die Spannung festgelegt werden, ab welcher der '''Brown-out Detector''' den Controller neu startet (also RESET ausführt).
|-
|'''BOOTRST'''
|Gewöhnlich startet ein Programm im Controller nach einem RESET ab Adresse 0. Durch dieses Fusebit kann der Controller jedoch veranlasst werden, nach einem Reset einen sogenannten Bootloader-Bereich auszuführen. Ein [[Bootloader]] kann genutzt werden, um Controller über andere Schnittstellen (z.B. RS232) zu programmieren.
|-
|'''BOOTSZ0, BOOTSZ1'''
|Der zuvor genannte Bootloaderbereich kann bei AVR-Controllern verschieden groß sein. Über diese beiden Bits können vier verschiedene Größen eingestellt werden. Siehe unter [[Bootloader]].
|-
|'''EESAVE'''
|Dieses Bit legt fest, ob beim Programmieren des Controllers (man nennt es auch brennen) immer das EEPROM gelöscht werden soll.
|-
|'''CKOPT'''
|Abhängig von den Einstellungen von CKSEL kann hier dir Oszillator-Verstärkung eingestellt werden. Genaueres im Datenblatt des jeweiligen Controllers.
|-
|'''WDTON'''
|Schaltet den WatchDog-Timer beim Booten ein/aus. Dies ist auch per Software möglich
|-
|'''RSTDISBL'''
|Durch dieses Bit kann man den RESET-Pin deaktivieren und dann als normalen I/O-Port nutzen. Aber Vorsicht! Da die RESET-Leitung beim Programmieren (Brennen) des Chips genutzt wird, kann man nach dessen Deaktivierung den Controller mit den üblichen [[AVR-ISP Programmierkabel|ISP-Adaptern]] nicht mehr programmieren. In diesem Fall könnte man zwar den Controlle noch mit speziellen Programmiergeräten im Parallelmodus programmieren, aber in der Praxis verfügen nur wenige Bastler über ein Programmiergerät, das dies leistet.
|-
|'''LB1, LB2'''
|Das sind die sogenannten Lockbits, mit denen sich das Auslesen des Flash- als auch EEPROM-Speichers verhindern läßt. Zwar können andere Anwender immer noch Daten lesen, allerdings handelt es sich dabei nicht mehr um den wirklichen Inhalt sondern lediglich um wirre Datenbytefolgen. Programmierer, die den erarbeiteten Code vor Raubkopierern schützen wollen, nutzen diese Lockbits. Das Programmieren ist auch bei gesetzen Lockbits noch möglich. Der Bootloader-Bereich wird nicht durch die Lockbits geschützt.
|-
|'''BLB01, BLB02'''
|Durch diese Bits kann der Code sogar vor dem Zugriff durch den Bootloader geschützt werden
|-
|'''BLB11, BLB12'''
|Diese Bits schützen den Bootloaderbereich selbst
|}

Wie man die Fusebits mit [[Bascom]] einstellt, wird im Beitrag [[Bascom - Erstes Programm in den AVR Controller übertragen]] erläutert.

''Autoren des Artikels: Frank, Luma''

== Siehe auch ==
* [[AVR-Einstieg leicht gemacht]]
===Entwicklungsumgebungen===
* [[Microsoft_Visual_Studio_2008_als_AVR_Entwicklungsumgebung| Microsoft Visual Studio]] - Die kostenlose "Express Edition" setzt auf WinAVR und auf den GCC auf, compiliert über custom-build und generiert ein Script für Ponyprog

* [[Bascom]] - Basic-Entwicklungssystem
* [[Bascom - Erstes Programm in den AVR Controller übertragen]]
* [[Avr-gcc|avr-gcc]] - Leistungsfähiger AVR-Port des freien Compilers GCC
* [[WinAVR]] - Freies, kostenloses Werkzeugpaket mit avr-gcc, binutils, tools ([[make]], [[Programmer's Notepad]], [[avrdude]], etc.) für MS-Windows.
* [[Linuxdistribution_Avr-live-cd]]
* [[AVR_Assembler_Einf%C3%BChrung|AVR Assembler Einführung (AvrStudio)]]
* [http://www.mikroe.com/en/compilers/mikropascal/avr/ MikroPascal for AVR] Sehr gute kommerzielle Pascal Entwicklungsumgebung. Der Compiler ist auch für PIC und andere Controller verfügbar.

=== Hardware ===
* [[AVR-ISP Programmierkabel]] - Bauanleitung für die AVR Controller Programmierkabel
* [[RN-Control]] - Eines der beliebtestet AVR-Boards im Roboternetz
* [[RNBFRA-Board]] - Größeres Board mit zwei Atmel Controllern
===Sonstiges===
* [[Atmel]]
* [[HEX Beispiel-Dateien für AVR]]
* [[Bootloader]]
* [[On Chip Debugging]]

== Weblinks ==
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC Aktuelle AVR Vergleichstabelle]
* [http://www.atmel.com/dyn/products/devices.asp?family_id=607 Die Datenblätter zu Atmel Controllern]
* [https://mpg.dnsalias.com/~magerlu/rn-wiki/avrtimer_applet Java Applet Timer Berechnung]
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool (für Bascom, nur nach Anmeldung)]
* [http://people.freenet.de/gjl/helferlein/avr-uart-rechner.html AVR-Baudraten-Rechner (JavaScript)]

[[Kategorie:Microcontroller]]
[[Kategorie:Grundlagen]]
[[Kategorie:Elektronik]]
[[Kategorie:Abkürzung|AVR]]

UART mit avr-gcc

2009-01-03T15:35:04Z

Andun: /* WebLinks */

Hier werden zwei verschiedene Arten vorgestellt, wie die [[UART]] benutzt werden kann. Die erste Variante verzichtet auf [[Interrupt]]s und [[Interrupt#Unterschiede zum Polling|pollt]] permanent oder auf Wunsch nach eingehenden Daten. Diese Variante ist einfach, aber nicht effizient. Die zweite Variante arbeitet mit Interrupts und ermögliche eine nebenläufige Kommunikation.

Die Routinen sind erstellt worden für den USART des [[ATmega8]]. Für andere AVR – neuere Modelle und solche, die mehrer UART-Module besitzen – haben die Register teilweise andere Namen. Dann gibt es z.B. Register <tt>UBRR0L</tt>, <tt>UBRR1L</tt>, etc.

= Variante 1: Ohne Interrupts =

Hier eine der einfachsten Möglichkeiten, den Hardware-[[UART]] von [[AVR]] zu nutzen. Die Empfangs- und Sendefunktionen sind so kurz, daß sie am besten als inline-Funktionen definiert werden. Auf Zeichen bzw. Ereignisse zu warten bezeichnet man auch als "''polling''".

== C-Datei ==

Der USART wird initialisiert als UART mit dem Datenformat 8N1 (8 Datenbits, kein Parity, 1 Stopbit).

'''uart.c'''
#include "uart.h"

#define BAUDRATE 38400UL //Definition als unsigned long, sonst gibt es Fehler in der Berechnung

void uart_init()
{
uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*BAUDRATE) - 1);

UBRRH = (uint8_t) (ubrr>>8);
UBRRL = (uint8_t) (ubrr);

{{ccomment|UART Receiver und Transmitter anschalten }}
{{ccomment|Data mode 8N1, asynchron }}
UCSRB = (1 << RXEN) | (1 << TXEN);
UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

{{ccomment|Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte) }}
do
{
UDR;
}
while (UCSRA & (1 << RXC));
}

== Benutzer-Schnittstelle und Header ==

Im Header <tt>uart.h</tt> werden die Funktionen veröffentlicht und stehen in anderen Modulen zur Verfügung:
;<tt>extern void uart_init()</tt>: Initialisiert den UART und aktiviert Receiver und Transmitter.
;<tt>static inline int uart_putc (const uint8_t c)</tt>: Sendet das Zeichen <tt>c</tt> über den UART. Der return-Wert ist immer 1.
;<tt>static inline uint8_t uart_getc_wait()</tt>: Wartet bis zum nächsten Empfang bzw. liefert das empfangene Zeichen.
;<tt>static inline int uart_getc_nowait()</tt>: Schaut nach, ob ein Zeichen empfangen wurde und liefert dieses gegebenenfalls als <tt>int</tt> zurück (Wertebereich ist 0...255). Wurde nichts empfangen, wird <tt>-1</tt> geliefert.
Die Defines <tt>F_CPU</tt> und <tt>BAUDRATE</tt> geben die Taktrate des AVR sowie die Baudrate an. Dabei hat <tt>F_CPU</tt> nur rein informativen Character, es ''ändert'' die CPU-Frequenz nicht! Der Define für <tt>F_CPU</tt> kann man in die Quelle dazu schreiben, oder man gibt einen Wert per Kommandozeile/[[make|Makefile]] an mit <tt>-DF_CPU=...</tt>

<tt>'''uart.h'''</tt>
#ifndef _UART_H_
#define _UART_H_

#include <avr/io.h>

extern void uart_init();

static inline int
uart_putc (const uint8_t c)
{
{{ccomment|Warten, bis UDR bereit ist für einen neuen Wert }}
while (!(UCSRA & (1 << UDRE)))
;

{{ccomment|UDR Schreiben startet die Übertragung }}
UDR = c;

return 1;
}

static inline uint8_t
uart_getc_wait()
{
{{ccomment|Warten, bis etwas empfangen wird }}
while (!(UCSRA & (1 << RXC)))
;

{{ccomment|Das empfangene Zeichen zurückliefern }}
return UDR;
}

static inline int
uart_getc_nowait()
{
{{ccomment|Liefer das empfangene Zeichen, falls etwas empfangen wurde; -1 sonst }}
return (UCSRA & (1 << RXC)) ? (int) UDR : -1;
}

#endif {{comment|_UART_H_ }}

= Variante 2: Mit Interrupts =

Diese Interrupt-getriebene Variante benutzt FIFO-Methoden aus dem Artikel "[[FIFO mit avr-gcc]]" zur Zwischenspeicherung der zu sendenden und empfangenen Daten.

== Benutzer-Schnittstelle und Header ==

Im Header <tt>uart.h</tt> werden die Funktionen veröffentlicht und stehen in anderen Modulen zur Verfügung. Das Interface ist das gleiche wie beim Polling.

;<tt>extern void uart_init()</tt>: Initialisiert den UART und aktiviert Receiver und Transmitter sowie den Receive-Interrupt. Die Ein- und Ausgebe-FIFO werden initialisiert. Das globale Interrupt-Enable-Flag (I-Bit in SREG) wird nicht verändert.
;<tt>extern int uart_putc (const uint8_t c)</tt>: Speichert das Zeichen <tt>c</tt> in der Ausgabe-Warteschlange. Der return-Wert ist 1, falls das Zeichen in die FIFO eingetragen wurde, und 0, falls die Ausgabe-FIFO voll ist. Der UART DATA-Interupt wird aktiviert, der die Zeichen aus der Ausgabe-FIFO über den UART verschickt.
;<tt>extern uint8_t uart_getc_wait()</tt>: Liefert das nächste empfangene Zeichen aus der Eingabe-FIFO bzw. wartet darauf, falls die FIFO leer ist.
;<tt>extern int uart_getc_nowait()</tt>: Schaut nach, ob ein Zeichen empfangen wurde und liefert dieses gegebenenfalls als <tt>int</tt> zurück (Wertebereich ist 0...255). Wurde nichts empfangen, wird <tt>-1</tt> geliefert.
;<tt>static inline void uart_flush()</tt>: Wartet, bis die Übertragung fertig ist.

;<tt>uart.h</tt>

<pre>
#ifndef _UART_H_
#define _UART_H_

#include <avr/io.h>

extern void uart_init();
extern int uart_putc (const uint8_t);
extern uint8_t uart_getc_wait();
extern int uart_getc_nowait();

static inline void uart_flush()
{
while (UCSRB & (1 << UDRIE));
}

#endif /* _UART_H_ */
</pre>

== C-Datei ==

===Dateikopf und Initialisierung ===
#include <avr/io.h>
#include <avr/interrupt.h>
#include "uart.h"
#include "fifo.h" {{ccomment|erklärt im Artikel "[[FIFO mit avr-gcc]]"}}

#define BAUDRATE 38400UL //Definition als unsigned long, sonst gibt es Fehler in der Berechnung

{{ccomment|FIFO-Objekte und Puffer für die Ein- und Ausgabe }}

#define BUFSIZE_IN 0x40
uint8_t inbuf[BUFSIZE_IN];
fifo_t infifo;

#define BUFSIZE_OUT 0x40
uint8_t outbuf[BUFSIZE_OUT];
fifo_t outfifo;

void uart_init()
{
uint8_t sreg = SREG;
uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*BAUDRATE) - 1);

UBRRH = (uint8_t) (ubrr>>8);
UBRRL = (uint8_t) (ubrr);

{{ccomment|Interrupts kurz deaktivieren }}
cli();

{{ccomment|UART Receiver und Transmitter anschalten, Receive-Interrupt aktivieren }}
{{ccomment|Data mode 8N1, asynchron }}
UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

{{ccomment|Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte) }}
do
{
{{ccomment|UDR auslesen (Wert wird nicht verwendet) }}
UDR;
}
while (UCSRA & (1 << RXC));

{{ccomment|Rücksetzen von Receive und Transmit Complete-Flags }}
UCSRA = (1 << RXC) | (1 << TXC);

{{ccomment|Global Interrupt-Flag wieder herstellen }}
SREG = sreg;

{{ccomment|FIFOs für Ein- und Ausgabe initialisieren }}
fifo_init (&infifo, inbuf, BUFSIZE_IN);
fifo_init (&outfifo, outbuf, BUFSIZE_OUT);
}

===Interrupt-Routinen===

{{ccomment|Empfangene Zeichen werden in die Eingabgs-FIFO gespeichert und warten dort }}
SIGNAL (SIG_UART_RECV)
{
_inline_fifo_put (&infifo, UDR);
}

{{ccomment|Ein Zeichen aus der Ausgabe-FIFO lesen und ausgeben }}
{{ccomment|Ist das Zeichen fertig ausgegeben, wird ein neuer SIG_UART_DATA-IRQ getriggert }}
{{ccomment|Ist die FIFO leer, deaktiviert die ISR ihren eigenen IRQ. }}
SIGNAL (SIG_UART_DATA)
{
if (outfifo.count > 0)
UDR = _inline_fifo_get (&outfifo);
else
UCSRB &= ~(1 << UDRIE);
}

=== Ein- und Ausgabe ===
Die Ein- und Ausgebefunktionen machen nichts weiter, als die empfangenen/zusendenden Zeichen aus der FIFO zu lesen/in die FIFO zu schreiben.
<pre>
int uart_putc (const uint8_t c)
{
int ret = fifo_put (&outfifo, c);

UCSRB |= (1 << UDRIE);

return ret;
}

int uart_getc_nowait ()
{
return fifo_get_nowait (&infifo);
}

uint8_t uart_getc_wait ()
{
return fifo_get_wait (&infifo);
}
</pre>

=Weitere Routinen=
== Einen String senden ==

Übergeben wird die Start-Adresse des Strings. Die Zeichenkette wird solange durchlaufen und die Zeichen ausgegeben, bis eine <tt>'\0'</tt> (Stringende-Marke) gelesen wird.
#include <avr/interrupt.h> {{ccomment|Wird nur gebraucht bei der Interrupt-Version }}
#include "uart.h"

{{ccomment|Einen 0-terminierten String übertragen. }}
void uart_puts (const char *s)
{
do
{
uart_putc (*s);
}
while (*s++);
}

{{ccomment|Ein Zeilenumbruch, abhängig davon, was die Gegenstelle haben will }}
{{ccomment|Windows: "rn" }}
{{ccomment|Linux : "n" }}
{{ccomment|MacOS : "r" }}
#define CR "\r\n"

char text[] = "Hallo Welt." CR;

int main()
{
uart_init();
sei(); {{ccomment|Wird nur gebraucht bei der Interrupt-Version }}

uart_puts (text);
uart_puts ("Hallo Welt!" CR);

return 0;
}

== Einen konstanten String senden ==

Unveränderliche Strings brauchen kein Platz im SRAM zu verschwenden, man lässt sie im Flash (wo sie sonst ebenfalls stehen für die SRAM-Initialisierung).

#include <avr/interrupt.h> {{ccomment|Wird nur gebraucht bei der Interrupt-Version }}
#include <avr/pgmspace.h>
#include "uart.h"

{{ccomment|Einen 0-terminierten String senden, der im Flash steht. }}
void uart_puts_P (PGM_P s)
{
while (1)
{
unsigned char c = pgm_read_byte (s);
s++;
if ('\0' == c)
break;
uart_putc (c);
}
}

{{ccomment|Ein Zeilenumbruch, abhängig davon, was die Gegenstelle haben will }}
{{ccomment|Windows: "rn" }}
{{ccomment|Linux : "n" }}
{{ccomment|MacOS : "r" }}
#define CR "\r\n"

const prog_char text_p[] = "Hallo Welt." CR;

int main()
{
uart_init();
sei(); {{ccomment|Wird nur gebraucht bei der Interrupt-Version }}

uart_puts_P (text_p);
uart_puts_P (PSTR("Hallo Welt!" CR));

return 0;
}

= Siehe auch =

*[[UART]]
*[[RS232]]
*[[Software-UART mit avr-gcc]]
*[[FIFO mit avr-gcc]]

==WebLinks==
* [http://www.gjlay.de/helferlein/avr-uart-rechner.html AVR-Baudraten-Rechner (JavaScript)]
* [http://jump.to/fleury Peter Fleurys Webseite mit UART Library (AVR-Software -> AVR-GCC libraries)]

[[Kategorie:Kommunikation]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode C]]
[[Kategorie:Software]]
[[Kategorie:Microcontroller]]

Leiterplatten herstellen - Toner-Transfer-Methode

2009-01-01T15:09:44Z

Andun:

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. platziert man kleine Kreuze an verschiedenen Stellen im Layout. Praktisch ist auch ein wenig Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

[[Bild:BM_auflegen.jpg|center]]

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

[[Bild:BM_fertig.jpg |center]]

Mit etwas mehr Übung und Ausprobieren sollten auch noch bessere Ergebnisse erzielt werden können, speziell wenn man den Toner z.B. noch einbrennt in die Platine, indem die Platine nach dem Entfernen des Trägers nochmal auf das Bügeleisen gelegt wird, so dass der Toner in die Platine einziehen kann.

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
Aufgrund der Umsortierung sei hier generell [[:Kategorie:Leiterplattenentwicklung]] genannt.

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.subms.de/bugelmethode/
* http://www.5bears.com/pcb.htm

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Leiterplattenentwicklung]]

Leiterplatten herstellen - Toner-Transfer-Methode

2009-01-01T15:08:45Z

Andun: Toten Link enfernt und neuen eingepflegt

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. platziert man kleine Kreuze an verschiedenen Stellen im Layout. Praktisch ist auch ein wenig Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

[[Bild:BM_auflegen.jpg|center]]

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

[[Bild:BM_fertig.jpg |center]]

Mit etwas mehr Übung und Ausprobieren sollten auch noch bessere Ergebnisse erzielt werden können, speziell wenn man den Toner z.B. noch einbrennt in die Platine, indem die Platine nach dem Entfernen des Trägers nochmal auf das Bügeleisen gelegt wird, so dass der Toner in die Platine einziehen kann.

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
Aufgrund der Umsortierung sei hier generell [[:Kategorie:Leiterplattenentwicklung]] genannt.

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.subms.de/bugelmethode/
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Leiterplattenentwicklung]]

Leiterplatten Entwicklung - Programme

2009-01-01T14:53:28Z

Andun:

== Vorwort ==
Leiterplatten Entwicklung war früher ein, für den Hobbyanwender, recht mühsames unterfangen.
Entweder wurden die Leiterbahnen und "Pad's" direkt auf die Kupferschicht, mit einem ätzfesten Stift gezeichnet oder zunächst auf Folie/Papier gezeichnet und dann mittels Fototransfer auf die Platine übertragen. Man sollte sich aber auch fragen ob man ein geätzte Platine braucht, oder die Schaltung noch auf Lochraster oder Streifenraster geht.

Heute stehen hierfür sehr umfangreiche aber dennoch mehr oder weniger leicht bedienbare Programme zur Verfügung, welche einen Entwurf von Leiterplatten erleichtern.

Oft stehen verschiedene Versionen z.T. auch kostenlose Testversionen oder Versionen für den Hobby-Anwender zur Verfügung.

Hier eine Liste von freien und kommerziellen Programmen welche es erlauben Leiterplatten mit dem Computer zu designen.

----

: '''Hier soll nicht der Umgang (Bedienungsanleitung) mit den beschriebenen Programmen sondern die Verfügbarkeit von verschiedenen Programmen und deren Usability im Vordergrund stehen.'''

----

== Die wohl bekanntesten PCB Programme: ==
:* EAGLE
:* TARGET
:* Sprint-Layout
:* PCB-POOL®Edition
:* ORCAD
:* KiCAD
=== Weitere Programme ===
'''z.T. kommerzielle, limitierte, freie und z.T nicht mehr verfügbare Cad Programme'''
:* Protel
:: nicht mehr verfügbar (jetzt Altium)
:* Altium Designer
:* PROTEUS
:* ULTIBOARD
:* EASY PC
:* EDWIN
:* QUICK ROUTE
:* ARIADNE
:* AUTOENGINEER
:* BPECS32
:* CADSTAR
:* CADint
:* CIRCUIT LAYOUT
:* CIRCUIT CREATOR
:* CIRCAD
:* FreePCB
:* gEDA

Diese Liste kann noch weitergeführt werden, was allerdings leicht dazu führt den Überblick zu verlieren.
Diese Liste wird/kann im Laufe der Zeit mit Kommentaren und Erfahrungswerten versehen bzw. aktualisiert werden.
Auch Streichungen und Erweiterungen sind gestattet (bitte nicht übertreiben).

== AddOns für diese Programme ==
:* Eagle3D
:: ein kostenloses 3D Zusatzprogramm für Eagle

== Bewertungen und Infos zu den gelisteten Programmen ==
''Info, Empfehlungen und Kritik zu den vorgestellten Programmen''

::* EAGLE
::** Dieses Programm kann man hier im Roboternetz wohl als 1. Wahl bezeichnen, da die meisten Anwender hier hiermit arbeiten. Die kostenlose Version erlaubt Platinen bis zu 80mm x 100mm mit Schaltplan und Autorouter auf zwei Signal-Ebenen (Dual-Layer) zu erstellen. Auch eine sog. Studenten-Version (aber nicht nur diese) ist zu sehr guten Konditionen zu erwerben.
::** Nachdem die Einarbeitungsphase überwunden wurde, sehr gut zu bedienendes Tool.
::** Der Autorouter liefert (wie viele andere Programme auch) nur teilweise brauchbare Ergebnisse.
::** Gut ist die Verlinkung von Schaltplan und Board. Änderungen, die man im Schaltplan macht, werden automatisch auch in der Board-Ansicht vorgenommen. Dadurch bleiben Schaltplan und Board konsistent (funktioniert aber nur, wenn beide Ansichten geöffnet sind).
::* Eagle3D
::** bereits in der Entwurfsphase kann einem dieses Tool bei Design-Fehlern (LookOut) gute Dienste leisten
::** leider ist das erstellen von eigenen Bauteilen (noch) etwas aufwendig.
::** Auch eine Animation (Flug über die Platte) soll möglich sein ...
::** Sieht einfach klasse aus und macht auch Spaß damit zu 'Spielen'
::: '''INFO:''' Benötigt weitere Zusatzsoftware (auch als Freeware/GNU), mehr dazu auf der Homepage

==Siehe auch==
* Aufgrund der Umsortierung sei hier generell [[:Kategorie:Leiterplattenentwicklung]] genannt.
* [[CAD]]
* [[PCB]]

== Weblinks ==
'''Programme'''
* [http://www.cadsoft.de/ Eagle Homepage von CadSoft]
* [http://www.ibfriedrich.com/home.htm Target 3001 Homepage von Ing.-Büro FRIEDRICH]
* [http://www.abacom-online.de/html/demoversionen.html Sprint-Layout Homepage von ABACOM Ingenieurbüro GbR]
* [http://www.pcb-pool.de/html_de/de_service_1.htm free PCB-POOL Homepage von Beta LAYOUT GmbH]
* [http://www.altium.com/Products/AltiumDesigner/ AltiumDesigner Homepage von Altium Limited]
* [http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCAD-Homepage]
'''AddOn's'''
* [http://www.matwei.de/doku.php?id=de:eagle3d:eagle3d Eagle3D Homepage von Matthias Weißer]


--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 12:39, 3. Feb 2007 (CET)
{{Ausbauwunsch|Was Euch noch dazu einfällt, Erfahrungen mit diesen Programmen usw., Kommentare}}

[[Kategorie:Grundlagen]]
[[Kategorie:Praxis]]
[[Kategorie:Software]]
[[Kategorie:Leiterplattenentwicklung]]

Leiterplatten herstellen - Toner-Transfer-Methode

2009-01-01T14:52:14Z

Andun: /* Siehe auch */

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. platziert man kleine Kreuze an verschiedenen Stellen im Layout. Praktisch ist auch ein wenig Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

[[Bild:BM_auflegen.jpg|center]]

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

[[Bild:BM_fertig.jpg |center]]

Mit etwas mehr Übung und Ausprobieren sollten auch noch bessere Ergebnisse erzielt werden können, speziell wenn man den Toner z.B. noch einbrennt in die Platine, indem die Platine nach dem Entfernen des Trägers nochmal auf das Bügeleisen gelegt wird, so dass der Toner in die Platine einziehen kann.

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
Aufgrund der Umsortierung sei hier generell [[:Kategorie:Leiterplattenentwicklung]] genannt.

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.qsl.net/k5lxp/projects/PCBFab/PCBFab.html
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Leiterplattenentwicklung]]

Leiterbahnbreiten

2009-01-01T14:51:57Z

Andun: /* Siehe auch */

[[Bild:Leiterplatten_Herstellen_03_Entwickelte-Fotoschicht.jpg|thumb|Leiterbahnen]]Beim Entwurf von Leiterbahnen ist es wichtig, dass die Leiterbahnen die entsprechende Mindestbreite aufweisen, damit der maximal vorgesehene Strom nicht zum Durchbrennen oder Beschädigen der Leiterbahn führt.

Die Temperatur der Leiterbahn darf wegen der Temperaturunbeständigkeit des Leiterplattenmaterials FR4 nicht beliebig hoch sein. Ab einer Temperatur von ca. 130 °C („Glaspunkt“) beginnt der Kunststoff weich zu werden und die Leiterplatte verbiegt sich. Ab ca. 110°C weichen auch Lötstellen auf.

Breitere Leiterbahnen haben mehr Kapatzität und weniger Induktivität als schmale. Deshalb sollten Leiterbahnen für GND und VCC in der Regel etwas breiter sein, z.B. 1,5 mm. Besonders bei SMD Bauteilen wird ein wesentlicher Teil der Wärme über die Leiterbahnen abgeführt, was genügend breite Leiter voraussetzt.

==Richtwerte==
In der folgenden Tabelle wird die Temperaturerhöhung der Leiterbahn bei verschiedenen Breiten und Stromstärken aufgelistet. Die Breitenangabe erfolgt in mm und mil (1/1000 Inch).
Die Tabelle geht von einer üblichen Kupferbeschichtung von 35 µm (Mikrometer) und Standardplatinenmaterial FR4 aus.

{| {{Blauetabelle}}
|'''Breite in Millimeter'''
|'''Breite in Mil'''
|'''10 °C'''
|'''20 °C'''
|'''30 °C'''
|'''45 °C'''
|'''60 ° C'''
|-
|0,25 mm
|9,8mil
|0,5 A
|0,8 A
|1,0 A
|1,3 A
|1,6 A
|-
|0,38 mm
|14,7mil
|0,8 A
|1,20 A
|1,50 A
|2,0 A
|2,4 A
|-
|0,50 mm
|19,7 mil
|1,0 A
|1,6 A
|2,0 A
|2,5 A
|3,0 A
|-
|1,00 mm
|39,4 mil
|2,2 A
|3,0 A
|3,6 A
|4,2 A
|4,8 A
|-
|1,50 mm
|59 mil
|3,0 A
|3,8 A
|4,6 A
|5,3 A
|6,5 A
|-
|2,00 mm
|78,7 mil
|3,8 A
|5,0 A
|6,5 A
|7,5 A
|8,5 A
|-
|3,00 mm
|118,1 mil
|4,5 A
|6,5 A
|8,0 A
|9,5 A
|11,0 A
|-
|5,00 mm
|197 mil
|7,0 A
|10,0 A
|12,0 A
|14,5 A
|16,0 A
|-
|8,00 mm
|315 mil
|9,0 A
|14,0 A
|17,0 A
|20,0 A
|22,5 A
|-
|10,00 mm
|394 mil
|10,0 A
|16,0 A
|20,0 A
|23,0 A
|26,0 A
|}

==Siehe auch==
Aufgrund der Umsortierung sei hier generell [[:Kategorie:Leiterplattenentwicklung]] genannt.

[[Kategorie:Grundlagen]]
[[Kategorie:Elektronik]]
[[Kategorie:Leiterplattenentwicklung]]

Platinen doppelseitig layouten mit Eagle

2009-01-01T14:48:45Z

Andun: /* Siehe auch */

= Einleitung =
Die eigene Herstellung doppelseitiger Platinen kann sich problematisch gestalten. Da Eagle für den professionellen Einsatz entwickelt wurde, fallen die meisten Fehlerquellen erst beim Löten auf, also wenn es zu spät ist.
Im Folgenden werden Ratschläge zum Bedienen des Programms Eagle hinsichtlich des Layoutens von Platinen erteilt, die unter Hobbybedingungen hergestellt (geätzt) werden. Dabei wird vorausgesetzt, dass der gesamtheitliche Vorgang der Platinenherstellung bekannt ist oder in anderen Teilen dieser Wissensseite nachgeschlagen wird (Links unter dem Punkt: "Siehe auch").

'''Ziel dieses Dokuments ist es, Hilfestellung zu geben bei...'''
*der Konfiguration des Layout-Programms EAGLE zum Layouten von Schaltungen zur Herstellung ein- oder doppelseitiger Platinen

'''Dabei wird auf folgende Punkte Wert gelegt:'''

So wenige Vias wie möglich.

Bauteile möglichst einfach lötbar

Toleranz gegenüber Über-/Unterätzung

Einsparung von Chemikalien

= Layoutprogramm EAGLE =

== Layouteditor konfigurieren ==

'''Hinweis'''

Werte, die im Folgenden nicht erwähnt werden, sollten auf Default bleiben!

=== Raster ===
Raster als "Teilwert" von 50mil (1.25; 2.5; 5; 10; 12,5; 25; 50)
Wenn möglich mit einem Raster von 25mil auskommen.

=== Autoroutereinstellungen ===
'''Wichtig:'''

*Bei zweiseitigen Platinen immer eine "Prefered Direction" pro Layer vorgeben (nicht den Stern wählen!)!
*Das Routing Grid immer als Vielfaches des Rastergrids wählen!
*Die Costs nicht ändern (außer für Vias wie unten)!
*Via-Anzahl bei Optimize im Folgenden beachten!

'''Autorouter -->'''

'''General'''

--> Prefered Directions --> Top=senkrecht, Bottom=waagrecht (oder umgekehrt)

--> Routing Grid=2.5; 5; 10; 12,5; 25; 50 (als "Teilwert" von 50mil wie Raster, je nach Rechenleistung und Komplexität der Platine)

--> Via Shape=octagon (schützt etwas besser bei Überätzung)

'''Route''' --> Maximum --> Via=50

'''Optimize 1-6''' --> Costs --> Via=99

'''Optimize 1''' --> Maximum Vias=0

'''Optimize 2''' --> Maximum Via=5

'''Optimize 3''' --> Maximum Via=0

'''Optimize 4''' --> Maximum Via=5

'''Optimize 5''' --> Maximum Via=0

'''Optimize 6''' --> Maximum Via=0

=== DRC-Einstellungen (Design Rule Check) ===
Im DRC werden Vorgaben getroffen, nach denen der Autorouter seine Bahnen und Vias verlegt.

'''Clearance'''

* alle Werte auf min. 10mil, besser 12mil (je nach Löt- und Ätzvermögen) --> Damit bleibt es möglich, Leiterbahnen zwischen zwei IC-Pads hindurchzuführen.

'''Distance'''

* Copper/Dimension=25 --> Damit bleibt ein größerer Abstand zum Platinenrand
* Drill/Hole=10mil. --> Wie die Clearance-Werte

'''Sizes'''

* Minimum Width=12mil --> schützt vor Überätzung
* Minimum Drill=32mil --> Damit werden Vias 0,8mm und damit genauso dick wie Widerstandsbohrungen, man kann also den gleichen, relativ großen Bohrer benutzen

=== Groundplane ===
'''Achtung: Erst nach vollständig gelayouteter Platine anwenden! Ansonsten kann es passieren, dass Airwires übrig bleiben.'''

Die Groundplane verhilft zu besseren Groundeigenschaften und spart Ätzmittel und Entwickler! Man erzeugt sie wie folgt:

* Poligon anklicken
* Werte wie folgt ändern (oben in der Symbolleiste, beim Daraufzeigen erscheint in der Leiste am unteren Bildschirmrand die Erklärung):
** Layer=Top bzw. Bottom
** Poligon Thermals=ON (erleichtert das Löten von GND-Pads und beugt der übermäßigen thermischen Belastung der Bauteile vor)
** Poligon Orphans=OFF (damit alle Flächen der Plane mit einem festen Potenzial, z.B.: GND, verbunden sind und sie nicht als Antennen, z.B.: für Bürstenfeuer von Bürstenmotoren oder in der Nähe von Taktleitungen, fungieren)
** Isolate=0.016-0.035 (z.B. 0.024. Dieser Abstand zwischen Signals und GND-Plane beugt Unterätzungen vor und erleichtert das Löten)
** Poligon auf Dimension (Platinenumriss) zeichnen
** Poligon zu "GND" umbenennen (dabei auf den Rand des Poligons klicken)

== Nicht lötbare Pads ==
Da selbst hergestellte Platinen keine Durchkontaktierungen besitzen, kann es notwendig werden, sie auf dem Top-Layer zu verlöten. Dies ist aber bei manchen Bauteilen nicht möglich (z. B. Pinheads, Spindeltrimmer, Trafos usw.).
Abhilfe:
Diejenigen Pads von Bauteilen, die man nicht von oben löten kann mit einem Rechteck auf dem Layer "tRestrict" umgeben. Nur die Pads, nicht das gesamt Bauteil! Dadurch wird der Autorouter keine Top-Verbindung herstellen. Die Fehlermeldungen des DRC (Design Rule Check) können ignoriert werden. Diese beziehen sich auf das Pad.

= Hinweise zu Belichtungsmaske und Ausdruck =

Das Layout wird am besten mit Hilfe eines Laserdruckers auf eine Spezialfolie gedruckt. Diese Folien sind im Elektronikfachhandel erhältlich.

== Verzerrungen im Ausdruck / Keine Deckungsgleichheit zwischen Top- und Bottom-Layout ==
Auf Grund der "Glattheit" der Druckerfolie entstehen bei manchen Druckern Verzerrungen beim Ausdruck des Layouts, die dazu führen, dass Bohrungen nicht deckungsgleich sind. Diese Verzerrungen werden größtenteils vermieden, indem Top- und Bottom-Layout auf einer Seite direkt nebeneinander und im gleichen Druckvorgang ausgedruckt werden. Die Verzerrungen sollten dann auf beiden Layouts gleich sein, sodass Bohrungen auf beiden Seiten zentriert sind. Natürlich muss das Layout auf zu große Verzerrungen geprüft werden.

== Material: Fotobeschichtete Platinen ==
Ich habe zwar nicht sehr viele unterschiedliche Platinen getestet und ich will auch keine Werbung für Produkte machen, aber aus eigener Erfahrung kann ich sagen, dass fotobeschichtete Platinen der Firma Bungard die besten Ergebnisse erzielen. Sie sind äußerst Fehlertolerant, was dem Hobbyelektroniker zu Gute kommt, der nicht über professionelle Technik verfügt. Allerdings gibt es sicherlich Hersteller, die vergleichbar gute Platinen anbieten und die mir nicht bekannt sind.

= Siehe auch =
Aufgrund der Umsortierung sei hier generell [[:Kategorie:Leiterplattenentwicklung]] genannt.

= Autor =
[[Gock]]

Stichworte:

Platine, Herstellung, ätzen, selbst selber herstellen, doppelseitig, zweiseitig, fotobeschichtet, Layout, Eagle, Autorouter, Einstellungen, Parameter, löten, Tips und Tricks, Routen, Problem

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Software]]
[[Kategorie:Leiterplattenentwicklung]]

Ätzgerät Bauanleitung

2009-01-01T14:37:29Z

Andun: Umsortierung der Artikel

== Selbstbauanleitung für ein 1–Liter-Ätzgerät ==
(Volumen für 0,5 l Ätzlösung)

Für Leiterplatten im Europaformat (100mm x 160 mm)

[[Bild:Bauanleitung-Ätzgerät_InAction_.jpg|640px|center]]
(Die Luftblasen werden im laufenden Betrieb noch feiner und kleiner)

Bitte diese Anleitung zunächst komplett durchlesen,
bevor mit dem Nachbau und dem Materialeinkauf begonnen wird.

== Beschreibung des verwendeten Materials ==
Die meisten Materialien bekommt man
* im Baumarkt (BayWa, Hornbach, Max Bahr, OBI Baumarkt, Praktiker, TOOM ect.pp.)
* Aquariumszubehör (auch in vielen OBI Märkten)
Ja, ihr habt richtig gelesen, genau die gleichen Materialien wie in der vorliegenden Bauanleitung bekommt man zwar im einschlägigen Elektronik-Fachmarkt, sind dort jedoch um ein Vielfaches teurer als im Aquariumzubehörhandel.

==== Glasplatten ====
Sämtliche Glasplatten sollten, sofern verfügbar, eine Stärke von 5 mm haben.
Geringere Plattenstärken sind anfälliger für Bruch oder Risse.

Von Kunststoffglas wie Plexi- oder Acrylglas rate ich ab, da dies matt und bei den im Ätzprozess verwendeten Temperaturen (50°C bis 80°C) brüchig wird. Außerdem lässt sich Glas (mit entsprechender Übung) besser und einfacher verarbeiten. Glas ist, entgegen verbreiteter Meinung, sehr leicht zu verarbeiten, wenn man sich an gewisse Regeln hält und etwas Übung hat. Wer den Zuschnitt von Glas scheut, kann sich beim Glaser entsprechende (fertige) Zuschnitte (aus Resten) besorgen. Die Reste dürften auch relativ günstig zu erstehen sein. Eine geschnittene (sauber gebrochene) Glasplatte hat im Gegensatz zu gesplittertem Glas keine so scharfen Kanten, jedenfalls sind diese bei weitem nicht so gefährlich. Trotzdem sollten die Kanten abgestumpft werden, außerdem begünstigt dies auch das Verkleben der Glasplatten untereinander. Hierzu reicht es meist aus die Kanten z.B. mit einem Edelkorund oder Diamantschleifstift (wie für viele Mini–Bohrmaschinen erhältlich) zu entgraten. Wer hat, darf natürlich auch seine Glasschleifmaschine (wie für Tiffany-Glastechnik) einsetzen.

==== Luftverteiler für Umwälzung ====
(Aquaristik) Air Curtain. Ein poröser Schlauch, durch welchen die eingeblasene Luft über dessen gesamte Länge in kleinen Bläschen austritt. Diese Bläschen sorgen durch ihr Aufsteigen dafür, dass das Ätzbad in Bewegung kommt, um so eine gleichmäßige Temperatur über die gesamte Apparatur zu gewährleisten und das Aufheizen zu beschleunigen und zum anderen, dass die Leiterplatte schneller und gleichmäßiger geätzt wird. Andere Möglichkeiten das Ätzbad umzuwälzen, z.B. durch Umpumpen, sind für diese Anwendung finanziell nicht akzeptabel, da alle Komponenten säurefest sein müssten.

==== Membran-Luftpumpe ====
(Aquaristik) diese sorgt für die benötigte Luft des Luftverteilers

==== Rücklaufstopp (Ventil) ====
(Aquaristik) um zu verhindern, dass Ätzlösung über den Luftschlauch in die Luftpumpe und aus dem Gerät ausläuft ist diese geringe Investition ein absolutes Muss

==== PVC-Luftschlauch ====
(Baumarkt) (Aquaristik) verbindet die Luftpumpe über das Ventil mit dem Luftverteiler.

==== Latex Luftschlauch ====
(Baumarkt) (Aquaristik) aus Latex lieber als aus PVC; säurebeständiger. Schlauch aus PVC wird mit der Zeit porös. 4.99 €

==== Heizelement ====
(Aquaristik/Elektronik Bedarf) sorgt für die benötigte Temperatur. Ein in einem Glaskolben wasserdicht eingebautes Heizelement mit Thermostat, welches in die Lösung eintaucht und diese erwärmt.

----

Wer sich aufgrund fehlender Infos oder Datenblätter nicht entscheiden kann und dennoch eine zuverlässige Heizung erstehen möchte, dem sind von mir folgende Heizungen empfohlen:

'''Von Reichelt:''' Heizung0 € 1,50 - Heizung1 € 29,65 - Heizung2 € 19.95

'''Von Conrad:''' 552020 - 62 € 29,95 - 530425 - 62 € 32,95

(Preisinfo vom 29.10.2005)

----

==== Silikon und Pistole für die Kartusche ====
(Baumarkt) Sanitärsilikon (essigvernetzt) für Glasabdichtung / Verklebung. Bitte kein Acryl oder sonstiges Fugen- oder Bausilikon verwenden, dies haftet nicht so gut, dichtet nicht wie benötigt und wird auf Dauer gesehen brüchig und undicht.

==== Fugenhilfe ====
Ein aus PVC bestehendes Fugenprofil hilft die Silikonnähte sauber zu verstreichen. Die Zeiten, in welchen man das Silikon mit dem in Spülmittel getränktem Finger verstrichen hat, sind ein für allemal vorbei. In einigen Home-Shopping-Sendern auch als „Fugi“ beworben und hat nichts mit Pilzen zu tun.

==== Kunststoffprofile und Kunststoffplatten ====
(Baumarkt) Zur Erstellung der Halter für die Leiterplatten und als Montagegerüst für den Luftverteiler sowie des Heizelementes.

== Dimensionierung ==
Bevor wir uns an die Materialbeschaffung machen und uns mit der Größe befassen, müssen wir einiges berücksichtigen: Breite der Glasküvette: Das Heizelement befindet sich in einem Glaskolben, welcher einen Durchmesser von mind. 20 mm hat. Somit entspricht die Breite der Glasküvette mindestens diesem Maß. Länge der Glasküvette: Die Länge der Glasküvette richtet sich nach mehreren Faktoren:
* Durchmesser des Heizelements + Spielraum
* Breite der maximalen Leiterplattenbreite (welche geätzt werden kann/soll)
* Breite der Halterung + Spielraum für die Leiterplatte, um diese ins Ätzbad tauchen und herausnehmen zu können.
* Platz für den Luftschlauch, welcher den Luftverteiler versorgt
Die Höhe der Glasküvette ist vom Volumen abhängig, Breite und Länge sowie Verdrängung des Heizelementes und der Halter + Abstand, damit die Luftbläschen, welche ebenfalls die Lösung verdrängen und somit den Pegel anheben und die aufsteigenden (welche auf der Oberfläche zerplatzen und daher spritzen) die Küvette nicht zum Überlaufen bringen. Für den Luftverteilschlauch (am Boden der Küvette) muss ebenfalls etwas Platz berücksichtigt werden.

'''Prinzipielle Bestimmung der Glasküvettengröße'''

Innenmaße
{|{{Blauetabelle}}

|Breite:
|25mm
|20mm Heizelement + 5mm Spielraum
|-
|Länge:
|210mm
|160mm Leiterplatte
|-
|
|
|2x 20mm für die Halter
|-
|
|
|10mm für den Luftschlauch
|-
|
|
|20mm Heizelement
|-
|Höhe:
|220mm
|Volumen / Breite / Länge = Höhe + Spielraum
|-
|
|
|Volumen sollte 1 l betragen (1000000 mm³)
|-
|
|
|1000000 / 210 / 25 ~ 190,5 mm + 30 mm Spielraum
|}

Mit etwas angepassten Werten
(damit das Ganze etwas ansprechender aussieht):
{|
|B
|=
|25 mm
|-
|L
|=
|230 mm
|-
|H
|=
|200 mm
|}
Mit diesen Werten kann eine Europaplatine (160 mm x 100 mm) spielend „gebadet“ werden.
Bestimmung der Glasplattengröße.
Da sich Glasplatten mit einer Stärke von 5 mm und einer Breite von 25 mm nur für sehr geübte Hobbyglaser verarbeiten lassen, wähle ich eine breitere Variante, welche an den Stirnseiten verklebt wird; die verleiht der Glasküvette außerdem einen besseren Stand.

=== Glaszuschnitte === Maße etwas abgeändert:
{|{{Blauetabelle}}
|Seitenteile:
| 2x
|Glasplatte a '''5 mm''' (Stärke) x
'''220 mm''' (Höhe) '''x 55 mm''' (Tiefe)
|-
|Vorder/Rückseiten:
| 2x
|Glasplatte a '''5 mm''' (Stärke) x
'''210 mm''' (Breite) '''x 220 mm''' (Höhe)
|-
|Fußplatte:
| 1x
|Glasplatte a '''5 mm''' (Stärke) x
'''220 mm''' (210 mm + 10 mm (Breite + Überhang)) '''x 55 mm''' (Tiefe)
|}

== Nachbau Schritt für Schritt ==
[[Bild:Bauanleitung-Ätzgerät_Schleifen1.jpg|thumb|right|Stumpfschleifen mit einer Glasschleifmaschine]][[Bild:Bauanleitung-Ätzgerät_Schleifen2.jpg|thumb|right|Kanten mit einem Edelkorund stumpfschleifen]]
ACHTUNG: '''Immer mit Schutzbrille arbeiten!'''

Besonders beim Schleifen springen feine Glassplitter herum, welche die Augen verletzen können.

===Materialbearbeitung===
* 1. Die Glasplatten werden den Abmessungen entsprechend zugeschnitten (gebrochen)
TIPP:
Wer sein Glas selbst schneiden will, dem sei folgender Hinweis gegeben.
Die Bruchstelle wird sauberer, wenn man den Schnitt vor dem Brechen mit Wasser vernetzt.
Noch bessere Ergebnisse erzielt man, wenn man den Glasschneider mit Schneidöl (Kriechöl wie z.B. Balistol) tränkt.

Es gibt sogar Glasschneider mit eingebautem Öltank, diese kosten ab € 35,- aber dies ist für nur einmaligen Gebrauch etwas zuviel.

Einen sauberen Schnitt kann man kaum erkennen, ist die Schnittlinie hingegen deutlich sichtbar (ausgefranst,) deutet dies auf eine ungenaue Schnittführung oder einen defekten Glasschneider hin. Man kann sogar während des Anschneidens hören ob dieser gelingt oder unsauber wird (Übung ist alles). Mit unsauberen Schnittlinien wird dann auch die Bruchstelle unregelmäßig und „fransig“ oder wellig.
Ein gemäßigter nicht zu kräftiger Schlag auf die dem Schnitt abgewandten Seite der Platte lässt diese einreißen. Ein dünnes Hölzchen (Zahnstocher) direkt unter den Schnitt gelegt und mit den Daumen soweit wie möglich links und rechts vom Schnitt entfernt auf die Glasplatte drücken (Knack).

* 2. Die Kanten müssen geschliffen (entgratet) werden, damit man sich nicht daran verletzen und der Silikon-Kleber besser haften kann (bessere Verbindung).
Dies kann, falls verfügbar, mit einem Glasschleifgerät (Diamantschleifkopf) oder mit weniger Aufwand aber ebenso effektiv, mit einer Minibohrmaschine und einem Edelkorund-Schleifstein erfolgen.

Auch mit Korund beschichtetes Schleifpapier (Teller-Schleifgeräte) kann verwendet werden.

=== Verkleben der einzelnen Teile ===
[[Bild:Bauanleitung-Ätzgerät_Verkleben1.jpg|thumb|right|Silikonauftrag]][[Bild:Bauanleitung-Ätzgerät_Verkleben2.jpg|thumb|right|Immer einen dünnen aber mit Silikon lückenlos gefüllten Spalt lassen (elastische Fuge)]][[Bild:Bauanleitung-Ätzgerät_Verkleben3.jpg|thumb|right|ungenutzte Glasplatten dienen als Abstandshalter bis das Silikon getrocknet ist]][[Bild:Bauanleitung-Ätzgerät_Verkleben6.jpg|thumb|right|Silikon auftragen]][[Bild:Bauanleitung-Ätzgerät_Verkleben5.jpg|thumb|right|Glasplatte nur leicht andrücken, wieder einen schmalen, aber mit Silikon lückenlos gefüllten Spalt lassen]]

Die einzelnen Glasplatten werden mit Silikon verklebt. Nur essigvernetztes Sanitärsilikon verwenden, transparent oder gefärbt ist egal.
Acryl oder Bausilikon ist ungeeignet.

Um eine einwandfreie Klebestelle zu gewährleisten müssen die betroffenen Stellen absolut sauber, trocken und fettfrei sein. Auch Fingerabdrücke beeinflussen die Klebekraft.
Am besten die entsprechenden Stellen unmittelbar vorher mit ACETON und einem Küchenkrepp reinigen. Nagellackentferner enthält oft auch Aceton, ist aber wegen der beigemengten Öle und Pflegemittel ungeeignet.
„Normales“ Aceton ist im Baumarkt oder in einer Drogerie erhältlich.

====Rückwärtiges- und Bodenteil====
Die ersten beiden Bauteile werden zusammengefügt.

Nicht Platte an Platte pressen, sondern einen hauchdünnen Spalt ohne Lufteinschlüsse lassen.
So bleibt die Fuge elastisch und kann besser trocknen.

Kleinere Fehlstellen ohne dichte Verklebung sind hier zunächst nicht so tragisch. Die endgültige Dichtigkeit wird am Schluss sichergestellt.
Hier geht es zunächst um die mechanische Stabilität. Nicht alle Bauteile auf einmal zusammenfügen, hier ist viel Geduld notwendig. Zunächst sollte die erste Verbindung aushärten, bevor man mit der nächsten weitermacht. Dies kann durchaus einen ganzen Tag dauern (je nach Silikon). Oberflächlich getrocknetes Silikon ist im Kern noch lange nicht fest, daher lieber etwas mehr Zeit verstreichen lassen als zuwenig. Im schlimmsten Falle haften die einzelne Teile nicht fest genug aneinander. Nach ca. 12h dürfte allerdings eine genügende Trocknung erreicht sein.
Jetzt darf diese erste Klebestelle erst einmal bis zur Festigkeit austrocknen.

==== Frontseitiges- und Bodenteil ====
Ist diese erste Verklebung nun getrocknet, legt man wieder einige Reststücke von den Glasplatten oder was man sonst so findet, um die 2. Platte mit einem Abstand (25 mm) auflegen zu können. Wichtig ist, dass die Platte stabil zu liegen kommt und nicht verwackelt sowie dass die Ränder frei bleiben.
Diesmal sollten es aber so ziemlich genau die berechneten 25 mm sein.

Auf diesen Abstandshalter legt man dann die zweite, mit an der eine Kante mit Silikon vorbereitete Glasplatte und bringt diese in Stellung (Kontakt mit geringem Spalt zur Bodenplatte, so dass das Silikon gut anhaftet).
Nicht Platte an Platte pressen, sondern einen hauchdünnen Spalt ohne Lufteinschlüsse lassen.
Nun wieder warten, bis die Klebestelle getrocknet ist und ihre Endfestigkeit erreicht hat
(über Nacht {mind. 8h} dürfte auch hier reichen, aber wie erwähnt, lieber länger warten als zu kurz).

==== Seitenteile ====
Nachdem die Silikonnähte der Front- und Rückseite an der Bodenplatte wirklich Endfestigkeit haben, drehen wir diese so um 90°, dass der Aufbau auf einem Seitenteil zu stehen kommt.
Jetzt ist etwas mehr Sorgfalt angesagt.

Den inneren Abstand der Küvette fixieren wir wieder mit den Teilen, welche schon zuvor den Abstand bestimmt haben. An der offenen Seite fixieren wir die Platten z.B. mit Klebeband, so dass diese nicht aus Versehen auffächern können. Somit ist über die gesamte Höhe ein gleichmäßiger Abstand gewährleistet.
Jetzt noch die Platten so ausrichten, dass diese im rechten Winkel zueinander stehen.
Auf die Kanten wird wieder das Silikon aufgetragen.
Hier ist es ratsam besonders in den Ecken keine „offene“ Stelle zu haben, da dies ein besonders kritischer Bereich ist.

Jetzt wieder trocknen lassen ...
Danach genauso mit der gegenüberliegenden Seite verfahren.

=== Finishing ===
[[Bild:Bauanleitung-Ätzgerät_Finishing1.jpg|thumb|right|Finishing]] [[Bild:Bauanleitung-Ätzgerät_Dichtetest1.jpg|thumb|right|Dichte-Test mit Wasser]]
Das Finishing entscheidet letztendlich ob unsere Glasküvette dicht wird oder ob diese leckt.
Zunächst entfernen wir die herausgequollenen „Silikonwürste“ auf der Außenseite mit einem Cuttermesser. Auf der Innenseite ist dieses herausgequollene Silikon nicht störend (nur optisch).
* '''Achtung:''' nicht in die Fuge hineinschneiden, sondern nur das überstehende Material entfernen.

=== Erster Dichtigkeitstest ===
Die Küvette mit Wasser füllen und entsprechende Stellen, an welchen Wasser austritt,
mit Filzstift oder Fettstift markieren. Diese Stellen müssen im letzten Schritt besonders beachtet und abgedichtet werden

=== Fugen mit der Fugenhilfe nacharbeiten ===
[[Bild:Bauanleitung-Ätzgerät_Fugi1.jpg|thumb|right|Silikon-Fugenhilfe]]
Jetzt kommt das auch als „Fugi“ bekanntes Werkzeug zum Einsatz.
Natürlich muss es nicht das Original aus dem TV-Shopping sein, auch im Baumarkt bekommt man ein entsprechendes äquivalentes Werkzeug.
Wählt einen eurer Meinung nach einen passenden Radius an der Fugenhilfe aus.
Natürlich muss wieder alles trocken, sauber, staub- und fettfrei sein, sonst ist alles umsonst.

'''Pauschal alles noch mal mit Aceton (fettlösend) reinigen'''.

In den bereinigten Kanten an den Fugen wird nun nochmals frisches Silikon aus der Kartusche aufgetragen und mit der Fugenhilfe geformt und geglättet.
Nicht zu viel und nicht zu wenig Silikon auftragen und vor allem gleichmäßig.
Wie viel ihr verwenden müsst, bekommt ihr mit der ersten Fuge schnell heraus (Don’t Panic).
Nicht alle Fugen auf einmal nacharbeiten, erst die eine, dann die nächste Fuge.

Durch die genaue Führung mit der Fugenhilfe kann „nass in nass“ gearbeitet werden,
d.h es muss hier nicht immer wieder gewartet werden bis alles getrocknet ist.
Es geht eigentlich alles fix und sehr sauber.

=== Handhabung der Fugenhilfe ===
[[Bild:Bauanleitung-Ätzgerät_Fugi2.jpg|thumb|right|Silikon-Fugenhilfe anwenden]]
Die Fugenhilfe wird so geführt, dass diese an den beiden Glasplatten anliegt um so überschüssiges Silikon abzuziehen.
Dabei nicht in Richtung der abgeschrägten Seite ziehen, sondern in die Richtung ziehen, zu welcher die flache Seite schaut (im Bild die abgewandte Seite).
In einem Zug ohne Unterbrechung das Silikon „abziehen“.
Ist eine Stelle mit zu wenig Silikon vorhanden einfach die betreffende Stelle mit frischem Silikon aus der Tube auffüllen und gleich noch einmal abziehen.
Die Fugenhilfe immer vor dem Abziehen von Silikon befreien (mit Küchenkrepp abwischen) „sonst verschmiert’s alles“
Übrigens: Mit Kreditkarten oder anderen Plastikkarten funktioniert dies nicht, dann lieber wieder mit dem "nassen Finger" arbeiten.

== Ein- und Anbauarbeiten ==
=== Luftverteiler ===
Hierfür benötigen wir
[[Bild:Bauanleitung-Ätzgerät_AirCurtain.jpg|thumb|right|AirCurtain und Rücklaufstopp-Ventil]]
[[Bild:Bauanleitung-Ätzgerät_Luftverteiler_Base1.jpg|thumb|right|Halter für Luftverteiler]]
[[Bild:Bauanleitung-Ätzgerät_Luftverteiler_Base2.jpg|thumb|right|Luftverteiler auf Halter fixieren]]
eine Sprudelquelle (Air Curtain),
einen PVC-Schlauch,
ein Rückschlagventil und
ein Kunststoffprofil sowie
etwas Silikon und
Frischhaltefolie.
Natürlich auch eine elektrische Luft- bzw. Membranpumpe.

Um zu verhindern, dass der Sprudelschauch nach oben treibt, verankern wir diesen auf einem Kunststoffprofil und fixieren den Schlauch mit Silikon, da dies gegen die Ätzbäder resistent ist.
Silikon haftet aber nicht auf allen Materialien, speziell nicht auf PVC und ähnlichen Kunststoffen, so behelfen wir uns mit einem Trick:
Das Kunststoffprofil hat in etwa die Abmessungen der Innenfläche unserer Glasküvette, eher etwas kleiner. Dieses Kunststoffprofil bohren wir in regelmäßigen Abständen mit ca. 4 mm durch und senken diese auf der Unterseite großzügig an. Auf diese Bohrungen geben wir großzügig Silikon, so dass dieses durch die Bohrung auf der anderen Seite austritt, zusätzlich legen wir einen Silikonstrang quer zum Profil auf.

Diese so vorbereitete Profil legen wir auf Frischhaltefolie, da diese später leicht vom getrockneten Silikon entfernt werden kann.
Darauf legen wir dann den vorher abgelängten „Air Curtain“-Schlauch und fixieren diesen wiederum mit Silikonsträngen. Diese „Konstruktion“ lassen wir über Nacht trocknen.

Da das Silikon in die Senkungen gepresst wird hält dies mechanisch, sozusagen wie ein Niet oder Druckknopf, den Luftverteiler am Profil. Das an den Seiten überstehende Silikon kann nach dem Austrocknen problemlos abgeschnitten werden oder mit Hilfe der Frischhaltefolie im feuchten Zustand in die Fugen unter dem Schlauch verteilt werden.

Das '''Silikon nicht über die gesamte Schlauchlänge verteilen''', da sonst keine Luft mehr austreten kann. Nach dem Abbinden des Silikons können die überstehenden Reste abgeschnitten werden und dann wird abschließend der PVC-Schlauch angeschlossen und dieser Luftverteiler, evtl. wieder mit etwas (sehr wenig) Silikon, am Glasküvettenboden fixiert.

=== Heizelement ===
[[Bild:Bauanleitung-Ätzgerät_Heizelement_Halter.jpg|thumb|right|Heizungshalter]]
Für das Heizelement benötigen wir als Halter eigentlich nur ein Stück vom Kunststoffprofil, dessen Mindestabmessungen so groß sind, damit dieses nicht in die Küvette fallen kann und Platz für eine Bohrung bietet, damit dieses über den Glaskolben des Heizelementes geschoben werden kann ohne dass dieses komplett durchrutschen kann.
Die abgebildete Version zeigt den Halter mit einer zusätzlichen Bohrung zur Durchführung des Luftschlauches für den Luftverteiler.

=== Leiterplattenhalter ===
Der Leiterplattenhalter muss mehrere Eigenschaften besitzen.
* zum einen soll die Leiterplatte sicher gehalten werden,
* zum anderen muss die Leiterplatte auch am Rand von der Ätzlösung umspült werden können
* und nicht zuletzt muss der Halter an unterschiedliche Leiterplattengrößen angepasst werden können.

Eine nahezu perfekte Lösung dieser gestellten Probleme bieten die u.a. von der Fa. ISEL auch einzeln erhältlichen Leiterplattenhalter, welche auch auf die Abmessungen unserer selbst gebauten Ätzmaschiene angepasst werden kann.
* '''Achtung:''' Wenn z.B. der ISEL Platinenhalter gekauft wird, reicht der Platz für eine Europaplatine (100x160mm) nicht mehr aus, da der Halter breiter ist als der hier im folgenden beschriebene Selbstbauhalter. Es können dann eben nur schmälere (max. 100x120mm) Platinen geätzt werden.
Aber was wäre das denn für eine Bauanleitung, wenn nicht auch alles selbst gebaut bzw. beschrieben wird? (So einfach mache ich es mir dann doch nicht.)
Das Problem besteht darin, eine einfache und dennoch praktikable und relativ einfach nachzubildende Konstruktion zu finden. Die entsprechenden Profile, wie von Isel verwendet, sind nicht so leicht zu beschaffen.
Wir benötigen folgende Materialien:
Ein quadratisches Kunststoffvollprofil mit etwa 11mm (11,5mm) Kantenlänge
ein flaches Kunststoffprofil mit etwa 3mm Stärke und ca. 35mm (35,5mm) Breite
ein rundes Kunststoffvollprofil mit einem Durchmesser von ca. 7mm (7,5mm)
Kunststoff- oder Blechschrauben 3,5 x 20mm (Linsenkopf)
Die quadratischen Profile werden auf eine Länge von ca. 19 cm geschnitten, an beiden Enden mit einem Abstand von ca. 1 cm und ca. 2 cm zur Kante mit einer 8-mm-Bohrung versehen und eine Nut in das Profil von Bohrung zu Bohrung gefräst.

==== Eingefräste Nuten ====
[[Bild:Bauanleitung-Ätzgerät_Leiterplattenhalter1.jpg|thumb|right|Platinenhalter Oberteil]][[Bild:Bauanleitung-Ätzgerät_Leiterplattenhalter2.jpg|thumb|right|Platinenhalter Seitenteile]][[Bild:Bauanleitung-Ätzgerät_Leiterplattenhalter3.jpg|thumb|right|Platinenhalter komplett montiert]]Zum Fräsen kann eine Mini-Bohrmaschine in einem Bohrständer fixiert und mit einem entspr. Fräsbohrer bestückt werden. Das Kunststoffprofil wird dann entweder in einem Schraubstock, in welchem das Profil locker geführt wird oder an einem entspr. Anschlag geführt, damit die Nut auch gleichmäßig geführt wird. Natürlich kann auch ein Kreuzfrästisch benutzt werden, aber wer hat denn schon so was (außer mir natürlich) in seiner Werkstatt.

In die Bohrungen werden die runden, entsprechend gekürzten Kunststoffvollprofile gesteckt und später auf einer Seite verklebt, damit diese nicht herausrutschen können. Diese Stangen dienen später dazu, dass sich die Leiterplattenhalter, welche sich durch die Temperatur des Ätzbades verbiegen können, nicht zu stark auseinander biegen und somit die eingeklemmte Leiterplatte verlieren. Außerdem hat die Leiterplatte hiermit einen Halt und kann nicht aus der Halterung fallen.

==== Deckelteil ====
Deckelteil wird entsprechend der verbleibenden Länge aus dem flachen Kunststoffprofil gefertigt. (Die Breite der Glasküvette, abzüglich der Breite der Halterung für das Heizelement.
Dann wird eine Nut eingefräst, in der dann mittels Schrauben die quadratischen Halter befestigt werden. Die Nuten sollten einen Abstand zum Rand von ca. 1 cm und untereinander einen Abstand von ca. 4 cm haben, somit hat der Deckelteil noch genügend Stabilität, um nicht auseinander zu brechen und die gesamte Aufhängung am Küvettenrand zu halten.

==== Montage des Leiterplattenhalters ====
Die beiden bearbeiteten Vierkantprofile werden an einer Seite (größerer Abstand zu den Stabis) für die Schraubenaufnahme angebohrt. Mittels Schrauben werden diese am Deckelteil befestigt und die Rundstäbe durch die Bohrungen geführt. Die in die Vierkantprofile eingefrästen Nuten zeigen zueinander. Die Rundstäbe werden beide an einer Seite mit Kleber fixiert oder besser an einem Ende erhitzt und breit gedrückt (breiter als die Bohrungen im Halter).

== Endmontage ==
Die fertige Ätzmaschine kann jetzt in Betrieb genommen werden. Doch bevor ein endgültiges Befüllen mit Ätzlösung durchgeführt wird, bitte ich nochmals um einen anschließenden Dichtigkeitstest und Funktionscheck der fertigen Apparatur mit WASSER.
Der Schlauch des Luftverteilers wird über das Rückschlagventil mit der Membranpumpe verbunden und eingeschaltet.
Danach wird das Heizelement eingesetzt und in Betrieb genommen. Mit Hilfe eines Thermometers wird der Abschaltmoment auf ca. 50°C eingestellt.

[[Bild:Bauanleitung-Ätzgerät_Ätzgerät_fertig.jpg|640|center|FERTIG]]

== Volumen reduzieren ==
Ist das geringe Volumen (0,5 Liter für die Ätzlösung) für eure Zwecke zu groß, könnt ihr den Küvettenboden mit Glasperlen (Deko-Glaskiesel) auffüllen.
Diese Glasperlen verdrängen die Ätzlösung und somit kann man mit weniger Lösung arbeiten.
Warum nicht eine kleinere Küvette bauen oder einfach weniger Ätzlösung ansetzen?
Das Heizelement hat eine Mindestlänge, wenn dieses Heizelement nicht komplett mit der Heizwendel unter Wasser (Ätzlösung) steht, kann dieses zerplatzen. Durch die Glaskiesel wird gewährleistet, dass das Element komplett eintaucht aber weniger Volumen in der Küvette zur kompletten Füllung benötigt wird.

==Tipps zur Pflege==
Die Ätzlösung kann auch bei Nichtgebrauch in der Küvette gelagert werden. Dann kann es jedoch vorkommen, dass sich der Sprudelschlauch mit der Zeit zusetzt. Solange die Ätzlösung noch gebrauchsfähig ist, reicht es dann diesen z.B. mit einem entgrateten Holzstab abzustreifen. Die Poren des Schlauches werden dadurch wieder frei.
Bevor man sein Ätzgerät mit einer frischen Lösung neu befüllt sollte man die komplette Küvette gründlich mit Spülmittel reinigen. Auch in einer Spülmaschine kann die Küvette (kopfüber) gereinigt werden (Achtung! "Mutti" fragen ;-)). Der Sprudelschlauch kann mit einem groben Schwamm von den z.T. unsichtbaren Ablagerungen gereinigt und somit wieder durchlässig gemacht werden.

==Mögliche Ätzlösungen==
welche für dieses Gerät geeignet sind:

===Ammoniumpersulfat===
Das Mittel wird als weißes, kristallines Pulver geliefert, sollte luftdicht gelagert werden und ist etwas umweltfreundlicher als Eisen-III-Chlorid. Es reagiert ebenfalls hygroskopisch. 500 g des Mittels reichen für 2 Liter Ätzlösung. Beim Auflösen unter Rühren kühlt sich die Lösung deutlich ab. Die frische Ätzlösung ist klar bis leicht milchig, mit zunehmendem Kupfergehalt verfärbt sie sich blau, bleibt jedoch immer durchsichtig, so dass der Ätzvorgang sehr gut kontrolliert werden kann. Die optimale Ätztemperatur beträgt ca. 40° C, sie sollte weder deutlich höher (<50° C) noch viel niedriger (>30° C) sein. Die Ätzzeit beträgt 5 bis 10 Minuten. Nach dem Ätzen die Leiterplatte sofort gut unter fließendem Wasser abspülen. Ein Ansatz ist in einem geschlossenen Glasgefäß lagerbar und mehrfach verwendbar (Aufnahme von bis zu 40 g Kupfer je Liter). Bei intensiver Blaufärbung ist die Lösung verbraucht.
* Nach Abkühlen bleiben blaue Kristalle zurück, die hochgiftig sind!

===Natriumpersulfat===
'''Mein Mittel der Wahl'''.
Das als „Feinätzkristall” u.a. von Seno gehandelte Ätzmittel. Das Ätzmittel wird im Beutel für 0,5 l Ätzansatz geliefert. Es löst sich im Wasser schnell auf, kristallisiert nicht aus, ätzt mit sehr hoher Konturenschärfe und sehr geringer Unterätzung. Das Ätzen soll bei 40°C bis 50°C erfolgen. Die Ätzzeit beträgt 10 bis 20 Minuten bei frisch angesetzten Lösungen. Nach dem Ätzen die Leiterplatte sofort gut unter fließendem Wasser abspülen. Die Lösung kann in einem offenen! Gefäß (z.B. die Ätzküvette) aufbewahrt werden. Durch die ständige Gasentwicklung könnte ein verschlossenes Gefäß bersten!

===Absolut ungeeignete Ätzlösungen===

* Eisen-III-Chlorid
Dieses fast schon historische Ätzmittel neigt stark zum Schäumen und würde aus der Küvette überquellen. Hierfür gibt es andere „Schaumätzgeräte“
Außerdem ist ein Begutachten der Leiterplatte und des Ätzfortschrittes durch die undurchsichtige bräunliche Lösung fast unmöglich.

* Andere schaumbildende Mittel
* Stark säurehaltige Lösungen (HCL) sind wegen der Aggressivität gegenüber der Umgebung (nicht für die Ätzmaschine) auch für Mensch und Tier nicht empfehlenswert, da durch den Luftverteiler Spritzer verusacht werden, welche sich im direkten Umfeld des Gerätes ablegen.

==Entsorgen von Ätzlösungen==
[[Bild:Aetzend.gif|left|Ätzend]][[Bild:Geshschaedl.gif|left|Gesundheitsschädlich]]Die Chemikalien bitte auf gar keinen Fall in das Abwasser leiten. Die in den Klärwerken eingesetzten Bakterien können auch durch geringste Mengen der Chemikalien und des darin gelösten Kupfers absterben. Es könnte also mit nur einer Ätzküvette eine kleine Kläranlage komplett "kippen" und dann kann es richtig teuer werden. Anleitungen, die immer noch im Internet verbreitet sind und welche eine unproblematische Entsorgung über das Abwasser bei entsprechender Verdünnung suggerieren, sind nach aktueller Gesetzeslage nicht mehr erlaubt!

* Bitte die Chemikalien zur Reststoffverwertung / '''Sondermüllentsorgung''' bringen.
* Dies ist '''für Privatleute meist unentgeltlich''' und erspart einem viel Ärger.

==Autor==
* [[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 08:40, 26. Mai 2006 (CEST)

== Siehe auch ==
* [[:Kategorie: Leiterplattenentwicklung]]
* [[Ätzgerät (einfach)]]

== Weblinks ==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=225 Diesen (ähnlichen) Artikel als PDF aus dem RoboterNetz-Forum Downloaden]
*[http://www.glaserie.de/ Werkzeug zur Glasbearbeitung gibt's unter anderem hier (falls man intensiver damit arbeiten möchte)]

[[Kategorie:Grundlagen]]
[[Kategorie:Praxis]]
[[Kategorie:Projekte]]
[[Kategorie:Leiterplattenentwicklung]]

Ätzgerät (einfach)

2009-01-01T14:36:10Z

Andun: Umsortierung der Artikel

Mit einem temperaturgeregelten Heissluftgerät für ca. 50-60 € lässt sich eine sehr einfache Ätzmaschine herstellen.

[[Bild:HL-Gerät hinten red.jpg|center]]

Das verwendete Gerät vom Typ Steinel HL 2010E lässt sich in 10°C-Schritten einstellen und leistet maximal 2kW. Die maximal einstellbare Temperatur beträgt 600°C. Weitere Teile der Ätzmaschine können somit durch Weichlöten mit Standardlötzinn hergestellt werden.

==Das Ergebnis sieht etwa so aus==

[[Bild:Ergebnis red.jpg|center]]

In der Schale liegt die Platine in der Ätzlösung (kein Eisen-III-Chlorid verwenden). Die Pumpe ist eine 12-V-Kfz-Wischwasserpumpe, wie sie in jedem Auto zu finden ist. Sie vertragen korrosive Medien recht gut. Die Leistungsfähigkeit solcher Pumpen reicht mehr als aus. Eine Betriebsspannung von 6V genügt um eine sehr gute Zirkulation zu erhalten. Mit der Position des Eintrittschlauches der Ätzlösung (rote Wäscheklammer) lassen sich die Strömungsverhältnisse im Behälter sehr gut steuern. Die Flüssigkeit wird durch den Wärmetauscher, welcher am Heissluftgerät befestigt ist, gepumpt. Der Schlauch ist ein herkömmlicher Aquariumschlauch (<1€/m). Um den Schlauch auf Pumpendurchmesser zu weiten bietet sich das Heissluftgerät an. Den Pumpenanschluss hierzu schmieren, dann den heissen Schlauch darüber schieben.

Der Wärmetauscher wurde aus einem Kupferrohr und dünnem Messingblech hergestellt.

[[Bild:Detail Wätau Ring red.jpg|center]]

[[Bild:Detail Wätau Rohr red.jpg|center]]

Mit dem Heissluftgerät und einem Lötkolben können der Blechring und das Rohr problemlos zusammengelötet werden. Der Ring wird lediglich auf die Austrittsdüse gesteckt. Angelötete Drahtlaschen fixieren den Schlauch.

==Es bleibt zu sagen ...==

Das Heissluftgerät wird auf ca. 70-80°C gestellt.

Für optimale Ergebnisse muss die Pumpendrehzahl einstellbar sein.

Nach dem Ätzen sollte man die Pumpe mit warmem Wasser durchspülen. Sollte die Pumpe nach dem Trocknen nicht anlaufen hilft eine kurzzeitige Spannung von z.B. 20V (Gefahr von Spritzern !!!).

Die Badtemperatur bei eingestellter Temperatur kann mit einem mit Folie überzogenem Fieberthermometer kontrolliert werden. (ca. 45°C)

Die Badtemperatur kann sehr gut justiert werden.

Leider sind diese Pumpen nicht selbstansaugend.

Zum Thema „low-cost“-Belichten kann ich einen Röhren-Gesichtsbräuner empfehlen. Hier mein Modell Privileg (Quelle Versandhaus ?) welches ich bei ebay für 10 € erstanden habe.

[[Bild:Belichter red.jpg|center]]

4 Min. bei ca. 10 cm Abstand mit einer 3-mm-Glasplatte dazwischen haben sich als optimal herausgestellt.

Als Film habe ich mit Soennecken-Overhead-Inkjet-Folie und HP-Tinte gute Erfahrungen gemacht.

==Autor/en==
* Plasmagerd

==Siehe auch==
* [[Ätzgerät Bauanleitung]]
* [[:Kategorie: Leiterplattenentwicklung]]

[[Kategorie: Praxis]]
[[Kategorie: Grundlagen]]
[[Kategorie: Projekte]]
[[Kategorie: Leiterplattenentwicklung]]

Platinenherstellung mit der "Belichtungsmethode"

2009-01-01T14:34:21Z

Andun: Umsortierung der Artikel

'''Dieser Artikel überschneidet sich vermutlich mit diesem: [[Platinenherstellung mit der "Foto-Transfer-Technik"]]'''

==Sicherheitshinweis==
{{FarbigerRahmen|
Die verwendeten Chemikalien sind in fester Form und als Lösung sehr gefährlich. Sicherheitsdatenblatt beachten – Natriumhydroxid als Plätzchen ist stark ätzend, die 1%ige Lösung reizt Augen und Haut. Es ist dringend anzuraten, für das gesamte Hantieren mit den Chemikalien Gummihandschuhe und eine Schutzbrille zu tragen.
}}
:[http://chemdat.merck.de/documents/sds/emd/deu/de/1064/106467.pdf Sicherheitshinweise NaOH Plätzchen]

:[http://de.vwr.com/app/MSDS?uri=/html/de_msds/P31956de.pdf Sicherheitshinweise 1%ige NaOH Lösung]

:[http://de.vwr.com/app/MSDS?uri=/html/de_msds/30203de.pdf Sicherheitshinweise Natriumpersulfat]

==Einleitung==
Die Lochrasterplatine ist eine Erfindung, die es Normalsterblichen erlaubt ihre Breadboardschaltungen auf eine solidere Basis zu stellen. Doch mit zunehmender Teilzahl nimmt die Übersicht ab und das Chaos zu: Gut für die Entropie - schlecht für den ambitionierten Bastler. Doch wie kann man eine übersichtlichere Schaltung herstellen, ohne dabei zu tief ins Portemonnaie greifen zu müssen? Eine Methode dazu ist die Tonermethode ([[Platinenherstellung]]), die im Wiki ebenfalls dokumentiert ist.
In diesem Tutorial wird gezeigt, wie man mit einfachsten Mitteln eine ordentliche, belichtete Platine herstellt. Die Gesamtkosten halten sich bei dieser Methode auch in Grenzen (Ausgabe für Verbrauchsmaterialien Juni 2008: (Fotoplatine 75x100mm 0,61 €; Natriumhydroxid 250g, 3,45 €; Natriumpersulfat 120g, 2,45 €). Als Beispielprojekt wird in diesem Tutorial die Herstellung einer einfachen RS232-Interfaceplatine dienen.

==Man benötigt==
*1x fotobeschichtete Platine (ca. 0,60ct)
*1x Thermometer
*1x hitzebeständiges Glasgefäß (zB. ein Weithalserlenmeyerkolben, Kaffeekanne, etc.)
*1x Bunsenbrenner (oder auch Campingkocher, Spiritusbrenner, Heizplatte)
*1x Halogenscheinwerfer (unser "Belichtungsgerät")
*1x Waage (Briefwaage oä.)
*1x Messlöffelchen (oä.)
*1x (Tintenstrahler-)overheadfolie
*1g Natriumhydroxid (Entwickler)
*5g Natriumpersulfat (Ätzmittel)

==Vorbereitung : Platinenlayout erstellen==
{|
|[[Bild:B_layout.jpeg|framed|left|Das Layout der Interfaceplatine ]]
|Bevor man damit beginnen kann eine Platine zu ätzen, benötigt man logischerweise eine Schaltung, die man auf seine Platine übertragen möchte. Diese kann man von Hand zeichnen, mit Paint zeichnen - oder man greift auf ein speziell dafür konzipiertes Programm wie zb. CadSoft Eagle zurück, welches im Rahmen der Light-Version kostenlos genutzt werden darf. Ein solches Layout könnte zum Beispiel so aussehen:
Auf dem Bild ist in blau das Wort "UP" zu erkennen und das hat einen speziellen Grund: Da die ICs später von der Oberseite durch die Platine in die Schaltung eingefügt werden, muss die Schaltung spiegelverkehrt sein. Um zu gewährleisten, dass dies auch wirklich der Fall ist, sollte man vor dem Bedrucken der Folie ein Wort auf einer leeren Stelle des Layouts einfügen, denn sobald das Layout einmal auf der Folie ist und einem die Folie einmal runtergefallen ist, wird es schwieriger zu sagen wo oben und wo unten ist.
Wenn man soweit ist, kann man das Layout auf seine Overheadfolie ausdrucken (Möglichst platzsparend vorgehen - die Folien sind nicht billig, aber man bekommt viele Layouts drauf).
|}

==Vorbereitung: Die Entwicklerlösung==
{|
|[[Bild:B_entwickler.JPG|framed|left|Herstellung der Entwicklerlösung. Unten links sieht man die Fotoplatine und das Layout auf der Folie]]
|Man sollte darauf achten, dass man die Entwicklerlösung bereits VOR dem Belichten fertig hat, denn es ist höchst schwierig, sie in den 2 Minuten Belichtungszeit anzurühren.
Als Entwickler benutze ich Natriumhydroxid (NaOH), das es im Elektronikversand sehr günstig einzukaufen gibt. Bei den Daten der Fotoplatine stehen Entwicklungszeit (25-90s) und Temperatur (25-30 Grad C) und auf dem Entwickler die Menge (10g), die pro Liter Wasser benötigt wird. Da wir aber nur eine kleine Platine herstellen wollen reichen uns 100ml -> folglich 1g NaOH. Diese wiegt man (sofern man eine genügend genaue Waage besitzt - sonst abschätzen: 1 Teelöffel sind etwa 5 g) ab und gibt sie zusammen mit 100ml lauwarmen Wassers in das Glasgefäß. Nun schwenkt man das Gefäß, bis sich alle NaOH-"Plätzchen" aufgelöst haben und prüft die Temperatur mit dem Thermometer (wenn man kein Thermometer hat sollte die Temperatur angenehm, lauwarm sein aber wegen der Ätzgefahr Gefäß nur von außen prüfen!). Sie sollte zwischen 25-30 Grad C liegen. Wenn dies nicht der Fall ist, muss man die Lösung kurz mit dem Brenner/Kocher aufwärmen.
|}

==Das Belichten==
{|
|[[Bild:B_belichter.JPG |framed|left|Hier sieht man den "Belichter", auf dem sich Layout und Platine befinden. Jetzt muss man die Lampe nur noch einschalten]]
|Wenn die Entwicklerlösung fertig ist und die richtige Temperatur hat kann belichtet werden. Als Belichtungsgerät benutze ich einen kleinen Halogenscheinwerfer, da ich kein UV-Belichtungsgerät besitze. Zuerst sollte man die Lampe so hinstellen, dass sie nach oben strahlt. Dann sollte man sich auf jeden Fall die Mühe machen sie noch einmal richtig sauber zu machen (Tuch+Glasreiniger und vorher Netzstecker ziehen!). Nun legt man seine Folie mit dem Layout so auf die Scheibe der Lampe, dass man das Wort im Layout lesen kann - also nicht spiegelverkehrt. Ich spreche aus eigener Erfahrung, wenn ich sage, dass man es sehr leicht falsch macht. Lasst euch nicht von meinen Fotos irritieren, denn sie zeigen eine Platine, auf der das Wort "UP" lesbar ist. Dies liegt daran, dass ich es beim ersten Versuch falsch gemacht habe. Es kann nicht schaden die Folie mit einem durchsichtigen Klebestreifen am Rand ein wenig zu befestigen, damit sie beim Positionieren der Platine nicht verrutscht. Bei meiner Platine war angegeben, dass man sie, bei Verwendung einer 1000W Halogenlampe, 45-70 Sekunden belichten soll. Also nimmt man einen Mittelwert von etwa 60 Sekunden. Da meine Lampe jedoch nicht 1000W, sondern nur 500W hat ergibt das 2 Minuten Belichtungszeit. Gut, nun kann belichtet werden. Die Schutzfolie von der Platine abziehen und die Platine mit der lichtempfindlichen Seite auf die Folie legen, die sich auf der Lampe befindet. Nun kann man sie noch zurechtrücken und dann die Lampe einschalten. Nach der ausgerechneten Belichtungszeit schaltet man die Lampe wieder aus und nimmt die Platine vom Belichter. Komischerweise ist ja gar kein Layout darauf zu erkennen...
|}

==Das Entwickeln==
{|
|[[Bild:P1010098.JPG |framed|left|So sieht die Platine nach 2 Minuten belichten und 70 Sekunden Entwicklungszeit aus.]]
|Um das Layout erkennbar zu machen, lässt man die Platine ohne größere Verzögerung ins Entwicklerbad fallen. Schwenken. Fast sofort taucht ein dunkler Schleier über manchen Bereichen der Platine auf und das Layout wird langsam erkennbar. Schwenken. Als Entwicklungszeit hieß es bei meiner Platine 25-90 Sekunden. Bei mir haben sich 70 Sekunden bewährt. Danach nimmt man die Platine mit einer Zange aus dem Entwicklungsbehälter und entsorgt die Natronlauge fachgerecht. Nun spült man die Platine unter dem Wasserstrahl ab. Man sollte es vermeiden die Oberfläche der Platine mit den Fingern zu berühren, denn die Fingerabdrücke könnten die Ätzwirkung später an Stellen negativ beeinflussen. Nun schüttelt man die Platine ab und kann sie trocknen lassen wenn man möchte. Dies ist ein guter Zeitpunkt um, sofern gewünscht, eine Pause einzulegen, denn die Platine ist nun nicht mehr lichtempfindlich und daher muss nicht sofort weitergearbeitet werden.
|}

==Das Ätzen==
{|
|[[Bild:P1010101.JPG |framed|Die Platine im Ätzbad]]
|So, wir nähern uns der Vollendung der Platine. Es gilt nun das überschüssige Kupfer zu entfernen, sodass nur die Leiterbahnen stehen bleiben. Dies geschieht durch Ätzen. Es gibt viele unterschiedliche Methoden und Ätzmittel. Die gebräuchlichsten davon sind: Eisen(III)Chlorid, Salzsäure+Wasserstoffperoxid, sowie Natriumpersulfat. Für Letzteres habe ich mich entschieden, weil ich hörte, dass FeCl3 eine ziemliche Sauerei verursacht und die Salzsäure-Wasserstoffperoxidvariante zu aggressiv ist. Natriumpersulfat gibt es ebenfalls im Elektronikversand günstig zu erstehen. 500g kosten dort teils weniger als 5 Euro und bei den Mengen, die ich für einen Ansatz verwende, kann man damit Schaltungen quadratmeterweise ätzen. Für das Ätzbad benutze ich lediglich 50ml Wasser mit 5g Nartriumpersulfat. Die meisten Leute verwenden sehr viel mehr, jedoch hat dies bei meinen kleinen Platinen bisher problemlos gereicht. Das weiße Salz wird zusammen mit 50ml Wasser in das selbe, zuvor gereinigte Gefäß gegeben, in dem man bereits Entwickelt hatte. Nun erhitzt man das Gemisch auf 40-50 Grad C und auch die letzten Kristalle werden sich auflösen. Wenn die Lösung die richtige Temperatur erreicht hat gibt man die Platine hinein und schwenkt das Gefäß kontinuierlich. Als Richtwert für den Ätzvorgang sind 5-10 Minuten angegeben, aber man schwenkt so lang weiter, bis nur noch die Leiterbahnen auf dem Kunststoff erkennbar sind. Keine Angst, wenn sich anfangs nicht viel tut. Die größten, visuellen Veränderungen treten in den letzten 2 Minuten ein. Als erstes Kennzeichen macht sich die für die Cu2+ Ionen charakteristische Blaufärbung der Lösung bemerkbar. Während des Ätzvorgangs sollte man die Temperatur gelegentlich überprüfen und gegebenenfalls die Lösung mitsamt Platine erneut auf 40-50 Grad C erwärmen. Wenn der Ätzvorgang beendet ist, gießt man die Natriumpersulfatlösung in eine Flasche (nicht ins Abwasser! Die Lösung muss später beim Sondermüll abgegeben werden) und reinigt die Platine unter fließendem Wasser mit Spülmittel. Man kann hierzu auch einen weichen Lappen oder Schwamm benutzen, aber keine harten Topfkratzer, oä.
|[[Bild:P1010104.JPG |framed|So sieht die Platine nach dem Ätzen aus. Vorsicht spiegelverkehrt!]]
|}

==Das Bohren==
{|
|Nun hat man es fast geschafft. Nur noch zwei Schritte fehlen zu einer fertigen, funktionstüchtigen, lochrasterfreien Interfaceplatine. Der erste dieser Schritte ist das Bohren. Hierzu verwendet man am besten einen Bohrer mit 0,7 mm oder 0,8 mm Stärke. Diese findet man im Baumarkt bei den Minibohrmaschinen (Dremel, etc.). Man sollte allerdings darauf achten, dass man solche holt, die auch in ein normales Bohrfutter passen. Ich habe für drei Wolfram-Vanadium-Stahlbohrer knapp 5 Euro ausgegeben und die funktionieren wunderbar. Am besten verwendet man zum Bohren einen Bohrständer, wenn man nicht sehr gut und präzise "freihand"-bohren kann. Man sollte sich hierfür viel Zeit lassen und den Bohrer (auf hoher Geschwindigkeit) ganz langsam auf die Platine hinabsenken und sicherstellen, dass man tatsächlich die Mitte der Bohrlöcher erwischt.
|}

==Das Bestücken==
{|
So sieht das fertige RS232 Interface aus. Dieses Bild zeigt die zweite, richtige Version meiner Platine]]
|Wenn man alles richtig gemacht hat, gilt es nun nur noch die ICs, Kondensatoren und Stiftleisten einzulöten. Wenn ihr damit fertig seid sollte das Ganze ungefähr wie auf dem Bild aussehen.
|}

==Nachwort==

So, jetzt ist sie fertig, die Platine. Bei mir nach dem zweiten, bei euch hoffentlich nach dem ersten Ätzvorgang. Ich hoffe, dass ich euch mit diesem Tutorial ein wenig helfen konnte, bzw. euch motivieren konnte, es auch mal zu probieren, denn diese Art der Platinenherstellung ist wirklich nicht schwierig. Ich freue mich auf euer Feedback und wünsche euch

Viel Erfolg !

==Siehe auch==
Aufgrund der Umsortierung sind hier die verwandten Themen:
[[:Kategorie:Leiterplattenentwicklung]]

[[Kategorie:Elektronik]]
[[Kategorie:Leiterplattenentwicklung]]

Platinenherstellung mit der "Foto-Transfer-Technik"

2009-01-01T14:32:27Z

Andun: Umsortierung der Artikel

'''Dieser Artikel überschneidet sich vermutlich mit diesem: [[Platinenherstellung mit der "Belichtungsmethode"]]'''

== Foto-Transfer-Methode ==

=== Benötigtes Material ===
:* Eine Vorlage, nach welcher die Leiterplatte entstehen soll; auch "Film" genannt
:: z.B. '''Transparentpapier''', Layoutfolie, OHP-Folie
::Im Schulzeichenbedarf bekommt man etwas stärkeres Transparentpapier für technisches Zeichen (etwa wie Postkartenkarton) - das wellt sich mit Tinte nicht so sehr auf und bleibt schön glatt. Bei bedruckbaren Folien sollte darauf geachtet werden, dass die Deckkraft der Tinte bzw. des Toners ausreicht (Bei zu geringer Deckung ggf. mit den Druckereinstellungen experimentieren oder einfach auf die selbe Folie noch einmal exakt "drüber"-drucken)
:Eine weitere Möglichkeit ist, normales Büropapier (Kopierpapier) zu bedrucken und mit Pausklar-Spray transparent zu machen (evtl. nicht für Tintenstrahlausdrucke geeignet)
:: Wichtig ist, eine möglichst gute Vorlage zu erstellen, hierzu sollte man in den Optionen des Druckers die maximale Schwärzung einstellen. Im Durchlicht sollten die Flächen dunkelgrau bis schwarz sein, und auf gar keinen Fall Risse oder Unterbrechungen aufweisen (Ihr werdet euch wundern, wie hoch die Auflösung beim Ätzen sein kann).
:* Fotopositiv beschichtete Leiterplatten
:* Eine geeignete Lichtquelle (z.B. UV-Quelle oder Nitraphot-Leuchtmittel)
::ich verwende mittlerweile einen UVA-Gesichtsbräuner, die funktionieren genauso gut wie "richtige" Belichtungsgeräte, sind aber um ein vielfaches günstiger zu beschaffen.
:: Prinzipiell funktioniert fast jede Lichtquelle (Sonne, Schreibtischlampe) mehr oder weniger gut und zuverlässig. Wer nichts dem Zufall überlassen will, kann sich nach z.B. [http://www.blafusel.de/misc/uv.html dieser Anleitung] ein "Belichtungsgerät" aus einem alten Gesichtsbräuner und einem kaputten Scanner bauen - oder natürlich auf kommerzielle Geräte zurückgreifen.
:* Glasplatte (etwas größer als die zu belichtende Platine) - 3mm bis 5mm Stärke
:: z.B. aus einem einfachen, billigen Bilderrahmen - wobei verschiedene Glassorten zu starken Schwankungen führen können. Echtes, unbeschichtetes Glas filtert z.B. im Gegensatz zu Acryl- oder Plexiglas kaum UV-Licht aus und ist daher wesentlich besser geeignet.
:* Entwickler
:** z.B. Seno Entwickler 4007 oder
:** Natriumhydroxid (NaOH)
:* Entwicklerschale
:* Ätzmittel
:** Vorzugsweise Natriumpersulfat (NaPS), auch Feinätzkristall genannt
:** Ammoniumchlorid (findet wegen des giftigen Ammoniaks seltener Verwendung)
:** oder Eisen(III)-chlorid (FeCl3)
:::dies ist jedoch wegen der Schaumbildung nicht für Ätz-Küvetten mit Luftverteiler geeignet.
:* Ätzschale oder Ätzküvette (dann aber mit Heizung)
:* Aufbewahrungsbehälter (Saugflaschen)
:* Timer (Wecker) oder Stoppuhr
:* Fließendes Wasser
:* Spülmittel oder Klarspüler (Spülmaschine)
:* Stahlwolle (Ako-Pads oder Abrazzo)
:* Aceton
:* Lötlack
:* Kleinbohrmaschine (am besten mit Ständer) und entspr. Bohrer (z.B. 0,6mm/0,8mm/1,0mm/1,3mm)
:* sicherheitshalber Schutzhandschuhe, Schutzbrille und eine Schürze, bzw. nicht gerade den Smoking, mit dem man mit dem/r Partner/in nächsten Abend chinesisch essen gehen wollte.

[[Bild:LeiterplattenHerstellen-benötigetsMaterial.gif|640px|center]]

Anfangs kann auch mit sog. Einsteigersets gearbeitet werden.

=== Bestimmung der Belichtungszeit ===
Die Belichtungszeit ist von vielen Faktoren abhängig:
:* Stärke und Art der Lichtquelle
:* Abstand der Lichtquelle zur Platine
:* Material (unterschiedliches Basismaterial)

Um die richtige Belichtungsdauer zu bestimmen, ist es sinnvoll einen sog. Belichtungstest durchzuführen:

==== Belichtungsteststreifen ====

'''Vorbereitung:''' Verwendet man eine Nitraphot-Lampe, wird noch ein Stativ benötigt, welches die Lampe etwa 25 cm über der Tisch-/Arbeitsfläche hält.

Das '''Belichten''' kann '''bei normalem Tageslicht''' erfolgen; eine "Dunkelkammer" ist nicht nötig. Direktes Sonnenlicht sollte jedoch vermieden werden.

[[Bild:LeiterplattenHerstellen-Belichtungsteststeifen.gif|400px]]

Diesen Belichtungsteststeifen druckt man sich nun auf transparentes Material aus (bzw. verwendet '''Pausklar''' auf normalem Papier)

[[Bild:Leiterplatten_Herstellen_01_Film-Layout.jpg|150px|right|Eine Vorlage für Platinen]]
Dass der Ausdruck '''spiegelverkehrt''' ist, hat folgenden Grund:
Wenn man den Ausdruck "seitenrichtig" auf die Fotoschicht legt, ist die Druckfarbe (Toner oder Tinte) direkt auf der Fotolack-Schicht und wird nicht durch die Filmschicht (Pergamentpapier) auf zwar kurzer aber mitunter signifikanter Distanz gehalten. Bei sehr feinen Leiterbahnen könnte sonst Streulicht die Leiterbahnränder auch belichten.

Nun zieht man die Schutzschicht von der fotopositiv beschichteten Platine ab, legt darauf den Teststreifen und deckt mit etwas Lichtdichtem (zusätzliches, schwereres Papier) die Vorlage bis zur Markierung 3:50 ab.
Obendrauf legt man nun noch eine unbeschichtete Glasplatte (Bilderrahmen-Glasscheibe), welche die "Filme" durch ihr Eigengewicht auf der Leiterplatte fixiert und andrückt. Den Timer stellt man auf 3:50 Minuten ein.
Nun schaltet man gleichzeitig das Licht ein und startet den Timer.
Alle 10 Sekunden zieht man das Abdeckpapier einen Schritt weiter vom Film, bis zur nächsten Markierung.

Aufpassen dass der Film mit dem Teststreifenmuster und die Platine nicht verrutschen. Am Ende ('''Licht ausschalten''' nicht vergessen!) hat man dann eine mit verschiedenen Belichtungszeiten belichtete Platine. Diese wird im nächsten Schritt entwickelt.

=== Entwickeln der belichteten Leiterplatte ===
====Vorarbeiten====
Hier kann man schnell und am meisten falsch machen: Eine zu stark angesetzte Entwicklerlösung und eine zu hohe Temperatur können einem alles schnell versauen. Mit der Zeit bekommt man allerdings ein Gefühl hierfür, so dass man ohne Thermometer auskommt. Es kann anfangs ruhig etwas mehr Wasser als empfohlen zum Verdünnen genommen werden, um die Entwicklung zu verlangsamen.

Gängige Verdünnungen:

:* NaOH: 10g auf 1 Liter Wasser (bei Bungard Platinen 20g/l).
:* Seno Entwickler 4007 ist für 0,3 Liter Wasser fertig portioniert.

Die Lösung wird nach Herstellerangaben angesetzt. Der Entwickler muss sich '''vollständig''' aufgelöst haben.

Beim Ansetzen der Entwicklerlösung sollte man eine Schutzbrille tragen, da die Chemikalien insbesondere in fester Form, wenn sie ins Auge gelangen, zur Erblindung führen können.

==== Entwickeln ====
[[Bild:Leiterplatten_Herstellen_02_Entwickeln.jpg|150px|right|Entwickeln der Fotoschicht]]
:* Zunächst legt man die belichtete Leiterplatte mit der beschichteten Seite nach oben in die Schale
:* Den Entwickler bringt man auf angenehme Handwärme (etwa 25°C bis 30°C)
::(ein paar (30-40) Sekunden in der Mikrowelle bei 600W)
:* Dann wieder etwas abkühlen lassen und umrühren bzw. schütteln.
:* Die Entwicklerlösung zu der Platine in die Schale gießen (möglichst in einem Schwung)
:* nach kurzer Zeit (ein paar Sekunden) sollte der Fotolack an einigen Stellen "Wölkchen" bilden.
:* Ein sehr weicher Pinsel und sehr vorsichtiges Abstreifen oder eine Bewegung des
::Entwicklerbades lassen schnell die Konturen erkennen.
:* Sobald man die Konturen klar erkennen kann (bei dem Testmuster natürlich nur ein Teil der gesamten Fläche) schnell die Platine aus dem Entwicklerbad nehmen und sofort mit klarem Leitungswasser abspülen. Ein paar Tropfen Spülmittel oder Klarspüler (Spülmaschine) lassen das Wasser ohne Fleckenbildung ablaufen.
:* '''NICHT ABREIBEN!''' Feine Kratzer sind schneller drin als man meint.

==== Gern gemachte Fehler ====
{{FarbigerRahmen|
Die gesamte Entwicklung sollte nach ca. 30 bis 45 Sek. abgeschlossen sein}}

:* Dauert das Entwickeln wesentlich länger (>2:00 Min.) weil der Entwickler zu "schwach" oder zu kalt angesetzte wurde, kann es passieren, dass die Fotoschicht an ungewünschten Stellen wegen der längeren Tauchzeit "einweicht" und dann beim abspülen zu dünn wird oder sich ganz ablöst. Leiterbahnunterbrechungen sind die Folge.

:* Geschieht die Entwicklung zu schnell und ist fast sofort nach dem Einfüllen des Entwicklers abgeschlossen, weil die Lösung zu "scharf" angesetzt wurde oder zu warm ist, hat man meist schon verloren, da auch die unbelichteten Leiterbahnen angegriffen worden sind. Bis man sein "gutes Stück" dann aus dem Bad genommen hat, ist meist schon alles weg.

:* Wurde die Fotoschicht nicht ausreichend Belichtet, kann es passieren, dass der Fotolack nicht korrekt entwickelt werden kann. Dies würde zum einen eine längere Entwicklungszeit mit ihren Folgen (s. oben) nach sich ziehen oder zum anderen Kurzschlüsse durch Fotolackreste beim Ätzen verursachen.

==== Die optimale Belichtungszeit ====
[[Bild:Leiterplatten_Herstellen_03_Entwickelte-Fotoschicht.jpg|150px|right|Fertig entwickelte Leiterplatte]]Welche Belichtungszeit nun die Optimale ist, lässt sich nun aufgrund des entwickelten Belichtungstestmusters schnell erkennen. Saubere, scharfe Konturen und eine satte Lackschicht an den nicht belichteteten Stellen (Leiterbahnen) geben hierüber Aufschluss.

Je öfter und länger man mit seinem Belichtungsgerät arbeitet, desto schwächer wird dessen UV-Ausbeute. Ist also die UV-Quelle schon länger in Betrieb, können die Belichtungszeiten etwas länger werden. Irgendwann werden die Ergebnisse immer schlechter, da dies jedoch ein schleichender Prozess ist und nicht plötzlich auftritt, bemerkt man die Qualitätsminderung meist nicht. Oft schiebt man dann die Schuld auf den Entwickler oder das Basismaterial, obwohl eigentlich die Lichtquelle die Ursache ist.

=== Ätzen der entwickelten Leiterplatte ===
[[Bild:Leiterplatten_Herstellen_04_Ätzen.jpg|150px|right|Ätzen in einer Ätzküvette]]Das Ätzen kann entweder in einer Schale erfolgen, ist jedoch wegen der schnellen Abkühlung des Ätzbades nicht besonders schnell. Beim Ätzen muss der Ätzprozess in der Schale oft unterbrochen werden und das Ätzmittel wieder auf Temperatur gebracht werden. Eine '''Ätzküvette mit Heizung''' ist eine lohnenswerte Anschaffung.

Wie man sich so eine '''Ätzküvette selbst bauen''' kann, ist in den Weblinks zu finden.
Ansonsten kann man beim Ätzen eigentlich nicht viel falsch machen.
:* Ätzbad sollte eine den Angaben gemäße Temperatur aufweisen und möglichst konstant gehalten werden. Das geht in einer Schale natürlich nur bedingt; Der Ätzvorgangang kann aber entgegen dem Entwicklungsvorgang durchaus mehrmals unterbrochen werden
:* Dosierung des Ätzmittels gemäß Herstellerangaben. z.B. '''Natriumpersulfat''' ca. 200g bis '''250g für 1 Liter''' Wasser bzw. 100g bis '''125g für 0,5 Liter''' Wasser. Weniger Ätzlösung ist nicht empfehlenswert, da diese sonst zu schnell in die Sättigung kommt. Nachdem das Ätzmittel im vorgewärmten Wasser aufgelöst wurde, muss die Lösung wieder auf die '''Arbeitstemperatur von 45°C bis 50°C''' aufwärmt werden, bevor mit dem Ätzen begonnen wird.
:* Bewegen des Ätzbades beschleunigt den Vorgang und begünstigt ein gleichmäßiges Abätzen der Kupferschicht
:: Ätzküvetten sorgen durch einblasen von Luftperlen für eine ständige Umwälzung, ansonsten hat die Luftbeimengung keine Bedeutung (kein zusätzlicher Sauerstoff oder sonstige Gimmiks nötig)
:* Sobald die Leiterplatte an den entsprechenden Stellen keine Kupferreste mehr aufweist, kann diese entnommen und sorgfältig gespült werden.
:* Mit einer frisch angesetzten Ätzlösung sollte eine Platine (halbe Europaplatte 80mm x 100mm) unter optimalen Bediungungen etwa nach 5 Minuten, spätestens nach 10 Minuten, fertig geätzt sein.

=== Nachbearbeiten der fast fertigen Leiterplatte ===
[[Bild:Leiterplatten_Herstellen_05_Fertige-Platine.jpg|150px|right|Fertig geätzt, gebohrt und geschnitten]] Die nun fertig geätzte Platine muss noch etwas nachbearbeitet werden.
:* Abschnitte durch Sägen und/oder Feilen geben der Platine ihre finale Form (Konturen!)
:* Bohrungen durch die Lötaugen (Pads) damit die Bauteile hindurchgesteckt werden können
:* Entschichten der Platte
:: den verbliebenen Fotolack mit Stahlwolle unter fließendem Wasser entfernen
:: Bohrgrate werden hiermit ebenfalls geglättet, außerdem werden die Leiterbahnen schön blank
:* Besonders hartnäckige Lackreste oder Fett (Fingerabdrücke) lassen sich mit Aceton entfenen
:: Vorsicht: Aceton greift die meisten Kunststoffe an
:* Beschichten mit '''Lötlack''' erleichtert zum einen das saubere Einlöten der Bauelemente bzw. die Lotannahme und schützt zum anderen auch die Leiterbahnen vor Korrosion (Grünspan)

----

== Aufbewahrung der Chemikalien ==
Die Ätzlösung und der Entwickler können in den Saugflaschen aufbewahrt werden, diese Saugflaschen eigen sich sehr gut, um die Lösungen aus flachen und tiefen Behältnissen (Schale) tropf- und verlustfrei abzusaugen. Natürlich kann auch ein Trichter mit einem anderen Behältnis dafür herhalten.
Die Behälter sollten je nach Chemikalie wegen Gasentwicklung (Explosionsgefahr!) nicht unbedingt luftdicht verschlossen werden! Ansonsten können die Lösungen im berühmten dunklen und kühlen Ort gelagert werden.

{{FarbigerRahmen|
Die Ätzlösungen/Chemikalien dürfen nicht in Trinkflaschen, Nahrungsmittelbehältern oder Gefäßen, die letzteren ähneln, gefüllt werden!

-> '''Vergiftungsgefahr durch Verwechslung!'''}}

== Gutgemeinte Tipps ==

Nur wenn die Vorgänge einigermaßen reproduzierbar sind, kann man mit annähernd gleichbleibenden Ergebnissen rechnen. Je genauer man sich an die Konzentrationen und Temperaturen der Lösungen hält und diese auch immer wieder erreichen kann, desto weniger Ausschuss produziert man. Es kann durchaus sein, dass Platinen unterschiedlicher Hersteller oder Platinen aus anderen Materialien (Pertinax oder Epoxid) sowie deren Alter (Lagerdauer) gravierend unterschiedliche Resultate liefern.

'''Also:'''
* Sämtliche Parameter, die zum Erfolg geführt haben, notieren. Beispielsweise beim Belichten: Abstand der Lichtquelle zur Platine, Belichtungsdauer, Typ der Folie, auf die gedruckt wurde.
* Lösungen immer in möglichst gleicher Konzentration anmischen (Messbecher und genaue Waage verwenden)
* Temperaturen in gewissen Grenzen einhalten (Thermometer verwenden)
* Gleichartige Materialien/Platinen verwenden
* Gleichartige Ätzmittel und Entwickler verwenden

Nur so kann man gleichwertige Ergebnisse erwarten, und die Platinen gelingen jedes Mal auf Anhieb.

== Entsorgen der Chemikalien ==
[[Bild:Aetzend.gif|left|Ätzend]][[Bild:Geshschaedl.gif|left|Gesundheitsschädlich]]Die Chemikalien bitte '''auf gar keinen Fall''' in das Abwasser kippen! Die in den Klärwerken eingesetzten Bakterien können auch durch geringste Mengen der Chemikalien und des darin gelösten Kupfers absterben. Es könnte also mit nur einer Ätzküvette eine kleine Kläranlage komplett "kippen", und dann kann es richtig teuer werden. Anleitungen, wie sie immer noch im Internet zu finden sind und welche einem eine unproblematische Entsorgung über das Abwasser bei entsprechender Verdünnung suggerieren, sind nach aktueller Gesetzeslage nicht mehr erlaubt!

* Bitte die Chemikalien zur Reststoffverwertung / '''Sondermüllentsorgung''' / "Recyclinghof" bringen.
* Dies ist '''für Privatleute meist unentgeltlich''' und erspart einem viel Ärger.

==Autor==
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 23:38, 20. Mai 2006 (CEST)--

==Siehe auch==
Aufgrund der Umsortierung sind hier die verwandten Artikel:
[[:Kategorie:Leiterplattenentwicklung]]

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Grundlagen]]
[[Kategorie:Leiterplattenentwicklung]]

Platinenherstellung mit der "Foto-Transfer-Technik"

2009-01-01T14:29:56Z

Andun: Leiterplatten herstellen wurde nach Platinenherstellung mit der "Foto-Transfer-Technik" verschoben

'''Herstellen von Leiterplatten mit der Foto-Transfer-Technik'''

== Foto-Transfer-Methode ==

=== Benötigtes Material ===
:* Eine Vorlage, nach welcher die Leiterplatte entstehen soll; auch "Film" genannt
:: z.B. '''Transparentpapier''', Layoutfolie, OHP-Folie
::Im Schulzeichenbedarf bekommt man etwas stärkeres Transparentpapier für technisches Zeichen (etwa wie Postkartenkarton) - das wellt sich mit Tinte nicht so sehr auf und bleibt schön glatt. Bei bedruckbaren Folien sollte darauf geachtet werden, dass die Deckkraft der Tinte bzw. des Toners ausreicht (Bei zu geringer Deckung ggf. mit den Druckereinstellungen experimentieren oder einfach auf die selbe Folie noch einmal exakt "drüber"-drucken)
:Eine weitere Möglichkeit ist, normales Büropapier (Kopierpapier) zu bedrucken und mit Pausklar-Spray transparent zu machen (evtl. nicht für Tintenstrahlausdrucke geeignet)
:: Wichtig ist, eine möglichst gute Vorlage zu erstellen, hierzu sollte man in den Optionen des Druckers die maximale Schwärzung einstellen. Im Durchlicht sollten die Flächen dunkelgrau bis schwarz sein, und auf gar keinen Fall Risse oder Unterbrechungen aufweisen (Ihr werdet euch wundern, wie hoch die Auflösung beim Ätzen sein kann).
:* Fotopositiv beschichtete Leiterplatten
:* Eine geeignete Lichtquelle (z.B. UV-Quelle oder Nitraphot-Leuchtmittel)
::ich verwende mittlerweile einen UVA-Gesichtsbräuner, die funktionieren genauso gut wie "richtige" Belichtungsgeräte, sind aber um ein vielfaches günstiger zu beschaffen.
:: Prinzipiell funktioniert fast jede Lichtquelle (Sonne, Schreibtischlampe) mehr oder weniger gut und zuverlässig. Wer nichts dem Zufall überlassen will, kann sich nach z.B. [http://www.blafusel.de/misc/uv.html dieser Anleitung] ein "Belichtungsgerät" aus einem alten Gesichtsbräuner und einem kaputten Scanner bauen - oder natürlich auf kommerzielle Geräte zurückgreifen.
:* Glasplatte (etwas größer als die zu belichtende Platine) - 3mm bis 5mm Stärke
:: z.B. aus einem einfachen, billigen Bilderrahmen - wobei verschiedene Glassorten zu starken Schwankungen führen können. Echtes, unbeschichtetes Glas filtert z.B. im Gegensatz zu Acryl- oder Plexiglas kaum UV-Licht aus und ist daher wesentlich besser geeignet.
:* Entwickler
:** z.B. Seno Entwickler 4007 oder
:** Natriumhydroxid (NaOH)
:* Entwicklerschale
:* Ätzmittel
:** Vorzugsweise Natriumpersulfat (NaPS), auch Feinätzkristall genannt
:** Ammoniumchlorid (findet wegen des giftigen Ammoniaks seltener Verwendung)
:** oder Eisen(III)-chlorid (FeCl3)
:::dies ist jedoch wegen der Schaumbildung nicht für Ätz-Küvetten mit Luftverteiler geeignet.
:* Ätzschale oder Ätzküvette (dann aber mit Heizung)
:* Aufbewahrungsbehälter (Saugflaschen)
:* Timer (Wecker) oder Stoppuhr
:* Fließendes Wasser
:* Spülmittel oder Klarspüler (Spülmaschine)
:* Stahlwolle (Ako-Pads oder Abrazzo)
:* Aceton
:* Lötlack
:* Kleinbohrmaschine (am besten mit Ständer) und entspr. Bohrer (z.B. 0,6mm/0,8mm/1,0mm/1,3mm)
:* sicherheitshalber Schutzhandschuhe, Schutzbrille und eine Schürze, bzw. nicht gerade den Smoking, mit dem man mit dem/r Partner/in nächsten Abend chinesisch essen gehen wollte.

[[Bild:LeiterplattenHerstellen-benötigetsMaterial.gif|640px|center]]

Anfangs kann auch mit sog. Einsteigersets gearbeitet werden.

=== Bestimmung der Belichtungszeit ===
Die Belichtungszeit ist von vielen Faktoren abhängig:
:* Stärke und Art der Lichtquelle
:* Abstand der Lichtquelle zur Platine
:* Material (unterschiedliches Basismaterial)

Um die richtige Belichtungsdauer zu bestimmen, ist es sinnvoll einen sog. Belichtungstest durchzuführen:

==== Belichtungsteststreifen ====

'''Vorbereitung:''' Verwendet man eine Nitraphot-Lampe, wird noch ein Stativ benötigt, welches die Lampe etwa 25 cm über der Tisch-/Arbeitsfläche hält.

Das '''Belichten''' kann '''bei normalem Tageslicht''' erfolgen; eine "Dunkelkammer" ist nicht nötig. Direktes Sonnenlicht sollte jedoch vermieden werden.

[[Bild:LeiterplattenHerstellen-Belichtungsteststeifen.gif|400px]]

Diesen Belichtungsteststeifen druckt man sich nun auf transparentes Material aus (bzw. verwendet '''Pausklar''' auf normalem Papier)

[[Bild:Leiterplatten_Herstellen_01_Film-Layout.jpg|150px|right|Eine Vorlage für Platinen]]
Dass der Ausdruck '''spiegelverkehrt''' ist, hat folgenden Grund:
Wenn man den Ausdruck "seitenrichtig" auf die Fotoschicht legt, ist die Druckfarbe (Toner oder Tinte) direkt auf der Fotolack-Schicht und wird nicht durch die Filmschicht (Pergamentpapier) auf zwar kurzer aber mitunter signifikanter Distanz gehalten. Bei sehr feinen Leiterbahnen könnte sonst Streulicht die Leiterbahnränder auch belichten.

Nun zieht man die Schutzschicht von der fotopositiv beschichteten Platine ab, legt darauf den Teststreifen und deckt mit etwas Lichtdichtem (zusätzliches, schwereres Papier) die Vorlage bis zur Markierung 3:50 ab.
Obendrauf legt man nun noch eine unbeschichtete Glasplatte (Bilderrahmen-Glasscheibe), welche die "Filme" durch ihr Eigengewicht auf der Leiterplatte fixiert und andrückt. Den Timer stellt man auf 3:50 Minuten ein.
Nun schaltet man gleichzeitig das Licht ein und startet den Timer.
Alle 10 Sekunden zieht man das Abdeckpapier einen Schritt weiter vom Film, bis zur nächsten Markierung.

Aufpassen dass der Film mit dem Teststreifenmuster und die Platine nicht verrutschen. Am Ende ('''Licht ausschalten''' nicht vergessen!) hat man dann eine mit verschiedenen Belichtungszeiten belichtete Platine. Diese wird im nächsten Schritt entwickelt.

=== Entwickeln der belichteten Leiterplatte ===
====Vorarbeiten====
Hier kann man schnell und am meisten falsch machen: Eine zu stark angesetzte Entwicklerlösung und eine zu hohe Temperatur können einem alles schnell versauen. Mit der Zeit bekommt man allerdings ein Gefühl hierfür, so dass man ohne Thermometer auskommt. Es kann anfangs ruhig etwas mehr Wasser als empfohlen zum Verdünnen genommen werden, um die Entwicklung zu verlangsamen.

Gängige Verdünnungen:

:* NaOH: 10g auf 1 Liter Wasser (bei Bungard Platinen 20g/l).
:* Seno Entwickler 4007 ist für 0,3 Liter Wasser fertig portioniert.

Die Lösung wird nach Herstellerangaben angesetzt. Der Entwickler muss sich '''vollständig''' aufgelöst haben.

Beim Ansetzen der Entwicklerlösung sollte man eine Schutzbrille tragen, da die Chemikalien insbesondere in fester Form, wenn sie ins Auge gelangen, zur Erblindung führen können.

==== Entwickeln ====
[[Bild:Leiterplatten_Herstellen_02_Entwickeln.jpg|150px|right|Entwickeln der Fotoschicht]]
:* Zunächst legt man die belichtete Leiterplatte mit der beschichteten Seite nach oben in die Schale
:* Den Entwickler bringt man auf angenehme Handwärme (etwa 25°C bis 30°C)
::(ein paar (30-40) Sekunden in der Mikrowelle bei 600W)
:* Dann wieder etwas abkühlen lassen und umrühren bzw. schütteln.
:* Die Entwicklerlösung zu der Platine in die Schale gießen (möglichst in einem Schwung)
:* nach kurzer Zeit (ein paar Sekunden) sollte der Fotolack an einigen Stellen "Wölkchen" bilden.
:* Ein sehr weicher Pinsel und sehr vorsichtiges Abstreifen oder eine Bewegung des
::Entwicklerbades lassen schnell die Konturen erkennen.
:* Sobald man die Konturen klar erkennen kann (bei dem Testmuster natürlich nur ein Teil der gesamten Fläche) schnell die Platine aus dem Entwicklerbad nehmen und sofort mit klarem Leitungswasser abspülen. Ein paar Tropfen Spülmittel oder Klarspüler (Spülmaschine) lassen das Wasser ohne Fleckenbildung ablaufen.
:* '''NICHT ABREIBEN!''' Feine Kratzer sind schneller drin als man meint.

==== Gern gemachte Fehler ====
{{FarbigerRahmen|
Die gesamte Entwicklung sollte nach ca. 30 bis 45 Sek. abgeschlossen sein}}

:* Dauert das Entwickeln wesentlich länger (>2:00 Min.) weil der Entwickler zu "schwach" oder zu kalt angesetzte wurde, kann es passieren, dass die Fotoschicht an ungewünschten Stellen wegen der längeren Tauchzeit "einweicht" und dann beim abspülen zu dünn wird oder sich ganz ablöst. Leiterbahnunterbrechungen sind die Folge.

:* Geschieht die Entwicklung zu schnell und ist fast sofort nach dem Einfüllen des Entwicklers abgeschlossen, weil die Lösung zu "scharf" angesetzt wurde oder zu warm ist, hat man meist schon verloren, da auch die unbelichteten Leiterbahnen angegriffen worden sind. Bis man sein "gutes Stück" dann aus dem Bad genommen hat, ist meist schon alles weg.

:* Wurde die Fotoschicht nicht ausreichend Belichtet, kann es passieren, dass der Fotolack nicht korrekt entwickelt werden kann. Dies würde zum einen eine längere Entwicklungszeit mit ihren Folgen (s. oben) nach sich ziehen oder zum anderen Kurzschlüsse durch Fotolackreste beim Ätzen verursachen.

==== Die optimale Belichtungszeit ====
[[Bild:Leiterplatten_Herstellen_03_Entwickelte-Fotoschicht.jpg|150px|right|Fertig entwickelte Leiterplatte]]Welche Belichtungszeit nun die Optimale ist, lässt sich nun aufgrund des entwickelten Belichtungstestmusters schnell erkennen. Saubere, scharfe Konturen und eine satte Lackschicht an den nicht belichteteten Stellen (Leiterbahnen) geben hierüber Aufschluss.

Je öfter und länger man mit seinem Belichtungsgerät arbeitet, desto schwächer wird dessen UV-Ausbeute. Ist also die UV-Quelle schon länger in Betrieb, können die Belichtungszeiten etwas länger werden. Irgendwann werden die Ergebnisse immer schlechter, da dies jedoch ein schleichender Prozess ist und nicht plötzlich auftritt, bemerkt man die Qualitätsminderung meist nicht. Oft schiebt man dann die Schuld auf den Entwickler oder das Basismaterial, obwohl eigentlich die Lichtquelle die Ursache ist.

=== Ätzen der entwickelten Leiterplatte ===
[[Bild:Leiterplatten_Herstellen_04_Ätzen.jpg|150px|right|Ätzen in einer Ätzküvette]]Das Ätzen kann entweder in einer Schale erfolgen, ist jedoch wegen der schnellen Abkühlung des Ätzbades nicht besonders schnell. Beim Ätzen muss der Ätzprozess in der Schale oft unterbrochen werden und das Ätzmittel wieder auf Temperatur gebracht werden. Eine '''Ätzküvette mit Heizung''' ist eine lohnenswerte Anschaffung.

Wie man sich so eine '''Ätzküvette selbst bauen''' kann, ist in den Weblinks zu finden.
Ansonsten kann man beim Ätzen eigentlich nicht viel falsch machen.
:* Ätzbad sollte eine den Angaben gemäße Temperatur aufweisen und möglichst konstant gehalten werden. Das geht in einer Schale natürlich nur bedingt; Der Ätzvorgangang kann aber entgegen dem Entwicklungsvorgang durchaus mehrmals unterbrochen werden
:* Dosierung des Ätzmittels gemäß Herstellerangaben. z.B. '''Natriumpersulfat''' ca. 200g bis '''250g für 1 Liter''' Wasser bzw. 100g bis '''125g für 0,5 Liter''' Wasser. Weniger Ätzlösung ist nicht empfehlenswert, da diese sonst zu schnell in die Sättigung kommt. Nachdem das Ätzmittel im vorgewärmten Wasser aufgelöst wurde, muss die Lösung wieder auf die '''Arbeitstemperatur von 45°C bis 50°C''' aufwärmt werden, bevor mit dem Ätzen begonnen wird.
:* Bewegen des Ätzbades beschleunigt den Vorgang und begünstigt ein gleichmäßiges Abätzen der Kupferschicht
:: Ätzküvetten sorgen durch einblasen von Luftperlen für eine ständige Umwälzung, ansonsten hat die Luftbeimengung keine Bedeutung (kein zusätzlicher Sauerstoff oder sonstige Gimmiks nötig)
:* Sobald die Leiterplatte an den entsprechenden Stellen keine Kupferreste mehr aufweist, kann diese entnommen und sorgfältig gespült werden.
:* Mit einer frisch angesetzten Ätzlösung sollte eine Platine (halbe Europaplatte 80mm x 100mm) unter optimalen Bediungungen etwa nach 5 Minuten, spätestens nach 10 Minuten, fertig geätzt sein.

=== Nachbearbeiten der fast fertigen Leiterplatte ===
[[Bild:Leiterplatten_Herstellen_05_Fertige-Platine.jpg|150px|right|Fertig geätzt, gebohrt und geschnitten]] Die nun fertig geätzte Platine muss noch etwas nachbearbeitet werden.
:* Abschnitte durch Sägen und/oder Feilen geben der Platine ihre finale Form (Konturen!)
:* Bohrungen durch die Lötaugen (Pads) damit die Bauteile hindurchgesteckt werden können
:* Entschichten der Platte
:: den verbliebenen Fotolack mit Stahlwolle unter fließendem Wasser entfernen
:: Bohrgrate werden hiermit ebenfalls geglättet, außerdem werden die Leiterbahnen schön blank
:* Besonders hartnäckige Lackreste oder Fett (Fingerabdrücke) lassen sich mit Aceton entfenen
:: Vorsicht: Aceton greift die meisten Kunststoffe an
:* Beschichten mit '''Lötlack''' erleichtert zum einen das saubere Einlöten der Bauelemente bzw. die Lotannahme und schützt zum anderen auch die Leiterbahnen vor Korrosion (Grünspan)

----

== Aufbewahrung der Chemikalien ==
Die Ätzlösung und der Entwickler können in den Saugflaschen aufbewahrt werden, diese Saugflaschen eigen sich sehr gut, um die Lösungen aus flachen und tiefen Behältnissen (Schale) tropf- und verlustfrei abzusaugen. Natürlich kann auch ein Trichter mit einem anderen Behältnis dafür herhalten.
Die Behälter sollten je nach Chemikalie wegen Gasentwicklung (Explosionsgefahr!) nicht unbedingt luftdicht verschlossen werden! Ansonsten können die Lösungen im berühmten dunklen und kühlen Ort gelagert werden.

{{FarbigerRahmen|
Die Ätzlösungen/Chemikalien dürfen nicht in Trinkflaschen, Nahrungsmittelbehältern oder Gefäßen, die letzteren ähneln, gefüllt werden!

-> '''Vergiftungsgefahr durch Verwechslung!'''}}

== Gutgemeinte Tipps ==

Nur wenn die Vorgänge einigermaßen reproduzierbar sind, kann man mit annähernd gleichbleibenden Ergebnissen rechnen. Je genauer man sich an die Konzentrationen und Temperaturen der Lösungen hält und diese auch immer wieder erreichen kann, desto weniger Ausschuss produziert man. Es kann durchaus sein, dass Platinen unterschiedlicher Hersteller oder Platinen aus anderen Materialien (Pertinax oder Epoxid) sowie deren Alter (Lagerdauer) gravierend unterschiedliche Resultate liefern.

'''Also:'''
* Sämtliche Parameter, die zum Erfolg geführt haben, notieren. Beispielsweise beim Belichten: Abstand der Lichtquelle zur Platine, Belichtungsdauer, Typ der Folie, auf die gedruckt wurde.
* Lösungen immer in möglichst gleicher Konzentration anmischen (Messbecher und genaue Waage verwenden)
* Temperaturen in gewissen Grenzen einhalten (Thermometer verwenden)
* Gleichartige Materialien/Platinen verwenden
* Gleichartige Ätzmittel und Entwickler verwenden

Nur so kann man gleichwertige Ergebnisse erwarten, und die Platinen gelingen jedes Mal auf Anhieb.

== Entsorgen der Chemikalien ==
[[Bild:Aetzend.gif|left|Ätzend]][[Bild:Geshschaedl.gif|left|Gesundheitsschädlich]]Die Chemikalien bitte '''auf gar keinen Fall''' in das Abwasser kippen! Die in den Klärwerken eingesetzten Bakterien können auch durch geringste Mengen der Chemikalien und des darin gelösten Kupfers absterben. Es könnte also mit nur einer Ätzküvette eine kleine Kläranlage komplett "kippen", und dann kann es richtig teuer werden. Anleitungen, wie sie immer noch im Internet zu finden sind und welche einem eine unproblematische Entsorgung über das Abwasser bei entsprechender Verdünnung suggerieren, sind nach aktueller Gesetzeslage nicht mehr erlaubt!

* Bitte die Chemikalien zur Reststoffverwertung / '''Sondermüllentsorgung''' / "Recyclinghof" bringen.
* Dies ist '''für Privatleute meist unentgeltlich''' und erspart einem viel Ärger.

==Autor==
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 23:38, 20. Mai 2006 (CEST)--

==Siehe auch==
* [[Ätzgerät Bauanleitung]]
* [[Platinenherstellung]] mit der "Bügelmethode"
* [[Platinenherstellung mit der "Belichtungsmethode"]] Tutorial
* [[Leiterbahnbreiten]]
* [[Leiterplatten Entwicklung]]
* [[Platinen doppelseitig layouten mit Eagle]]

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Grundlagen]]

Leiterplatten herstellen

2009-01-01T14:29:56Z

Andun: Leiterplatten herstellen wurde nach Platinenherstellung mit der "Foto-Transfer-Technik" verschoben: Umsortierung wie hier beschrieben: http://www.roboternetz.de/phpBB2/viewtopic.php?p=416659#416659

#redirect [[Platinenherstellung mit der "Foto-Transfer-Technik"]]

Diskussion:Platinenherstellung mit der "Foto-Transfer-Technik"

2009-01-01T14:29:56Z

Andun: Diskussion:Leiterplatten herstellen wurde nach Diskussion:Platinenherstellung mit der "Foto-Transfer-Technik" verschoben

== Ätzmittel==

Ich denke nicht, das Eisen(III)Chlorid nicht mehr zeitgemäß ist, da es auch einige Vorteile hat:
* Lange Standzeit
* Hohe Kupferaufnahme
* Ätzt auch bei Zimmertemperatur
Der einzige Nachteil ist die Sauerei, die entsteht (aber Persulfat macht dafür Löcher...)
--[[Benutzer:BjS|BjS]] 04:46, 5. Mai 2006 (CEST)

----
Ja das EisenIIIChlorid bekommt man ja auch überall noch zu kaufen.
Und es funktioniert ja auch noch... sont hätte ich es auch nicht erwähnt.
Aber in der braunen Brühe kann man, wenn überhaupt, nicht erkennen,
wie weit der Ätzprozess fortgeschritten ist, daher war mir das Zeug schon
von Anfang an unsympatisch.

Ich habe auch in meiner sehr langen Zeit, in der ich schon Platinen erstelle, auch mit
anderen Methoden experimentiert, auch der "Salzsäuere-Prozess" hat mich einige Zeit
begleitet, leztendlich bin ich aber beim Feinätzkristall angekommen,
da dies wesentlich einfacher und sicherer zu handhaben ist.

Alle die behaupten daß das Natriumpersulfat zu langsam sei, kann ich nur sagen,
"Ihr werdet Euere Meinung auch noch irgenwann ändern".

Und wie schon in meiner Bauanleitung erwähnt ist das EisenIIIChlorid nicht für
Ätzküvetten geeignet, wegen der Schaumbildung.

--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 10:25, 6. Mai 2006 (CEST)

----

Ich habe alle Chemikalien viele Jahre lang getestet und bin nun doch wieder bei EisenIIIChlorid gelandet. Dass man nix sieht ist egal, da man eben weiss wie lang es dauert.
Was soll das mit der Schaumbildung? Ich blase jede Menge Luft durch meine Küvette und habe absolut keinen Schaum oben drauf.

--[[Benutzer: Steg14]] 03.03.07

----

@Steg14: OK, ist ja auch egal.
Leztendlich ändert das nichts an meinen Empfehlungen.
Ich nehme das FE3CL auch nicht so gerne, weil man in der dunklen "Brühe" den Ätzfortschritt nicht so gut (wenn überhaupt) erkennen kann ohne die Platte jedesmal aus der Lösung zu nehmen.

--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 11:12, 13. Mär 2007 (CET)

Diskussion:Leiterplatten herstellen

2009-01-01T14:29:56Z

Andun: Diskussion:Leiterplatten herstellen wurde nach Diskussion:Platinenherstellung mit der "Foto-Transfer-Technik" verschoben: Umsortierung wie hier beschrieben: http://www.roboternetz.de/phpBB2/viewtopic.php?p=416659#416659

#redirect [[Diskussion:Platinenherstellung mit der "Foto-Transfer-Technik"]]

Platinen doppelseitig layouten mit Eagle

2009-01-01T14:28:28Z

Andun: Umsortierung der Artikel

= Einleitung =
Die eigene Herstellung doppelseitiger Platinen kann sich problematisch gestalten. Da Eagle für den professionellen Einsatz entwickelt wurde, fallen die meisten Fehlerquellen erst beim Löten auf, also wenn es zu spät ist.
Im Folgenden werden Ratschläge zum Bedienen des Programms Eagle hinsichtlich des Layoutens von Platinen erteilt, die unter Hobbybedingungen hergestellt (geätzt) werden. Dabei wird vorausgesetzt, dass der gesamtheitliche Vorgang der Platinenherstellung bekannt ist oder in anderen Teilen dieser Wissensseite nachgeschlagen wird (Links unter dem Punkt: "Siehe auch").

'''Ziel dieses Dokuments ist es, Hilfestellung zu geben bei...'''
*der Konfiguration des Layout-Programms EAGLE zum Layouten von Schaltungen zur Herstellung ein- oder doppelseitiger Platinen

'''Dabei wird auf folgende Punkte Wert gelegt:'''

So wenige Vias wie möglich.

Bauteile möglichst einfach lötbar

Toleranz gegenüber Über-/Unterätzung

Einsparung von Chemikalien

= Layoutprogramm EAGLE =

== Layouteditor konfigurieren ==

'''Hinweis'''

Werte, die im Folgenden nicht erwähnt werden, sollten auf Default bleiben!

=== Raster ===
Raster als "Teilwert" von 50mil (1.25; 2.5; 5; 10; 12,5; 25; 50)
Wenn möglich mit einem Raster von 25mil auskommen.

=== Autoroutereinstellungen ===
'''Wichtig:'''

*Bei zweiseitigen Platinen immer eine "Prefered Direction" pro Layer vorgeben (nicht den Stern wählen!)!
*Das Routing Grid immer als Vielfaches des Rastergrids wählen!
*Die Costs nicht ändern (außer für Vias wie unten)!
*Via-Anzahl bei Optimize im Folgenden beachten!

'''Autorouter -->'''

'''General'''

--> Prefered Directions --> Top=senkrecht, Bottom=waagrecht (oder umgekehrt)

--> Routing Grid=2.5; 5; 10; 12,5; 25; 50 (als "Teilwert" von 50mil wie Raster, je nach Rechenleistung und Komplexität der Platine)

--> Via Shape=octagon (schützt etwas besser bei Überätzung)

'''Route''' --> Maximum --> Via=50

'''Optimize 1-6''' --> Costs --> Via=99

'''Optimize 1''' --> Maximum Vias=0

'''Optimize 2''' --> Maximum Via=5

'''Optimize 3''' --> Maximum Via=0

'''Optimize 4''' --> Maximum Via=5

'''Optimize 5''' --> Maximum Via=0

'''Optimize 6''' --> Maximum Via=0

=== DRC-Einstellungen (Design Rule Check) ===
Im DRC werden Vorgaben getroffen, nach denen der Autorouter seine Bahnen und Vias verlegt.

'''Clearance'''

* alle Werte auf min. 10mil, besser 12mil (je nach Löt- und Ätzvermögen) --> Damit bleibt es möglich, Leiterbahnen zwischen zwei IC-Pads hindurchzuführen.

'''Distance'''

* Copper/Dimension=25 --> Damit bleibt ein größerer Abstand zum Platinenrand
* Drill/Hole=10mil. --> Wie die Clearance-Werte

'''Sizes'''

* Minimum Width=12mil --> schützt vor Überätzung
* Minimum Drill=32mil --> Damit werden Vias 0,8mm und damit genauso dick wie Widerstandsbohrungen, man kann also den gleichen, relativ großen Bohrer benutzen

=== Groundplane ===
'''Achtung: Erst nach vollständig gelayouteter Platine anwenden! Ansonsten kann es passieren, dass Airwires übrig bleiben.'''

Die Groundplane verhilft zu besseren Groundeigenschaften und spart Ätzmittel und Entwickler! Man erzeugt sie wie folgt:

* Poligon anklicken
* Werte wie folgt ändern (oben in der Symbolleiste, beim Daraufzeigen erscheint in der Leiste am unteren Bildschirmrand die Erklärung):
** Layer=Top bzw. Bottom
** Poligon Thermals=ON (erleichtert das Löten von GND-Pads und beugt der übermäßigen thermischen Belastung der Bauteile vor)
** Poligon Orphans=OFF (damit alle Flächen der Plane mit einem festen Potenzial, z.B.: GND, verbunden sind und sie nicht als Antennen, z.B.: für Bürstenfeuer von Bürstenmotoren oder in der Nähe von Taktleitungen, fungieren)
** Isolate=0.016-0.035 (z.B. 0.024. Dieser Abstand zwischen Signals und GND-Plane beugt Unterätzungen vor und erleichtert das Löten)
** Poligon auf Dimension (Platinenumriss) zeichnen
** Poligon zu "GND" umbenennen (dabei auf den Rand des Poligons klicken)

== Nicht lötbare Pads ==
Da selbst hergestellte Platinen keine Durchkontaktierungen besitzen, kann es notwendig werden, sie auf dem Top-Layer zu verlöten. Dies ist aber bei manchen Bauteilen nicht möglich (z. B. Pinheads, Spindeltrimmer, Trafos usw.).
Abhilfe:
Diejenigen Pads von Bauteilen, die man nicht von oben löten kann mit einem Rechteck auf dem Layer "tRestrict" umgeben. Nur die Pads, nicht das gesamt Bauteil! Dadurch wird der Autorouter keine Top-Verbindung herstellen. Die Fehlermeldungen des DRC (Design Rule Check) können ignoriert werden. Diese beziehen sich auf das Pad.

= Hinweise zu Belichtungsmaske und Ausdruck =

Das Layout wird am besten mit Hilfe eines Laserdruckers auf eine Spezialfolie gedruckt. Diese Folien sind im Elektronikfachhandel erhältlich.

== Verzerrungen im Ausdruck / Keine Deckungsgleichheit zwischen Top- und Bottom-Layout ==
Auf Grund der "Glattheit" der Druckerfolie entstehen bei manchen Druckern Verzerrungen beim Ausdruck des Layouts, die dazu führen, dass Bohrungen nicht deckungsgleich sind. Diese Verzerrungen werden größtenteils vermieden, indem Top- und Bottom-Layout auf einer Seite direkt nebeneinander und im gleichen Druckvorgang ausgedruckt werden. Die Verzerrungen sollten dann auf beiden Layouts gleich sein, sodass Bohrungen auf beiden Seiten zentriert sind. Natürlich muss das Layout auf zu große Verzerrungen geprüft werden.

== Material: Fotobeschichtete Platinen ==
Ich habe zwar nicht sehr viele unterschiedliche Platinen getestet und ich will auch keine Werbung für Produkte machen, aber aus eigener Erfahrung kann ich sagen, dass fotobeschichtete Platinen der Firma Bungard die besten Ergebnisse erzielen. Sie sind äußerst Fehlertolerant, was dem Hobbyelektroniker zu Gute kommt, der nicht über professionelle Technik verfügt. Allerdings gibt es sicherlich Hersteller, die vergleichbar gute Platinen anbieten und die mir nicht bekannt sind.

= Siehe auch =
[[Leiterplatten Entwicklung]]

[[Leiterplatten herstellen]]

[[Platinenherstellung]]

= Autor =
[[Gock]]

Stichworte:

Platine, Herstellung, ätzen, selbst selber herstellen, doppelseitig, zweiseitig, fotobeschichtet, Layout, Eagle, Autorouter, Einstellungen, Parameter, löten, Tips und Tricks, Routen, Problem

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Software]]
[[Kategorie:Leiterplattenentwicklung]]

Leiterbahnbreiten

2009-01-01T14:27:44Z

Andun: Umsortierung der Artikel

[[Bild:Leiterplatten_Herstellen_03_Entwickelte-Fotoschicht.jpg|thumb|Leiterbahnen]]Beim Entwurf von Leiterbahnen ist es wichtig, dass die Leiterbahnen die entsprechende Mindestbreite aufweisen, damit der maximal vorgesehene Strom nicht zum Durchbrennen oder Beschädigen der Leiterbahn führt.

Die Temperatur der Leiterbahn darf wegen der Temperaturunbeständigkeit des Leiterplattenmaterials FR4 nicht beliebig hoch sein. Ab einer Temperatur von ca. 130 °C („Glaspunkt“) beginnt der Kunststoff weich zu werden und die Leiterplatte verbiegt sich. Ab ca. 110°C weichen auch Lötstellen auf.

Breitere Leiterbahnen haben mehr Kapatzität und weniger Induktivität als schmale. Deshalb sollten Leiterbahnen für GND und VCC in der Regel etwas breiter sein, z.B. 1,5 mm. Besonders bei SMD Bauteilen wird ein wesentlicher Teil der Wärme über die Leiterbahnen abgeführt, was genügend breite Leiter voraussetzt.

==Richtwerte==
In der folgenden Tabelle wird die Temperaturerhöhung der Leiterbahn bei verschiedenen Breiten und Stromstärken aufgelistet. Die Breitenangabe erfolgt in mm und mil (1/1000 Inch).
Die Tabelle geht von einer üblichen Kupferbeschichtung von 35 µm (Mikrometer) und Standardplatinenmaterial FR4 aus.

{| {{Blauetabelle}}
|'''Breite in Millimeter'''
|'''Breite in Mil'''
|'''10 °C'''
|'''20 °C'''
|'''30 °C'''
|'''45 °C'''
|'''60 ° C'''
|-
|0,25 mm
|9,8mil
|0,5 A
|0,8 A
|1,0 A
|1,3 A
|1,6 A
|-
|0,38 mm
|14,7mil
|0,8 A
|1,20 A
|1,50 A
|2,0 A
|2,4 A
|-
|0,50 mm
|19,7 mil
|1,0 A
|1,6 A
|2,0 A
|2,5 A
|3,0 A
|-
|1,00 mm
|39,4 mil
|2,2 A
|3,0 A
|3,6 A
|4,2 A
|4,8 A
|-
|1,50 mm
|59 mil
|3,0 A
|3,8 A
|4,6 A
|5,3 A
|6,5 A
|-
|2,00 mm
|78,7 mil
|3,8 A
|5,0 A
|6,5 A
|7,5 A
|8,5 A
|-
|3,00 mm
|118,1 mil
|4,5 A
|6,5 A
|8,0 A
|9,5 A
|11,0 A
|-
|5,00 mm
|197 mil
|7,0 A
|10,0 A
|12,0 A
|14,5 A
|16,0 A
|-
|8,00 mm
|315 mil
|9,0 A
|14,0 A
|17,0 A
|20,0 A
|22,5 A
|-
|10,00 mm
|394 mil
|10,0 A
|16,0 A
|20,0 A
|23,0 A
|26,0 A
|}

==Siehe auch==
* [[Leiterplatten herstellen]]
* [[Platinenherstellung|Platinenherstellung Bügelmethode]]
* [[Platinen doppelseitig layouten mit Eagle]]

[[Kategorie:Grundlagen]]
[[Kategorie:Elektronik]]
[[Kategorie:Leiterplattenentwicklung]]

Leiterplatten Entwicklung - Programme

2009-01-01T14:26:39Z

Andun: Umsortierung der Artikel

== Vorwort ==
Leiterplatten Entwicklung war früher ein, für den Hobbyanwender, recht mühsames unterfangen.
Entweder wurden die Leiterbahnen und "Pad's" direkt auf die Kupferschicht, mit einem ätzfesten Stift gezeichnet oder zunächst auf Folie/Papier gezeichnet und dann mittels Fototransfer auf die Platine übertragen. Man sollte sich aber auch fragen ob man ein geätzte Platine braucht, oder die Schaltung noch auf Lochraster oder Streifenraster geht.

Heute stehen hierfür sehr umfangreiche aber dennoch mehr oder weniger leicht bedienbare Programme zur Verfügung, welche einen Entwurf von Leiterplatten erleichtern.

Oft stehen verschiedene Versionen z.T. auch kostenlose Testversionen oder Versionen für den Hobby-Anwender zur Verfügung.

Hier eine Liste von freien und kommerziellen Programmen welche es erlauben Leiterplatten mit dem Computer zu designen.

----

: '''Hier soll nicht der Umgang (Bedienungsanleitung) mit den beschriebenen Programmen sondern die Verfügbarkeit von verschiedenen Programmen und deren Usability im Vordergrund stehen.'''

----

== Die wohl bekanntesten PCB Programme: ==
:* EAGLE
:* TARGET
:* Sprint-Layout
:* PCB-POOL®Edition
:* ORCAD
:* KiCAD
=== Weitere Programme ===
'''z.T. kommerzielle, limitierte, freie und z.T nicht mehr verfügbare Cad Programme'''
:* Protel
:: nicht mehr verfügbar (jetzt Altium)
:* Altium Designer
:* PROTEUS
:* ULTIBOARD
:* EASY PC
:* EDWIN
:* QUICK ROUTE
:* ARIADNE
:* AUTOENGINEER
:* BPECS32
:* CADSTAR
:* CADint
:* CIRCUIT LAYOUT
:* CIRCUIT CREATOR
:* CIRCAD
:* FreePCB
:* gEDA

Diese Liste kann noch weitergeführt werden, was allerdings leicht dazu führt den Überblick zu verlieren.
Diese Liste wird/kann im Laufe der Zeit mit Kommentaren und Erfahrungswerten versehen bzw. aktualisiert werden.
Auch Streichungen und Erweiterungen sind gestattet (bitte nicht übertreiben).

== AddOns für diese Programme ==
:* Eagle3D
:: ein kostenloses 3D Zusatzprogramm für Eagle

== Bewertungen und Infos zu den gelisteten Programmen ==
''Info, Empfehlungen und Kritik zu den vorgestellten Programmen''

::* EAGLE
::** Dieses Programm kann man hier im Roboternetz wohl als 1. Wahl bezeichnen, da die meisten Anwender hier hiermit arbeiten. Die kostenlose Version erlaubt Platinen bis zu 80mm x 100mm mit Schaltplan und Autorouter auf zwei Signal-Ebenen (Dual-Layer) zu erstellen. Auch eine sog. Studenten-Version (aber nicht nur diese) ist zu sehr guten Konditionen zu erwerben.
::** Nachdem die Einarbeitungsphase überwunden wurde, sehr gut zu bedienendes Tool.
::** Der Autorouter liefert (wie viele andere Programme auch) nur teilweise brauchbare Ergebnisse.
::** Gut ist die Verlinkung von Schaltplan und Board. Änderungen, die man im Schaltplan macht, werden automatisch auch in der Board-Ansicht vorgenommen. Dadurch bleiben Schaltplan und Board konsistent (funktioniert aber nur, wenn beide Ansichten geöffnet sind).
::* Eagle3D
::** bereits in der Entwurfsphase kann einem dieses Tool bei Design-Fehlern (LookOut) gute Dienste leisten
::** leider ist das erstellen von eigenen Bauteilen (noch) etwas aufwendig.
::** Auch eine Animation (Flug über die Platte) soll möglich sein ...
::** Sieht einfach klasse aus und macht auch Spaß damit zu 'Spielen'
::: '''INFO:''' Benötigt weitere Zusatzsoftware (auch als Freeware/GNU), mehr dazu auf der Homepage

== Weblinks ==
'''Programme'''
* [http://www.cadsoft.de/ Eagle Homepage von CadSoft]
* [http://www.ibfriedrich.com/home.htm Target 3001 Homepage von Ing.-Büro FRIEDRICH]
* [http://www.abacom-online.de/html/demoversionen.html Sprint-Layout Homepage von ABACOM Ingenieurbüro GbR]
* [http://www.pcb-pool.de/html_de/de_service_1.htm free PCB-POOL Homepage von Beta LAYOUT GmbH]
* [http://www.altium.com/Products/AltiumDesigner/ AltiumDesigner Homepage von Altium Limited]
* [http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCAD-Homepage]
'''AddOn's'''
* [http://www.matwei.de/doku.php?id=de:eagle3d:eagle3d Eagle3D Homepage von Matthias Weißer]


--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 12:39, 3. Feb 2007 (CET)
{{Ausbauwunsch|Was Euch noch dazu einfällt, Erfahrungen mit diesen Programmen usw., Kommentare}}

==Siehe auch==
* [[Leiterplatten herstellen]]
* [[CAD]]
* [[PCB]]

[[Kategorie:Grundlagen]]
[[Kategorie:Praxis]]
[[Kategorie:Software]]
[[Kategorie:Leiterplattenentwicklung]]

Leiterplatten Entwicklung - Programme

2009-01-01T14:24:44Z

Andun: Leiterplatten Entwicklung wurde nach Leiterplatten Entwicklung - Programme verschoben

== Vorwort ==
Leiterplatten Entwicklung war früher ein, für den Hobbyanwender, recht mühsames unterfangen.
Entweder wurden die Leiterbahnen und "Pad's" direkt auf die Kupferschicht, mit einem ätzfesten Stift gezeichnet oder zunächst auf Folie/Papier gezeichnet und dann mittels Fototransfer auf die Platine übertragen. Man sollte sich aber auch fragen ob man ein geätzte Platine braucht, oder die Schaltung noch auf Lochraster oder Streifenraster geht.

Heute stehen hierfür sehr umfangreiche aber dennoch mehr oder weniger leicht bedienbare Programme zur Verfügung, welche einen Entwurf von Leiterplatten erleichtern.

Oft stehen verschiedene Versionen z.T. auch kostenlose Testversionen oder Versionen für den Hobby-Anwender zur Verfügung.

Hier eine Liste von freien und kommerziellen Programmen welche es erlauben Leiterplatten mit dem Computer zu designen.

----

: '''Hier soll nicht der Umgang (Bedienungsanleitung) mit den beschriebenen Programmen sondern die Verfügbarkeit von verschiedenen Programmen und deren Usability im Vordergrund stehen.'''

----

== Die wohl bekanntesten PCB Programme: ==
:* EAGLE
:* TARGET
:* Sprint-Layout
:* PCB-POOL®Edition
:* ORCAD
:* KiCAD
=== Weitere Programme ===
'''z.T. kommerzielle, limitierte, freie und z.T nicht mehr verfügbare Cad Programme'''
:* Protel
:: nicht mehr verfügbar (jetzt Altium)
:* Altium Designer
:* PROTEUS
:* ULTIBOARD
:* EASY PC
:* EDWIN
:* QUICK ROUTE
:* ARIADNE
:* AUTOENGINEER
:* BPECS32
:* CADSTAR
:* CADint
:* CIRCUIT LAYOUT
:* CIRCUIT CREATOR
:* CIRCAD
:* FreePCB
:* gEDA

Diese Liste kann noch weitergeführt werden, was allerdings leicht dazu führt den Überblick zu verlieren.
Diese Liste wird/kann im Laufe der Zeit mit Kommentaren und Erfahrungswerten versehen bzw. aktualisiert werden.
Auch Streichungen und Erweiterungen sind gestattet (bitte nicht übertreiben).

== AddOns für diese Programme ==
:* Eagle3D
:: ein kostenloses 3D Zusatzprogramm für Eagle

== Bewertungen und Infos zu den gelisteten Programmen ==
''Info, Empfehlungen und Kritik zu den vorgestellten Programmen''

::* EAGLE
::** Dieses Programm kann man hier im Roboternetz wohl als 1. Wahl bezeichnen, da die meisten Anwender hier hiermit arbeiten. Die kostenlose Version erlaubt Platinen bis zu 80mm x 100mm mit Schaltplan und Autorouter auf zwei Signal-Ebenen (Dual-Layer) zu erstellen. Auch eine sog. Studenten-Version (aber nicht nur diese) ist zu sehr guten Konditionen zu erwerben.
::** Nachdem die Einarbeitungsphase überwunden wurde, sehr gut zu bedienendes Tool.
::** Der Autorouter liefert (wie viele andere Programme auch) nur teilweise brauchbare Ergebnisse.
::** Gut ist die Verlinkung von Schaltplan und Board. Änderungen, die man im Schaltplan macht, werden automatisch auch in der Board-Ansicht vorgenommen. Dadurch bleiben Schaltplan und Board konsistent (funktioniert aber nur, wenn beide Ansichten geöffnet sind).
::* Eagle3D
::** bereits in der Entwurfsphase kann einem dieses Tool bei Design-Fehlern (LookOut) gute Dienste leisten
::** leider ist das erstellen von eigenen Bauteilen (noch) etwas aufwendig.
::** Auch eine Animation (Flug über die Platte) soll möglich sein ...
::** Sieht einfach klasse aus und macht auch Spaß damit zu 'Spielen'
::: '''INFO:''' Benötigt weitere Zusatzsoftware (auch als Freeware/GNU), mehr dazu auf der Homepage

== Weblinks ==
'''Programme'''
* [http://www.cadsoft.de/ Eagle Homepage von CadSoft]
* [http://www.ibfriedrich.com/home.htm Target 3001 Homepage von Ing.-Büro FRIEDRICH]
* [http://www.abacom-online.de/html/demoversionen.html Sprint-Layout Homepage von ABACOM Ingenieurbüro GbR]
* [http://www.pcb-pool.de/html_de/de_service_1.htm free PCB-POOL Homepage von Beta LAYOUT GmbH]
* [http://www.altium.com/Products/AltiumDesigner/ AltiumDesigner Homepage von Altium Limited]
* [http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCAD-Homepage]
'''AddOn's'''
* [http://www.matwei.de/doku.php?id=de:eagle3d:eagle3d Eagle3D Homepage von Matthias Weißer]


--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 12:39, 3. Feb 2007 (CET)
{{Ausbauwunsch|Was Euch noch dazu einfällt, Erfahrungen mit diesen Programmen usw., Kommentare}}

==Siehe auch==
* [[Leiterplatten herstellen]]
* [[CAD]]
* [[PCB]]

[[Kategorie:Grundlagen]]
[[Kategorie:Praxis]]
[[Kategorie:Software]]

Leiterplatten Entwicklung

2009-01-01T14:24:44Z

Andun: Leiterplatten Entwicklung wurde nach Leiterplatten Entwicklung - Programme verschoben: Sortierung der Artikel wie in http://www.roboternetz.de/phpBB2/viewtopic.php?p=416659 beschrieben

#redirect [[Leiterplatten Entwicklung - Programme]]

Kategorie:Leiterplattenentwicklung

2009-01-01T14:22:29Z

Andun: Erstellung

Diese Kategorie sammelt alle Artikel die sich damit beschäftigen, wie man Leiterplatten entwickelt und anschließend auf die Platinen überträgt.

Leiterplatten herstellen - Toner-Transfer-Methode

2009-01-01T14:20:42Z

Andun: Umsortierung der Artikel

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. platziert man kleine Kreuze an verschiedenen Stellen im Layout. Praktisch ist auch ein wenig Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

[[Bild:BM_auflegen.jpg|center]]

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

[[Bild:BM_fertig.jpg |center]]

Mit etwas mehr Übung und Ausprobieren sollten auch noch bessere Ergebnisse erzielt werden können, speziell wenn man den Toner z.B. noch einbrennt in die Platine, indem die Platine nach dem Entfernen des Trägers nochmal auf das Bügeleisen gelegt wird, so dass der Toner in die Platine einziehen kann.

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
Achtung! Umsortierung der Artikel! Artikel in dieser Kategorie zu finden: [[:Kategorie:Leiterplattenentwicklung]]
* [[Leiterplatten_herstellen]] mit der "Foto-TransferTechnik"
* [[Leiterbahnbreiten]]
* [[Platinen doppelseitig layouten mit Eagle]]
* [[Platinenherstellung mit der "Belichtungsmethode"]]

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.qsl.net/k5lxp/projects/PCBFab/PCBFab.html
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Leiterplattenentwicklung]]

Diskussion:Leiterplatten herstellen - Toner-Transfer-Methode

2009-01-01T14:18:22Z

Andun: Diskussion:Platinenherstellung wurde nach Diskussion:Leiterplatten herstellen - Toner-Transfer-Methode verschoben

Hallo,

habe mich auch lange mit der Bügelmethode herumgeschlagen, mein Fazit: Belichten geht 100x besser.

Mfg --[[Benutzer:Nollsen|Nollsen]] 20:35, 3. Jan 2006 (CET)

PS: Werde bei Bedarf Bauanleitungen für Ätzmaschinen etc einbringen

Ein Ätzmaschinen-Artikel wäre im Wiki sicher ne feine Sache. Im Forum hatten wir schon mal eine Anleitung, aber da geht sie leider etwas unter, wäre hier sicherlich unter Projekte günstiger!

--[[Benutzer:Frank|Frank]] 01:05, 4. Jan 2006 (CET)

----
Wiso hatten?
gibt's doch immer noch...
http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=7415

Ich schau mal ob ich die Sources noch habe und werden dann eine Umsetzung versuchen...

--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 23:54, 25. Mai 2006 (CEST)

Diskussion:Platinenherstellung

2009-01-01T14:18:22Z

Andun: Diskussion:Platinenherstellung wurde nach Diskussion:Leiterplatten herstellen - Toner-Transfer-Methode verschoben: Sortierung der Artikel wie in http://www.roboternetz.de/phpBB2/viewtopic.php?p=416659 beschrieben.

#redirect [[Diskussion:Leiterplatten herstellen - Toner-Transfer-Methode]]

Platinenherstellung

2009-01-01T14:18:21Z

Andun: Platinenherstellung wurde nach Leiterplatten herstellen - Toner-Transfer-Methode verschoben: Sortierung der Artikel wie in http://www.roboternetz.de/phpBB2/viewtopic.php?p=416659 beschrieben.

#redirect [[Leiterplatten herstellen - Toner-Transfer-Methode]]

Leiterplatten herstellen - Toner-Transfer-Methode

2009-01-01T14:18:20Z

Andun: Platinenherstellung wurde nach Leiterplatten herstellen - Toner-Transfer-Methode verschoben

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. platziert man kleine Kreuze an verschiedenen Stellen im Layout. Praktisch ist auch ein wenig Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

[[Bild:BM_auflegen.jpg|center]]

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

[[Bild:BM_fertig.jpg |center]]

Mit etwas mehr Übung und Ausprobieren sollten auch noch bessere Ergebnisse erzielt werden können, speziell wenn man den Toner z.B. noch einbrennt in die Platine, indem die Platine nach dem Entfernen des Trägers nochmal auf das Bügeleisen gelegt wird, so dass der Toner in die Platine einziehen kann.

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
* [[Leiterplatten_herstellen]] mit der "Foto-TransferTechnik"
* [[Leiterbahnbreiten]]
* [[Platinen doppelseitig layouten mit Eagle]]
* [[Platinenherstellung mit der "Belichtungsmethode"]]

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.qsl.net/k5lxp/projects/PCBFab/PCBFab.html
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]

Programmer

2008-07-21T06:44:28Z

Andun: /* Weblinks */

== Einführung ==
Als '''Programmer''' bezeichnet man die Hardwarekomponente, mit der das ausführbare Mikrocontrollerprogramm (Firmware, HEX-File) auf den Controller übertragen wird. Es gibt verschiedene Konzepte der Programmübertragung neben dem Konzept des Bootloaders, der Parallelprogrammierung und des [[JTAG]]-Interfaces spielt bei [[Atmel]] Mikrocontrollern das Verfahren des "serial Download" eine große Rolle. Bekannt ist diese Variante der Programmierung als ISP (In System Programmierung). Dabei wird das [[SPI]] (Serial Processor Interface) genutzt, welches bei fast allen [[AVR]]-Controllern zu finden ist. ISP-Programmer zeichnen sich dadurch aus, dass der Hardwareaufwand für diese sehr gering ist. Das hat natürlich Auswirkungen auf den Preis. Für einen "Standard" [[ISP]] Parallel-Programmer liegen die Materialkosten im Cent-Bereich. Bei solchen "billig" Programmern werden die eigentlichen Programmierprotokolle (siehe Abschnitt Memory Programing in AVR Datenblättern) durch ein entsprechendes Programm auf dem PC erzeugt ([[AVR]]-Prog, PonyProg, YAAP, AVRDUDE, [[Bascom]] usw.) und die Programmerhardware ist bestenfalls zur Pegelanpassung da. Letztlich gibt es sogar derartige Programmer, die nur aus drei Schutzwiderständen bestehen. Meist wir aber ein kleiner preiswerter Treiberbaustein eingebaut, der für eine sichere Datenübertragung auch bei längeren Programmierkabeln sorgt. Damit ist ein extrem günstiger Einstieg in die Programmierung von [[Atmel]] AVR-Controllern möglich. Aufwendiger werden dann Programmer, die tatsächlich über eigene "Intelligenz" verfügen. Dabei handelt es sich in der Regel um so genannte Serial-Programmer. Hier erfolgt die Datenübertragung an den Programmer per serieller Schnittstelle oder über [[USB]]. Der Programmer selbst besitzt einen Controller, der die Daten empfängt und das Programmierprotokoll ausführt. Der weit verbreitete SI-Prog (siehe PonyProg) wird zwar an die Serielle Schnittstelle angeschlossen ist dem Wesen nach aber den Parallelprogrammern äquivalent (einfache Pegelanpassung, keine eigene Intelligenz). Darin liegt auch die Ursache, warum der SI-Prog nie an einem handelsüblichen [[USB]] zu Serial-Adapter laufen wird.

== Parallelport ISP Programmer ==

=== STK 200 kompatible Programmer ===
Bei den Parallelportprogrammern handelt es sich oft um Nachbauten von Programmierintrefaces der ersten Starterkits von ATMEL dem STK200 oder STK300. Damit wird auch geworben in dem man diese als STK200 kompatibel oder als sogenannte Standard-ISP-Programmer bezeichnet. Der Vorteil dieser Programmer liegt tatsächlich darin, dass so ziemlich jede Programmersoftware diese unterstützt.
Die Kompatibilität bezieht sich hier auf die Belegung der Leitungen am LPT-Port. Es hat nichts mit der Verwendung eines Treiberschaltkreises bei den meisten dieser Programmer zu tun.

LPT-Pinning des STK200
SCK = 6;
MOSI = 7;
RESET = 9;
MISO = 10;

=== SP12 kompatible Programmer ===
Bei dem SP12 (von Steve Bolt) Programmer handelt es sich ursprünglich um eine extrem einfache Lösung bei der nur drei Schutzwiderstände und keine weitere Pegelanpassung benutzt wurde. Dieser Programmer zum fast Nulltarif erfreut sich großer Beliebtheit. Der Hauptgrund dafür liegt aber in seiner Schaltungslösung die es erlaubt das Zielsystem über den LPT-Port mit Spannung zu versorgen. Bei der STK200 Schaltung muss der Programmer vom Zielsystem versorgt werden. Man braucht beim SP12 also zum Programieren kein zusätzliches Netzteil. Inzwischen werden ernsthafte SP12 Programmer auch mit einem Bustreiber versehen.

LPT-Pinning des SP12
VCC = 4,5,6,7,8;
RESET = 3;
SCK = 2;
MOSI = 9;
MISO = 11;

== Pseudo serielle Programmer (SI-Prog) ==
Ein Programmer, der vor allem wegen seiner guten Unterstützung durch das beliebte PonyProg eine weite Verbreitung erfahren hat, ist der SI-Prog. Dieser wird oft als serieller Programmer bezeichnet. Richtig ist, dass er an den COM-Port des PCs angeschlossen wird. Aber die Schaltung verrät, daß hier die Steuerleitungen wie DTR, RTS und CTS des COM-Ports verwendet werden, um ein [[SPI]]-Protokoll zu fahren. Die eigentlichen Signalleitungen TxD und RxD sind bei diesem Adapter gar nicht angeschlossen. Damit ist es auch beim besten USB-RS232-Adapter nicht möglich, diesen Programmer an einem modernen Notebook anzuschließen, der nur noch über USB verfügt. Deshalb kann PonyProg dann nicht mehr als Programmiertool verwendet werden.

== Echte serielle Programmer ==
Echte serielle Programmer basieren entweder auf dem Atmel Application-Note AN910 oder sind STK500 kompatible Programmer. Allen gemeinsam ist das Vorhandensein eines Controllers mit entsprechender AVR910 oder STK500 kompatibler Firmware. Diese kann meist über einen Bootloader aktualisiert werden. Da ein Controller und eine reguläre RS232 Pegelanpassung (z.B. mit einem MAX232) empfindlich kostenintensiver als das Material für einen Parallelprogrammer ist, sind diese in der Regel auch teurer. Dafür erhält man aber eine kompatible Lösung die, wie der STK200, durch die meisten Flash-Tools unterstützt wird und man kann diese mit einem handelsüblichen USB-Serial-Adapter auch an Systemen betreiben, die wie viele Notebooks heute nur noch über USB verfügen. Wichtige Weiterentwicklungen bei den Serialprogrammern ist das AVR911 und das STK500v2 Protokoll. Man sollte beim Neuerwerb darauf achten dass eines dieser aktuellen Protokolle unterstützt wird.

== USB Programmer ==
Bei USB-Programmern handelt es sich eigentlich nicht um eine eigenständige Gruppe von Programmern sondern um AVR910 oder STK500 kompatible Lösungen. Das Besondere ist hier, dass der Programmer selbst über einen USB-Controller verfügt. Dabei muss ein Treiber für diesen Controller installiert werden der im System einen virtuellen COM-Port zur Verfügung stellt. Beim Betrieb dieser Programmer gibt es keine Unterschiede zu den seriellen Programmern. Leider sind USB Programmer dadurch das die USB Controller recht teuer und ausschließlich in SMD verfügbar sind also Selbstbauprojekte für Anfänger ungeeignet.

Für die langsamste USB-Geschwindigkeit kann ein AVR Controller das USB Interface auch emulieren. Es gibt Baupläne für billige Programmierer die so auf den extra USB Controller verzichten. Das USB interface ist allerdings wohl nicht 100% normconform und es könnte dadurch zu inkompatibilitäten kommen.

== ISP-Anschluss ==

=== 10poliger ISP Anschluss ===
Die am meisten verwendete Steckerbelegung, nicht nur Im Roboternetz. Genauere Beschreibung unter [[RN-Definitionen]]. Nahezu alle RN-Bauanleitungen nutzen diese Belegung.

1 - MOSI
2 - VCC
3 - LED (oft auch unbelegt)
4 - GND
5 - RST
6 - GND
7 - SCK
8 - GND
9 - MISO
10 - GND

=== 6poliger ISP Anschluss ===
Nur in wenigen Roboternetz-Projekten gebräuchlich. Dieser Stecker spart etwas Platz, ist aber deutlich schwieriger (und teurer) zu bekommen als die zehnpolige Variante.
1 - MISO
2 - VCC
3 - SCK
4 - MOSI
5 - RST
6 - GND

== Autor ==
*[[Benutzer:Martin Fiedler|Martin Fiedler]]
*Kleinere Änderungen Frank

==Siehe auch==
* [[AVR-ISP Programmierkabel]]- Bauanleitung Bauanleitung Parallel Programmer ISP
* [[ISP]]
* [[RN-Definitionen]]

==Weblinks==
* [http://www.rowalt.de/mc/avr/progd.htm Rowalt Bauanleitung Parallel Programmer]
* [http://www.atmel.com/dyn/resources/prod_documents/DOC0943.PDF Atmel Serialprogrammer ]
* [http://www.klaus-leidinger.de/mp/Mikrocontroller/AVR-Prog/AVR-Programmer.html Klaus-Leidinger Serialprogrammer Bauanleitung ]
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/evertool/ Bauanleitung Serialprogrammer Englisch Evertool]
* [http://www.fischl.de/usbasp/ USBasp von fischl.de: USB-Programmer für Atmel AVR Controller] - Bauanleitung, Weblinks zu Schaltplänen und Layouts (Eagle, PDF), Linux und Win32, Firmware mit Quelldateien, Win32-Treiber.
* [http://www.avr-projekte.de/isp.htm USB-Programmer Bauanleitung]
* [http://www.matwei.de/doku.php?id=de:elektronik:usbisp USB-Programmer Bauanleitung]
* [http://www.obdev.at/products/avrusb/avrdoper.html USB-Programmer Bauanleitung] - AVR Doper - High Voltage Programmierung

[[Kategorie:Microcontroller]]

Diskussion:Regelungstechnik

2007-11-22T23:42:55Z

Andun:

Gratuliere zu dem sehr guten Artikel. Wird ständig noch besser, zurecht in der Beliebtheit ganz oben. --[[Benutzer:Frank|Frank]] 14:24, 14. Jan 2006 (CET)

Danke, freut mich, dass es so gut ankommt. --Waste

Ist es möglich das Thema aufzuteilen oder einem eigenen gebiet zusuordnen? Der Artikel ist sehr gut, doch inzwischen auch sehr lang. -- [[Benutzer:Olaf-petersen|Olaf-petersen]] 21:19, 20. Jan 2006 (CET)

Ich bin mir da nicht so sicher, ob durch eine Aufteilung die Nachteile nicht überwiegen, z.B. die Übersichtlichkeit verloren geht. Wenn es aber möglich ist, die Übersicht und Struktur zu erhalten, spricht nichts dagegen, den Artikel zu teilen.
Schön, dass du dich mit dem Kaskadenregler beteiligt hast. Leider ist die Terminologie bei den Symbolen total anders. Ist es vielleicht möglich, das noch anzupassen?
--Waste 22.1.06

Aufteilung würde ich auch erst machen wenn der Beitrag wirklich völlig aus den Nähten platzt. Kopieren kann man später immer noch.
Unter SIEHE AUCH bitte nur interne Links aus dem Wiki. Alle anderen Links unter WEBLINKS, auch die Forum links. Falls später mal das WIKI Offline zur Verfügung gestellt werden sollte, erleichtert die Unterscheidung die Übersicht.
--[[Benutzer:Frank|Frank]] 11:54, 22. Jan 2006 (CET)

Hallo overthere,
schon mal überlegt, ob mit uint8 überhaupt richtig gerechnet wird? Gibt es da eine Begrenzung? Was kommt bei 200 + 66 heraus? 255 oder 10 -- Waste 19.12.06

Ich wollte mich auch nur mal für diesen wirklich sehr guten Artikel bedanken! (Das muss ich einfach mal als Offtopic hier in der Diskussion los werden!)

Der hat ja mit den vielen Diagrammen und guten Erklärungen wirklich Qualität für eine Zeitung oder ein Buch. Respekt!
--[[Benutzer:Andun|Andun]] 00:42, 23. Nov 2007 (CET)

Leiterplatten herstellen - Toner-Transfer-Methode

2007-09-29T17:30:22Z

Andun: Entfernen des Hinweises + hinzufügen eines Bildes

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. kleine Kreuze an verschiedenen Stellen im Layout platziert. Praktisch ist auch ein bisschen Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

[[Bild:BM_auflegen.jpg|center]]

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

[[Bild:BM_fertig.jpg |center]]

Mit etwas mehr Übung und Ausprobieren sollten auch noch bessere Ergebnisse erzielt werden können, speziell wenn man den Toner z.B. noch einbrennt in die Platine, indem die Platine nach dem Entfernen des Trägers nochmal auf das Bügeleisen gelegt wird, so dass der Toner in die Platine einziehen kann.

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
* [[Leiterplatten_herstellen]] mit der "Foto-TransferTechnik"
* [[Leiterbahnbreiten]]
* [[Platinen doppelseitig layouten mit Eagle]]

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.qsl.net/k5lxp/projects/PCBFab/PCBFab.html
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]

Datei:BM auflegen.jpg

2007-09-29T17:29:34Z

Andun: Das Transfermaterial mit dem Toner wird auf die Platine gelegt.

Das Transfermaterial mit dem Toner wird auf die Platine gelegt.

Leiterplatten herstellen - Toner-Transfer-Methode

2007-09-29T17:24:48Z

Andun: Hinzufügen eines Bildes und anpassen des Textes

{{FarbigerRahmen|
Leider sind die Bilder für den Artikel verlorengegangen, wer welche nachtragen kann, sollte dies tun.

Hinweis: Vorallem der 2. Weblink enthält eine gute Anleitung, die derzeit auch mehr Bilder enthält, als dieser Artikel.
}}

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. kleine Kreuze an verschiedenen Stellen im Layout platziert. Praktisch ist auch ein bisschen Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

[[Bild:BM_fertig.jpg |center]]

Mit etwas mehr Übung und Ausprobieren sollten auch noch bessere Ergebnisse erzielt werden können, speziell wenn man den Toner z.B. noch einbrennt in die Platine, indem die Platine nach dem Entfernen des Trägers nochmal auf das Bügeleisen gelegt wird, so dass der Toner in die Platine einziehen kann.

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
* [[Leiterplatten_herstellen]] mit der "Foto-TransferTechnik"
* [[Leiterbahnbreiten]]
* [[Platinen doppelseitig layouten mit Eagle]]

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.qsl.net/k5lxp/projects/PCBFab/PCBFab.html
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]

Datei:BM fertig.jpg

2007-09-29T17:22:56Z

Andun: Die fertig geätzte Platine mit der Direkttoner/Bügel-Methode.

Die fertig geätzte Platine mit der Direkttoner/Bügel-Methode.

Leiterplatten herstellen - Toner-Transfer-Methode

2007-09-29T17:20:24Z

Andun: Hinzufügen eines Bildes und anpassen des Textes

{{FarbigerRahmen|
Leider sind die Bilder für den Artikel verlorengegangen, wer welche nachtragen kann, sollte dies tun.

Hinweis: Vorallem der 2. Weblink enthält eine gute Anleitung, die derzeit auch mehr Bilder enthält, als dieser Artikel.
}}

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. kleine Kreuze an verschiedenen Stellen im Layout platziert. Praktisch ist auch ein bisschen Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

[[Bild:BM_ohne_traeger.jpg|center]]

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

Oberseite meines AVR-Boards

[[Bild:AnsichtvonOben.jpg|center]]

Unterseite (Die Drähte haben nichts mit dem Bügeln zu tun. Das passiert, wenn man beim Layouten Leiterbahnen vergisst;-))

[[Bild:AnsichtvonUnten.jpg|center]]

Diese Bild zeigt was passiert, wenn man beim Bügeln das Bügeleisen verkantet. Also einen zu großen Druck mit der Kante der Heizfläche ausübt. Die Leiterbahnen bekommen einen "Bauch". Ich habe diesen Fehler hier mit der Nadel korrigiert. Die Funktion stört es nicht, es ist halt ein kleiner Schönheitsfehler

[[Bild:verkantet.jpg|center]]

Das hier ist eine Nahaufnahme eines MAX232. Ich finde die Form und die Scharfkantigkeit der Pads ist mit einer belichteten Platine durchaus vergleichbar.

[[Bild:Padform.jpg|center]]

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
* [[Leiterplatten_herstellen]] mit der "Foto-TransferTechnik"
* [[Leiterbahnbreiten]]
* [[Platinen doppelseitig layouten mit Eagle]]

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.qsl.net/k5lxp/projects/PCBFab/PCBFab.html
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]

Datei:BM ohne traeger.jpg

2007-09-29T17:18:47Z

Andun: Das Trägermaterial wurde im Wasser/Seife Bad vorsichtig entfernt.

Das Trägermaterial wurde im Wasser/Seife Bad vorsichtig entfernt.

Leiterplatten herstellen - Toner-Transfer-Methode

2007-09-29T16:51:22Z

Andun: /* Abziehen des Trägermaterials von der Platine */

{{FarbigerRahmen|
Leider sind die Bilder für den Artikel verlorengegangen, wer welche nachtragen kann, sollte dies tun.

Hinweis: Vorallem der 2. Weblink enthält eine gute Anleitung, die derzeit auch mehr Bilder enthält, als dieser Artikel.
}}

==Platinenmachen leicht gemacht - "Die Bügelmethode"==

===Was ist die Bügelmethode?===
Die Bügelmethode ist eine Technik Platinen herzustellen, ohne sie belichten zu müssen. Das spart eine Menge Zeit und Geld und ist eine schnelle Methode, sich einen Prototyp zu erstellen.
Der Nachteil ist allerdings, dass man einen Laserdrucker/Kopierer benutzen muss. Das Ätzen bleibt einem leider nicht erspart.

Das Herstellen einer Platine nach der Bügelmethode funktioniert in folgenden Schritten:

# Erstellen eines Layouts
# Ausdrucken des Layouts auf einem Laserdrucker/Kopierer
# Aufbügeln des Layouts auf die gereinigte Platine
# Ätzen der Platine

===Erstellen des Layouts===
Bei dieser Methode ist es wichtig, ein geeignetes Layout zu entwerfen. Man sollte auf die Leiterbahnbreite und die Abstände zwischen Leiterbahnen und Pads achten. Beim Aufbügeln des Layouts auf die Platine werden alle Konturen ein bisschen breiter.

Das Layout erstellt man am besten per Computer, da es ausgedruckt werden muss. Beim Erstellen von doppelseitigen Platinen ist es unbedingt notwendig, unsymmetrische Passmarken ins Layout einzubauen, z.B. kleine Kreuze an verschiedenen Stellen im Layout platziert. Praktisch ist auch ein bisschen Text, da man so leicht erkennt, ob das Layout gespiegelt ist oder nicht.

===Ausdrucken auf das Transfermaterial===
Wenn das Layout fertig ist, muss es auf das Transfermaterial gedruckt/kopiert werden. Als Trägermaterial bieten sich folgende Materialien an:

*'''Backpapier'''
Viele berichten, dass Backpapier das Mittel ihrer Wahl ist und einwandfrei funktioniert. Bei mir war das leider nicht der Fall. Anscheinend ist der Erfolg von der Marke abhängig.

*'''Trägerpapier von Klebeetiketten'''
Soll sehr gut funktionieren

*'''Seiten aus einem Hochglanzmagazin (Spiegel/Stern)'''
Mein persönlicher Favorit. Das Ausrichten der Passmarken auf dem bedruckten Papier ist zwar nicht so leicht, dafür lässt es sich sehr leicht nach dem Bügeln entfernen.

*'''Spezielle Transferfolie (Pressn'Peel)'''
Diese ist sehr teuer und soll auch nicht besser funktionieren als andere Materialien

* '''u.v.m'''
Vor dem Drucken sollte man den Drucker auf die höchste Farbdichte einstellen. Je mehr Toner auf den Träger gelangt, desto besser.
Natürlich muss das Layout spiegelverkehrt ausgedruckt werden.

Für doppelseitige Layouts übernehme ich die fertigen Layouts zuerst in ein Grafikprogramm, ordne sie übereinander an, und mache eine dünne Linie in der Mitte zwischen den beiden Layouts. So kann man alles auf einmal ausdrucken. Danach faltet man das Papier entlang der Linie und richtet es mit Hilfe der Passmarken aus. So erhält man eine Tasche in die man die Platine zum Bügeln einlegen kann. Das Ausrichten funktioniert im Gegenlicht am besten.

===Das Aufbügeln des Layouts===
Das ausgedruckte Layout sollte jetzt ungefähr so aussehen.

[[Bild:Buegelmethode_Ausdruck.jpg|center]]

Ich habe dieses auf eine Seite aus einem Reichelt-Katalog gedruckt.
Vor dem Aufbügeln sollte man die Deckung des Toners überprüfen. Wenn größere dünnere Flächen vorhanden sind, sollte man es noch einmal neu drucken.

Vor dem Aufbügeln muss die Platine (natürlich eine ohne Fotolack) gründlich gereinigt werden. Ich nehme dazu ein feines Schmirgelpapier und bearbeite die Platine damit. Dadurch wird sie auch aufgeraut, was den Toner besser haften lässt. Anschließend reibe ich sie noch mit Aceton, Waschbenzin, Nagellackentferner o.ä. ab, um die letzten Fettrückstände zu entfernen. Dies ist nicht unbedingt nötig, aber es erleichtert dem Toner das Haften. Achtung, die genannten Chemikalien sind mit Vorsicht zu benutzen. Aceton ist sogar ein Hautgift. Bitte Handschuhe benutzen.

Für das eigentliche Aufbügeln empfehle ich eine feuerfeste Unterlage, da die Platine sehr heiss wird und lange auf der gleichen Stelle gebügelt wird.
Auf diese wird ein Handtuch o.ä. gelegt. Es sollte etwas altes sein, weil der Toner unter Umständen darauf gelangen könnte und dieser sich sehr schlecht aus Textilien entfernen lässt.

Darauf kommt die Platine mit der zu beschichtenden Seite nach oben, und darüber das ausgedruckte Layout mit der Tonerseite nach unten. Darüber werden 2-3 Blatt Schreibmaschinenpapier gelegt, damit die Farbe der Hochglanzseite nicht das Bügeleisen verschmutzt. Außerdem werden so die Druckunterschiede ausgeglichen, die beim Bügeln entstehen und Leiterbahnen "zerquetschen" könnten.

Das Bügeleisen wird nun auf ca. 3/4 seiner Leistung eingestellt. Wenn es heiss genug ist, fängt man zuerst mit leichtem Druck an über den "Sandwich" aus Platine, Layout und Schreibmaschinenpapier zu bügeln. Nach ca. 5 Minuten müsste eigentlich der Toner überall geschmolzen worden sein (laut Internet schmilzt dieser schon bei 70°C).
Wichtig ist, dass sichergestellt ist, dass wirklich jeder Bereich ausreichend erhitzt worden ist.

Nach dem Bügeln sollte die Platine sich abkühlen dürfen. Ca. 5-6 Minuten.
Wenn sie handwarm ist, kann es weitergehen.

Bei doppelseitigen Platinen legt man die Platine in die oben beschriebene Layouttasche und bügelt zuerst eine Seite, indem man zwischen die untere Platinenseite und dem unteren Layout ein weiteres Stück Stoff oder ähnliches legt. Durch das Bügeln klebt die eine Hälfte des Layouts fest und die andere kann dadurch einfach ausgerichtet werden.

===Abziehen des Trägermaterials von der Platine===
Das Abziehen des Trägermaterials ist das Heikelste an der ganzen Methode. Die feine Tonerschicht auf der Platine ist spröde und kann leicht zerstört werden.

Bei Trägermaterialien aus Papier lege ich die '''abgekühlte''' Platine in eine Schüssel mit lauwarmem Wasser und Seife. Darin bleibt sie solange bis das Kupfer durch das Papier scheint und das Papier sich fast von alleine auflöst.
Wenn dies der Fall ist, beginne ich langsam, vom Rand ausgehend, das Papier von der Platine zu lösen. Wenn man das langsam macht, und die Platine dabei unter Wasser lässt, geht das relativ einfach.

Danach sollte man kontrollieren, ob Leiterbahnen zu sehr verlaufen sind. Falls dies der Fall ist, kann man sie mit einer Nadel wieder freikratzen.
Generell sollte das Ganze übertragene Layout noch einmal kontrolliert werden.
Kleinere Fehler lassen sich einfach mit einem wasserfesten Stift beheben.
Sind die Fehler zu groß, sollte man das Layout erneut aufbügeln. Dazu befreit man die Platine mit den oben genannten Mitteln vom Toner oder schmirgelt mit Schleifpapier den Toner weg.

===Das Ätzen===
Das Ätzen der Platine erfolgt genau wie bei jeder anderen belichteten Platine auch. Allerdings sollte man darauf achten, dass das Ätzen möglichst schnell geht. Je länger es dauert, desto größer ist die Gefahr, daß sich an den Rändern die Tonerschicht löst.
Mit FE3Cl hatte ich die schlechteren Ergebnisse. Natriumsulfat brachte die schöneren Ergebnisse.

===Das Ergebnis===
Das Ergebnis sollte ungefähr so aussehen.

Oberseite meines AVR-Boards

[[Bild:AnsichtvonOben.jpg|center]]

Unterseite (Die Drähte haben nichts mit dem Bügeln zu tun. Das passiert, wenn man beim Layouten Leiterbahnen vergisst;-))

[[Bild:AnsichtvonUnten.jpg|center]]

Diese Bild zeigt was passiert, wenn man beim Bügeln das Bügeleisen verkantet. Also einen zu großen Druck mit der Kante der Heizfläche ausübt. Die Leiterbahnen bekommen einen "Bauch". Ich habe diesen Fehler hier mit der Nadel korrigiert. Die Funktion stört es nicht, es ist halt ein kleiner Schönheitsfehler

[[Bild:verkantet.jpg|center]]

Das hier ist eine Nahaufnahme eines MAX232. Ich finde die Form und die Scharfkantigkeit der Pads ist mit einer belichteten Platine durchaus vergleichbar.

[[Bild:Padform.jpg|center]]

===Fazit===
Für mich ist die Bügelmethode die schnellste und einfachste Art einen Prototypen zu erstellen. Sie ist zwar nicht so genau wie eine belichtete Platine, aber für mich ist sie völlig ausreichend. Sie erspart einem eben den schwierigsten Teil der Platinenherstellung, das Belichten.

Die oben gezeigte Platine war übrigens die 3., die ich nach dieser Methode hergestellt habe. Seitdem mach ich es nur noch so. Ausprobieren lohnt sich auf jeden Fall.

==Siehe auch==
* [[Leiterplatten_herstellen]] mit der "Foto-TransferTechnik"
* [[Leiterbahnbreiten]]
* [[Platinen doppelseitig layouten mit Eagle]]

==Weblinks==
* http://home.arcor.de/dr.koenig/digital/platine.htm
* [http://thomaspfeifer.net/platinen_aetzen.htm Platinen ätzen mit der Direkt-Toner-Methode] (mit Video)
* http://diy.musikding.de/berichte/grund/platinen/platinen1.html
* http://www.die-wuestens.de/dindex.htm?/platine.htm
* http://www.fullnet.com/u/tomg/gooteepc.htm
* http://www.qsl.net/k5lxp/projects/PCBFab/PCBFab.html
* http://www.5bears.com/pcb.htm

'''''Artikel von Sonic''' Wiki-Konvertiert Frank''

[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]