Mikrocontroller.net - Benutzerbeiträge [de]

Schaltplaneditoren

2011-11-04T04:33:53Z

Johnjohn: /* Inkscape */ Fehlerhaften Link korrigiert

== AACircuit ==

'''AACircuit''' ist ein Schaltplaneditor mit einer Ausgabe als ASCII-Grafik. Das Programm wurde dafür entwickelt, um mal eben eine Frage oder eine Antwort in ''newsgroups'', Chats oder Foren zu veranschaulichen, wenn keine Upload-Möglichkeit von Bilddateien da ist. AACircuit gibt es bei http://www.tech-chat.de/

Beispiel:
<pre>
.---o----o------o---o---------------o---o----o------------o 12-15V
| | | 22uF| + | | | |
.-. | .-. ### | .-. | | .-------o
| |<-' | | --- | | | | | | .---o
| |5k | |5k6 | | | | | | | |
'-' '-' | o--. '-' | _|_ o /o
| | === | | | | |_/_|- /
.-. | GND | ---100n LED V - | /
| | | | --- - ^ | o
| |6k2 | | | | | | |
'-' | | GND '---o----o '-------o
| | 2|\|7 |
o-----------------|-\ LM741 ___ |/
| | | >-------o--|___|--o---|
| o---o----|+/ 6 | 22k | |> BC547
| | | 3|/|4 | | |
.-. | | === o---. .-. |
| | | o---. GND | | | |5k6 |
| |2k7 .-. | | ___ _V_ | | | |
'-' KTY10 | + '--|___|--|___|-' '-' |
| | | ### 47k 220k | |
| '-' --- | |
| | | | |
| | | | |
'--------o---o-------------------------o-----o------------o GND
</pre>

== BAE ==

'''B'''artels '''A'''uto '''E'''ngineer unterstützt die Erstellung von Schaltplänen, Leiterplatten und integrierten Schaltungen und läuft unter Windows, Linux und verschiedenen X11-/Unix-Systemen. Der Schaltplaneditor kann Pläne auf beliebig vielen Blättern erstellen, wobei auch hierarchische Strukturen möglich sind. Der Autorouter erzeugt recht brauchbare Ergebnisse, wobei beliebige Teile mit der Hand vorab geroutet werden können. Ein Autoplacer ist ebenfalls vorhanden.

