Hallo,
ich möchte den Druckerport meines PC mit einem Mikrocontroller
(atmega32) verbinden.
Dabei möchte ich nur eine einziges Bit an Information von dem Computer
an den Mikrocontroller weitergeben (1 und 0).
Ich möchte das so lösen, dass ich ein Pin des LPTs auf high, bzw. low
schalte,
der Mikrocontroller soll das jeweils registrieren.
Ich habe mich ein wenig über Mikrocontroller und über LPT informiert und
bin in der Lage einen Taster an den Mikrocontroller anzuschließen: Da
wird ja im Prinzip zwischen einen Pin und GND ein Taster angeschlossen.
So ähnlich stelle ich mir das auch vor, aber da der LPT ja zu einem
anderen Stromkreis wie der Mikrocontroller gehört, kann ich das nicht
genauso machen.
Wie kann ich den LPT mit möglichst wenig Aufwand mit dem Controller
verbinden, so dass der PC quasi ein Bit zu dem Controller schicken kann.
Natürlich soll möglichst kein RIsiko bestehen, dass meine
LPT-Schnittstelle kaputt geht.
Thomas
Den LPT halte ich dafür nicht für ideal.
Ich würde dazu lieber RS-232 nehmen, da du ja nur ein einziges Datenbit
übertragen willst. Der RS-232 Port hat sogenannte Handshake-Leitungen
(RTS, CTS, DSR und DTR). Zwei davon kann man per Software ein- und
ausschalten (ist ein bisschen weniger aufwendig, dafür ne eigene
Software zu basteln. Windoow stellt zum setzen des RTS- oder DSR-Signals
die Funktion SetCommState()* zuer verfügung).
Allgemein musst du, wenn du Signale zwischen zwei verschiedenen
Stromkreisen austauschen willst, die beiden Massen der Stromkreise
verbinden. Wenn das nicht erwünscht ist, muss ein Optokoppler
dazwischen.
Bei der RS-232 musst du übrigens aufpassen:
Logisch 1 wird durch -3..-25V und logisch 0 durch +3..+25V dargestellt.
Du musst also noch eine Schutzschaltung für deinen Mikrocontroller
basteln, damit der keine Spannung > 5V sieht (bzw. 3.3V halt, je nach
Mikrocontroller).
Wenn man mit C++ programmiert, gibts ein hübsches Include-File, das eine
Funktion zum beschreiben der Ports und lesen derselbigen anbietet. Wenn
man dann noch die IO-Adresse vom LPT kennt, kann man damit locker ein
baar Bits setzen und abfragen. Aber man muss halt C++ können.
Übrigens ist mir noch ein weiterer Vorteil eingefallen, den die RS-232
bietet: RS-232 ist relativ robust; der Strom ist auf 20 mA begrenzt
(jedenfalls sollte er das sein). Beim LPT gibts keine interne
Schutzvorrichtung; der soll auch sonst sehr empfindlich sein. Also
einmal was falsch angeschlossen und dein Port ist hin.... Darum: lieber
RS-232, dort macht auch ein Kurzschluss nichts (ich rede aus Erfahrung
;)).
Danke für eure Antworten.
Ich wollte den LPT eigentlich mit Delphi programmieren (unter vista):
Dazu habe ich das hier gefunden:
http://www.tech-ecke.de/index_quereinstieg.htm?/delphi/inpout32_dll.htm
Aber wenn ihr denkt, dass es mit RS-232 leichter ist, dann werde ich das
so lösen.
Ich möchte übrigens 2 Schrittmotoren und 2 Servos ansteuern. Deshalb
wollte ich ich die Schrittmotoren mit einer einfachen Schaltung direkt
an den LPT anschließen und den Mikrocontroller für die Servos
benutzen(die Servos sollen nur 2 Positionen anfahren).
Wenn es einfacher ist das ganze mit RS-232 und der seriellen
Schnittstelle unter vista mit delphi zu machen, werde ich die Motoren
alle an den Controller anschließen und den Controller an die serielle
Schnittstelle.
Kennt jemand den Code mit dem ich mit Delphi den Mikrocontroller über
RS-232 (über die serielle Schnittstelle) ansteuern kann?
Danke,
Thomas
PS: Noch eine Frage: Spricht was dagegen eine serielle Schnittstelle
durch einen USB-Adapter zu "erschaffen"?
Die Frage ist jetzt halt was du genau tun willst.
Wenn du wie gesagt nur ein einziges Bit übertragen willst - also eine
Leitung programmgesteuert entweder auf 1 oder 0 setzt, dann würde ich
persönlich dafür eine der Handshake-Leitungen nehmen (siehe oben). Du
kannst aber gleich Nägel mit Köpfen machen und den Mikrocontroller mit
der Datenleitung der RS-232 verbinden. Da kannst du dann mit einem
einfachen Terminalprogramme Dateien oder Tastatureingaben simpel mittels
3 Drähten an den Mikrocontroller übermitteln, und der kann dann sogar
eine Antwort darauf zurückgeben.
Delphi ist kein Problem, dort ist sowas auch machbar.
Übrigens: USB zu seriell Adapter würde ich nicht verwenden.
Unzuverlässig, hält sich oft nicht an die Standards... es ist einfach
ein gebastel. Besser du nimmst eine richtige, saubere RS-232.
Da ich beide Motorarten an einer Schnittstelle haben will, bleibt mir ja
eigentlich fast nichts anderes übrig als den Mikrocontroller mit der
Datenleitung des RS-232 zu verbinden.
Wie kann man ein Terminalprogramm mit Delphi programmieren? Gibt es
ddazu in Internet irgendwelche Anleitungen/Tutorials?
Danke,
Thomas
Du brauchst keines zu programmieren. Windoof stellt dir HyperTerminal
zur Verfügung, welches zwar ein bisschen popelig daherkommt, aber für
den Anfang durchaus ausreichend ist. Wenn du allerdings ein anständiges
Terminalprogramm ohne viel schnickschnack willst, kannst du TeraTerm Pro
verwenden oder ein beliebiges anderes Terminalprogramm deiner Wahl (hier
im Forum hat jemand mal was selber gemachtes Namens hTerm gepostet).
Aber ich möchte eigentlich ein Programm schreiben, dass in der Lage ist
die Motoren zu steuern. Wenn ich ein fertiges Terminal benutze, müsste
ich ja alle Sachen selber eingeben und das möchte ich vermeiden.
Es muss doch eine einfache Möglichkeit geben, mit dem Computer
Programmgesteuert Servos und Schrittmotoren anzusteuern.
Danke nocheinmal,
Thomas
ja gibt es.
Die Windows-Shell stellt 3 funktionen dazu zur Verfügung:
CreateFile, ReadFile und WriteFile.
Um ganz simpel mal ein paar Bytes zu senden, machst du folgendes:
Mittels CreateFile öffnest du eine imaginäre Datei mit dem Namen
"\\.\COM1". Die Funktion liefert ein Handle zurück, das auf den Com-Port
zeigt (Handle = Zeiger). Nun kannst du mittels WriteFile und diesem
Handle deine Bytes ausgeben. Eingelesen wird mit ReadFile.
Und nun siehst du auch schon das Problem: Du kannst nicht immer wissen,
wann deine Daten reinkommen, sprich wann du ReadFile aufrufen musst. Das
mit einem Interrupt so zu autmatisieren, dass ankommende Bytes nicht
verloren gehen, ist relativ kompliziert. Ich selber hab es nur halbwegs
geschafft (auch nur halbherzig versucht), dann habe ich mir eine fertige
Lib gesucht, die sowas kann. Evtl findest du auf Codeproject.com ein
bisschen Hilfe (ist allerdings für C++).
Mh, aber wenn ich mit diesem Programm nur senden möchte, dann müsste das
doch einfach sein, oder?
Wenn ich einfach mit writefile den text "Servo1bewegen" schicke, dem
Mikrocontroller bekannt ist, was er bei Eingang von diesem Text machen
soll, müsste das doch schon reichen, um einen einz9gen Servo
anzusteuern, oder?
Vielen, vielen Dank,
Thomas
Ja wenn du nur Text senden willst ist das total simpel. Dazu reichen 10
Zeilen Code. Naja, wenns ne GUI-Anwendung sein soll vielleicht eine,
zwei Zeilen mehr ;)
Ja,
nur Text sollte doch ausreichen. Man programmiert in den Mikrocontroller
dann einfach eine Schleife rein, in der ständig abgefragt wird: Wenn
ankommender Text=Servo1bewegen, dann bewege den Servo
oder so ähnlich :=), oder?
Thomas
Genau so wird das gemacht.
Du musst halt dann einfach noch einen Mikrocontroller haben, der einen
UART besitzt (siehe z.B. AVR-Tutorial). Und einen Pegelconverter
brauchts auch noch. Der soll aus den +3..25V eine logische 0 und aus
-3..-25V eine logische 1 machen. Umgekehrt soll er am Ausgang natürlich
die enstprechenden Pegel haben, wenn der Mikcotontroller was senden
will.
Zum verdrahten brauchst du dann nur noch RxD, TxD und GND. ACHTUNG: TxD
vom PC geht natürlich auf RxD vom Controller! Was der PC sendet soll der
Controller ja empfangen ;) Und umgekehrt - TxD vom Controller an RxD vom
PC.
Aber das war dir klar, schätze ich.
Äh, entschuldigung, dass ich nochmal nachfrage:
Ich wollte mir das eigentlich ganz einfach machen, einen atmega32 über
den IC Max232 direkt mit dem UART verbinden. So wie hier beschrieben
ist:
http://www.mikrocontroller.net/articles/AVR-Tutorial:_UART
Wenn ich das so mache, wofür brauche ich dann einen Pegelconverter?
Thomas
Thomas wrote:
> Wenn ich das so mache, wofür brauche ich dann einen Pegelconverter?
Der Max232 ist der Pegelkonverter und dafür da, damit aus den 0/5V (TTL)
die genormten +/- 10V (RS232) entstehen!
Oh. Tut mir Leid, dass das alles so lange gedauert hat.
Aber das scheint also alles zu sein:
Ich muss einfach diese Schaltung aus diesem Tutorial nach bauen, und
kann dann mit einem einfachen Delphicode Text zu dem Controller
schicken.
Und das ist alles! Habe ich das alles so richtig verstanden?
Vielen Dank, für eure ganzen Mühen,
Thomas
Thomas wrote:
> Ich muss einfach diese Schaltung aus diesem Tutorial nach bauen, und> kann dann mit einem einfachen Delphicode Text zu dem Controller> schicken.>> Und das ist alles! Habe ich das alles so richtig verstanden?
Kommt drauf an welchen Controller du benützen willst... bei AVR's geht
das nicht so einfach über UART die Programme runterzuspielen...
EDIT: Sorry... µC überlesen... Mega32... da brauchst du eine eigene
Schaltung zum Programmieren...
@Jürgen:
Er will ja keine Programme laden, sondern nur mit dem Controller
kommunizieren. Das geht, soviel ich weiss, auch mit dem popeligsten
AVR-UART. Oder?
Ich weiss halt nicht, ich verwende keine AVRs ;)
Ich meine natürlich, dass auf dem Controller schon ein Programm ist, das
ständig einen ankommenden Text von dem UART erwartet und dann
abgleicht...
Dann sollte das doch funktionieren mit Delphi den Text an die
Schaltung(vgl. Tutorial) zu schicken, so dass die dem Mikrocontoller
auch erreicht.
So ist jetzt alles richtig?