Eine auf Schaltplaneingabe beschränkte Version und eine kastrierte Evaluierungsversion sind auf der [http://www.bartels.de/bae/bae_de.htm BAE Homepage] downloadbar.

Die [http://www.bartels.de/bae/baeprice_de.htm preiswerteste] kostenpflichtige Version ist das BAE Light. Diese Version ist auf Leiterplatten der Groesse 180x120 mm² und auf 2 Lagen beschränkt, eine Beschränkung auf eine bestimmte Pinanzahl gibt es aber nicht.

Ansonsten wird eine Economy-, Professional- und Highendversion angeboten, die jeweiligen Eigenschaften sind im Abschnitt [http://www.bartels.de/baedoc/inst_de.htm Bartels AutoEngineer Softwarekonfigurationen] erklärt. Interessant ist z. B. der Bauteilhöhencheck.

Mit dem BAE IC Design dringt man bis in den Bereich der IC-Entwicklung vor.

[[BAE-Tutorial]]

== Basic Schematic ==

[[Bild:Base schematic example.png|right|thumb|Screenshot Base Schematic]]

Basic Schematic ('''BSch3V''') ist ein freier Schaltplaneditor für Windows (98/Me/2000/XP). Es enthält einen Component Library Editor, einen Parts List Generator und einen Netlist Generator, sowie eine Automatic Numbering Funktion.

Ein ZIP-Archiv mit engl. Programm, Handbuch und Sourcecode gibt es bei http://www.suigyodo.com/online/e/index.htm.

Ebenso ist dort eine Cross-Plattform Version '''Qt-BSch3V''' auf der Basis von Qt-Grafiklibraries erhältlich.

Das Programm ist bis dato (2011) gut gepflegt.

== BlackBoard Breadboard Designer ==

[[Bild:BlackBoard.png|right|thumb|Screenshot]]

BlackBoard Breadboard Designer ist ein freier Editor für Lochrasterplatinen Layouts, der das Planen der Bauteilplazierung sowie der beidseitigen Verdrahtung deutlich vereinfacht und sich u.a. auch für die Dokumenation solcher Prototypenaufbauten eignet.

Er läuft auf allen Plattformen für die eine Java Runtime zur Verfügung steht.

Die Homepage von Blackboard ist unter http://blackboard.serverpool.org zu erreichen. Blackboard steht unter Der GPL V2 und wird ständig weiterentwickelt.

== DipTrace ==

Design-Editor für PCB-Leiterplatten für Windows NT, 2000, XP, Server 2003
- erweiterte Pro-Version erlaubt den Export in DXF, Gerber und N/C Drill sowie Leiterplattenlayouts mit mehr als 250 Pins.

http://www.diptrace.com/

== Eagle ==

[[Bild:Eagle.png|right|thumb|Screenshot]]

Eagle von Cadsoft ist nicht nur ein Schaltplaneditor, sondern ein komplettes Paket mit Layoutprogramm und Autorouter. Das hat den Vorteil, dass man einen erstellten Schaltplan gleich zur Platine weiterverarbeiten kann.

Mitgeliefert werden umfangreiche Symbol- bzw. Bauteilbibliotheken, von Widerständen in allen Bauformen über Taster bis hin zu [[AVR]]s. Eine Library für viele aktuelle AVRs findet sich im Download-Bereich
von [http://www.embedit.de http://www.embedit.de].

Eagle läuft unter Linux, Windows (2000/XP/Vista/7) und Mac OS X.

Eine für nichtkommerzielle Anwendungen kostenlose Version ist von [http://www.cadsoft.de/ CadSoft] erhältlich. Diese ist auf zweilagige Platinen im halben Euro-Format (80x100mm) sowie Schaltpläne mit nur einer Seite beschränkt.

=== 3D-Ansicht===
[[Bild:Stereobild-elektronik-3d.jpg|right|thumb|Rot-Grün-Stereo-Bild]]
Zum Betrachten des fertigen, bestückten Platinenentwurfs in Form eines 3D-Bilds bietet sich das Paket [http://www.matwei.de/doku.php?id=en:eagle3d:eagle3d eagle3D] an. Mit Hilfe eines ULP wird eine Beschreibungsdatei für den open source Renderer POVray erzeugt, welche dann anschließend halbautomati generiert werden kann. Auch Bewegungsanimation und KAmeraflug ist möglich. Es wird bereits ein große Zahl an Bauteilen unterstützt.

Anwendungshinweise:
* [[Eagle im Hobbybereich]]
* [http://gaussmarkov.net/wordpress/category/tools/software/eagle/ Eagle CAD Tutorial] im Blog von gaussmarkov: diy fx (englisch)
* [[Stereobilder mit EAGLE 3D]]

== FreePCB ==

FreePCB ist ein freier, open-source PCB editor für Microsoft Windows, der unter der GNU General Public License veröffentlicht wurde. Er wurde entwickelt, um ihn einfach erlernen und nutzen zu können und dennoch für professionellesArbeiten geeignet. Er besitzt keinen eingebuten Auto Router, kann jedoch den web-basierten auto router auf www.freerouting.net verwenden.

== Electric ==

Das [http://www.staticfreesoft.com/index.html Electric(TM)] VLSI Design System ist ein Open Source Electronic Design Automation (EDA) System.

== ExpressPCB ==

Die Firma ExpressPCB bietet den kostenlosen Schaltplaneditor ExpressSCH an. Zusätzlich gibt es das kostenlose Layoutprogramm ExpressPCB zum Erstellen von zwei- und vierlagigen Leiterplatten. Die beiden Programme sind auf Windows (NT, 2000, XP, Vista) beschränkt. Die Firma bietet auf der [http://www.expresspcb.com/ ExpressPCB Homepage] ausserdem einen kommerziellen Service für die Herstellung von zwei- und vierlagigen Leiterplatten an. Auf der Seite finden sich [http://www.expresspcb.com/ExpressPCBHtm/Tips.htm hier] einige Hinweise zum Entwurf von Leiterplatten.

== FidoCadJ ==

[http://davbucci.chez-alice.fr/index.php?argument=elettronica/fidocadj/fidocadj.inc&language=English FidoCadJ] is a very easy to use editor, with a library of electrical symbols and footprints (through hole and SMD). Albeit its ease of use, it is a very immediate and effective EDA tool for the hobbyst. FidoCadJ stores its drawings in a compact text format. This choice is well suited for the copy and paste in newsgroups and forums. This explains the success of FidoCadJ in Usenet groups and in several portals. FidoCadJ is multi-platform Java program and runs on MacOSX, Linux and Windows. FidoCadJ and its manuals are in english, french and italian. Lizenz: Creative Commons 3.0 BY-NC-ND

== Fritzing ==

'''Fritzing''' verwendet die Metapher eines Breadboards (Steckbretts), auf dem die Benutzer virtuell Bauteile einstecken. Fritzings Zielgruppe sind Künstler, Designer und Hobbyisten aber nicht unbedingt Profielektroniker, und die Software soll speziell auf die Zielgruppe zugeschnitten werden. Dabei wird auf eine niedrige Zugangsschwelle wert gelegt. Versionen für Mac OS X, Linux und Windows (XP/Vista) sind bei http://www.fritzing.org/ erhältlich.

== Gschem ==

[[Bild:Gschem.png|right|thumb|Screenshot]]

gschem ist der Schaltplaneditor aus dem Open Source Projekt gEDA. gschem wird hauptsächlich auf Linux Rechnern entwickelt, läuft aber auch auf anderen Unix-Betriebssystemen und unter Windows. gschem ist für die Linuxdistributionen RedHat und Debian als Paket verfügbar, für Windows ist nur eine ältere Version erhältlich und für alle anderen ist selber kompilieren angesagt.

Die Bedienung ist nicht sonderlich anfängerfreundlich. Hat man sich aber mal daran gewöhnt, dass jeder Menupunkt mit 1 oder 2 Tasten erreichbar ist, läßt sich's mit gschem prima arbeiten.

In der Symbolbibliothek (die auch online betrachtet werden kann) sind etwas mehr als 1000 Symbole; das Selbsterzeugen von Symbolen ist jedoch problemlos möglich. Insbesondere ist es aufgrund des gut dokumentierten und einfachen Datei-Formates möglich, mit einfachen Perl-Programmen z. B. aus Reports von Xilinx ISE Symbole zu erzeugen und automatisch zu aktualisieren, wenn sich die Pinzuordnung ändert. Das fehlerhafte Eingeben der Pinbelegung von CPLDs und FPGAs von Hand und die Änderung derselben ist damit für gschem User Geschichte.

Die Schaltpläne lassen sich als png und als Postscript exportieren.

Netzlisten (insgesamt über 20 Formate für PCB, Protel, Eagle, BAE, spice, pads, ... ) lassen sich mit dem Programm gnetlist generieren. Aus diesem Grund ist man (bis auf die Namen der Footprints) unabhängig von der verwendeten Layout-Software und kann diese auch sehr leicht wechseln.

Ein großer Vorteil der gEDA-Suite sind die Dateiformate, welche alle reiner ASCII-Text sind. Dies macht die Entwicklung von Helper-Tools zur Lösung von speziellen Aufgaben sehr leicht. Außerdem können die Dateien deswegen sehr einfach in Versionsverwaltungssystemen wie CVS verwaltet werden, was insbesondere die Entwickler größerer Projekte zu schätzen wissen.

Nähere Informationen über gschem (gEDA) gibt es unter [[http://www.geda.seul.org/ http://www.geda.seul.org/]].

== Inkscape ==

Etwas bekannter noch als Jfig ist [http://inkscape.org/ '''Inkscape'''], ebenfalls ein reines Vektorzeichenprogramm, das vor allem (aber nicht nur) SVG-Dateien erstellt, die mit der Wikipedia eine große Verbreitung gefunden haben. Es ist in fast jeder gängigen Linux Distribution enthalten, eine Windowsversion sowie eine [http://portableapps.com/apps/graphics_pictures/inkscape_portable '''portable Windowsversion'''] existiert auch. In der Wikipedia findet sich eine Sammlung von Elektroniksymbolen im [http://commons.wikimedia.org/wiki/Category:SVG_electrical_symbols SVG-Format] und [http://commons.wikimedia.org/wiki/File:Electrical_symbols_library.svg hier]. Als Beispiele damit gezeichneter Schaltpläne sei diese [http://commons.wikimedia.org/wiki/Category:Created_with_electrical_symbols_library] genannt.

== JFig ==

[[Bild:Jfig.png|right|thumb|Screenshot]]
JFig ist eigentlich ein "ganz normales" Vektorzeichenprogramm. Um Schaltpläne zu zeichnen benötigt man deshalb zusätzliche Symbolbibliotheken.

Die Exportmöglichkeiten für das weitverbreitete fig-Format sind sehr vielfältig: mit dem Zusatzprogramm fig2dev, das direkt aus dem jfig-Menü aufgerufen kann, bleiben von Postscript über PNG bis hin zu [[LaTeX]] kaum Wünsche offen. Für kleine Schaltpläne oder Diagramme, die ausgedruckt oder in PDF-Dateien verbreitet werden sollen, gibt es deshalb nichts besseres.

Das Programm ist ein komplett in [http://java.sun.com/ Java] geschriebener 1:1-Klon des [[Linux]]-Programms xfig und sollte daher mit jedem Betriebssystem von Windows bis Mac OS laufen. Es ist kostenlos auf [http://tams-www.informatik.uni-hamburg.de/applets/jfig/ http://tams-www.informatik.uni-hamburg.de/applets/jfig/] erhältlich. (Leider ist der Download schon geraume Zeit nicht mehr möglich. Zitat von der Seite: "Sorry. Recently, I got two serious bug reports which have now been confirmed, and jfig downloads are suspended until these have been resolved.")

Die Bedienung wird für Windows-Benutzer am Anfang wohl ziemlich ungewohnt sein, aber wenn man mal das Grundprinzip verstanden, hat findet man sich durch die eindeutig beschrifteten Schaltflächen schnell zurecht.

== Kicad ==
[[Bild:kicad1.gif|right|thumb|Screenshot]]
[[Bild:kicad2.gif|right|thumb|Screenshot]]

[[KiCAD]] ([http://www.lis.inpg.fr/realise_au_lis/kicad/ Homepage&Download]) ist ein Paket aus Design / Layout / Routing Programmen. Es basiert auf wxWidgets und ist damit plattformübergreifend. Die Progamme sind unter der GPL veröffentlicht und damit Open Source.

Eine Kicad User-Group findet sich unter http://groups.yahoo.com/group/kicad-users/. Die Anmeldung erfolgt erst, nachdem man vom Besitzer der User-Group freigeschaltet wurde (wie üblich für die meisten Yahoo-Groups).

Neben der mitgelieferten, bereits umfangreichen Bibliothek gibt es auf vielen anderen Seiten (z. B. http://www.kicadlib.org/) weitere Bibliotheken zum Download, die einfach integriert werden können.

Für Umsteiger von anderen Programmen sollten sich nach wenigen Stunden bereits die gleichen Ergebnisse erzielen lassen. Beim Erlernen kann das Tutorial von http://www.curiousinventor.com/guides/kicad helfen.

Kicad liefert eine schöne 3D-Ansicht des fertigen Layouts einschließlich der bestückten Bauteile, so dass man an dieser Stelle schon einmal einen Überblick bekommt, ob vielleicht nicht doch etwas vergessen wurde. Es gibt zwar nicht für alle Bauformen ein 3D-Modell, allerdings lassen sich diese selbst erstellen.

Als Nachteil ließe sich noch aufführen, dass der PCB-Layouter in der Version vom Januar 2006 etwas instabil ist und gerne abstürzt. Die Version vom Mai 2010 läuft aber sehr stabil. Ebenso sind die Autorouterfunktionen nicht gut dokumentiert. Ein weiterer Kritikpunkt wäre, dass die offizielle Symbolbibliothek nur amerikanische, aber keine europäischen Schaltplansymbole enthält.

== Lochmaster ==

[http://www.abacom-online.de/html/lochmaster.html Lochmaster] ist ein Programm zur Erstellung von Layouts speziell auf [[Lochrasterplatine]]n. Schaltplan und Layout sind ein und das selbe.

== PCB ==

[http://pcb.sourceforge.net/index.html PCB] ist ein freies (open source) Layoutprogramm inklusive Autorouter. Zum Zeichnen der Schaltpläne kann [[Schaltplaneditoren#Gschem|Gschem]] verwendet werden.

PCB wurde ursprünglich für den Atari ST entwickelt und später nach
Unix portiert. PCB läuft meist unter Linux, kann allerdings mit [http://www.cygwin.com/ Cygwin] auch unter Windows betrieben werden.

Als Ausgabeformate stehen [http://de.wikipedia.org/wiki/Postscript Postscript] und Gerber RS-274-X zur Verfügung.

Ein großer Vorteil von PCB ist, dass alle Funktionen auch über
Hotkeys gesteuert werden können, was insbesondere nach längerer Einarbeitungszeit ein großer Gewinn gegenüber manchen Windows-Programmen ist.

Zur Einarbeitung ist es meines Erachtens sehr wichtig, sich das [http://www.geda.seul.org/wiki/geda:gsch2pcb_tutorial Tutorial] durchzulesen. PCB und Gschem sind nicht besonders einfach zu benutzen. Gerade am Anfang, wenn man sich versucht damit einzuarbeiten. Aber wenn man einmal mit dem Werkzeug arbeiten kann, wird man es nicht mehr missen wollen.

=== Wichtige Einstellungen & Tips ===

Die neue GTK+ Version aus dem CVS Archiv ist der alten, etwas angestaubten Version vorzuziehen. Auch das Kompilieren ist nicht wirklich schwierig. Alles, was dazu notwendig ist (und das Programm hat keine großen Abhängigkeiten), ist in der Readme erklärt. Somit fällt die Kompilierung recht einfach aus.

Auf der linken Seite befindet sich die Auswahl der jeweiligen Layer. Gerade bei Verwendung des Autorouters sollte man hier den 2. Layer deaktivieren. Dies kann ganz einfach mit einem Klick auf die Beschriftung erfolgen (component, GND-comp und VCC-comp). Ebenso sollte man unused (grün) und unused (blau) deaktivieren.

Als Route Style verwende ich den ''Power Style'' mit einer Dicke von 25 Mil (0.6 mm). Der ''Signal Style'' scheint mir gerade bei schlechten Belichtungsverhältnissen nicht ganz optimal zu sein.

=== Autorouter ===

Der Autorouter von PCB hat einige Schwächen, welche allerdings bei Hobby-Projekten völlig belanglos sind: Beispielsweise kann es bei TQFP-Gehäusen mit 100 Pins u. 0.5mm Pinabstand zu Problemen kommen, 64polige TQFP-Gehäuse (z. B. vom ATmega 128) gehen jedoch ohne Probleme.

Hat man sich soweit im [http://www.geda.seul.org/wiki/geda:gsch2pcb_tutorial Tutorial] durchgearbeitet und seine Bauteile positioniert, kann der Autorouter zum Einsatz kommen. Auch hier ist ein wenig Experimentierfreude erforderlich, um zu zufriedenstellenden Ergebnissen zu kommen.

Unter '''Connects / Optimize routed Tracks / Miter''' können die gerouteten Linien in 45 Grad Winkel modifiziert werden.

=== Footprints ===

[[Bild:Pcbgtk.png|right|thumb|Screenshot]]

Sehr wichtig für das Zusammenspiel zwischen dem Schaltplaneditor [http://www.geda.seul.org/tools/gschem/ Gschem] und dem [http://pcb.sourceforge.net PCB] ist die Verwendung der richtigen Footprints.

Mir persönlich ist aufgefallen, daß viele Pads zu klein sind. Gerade im Bereich der Hobbyätzerei könnten sie ruhig größer ausfallen.

<table border=1>
<tr>
<th>Element</th>
<th>Footprint</th>
<th>Alternativer Footprint</th>
<th>Beschreibung</th>
</tr>
<tr>
<td>Widerstand 1/4 Watt</td>
<td>R0w4</td>
<td>R025</td>
<td>Ich benutze R0w4, weil es die Pads größer sind.</td>
</tr>
<tr>
<td>Elko</td>
<td>CR200</td>
<td>RADIAL_CAN 200</td>
<td>CR200 ist für größere Elkos (Umfang), während bei RADIAL_CAN 200 der Umfang kleiner ist. Leider fehlt die Polarität bei diesem Symbol. Allgemein jedoch sind bei beiden Elementen die Pads zu klein.</td>
</tr>
</table>

[[Bild:Pcb_widerstand.png]]

Mir waren irgendwie alle Widerstände nicht ideal genug.
Die Löcher werden ja meist mit 0.8mm gebohrt: (0.8 mm * (1 mil/ 0.0254 mm) = 31 mil. Eine Richtlinie für den gesamten Paddurchmesser habe ich nicht gefunden. Aus einer Elektor Platine habe ich mit Meßschieber ungefähr 2 mm gemessen, also 78 mil.

<pre>
Element["" "R__0w4_10.16mm" "" "" 0 0 0 -10300 0 100 ""]
(
Pin[0 0 7800 3100 6100 3500 "" "1" "edge2"]
Pin[40000 0 7800 3100 6100 3500 "" "2" "edge2"]
ElementLine [7900 0 4400 0 1000]
ElementLine [32000 0 35500 0 1000]
ElementLine [7900 -3300 7900 3300 1000]
ElementLine [32000 -3300 32000 3300 1000]
ElementLine [7900 -3300 32000 -3300 1000]
ElementLine [7900 3300 32000 3300 1000]
)
</pre>

Für Kapazitäten mit einer Breite von 2.54 mm oder 5.08 mm nutze ich folgendes Element

<pre>
Element["" "" "" "" 65000 78500 0 0 0 100 ""]
(
Pin[2000 -2500 7000 3000 4200 2000 "" "cap_2" "edge2"]
Pin[-8000 -2500 7000 3000 4200 2000 "" "cap_1" "edge2"]
Pin[-18000 -2500 7000 3000 4200 2000 "" "cap_1" "edge2"]
Pad[-16000 -2500 -10000 -2500 1000 2000 3000 "" "1" ""]
ElementLine [-4000 -6500 -4000 2500 1399]
ElementLine [-2000 -6500 -2000 2500 1399]
)
</pre>

Für eine Breite von 5.08 mm oder 7.62 mm nutze ich folgendes Element:

<pre>
Element["" "" "" "" 63000 93500 0 0 0 100 ""]
(
Pin[14000 -4500 7000 3000 4200 2000 "" "cap_2" "edge2"]
Pin[4000 -4500 7000 3000 4200 2000 "" "cap_2" "edge2"]
Pin[-16000 -4500 7000 3000 4200 2000 "" "cap_1" "edge2"]
Pad[5500 -4500 12500 -4500 1000 2000 3000 "" "1" "edge2"]
ElementLine [-7500 -8500 -7500 500 1399]
ElementLine [-5500 -8500 -5500 500 1399]
)
</pre>

== ProtoCAD ==

[http://protomind.net/page.php?7 ProtoCAD] ist ein Werkzeug, um schnell Schaltpläne zu entwerfen. Es ist für [[Lochrasterplatine]]n entwickelt worden, kann aber auch für andere Methoden genutzt werden. (Java 1.5 kompatibel, Swing GUI, Open Source)

== QCAD ==

[http://www.ribbonsoft.de/qcad.html QCAD] gibt es in einer lizenzpflichigen und in einer Open Source Community Version. QCAD ist kein ausschliesslicher Schaltungseditor, sondern kann auch für andere 2D Zeichnungen (Konstruktionen etc.) eingesetzt werden.

== sPlan ==

'''sPlan''' ist ein relativ preiswerter Schaltplaneditor für Windows (95,98,ME,NT,2000,XP)
Infos und eine Demoversion von sPlan gibt es u.a. bei http://www.abacom-online.de/html/splan.html

== TARGET 3001! ==

[[Bild:target3001.png|right|thumb|Screenshot]]

TARGET 3001! für Windows (ME/NT4/2000/XP/Vista/Win7) bietet folgende Funktionen

* Schaltplan
* Bauteilerstellung
* Schaltungssimulation (PSPICE-Syntax)
* Platinen-Layout mit Autoplatzierer
* Autorouter
* Anzeige der Platine in 3D
* Frontplattenentwurf direkt an oder über der Platine

Die Platinen-Layout-Software ist in deutscher, englischer oder französischer Sprache. Es gibt eine für nicht kommerzielle Anwendungen kostenlose Version: TARGET 3001! discover ist beschränkt auf 250 Pins/Pads, 2 Kupferlagen
und 30 Signale sind simulierbar, die Fläche ist unbeschränkt (1,2m x 1,2m).

Auf der c't 11/07 CD ist eine SE Version von TARGET 3001! verfügbar welche 400 Pins/Pads verarbeiten kann.

Die PCB-Pool Edition hat keine Beschränkungen, speichert aber die Layouts in einem von normalen Target Versionen nicht lesbaren Format. Diese Layouts können dann allerdings nur zum selbst Ätzen ausgedruckt werden oder vom PCB-POOL® produziert werden.

Links:
* [http://server.ibfriedrich.com/wiki/ibfwikide Target3001 Homepage]
* [http://www.pcb-pool.com/ppde/service_downloads.html Target3001 PCB-Pool-Edition]

TARGET 3001! bietet ein typisches Windows Look-And-Feel. Eine einfache Einführung findet sich '''[http://server.ibfriedrich.com/wiki/ibfwikide/index.php?title=Kurzeinführung2 hier]'''. Wer sich schon mit Eagle auskennt, kann auch '''[http://server.ibfriedrich.com/wiki/ibfwikide/index.php?title=Eagle hier]''' schauen. Es gibt kostenlosen direkten Service durch den Hersteller telefonisch oder per E-Mail auch für Einsteiger oder Demo-User.

== TinyCAD ==

'''TinyCAD''' ist ein weiterer ''Open Source'' Schaltplaneditor für Windows. Mehr Infos gibt es auf der [http://tinycad.sourceforge.net Projektseite]. TinyCAD kann z. B. mit VeeCAD (s.u.) kombiniert werden.

== VeeCAD ==

[http://veecad.com/ VeeCAD] Stripboard Layout Editor ist ein Werkzeug, um [[Lochrasterplatine]]n zu entwerfen. VeeCAD ist als kommerzielle Version und als eingeschränkte Freiversion erhältlich.

== ZenitPCB Suite ==

[http://www.zenitpcb.com/eng/Index_Eng.html ZenitPCB Suite] is directed to all those people who want to make printed circuit board for hobby, or to student and academics from universities or high schools, who want to create their own pcb with a professional approach and particularly without having to pay for expensive licenses. ZenitPCB Layout (part of the ZenitPCB Suite) is completely freeware for personal or semi-professional use, limited to [http://www.zenitpcb.com/images/MainBoard_01_01.gif 800 pins]. (Windows XP, Vista)

Übersetzung: ZenitPCB richtet sich an all diejenigen, welche fürs Hobby, Schule, Studium etc professionelle PCBs erstellen möchten, ohne viel Geld für Lizenzen ausgeben zu müssen. ZenitPCb ist in der eingeschränkten Version mit 800 Pins für den semi-professionellen und privaten Gebrauch kostenfrei benutzbar.

== Siehe auch ==

* [[Schaltungssimulation]]
* [[Dos and don'ts - Platinenlayout]]
* [[Lochrasterplatine]]

== Weblinks ==

[[Category:Platinen]]
[[Kategorie:Schaltplaneditoren| ]]

AVR-Tutorial: Tasten

2011-09-28T22:17:12Z

Johnjohn: /* Weblinks */ Link aktualisiert

Bisher beschränkten sich die meisten Programme auf reine Ausgabe an einem Port. Möchte man Eingaben machen, so ist der Anschluss von [[AVR-Tutorial: IO-Grundlagen|Tasten]] an einen Port unumgänglich. Dabei erheben sich aber 2 Probleme
* Wie kann man erreichen, dass ein Tastendruck nur einmal ausgewertet wird?
* Tasten müssen entprellt werden

==Erkennung von Flanken am Tasteneingang==
Möchte man eine Taste auswerten, bei der eine Aktion nicht ausgeführt werden soll, solange die Taste gedrückt ist, sondern nur einmal beim Drücken einer Taste, dann ist eine Erkennung der Schaltflanke der Weg zum Ziel. Anstatt eine gedrückte Taste zu erkennen, wird bei einer Flankenerkennung der Wechsel des Zustands des Eingangspins detektiert. Dazu vergleicht man in regelmäßigen Zeitabständen den momentanen Zustand des Eingangs mit dem Zustand zum vorhergehenden Zeitpunkt. Unterscheiden sich die beiden, so hat man eine Schaltflanke erkannt und kann darauf reagieren. Solange sich der Tastenzustand nicht ändert, egal ob die Taste gedrückt oder losgelassen ist, unternimmt man nichts.

Die Erkennung des Zustandswechsels kann am einfachsten mit einer [[AVR-Tutorial:_Logik#XOR|XOR]] (Exklusiv Oder) Verknüpfung durchgeführt werden.

<center>
{| {{Tabelle|min-width:20em;text-align:center;}}
|- style="background-color:#ffddcc"
|+ '''Wahrheitstabelle XOR'''
!width="30%"| A ||width="30%"| B ||width="30%"| Ergebnis
|-
| 0 || 0 || 0
|-
| 0 || 1 || 1
|-
| 1 || 0 || 1
|-
| 1 || 1 || 0
|}
</center>

Nur dann, wenn sich der Zustand A vom Zustand B unterscheidet, taucht im Ergebnis eine 1 auf. Sind A und B gleich, so ist das Ergebnis 0.

A ist bei uns der vorhergehende Zustand eines Tasters, B ist der jetzige Zustand so wie er vom Port Pin eingelesen wurde. Verknüpft man die beiden mit einem [[AVR-Tutorial:_Logik#XOR|XOR]], so bleiben im Ergebnis genau an jenen Bitpositionen 1en übrig, an denen sich der jetzige Zustand vom vorhergehenden unterscheidet.

Nun ist bei Tastern aber nicht nur der erkannte Flankenwechsel interessant, sondern auch in welchen Zustand die Taste gewechselt hat:
* Ist dieser 0, so wurde die Taste gedrückt.
* Ist dieser 1, so wurde die Taste losgelassen.

Eine einfache [[AVR-Tutorial:_Logik#UND|UND]] Verknüpfung der Tastenflags mit dem [[AVR-Tutorial:_Logik#XOR|XOR]] Ergebnis liefert diese Information

Das folgende Programm soll bei jedem Tastendruck eines Tasters am Port D (egal welcher Pin) eine LED am Port B0 in den jeweils anderen Zustand umschalten:
<avrasm>
.include "m8def.inc"

.def key_old = r3
.def key_now = r4

.def temp1 = r17
.def temp2 = r18

.equ key_pin = PIND
.equ key_port = PORTD
.equ key_ddr = DDRD

.equ led_port = PORTB
.equ led_ddr = DDRB
.equ LED = 0

ldi temp1, 1<<LED
out led_ddr, temp1 ; den LED Port auf Ausgang

ldi temp1, $00 ; den Key Port auf Eingang schalten
out key_ddr, temp1
ldi temp1, $FF ; die Pullup Widerstände aktivieren
out key_port, temp1

mov key_old, temp1 ; bisher war kein Taster gedrückt

loop:
in key_now, key_pin ; den jetzigen Zustand der Taster holen
mov temp1, key_now ; und in temp1 sichern
eor key_now, key_old ; mit dem vorhergehenden Zustand XOR
mov key_old, temp1 ; und den jetzigen Zustand für den nächsten
; Schleifendurchlauf als alten Zustand merken

breq loop ; Das Ergebnis des XOR auswerten:
; wenn keine Taste gedrückt war -> neuer Schleifendurchlauf

and temp1, key_now ; War das ein 1->0 Übergang, wurde der Taster also
; gedrückt (in key_now steht das Ergebnis vom XOR)
brne loop ;

in temp1, led_port ; den Zustand der LED umdrehen
com temp1
out led_port, temp1

rjmp loop
</avrasm>

Probiert man diese Implementierung aus, so stellt man fest: Sie funktioniert nicht besonders gut. Es kann vorkommen, dass bei einem Tastendruck die LED zwar kurzzeitig umschaltet aber gleich darauf wieder ausgeht. Genauso gut kann es passieren, dass die LED beim Loslassen einer Taste ebenfalls wieder den Zustand wechselt. Die Ursache dafür ist: Taster prellen.

==Prellen==
Das Prellen entsteht in der Mechanik der Tasten: Eine Kontaktfeder wird durch das Drücken des Tastelements auf einen anderen Kontakt gedrückt. Wenn die Kontaktfeder das Kontaktfeld berührt, federt sie jedoch nach. Dies kann soweit gehen, dass die Feder wieder vom Feld abhebt und den elektrischen Kontakt kurzzeitig wieder unterbricht. Auch wenn diese Effekte sehr kurz sind, sind sie für einen Mikrocontroller viel zu lang. Für ihn sieht die Situation so aus, dass beim Drücken der Taste eine Folge von: Taste geschlossen, Taste offen, Taste geschlossen, Taste offen Ereignissen am Port sichtbar sind, die sich dann nach einiger Zeit auf den Zustand Taste geschlossen einpendelt. Beim Loslassen der Taste dann dasselbe Spielchen in der umgekehrten Richtung.

[[Bild:Entprellen.png|framed|center| Signal eines prellenden Tasters]]

Nun kann es natürlich sein, dass ein neuer Taster zunächst überhaupt nicht prellt. Ist der Taster vom Hersteller nicht explizit als 'prellfreier Taster' verkauft worden, besteht aber kein Grund zur Freude. Auch wenn der Taster heute noch nicht prellt, irgendwann wird er es tun. Dann nämlich, wenn die Kontaktfeder ein wenig ihrer Spannung verliert und ausleiert, bzw. wenn sich die Kontaktflächen durch häufige Benutzung abgewetzt haben.

==Entprellung==
Aus diesem Grund müssen Tasten entprellt werden. Im Prinzip kann eine Entprellung sehr einfach durchgeführt werden. Ein 'Tastendruck' wird nicht bei der Erkennung der ersten Flanke akzeptiert, sondern es wird noch eine zeitlang gewartet. Ist nach Ablauf dieser Zeitdauer die Taste immer noch gedrückt, dann wird diese Flanke als Tastendruck akzeptiert und ausgewertet.

<avrasm>
.include "m8def.inc"

.def key_old = r3
.def key_now = r4

.def temp1 = r17
.def temp2 = r18

.equ key_pin = PIND
.equ key_port = PORTD
.equ key_ddr = DDRD

.equ led_port = PORTB
.equ led_ddr = DDRB
.equ LED = 0

ldi temp1, 1<<LED
out led_ddr, temp1 ; den Led Port auf Ausgang

ldi temp1, $00 ; den Key Port auf Eingang schalten
out key_ddr, temp1
ldi temp1, $FF ; die Pullup Widerstände aktivieren
out key_port, temp1

mov key_old, temp1 ; bisher war kein Taster gedrückt

loop:
in key_now, key_pin ; den jetzigen Zustand der Taster holen
mov temp1, key_now ; und in temp1 sichern
eor key_now, key_old ; mit dem vorhergehenden Zustand XOR
mov key_old, temp1 ; und den jetzigen Zustand für den nächsten
; Schleifendurchlauf als alten Zustand merken

breq loop ; Das Ergebnis des XOR auswerten:
; wenn keine Taste gedrückt war -> neuer Schleifendurchlauf

and temp1, key_now ; War das ein 1->0 Übergang, wurde der Taster also
; gedrückt (in key_now steht das Ergebnis vom XOR)
brne loop ;

ldi temp1, $FF ; ein bisschen warten ...
wait1:
ldi temp2, $FF
wait2:
dec temp2
brne wait2
dec temp1
brne wait1
; ... und nachsehen, ob die Taste immer noch gedrückt ist
in temp1, key_pin
and temp1, key_now
brne loop

in temp1, led_port ; den Zustand der LED umdrehen
com temp1
out led_port, temp1

rjmp loop
</avrasm>

Wie lange gewartet werden muss, hängt im wesentlichen von der mechanischen Qualität und dem Zustand des Tasters ab. Neue und qualitativ hochwertige Taster prellen wenig, ältere Taster prellen mehr. Grundsätzlich prellen aber alle mechanischen Taster irgendwann. Man sollte nicht dem Trugschluss verfallen, daß ein Taster nur weil er heute nicht erkennbar prellt, dieses auch in einem halben Jahr nicht tut.

==Kombinierte Entprellung und Flankenerkennung==
Von Herrn Peter Dannegger stammt eine [[Entprellung|clevere Routine]], die mit wenig Aufwand an einem Port gleichzeitig bis zu 8 Tasten erkennen und zuverlässig entprellen kann. Dazu wird ein Timer benutzt, der mittels Overflow-Interrupt einen Basistakt erzeugt. Die Zeitdauer von einem Interrupt zum nächsten ist dabei ziemlich unkritisch. Sie sollte sich im Bereich von 5 bis 50 Millisekunden bewegen.

In jedem Overflow Interrupt wird der jetzt am Port anliegende Tastenzustand mit dem Zustand im letzten Timer Interrupt verglichen. Nur dann wenn an einem Pin eine Änderung festgestellt werden kann (Flankenerkennung) wird dieser Tastendruck zunächst registriert. Ein clever aufgebauter Zähler zählt danach die Anzahl der Timer Overflows mit, die die Taste nach Erkennung der Flanke im gedrückten Zustand verharrte. Wurde die Taste nach Erkennung der Flanke 4 mal hintereinander als gedrückt identifiziert, so wird der Tastendruck weitergemeldet.

===Einfache Tastenentprellung und Abfrage===

<avrasm>
.include "m8def.inc"

.def iwr0 = r1
.def iwr1 = r2

.def key_old = r3
.def key_state = r4
.def key_press = r5

.def temp1 = r17

.equ key_pin = PIND
.equ key_port = PORTD
.equ key_ddr = DDRD

.def leds = r16
.equ led_port = PORTB
.equ led_ddr = DDRB

.org 0x0000
rjmp init

.org OVF0addr
rjmp timer_overflow0

timer_overflow0: ; Timer Overflow Interrupt

push r0 ; temporäre Register sichern
in r0, SREG
push r0
push iwr0
push iwr1

get8key: ;/old state iwr1 iwr0
mov iwr0, key_old ;00110011 10101010 00110011
in key_old, key_pin ;11110000
eor iwr0, key_old ; 11000011
com key_old ;00001111
mov iwr1, key_state ; 10101010
or key_state, iwr0 ; 11101011
and iwr0, key_old ; 00000011
eor key_state, iwr0 ; 11101000
and iwr1, iwr0 ; 00000010
or key_press, iwr1 ; gedrückte Taste merken
;
;
pop iwr1 ; Register wiederherstellen
pop iwr0
pop r0
out SREG, r0
pop r0
reti

init:
ldi temp1, HIGH(RAMEND)
out SPH, temp1
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1

ldi temp1, 0xFF
out led_ddr, temp1

ldi temp1, 0xFF ; Tasten sind auf Eingang
out key_port, temp1 ; Pullup Widerstände ein

ldi temp1, 1<<CS02 | 1<<CS00 ; Timer mit Vorteiler 1024
out TCCR0, temp1
ldi temp1, 1<<TOIE0 ; Timer Overflow Interrupt einrichten
out TIMSK, temp1

clr key_old ; die Register für die Tastenauswertung im
clr key_state ; Timer Interrupt initialisieren
clr key_press

sei ; und los gehts: Timer frei

ldi leds, 0xFF
out led_port, leds
main:
cli ;
mov temp1, key_press ; Einen ev. Tastendruck merken und ...
clr key_press ; Tastendruck zurücksetzen
sei

cpi temp1, 0 ; Tastendruck auswerten. Wenn eine von 8 Tasten
breq main ; gedrückt worden wäre, wäre ein entsprechendes
; Bit in key_press gesetzt gewesen

eor leds, temp1 ; Die zur Taste gehörende Led umschalten
out led_port, leds
rjmp main
</avrasm>

===Tastenentprellung, Abfrage und Autorepeat===
Gerade bei Zahlenreihen ist oft eine '''Autorepeat''' Funktion eine nützliche Einrichtung: Drückt der Benutzer eine Taste wird eine Funktion ausgelöst. Drückt er eine Taste und hält sie gedrückt, so setzt nach kurzer Zeit der '''Autorepeat''' ein. Das System verhält sich so, als ob die Taste in schneller Folge immer wieder gedrückt und wieder losgelassen würde.

Leider muss hier für die Wartezeit ein Register im oberen Bereich benutzt werden. Der '''ldi''' Befehl macht dies notwendig. Alternativ könnte man die Wartezeiten beim Init in eines der unteren Register laden und von dort das Repeat Timer Register '''key_rep''' jeweils nachladen.

Alternativ wurde in diesem Code auch die Rolle des Registers '''key_state''' umgedreht. Ein gesetztes 1 Bit bedeutet hier, dass die zugehörige Taste zur Zeit gedrückt ist.

Insgesamt ist dieser Code eine direkte Umsetzung des von Herrn Dannegger vorgestellten C-Codes. Durch die Möglichkeit eines Autorepeats bei gedrückter Taste erhöhen sich die Möglichkeiten im Aufbau von Benutzereingaben enorm. Das bischen Mehraufwand im Vergleich zum vorher vorgestellten Code, rechtfertigt dies auf jeden Fall.

<avrasm>
.include "m8def.inc"

.def iwr0 = r1
.def iwr1 = r2

.def key_state = r4
.def key_press = r5
.def key_rep_press = r6
.def key_rep = r16

.def temp1 = r17

.equ KEY_PIN = PIND
.equ KEY_PORT = PORTD
.equ KEY_DDR = DDRD

.equ KEY_REPEAT_START = 50
.equ KEY_REPEAT_NEXT = 15

.def leds = r20
.equ led_port = PORTB
.equ led_ddr = DDRB

.equ XTAL = 4000000

rjmp init

.org OVF0addr
rjmp timer_overflow0

timer_overflow0: ; Timer Overflow Interrupt

push r0 ; temporäre Register sichern
in r0, SREG
push r0

push r16
; TCNT0 so vorladen, dass der nächste Overflow nach 10 ms auftritt.
ldi r16, -( XTAL / 1024 * 10 / 1000)
; ^ ^ ^^^^^^^^^
; | | = 10 ms
; | Vorteiler
; Quarz-Takt
;
out TCNT0, r16
pop r16

get8key:
in r0, KEY_PIN ; Tasten einlesen
com r0 ; gedrückte Taste werden zu 1
eor r0, key_state ; nur Änderunden berücksichtigen
and iwr0, r0 ; in iwr0 und iwr1 zählen
com iwr0
and iwr1, r0
eor iwr1, iwr0
and r0, iwr0
and r0, iwr1
eor key_state, r0 ;
and r0, key_state
or key_press, r0 ; gedrückte Taste merken
tst key_state ; irgendeine Taste gedrückt ?
breq get8key_rep ; Nein, Zeitdauer zurücksetzen
dec key_rep
brne get8key_finish; ; Zeit abgelaufen?
mov key_rep_press, key_state
ldi key_rep, KEY_REPEAT_NEXT
rjmp get8key_finish

get8key_rep:
ldi key_rep, KEY_REPEAT_START

get8key_finish:
pop r0 ; Register wiederherstellen
out SREG, r0
pop r0
reti
;
;

init:
ldi temp1, HIGH(RAMEND)
out SPH, temp1
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1

ldi temp1, 0xFF
out led_ddr, temp1

ldi temp1, 0xFF ; Tasten sind auf Eingang
out KEY_PORT, temp1 ; Pullup Widerstände ein

ldi temp1, 1<<CS00 | 1<<CS02
out TCCR0, temp1
ldi temp1, 1<<TOIE0 ; Timer mit Vorteiler 1024
out TIMSK, temp1

clr key_state
clr key_press
clr key_rep_press
clr key_rep

ldi leds, 0xFF
out led_port, leds

main:
; einen einzelnen Tastendruck auswerten
cli
mov temp1, key_press
clr key_press
sei

cpi temp1, 0x01 ; Nur dann wenn Taste 0 gedrückt wurde
breq toggle

; Tasten Autorepeat auswerten
cli
mov temp1, key_rep_press
clr key_rep_press
sei
; Nur dann wenn Taste 0 gehalten wurde
cpi temp1, 0x01
breq toggle

rjmp main ; Hauptschleife abgeschlossen

toggle:
eor leds, temp1 ; Die zur Taste gehörende Led umschalten
out led_port, leds
rjmp main
</avrasm>

==Fallbeispiel==
Das folgende Programm hat durchaus praktischen Wert. Es zeigt auf dem LCD den ASCII Code dezimal und in hexadezimal an, sowie das zugehörige LCD-Zeichen. An den '''PORTD''' werden an den Pins 0 und 1 jeweils 1 Taster angeschlossen. Mit dem einen Taster kann der ASCII Code erhöht werden, mit dem anderen Taster wird der ASCII Code erniedrigt. Auf beiden Tastern liegt jeweils ein Autorepeat, sodass jeder beliebige Code einfach angesteuert werden kann. Insbesondere die ASCII Codes größer als 128 sind interessant :-)

<avrasm>
.include "m8def.inc"

.def iwr0 = r1
.def iwr1 = r2

.def key_state = r4
.def key_press = r5
.def key_rep_press = r6
.def key_rep = r16

.def temp1 = r17

.equ KEY_PIN = PIND
.equ KEY_PORT = PORTD
.equ KEY_DDR = DDRD

.equ KEY_REPEAT_START = 40
.equ KEY_REPEAT_NEXT = 15

.def code = r20

.equ XTAL = 4000000

rjmp init

.org OVF0addr
rjmp timer_overflow0

timer_overflow0: ; Timer Overflow Interrupt

push r0 ; temporäre Register sichern
in r0, SREG
push r0

push r16
ldi r16, -( XTAL / 1024 * 10 / 1000 + 1 )
out TCNT0, r16
pop r16

get8key:
in r0, KEY_PIN ; Tasten einlesen
com r0 ; gedrückte Taste werden zu 1
eor r0, key_state ; nur Änderunden berücksichtigen
and iwr0, r0 ; in iwr0 und iwr1 zählen
com iwr0
and iwr1, r0
eor iwr1, iwr0
and r0, iwr0
and r0, iwr1
eor key_state, r0 ;
and r0, key_state
or key_press, r0 ; gedrückte Taste merken
tst key_state ; irgendeine Taste gedrückt ?
breq get8key_rep ; Nein, Zeitdauer zurücksetzen
dec key_rep
brne get8key_finish; ; Zeit abgelaufen?
mov key_rep_press, key_state
ldi key_rep, KEY_REPEAT_NEXT
rjmp get8key_finish

get8key_rep:
ldi key_rep, KEY_REPEAT_START

get8key_finish:
pop r0 ; Register wiederherstellen
out SREG, r0
pop r0
reti
;
;

init:
ldi temp1, HIGH(RAMEND)
out SPH, temp1
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1

ldi temp1, 0xFF ; Tasten sind auf Eingang
out KEY_PORT, temp1 ; Pullup Widerstände ein

rcall lcd_init
rcall lcd_clear

ldi temp1, 1<<CS00 | 1<<CS02
out TCCR0, temp1
ldi temp1, 1<<TOIE0 ; Timer mit Vorteiler 1024
out TIMSK, temp1

clr key_state
clr key_press
clr key_rep_press
clr key_rep

ldi code, 0x30
rjmp update

main:
cli ; normaler Tastendruck
mov temp1, key_press
clr key_press
sei
cpi temp1, 0x01 ; Increment
breq increment
cpi temp1, 0x02 ; Decrement
breq decrement

cli ; gedrückt und halten -> repeat
mov temp1, key_rep_press
clr key_rep_press
sei
cpi temp1, 0x01 ; Increment
breq increment
cpi temp1, 0x02 ; Decrement
breq decrement

rjmp main

increment:
inc code
rjmp update

decrement:
dec code

update:
rcall lcd_home
mov temp1, code
rcall lcd_number
ldi temp1, ' '
rcall lcd_data
mov temp1, code
rcall lcd_number_hex
ldi temp1, ' '
rcall lcd_data
mov temp1, code
rcall lcd_data

rjmp main

.include "lcd-routines.asm"
</avrasm>

== Weblinks ==

* [http://digital-diy.com/General-Electronics/10-keys-on-one-port-pin.html 10 Keys on One Port Pin?] - Eine ganz andere Art der Tastenerkennung über einen [[ADC]]. Damit lässt sich auch eine von vielen Tasten an nur einem ADC-Eingangspin abfragen.

----

{{Navigation_zurückhochvor|
zurücktext=ADC|
zurücklink=AVR-Tutorial: ADC|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=PWM|
vorlink=AVR-Tutorial: PWM}}

[[Category:AVR-Tutorial]]