Hallo zusammen!!!

Ich arbeite zur Zeit viel mit AVR's. Das sind RISC-Prozessoren von ATMEL (Mikrokontroller). Ein tolles Tutorial ist auf Mikrocontroller.net zu finden. Nun meine Frage: Ich kann mit dem ATmega8 Daten über das UART über die serielle schnittstelle an den PC übertragen, bei mikrocontroller.net sagt das Tutorial, mit Hyperterminal oder so einem ähnlichen Terminalprogramm kann ich die Daten empfangen. Das klappt auch, ich sende mit dem µC zum Beispiel den ASCII-Code für 'Y', und sofort erscheint im Hyperterminal 'Y'. So nun bringt mir das ja nix, wenn ich z.B. eine PC-Steuerung über RS232 und µC für irgendwas programmieren möchte.

---> Ich muss also über Delphi das UART der seriellen Schnittstelle ansprechen können, um dort raus Daten zu senden und zu empfangen!!!

Hat jemand da eine Idee????

Mein Ziel wäre es, z.B das man ein Delphi-Programm hat, welches Zahlenwerte absenden kann, die dann ein an den seriellen Port angeschlossener Mikrocontroller weiterverarbeiten kann, z.B die Geschwindigkeit für eine PWM am µC..

Vielen Dank schon mal im Voraus, ich bin auf Antworten gespannt!!!

Hi und erstmal herzlich Willkommen in der DP

Für die Arbeit mit der RS-232 Schnittstelle des Rechners (unter Delphi) findest Du eine Menge verschiedener Kapselungen. Ich würde Dir zu TComport raten. Ich habe bisher keine schlechten Erfahrungen mit dieser Komponente gemacht. Sie bietet Dir die einfache Möglichkeit Daten (als String oder Bytes) zu verschicken und zu empfangen. Für das Eintreffen von Daten in den Puffer stehen Ereignisse auch Ereignisse zur Verfügung, die Dich über das generelle Eintreffen von Daten oder sogar das Empfangen eines speziellen Zeichens informieren.
Zudem gibt es noch eine einfache Möglichkeit die vorhandenen Ports / ihren Bezeichnungen aufzulisten.

Das sind die wichtigsten Dinge, schau einfach mal wie gut Du mit der Komponente klar kommst und frag ggf. einfach wieder nach.

Gruß Der Unwissende

Vielen Dank für die schnelle Antwort, das ist so ziemlich das was ich wollte!
Nur hab ich das damit noch nicht programmiert ...
Also, ist eine Komponente dasselbe wie eine Klasse, die ich dann irgendwie einbinde, ( oben unter uses ...)
und von der ich dann Variablenwerte und Funktionen bekomme und an die ich Werte übergeben kann?

Und ist das dann im UART-Protokoll? oder gibt es für RS232 sowieso nur eines, was der µC halt UART nennt, und das universal von RS232 zu RS232 erkennt ,egal ob PC oder µC dahinter hängt!

Also ich probier das jetzt mal aus, doch ich nehme weiterhin jeden Tipp entgegen, und bestimmt treffen noch Fragen auf !!!!!




Mfg Moritz

Die Frage was eine Komponente ist müsste ich jetzt schon etwas ausführlicher beantworten. Meine Warnung vorab, lass Dich nicht davon verwirren. Bei TComPort handelt es sich um eine Bibliothek. Es gibt eine Klasse (die für Dich wichtig ist), aber auch mehr. So findest Du in einer Unit eine imperative Prozedur (die dann das auflisten aller Ports ermöglicht). Zudem gibt es noch andere Klassen (die Du aber nicht für die Kommunikation benötigst). Am einfachsten ist es, wenn Du die Klasse installierst (in die Entwicklungsumgebung integrierst). Dann hast Du ein eigenes Tab in der Komponenten-Palette (da wo Du Dinge wie Buttons und Labels findest).
Der Begriff der Komponente hingegen müsste allgemein etwas anders verstanden werden. Im Sinne der Informatik würdest Du Komponente immer mit dem Begriff Komponentenmodell verbinden. Eine Komponente ist einfach ein Stück Software, dass einem Komponentenmodell genügt. Das eigentlich wichtige ist, dass eine Komponente sich mit anderen Komponenten verbinden lässt (der Begriff leitet sich aus dem lat. Zusammensetzen ab). Die Idee hinter Komponenten ist, dass Du fertige Bausteine erstellen kannst und diese wie Lego zu einem Programm zusammensetzt. Damit das ganze klappt, musst Du natürlich wissen wie man zwei Komponenten zu einer neuen zusammensetzt. Dazu müssen die irgendwie kombiniert werden, was wiederum eine gewisse Kompatiblität erfordert. Der eigentliche Sinn eines Komponentenmodells besteht darin, dass hier Schnittstellen festgelegt werden. Eine Schnittstelle ist das, was nach außen sichtbar ist. Eine Komponente hat ein geheimes Innenleben und eben eine solche Schnittstelle. Die Schnittstelle beinhaltet dann einfach die Beschreibung dessen, was die Komponente leistet (was für Funktionen gibt es, was leisten die Funktionen, was für Parameter, was für Rückgabewerte).
Der Vorteil besteht dann darin, dass Du einfach Komponenten zu neuen Komponenten (/Programmen) zusammensetzen kannst. Dazu musst Du natürlich noch Code schreiben, der die Komponenten verbindet (aber das ist nebensächlich). Wichtig ist, dass eben das Innenleben uninteressant/geheim ist. Solange Du die Schnittstelle kennst, weißt Du alles was Du wissen musst (was kann die Komponente und wie verwendet man das was sie kann). Die eigentliche Implementierung kannst Du hingegen austauschen, von außen wird das keiner merken. Damit kannst Du dann auch einfach fremde Komponenten zukaufen und profitierst dann vom know-how anderer. Über die Schnittstellen kannst Du solche Komponenten einfach in dein Programm integrieren.

Ja, in Delphi wird der Begriff der Komponente häufig auch im Zusammenhang mit Klassen gebraucht, die Nachfahren von TComponent sind. Zudem gibt es eben noch solche Klassen, die in der Komponenten-Palette (glaube die heißt so) registriert werden können (wie Buttons oder Label halt). An sich ist das aber etwas abweichend vom allgemeinen Begriff einer Komponente. So sind Klassen eigentlich immer Komponenten, da nur der Zugriff auf öffentliche Elemente möglich ist und auch die Interaktion (wie wird eine Methode aufgerufen, welche Parameter hat sie, ...) ist für jede Programmiersprache festgelegt (es gibt aber auch Programmiersprachen übergreifende Komponentenmodelle).

Ist wie gesagt auch nicht weiter wichtig. Hab den Begriff etwas unglücklich gewählt. Es handelt sich zwar auch bei TComport um eine Komponente, Du kannst es aber auch einfach mit einer Unit gleichsetzen (CPort), die dir Funktionen und Klassen zur Verfügung stellt, die Du verwenden kannst.

Hier musst Du etwas unterscheiden. Eine UART ist ein Baustein, der für die Universelle Asychrone Kommunikation (Receiver/Tranceiver) zuständig ist. Kann jetzt sein, dass ich mich irre und UART für etwas anderes stand, aber es geht wirklich allgemein um die Asynchrone Kommunikation.
RS-232 hingegen ist eine sehr spezielle Form der Asynchronen Kommunikation. Hier ist das verwendete Protokoll festgelegt. Was letztlich dahinter steckt (ob PC oder µC) kann nicht festgestellt werden (selbst im PC kannst Du ja einen speziellen µC verwenden). Bei RS-232 werden also Daten (Bytes) auf eine bestimmte Art und Weise übertragen. Das wie wird dabei durch die Kommunikationsparameter (Stopbits, Baudrate, Flusskontrolle,..) bestimmt. Werden hier auf beiden Seiten die gleichen Parameter verwendet, so kannst Du Dir die Kommunikationspartner als Komponenten vorstellen Du hast nach außen nur eine Schnittstelle (RS-232), was dahinter passiert (wo die Daten landen, wie sie interpretiert werden) ist völlig verborgen. RS-232 legt nur fest wie die Daten übertragen werden.

Hoffe es hat etwas geholfen.

Ah ja top, vielen Dank für die ausführliche Info, ich seh schon das wird was. Okk Baud-Rate und so hab ich im µC programmiert und am PC kann man ja die RS232 konfigurieren (Systemsteuerung). Deinen Link hab ich mir runtergesaugt, und wollte mal die Beispiele aus der comLibrary zu laden, es Fehlt Ihm eine Klasse "TComLed"
Und wenn ichs ignoriere, kommen beim Programmstart immer noch tausend Fehler... Ich habe Delphi 2005. Aber wenn ich das richtig verstanden habe brauch ich nur eine Unit einbinden, oder am besten :
>Am einfachsten ist es, wenn Du die Klasse installierst (in die Entwicklungsumgebung integrierst). Dann hast Du >ein eigenes Tab in der Komponenten-Palette (da wo Du Dinge wie Buttons und Labels findest).


Das werd ich jetzt mal testen.

Soll Ich .NET oder WIN32 nehmen???

Vielen Dank noch mal für die Mühe!!!!

Gruss Moritz

Ja, die TComLed ist ebend eine der anderen Klasse. Du solltest etwas wie ein Delphi-Package finden, das kannst Du dann installieren, da werden dann alle Klassen (auch TComLed) aut. mit installiert.
Gibt es kein Beispiel ohne eine TComLed?
Wichtig ist auch, dass Du die entpackten Klassen (die .pas Dateien) in deinen Bibliothekspfad packst (es gibt irgendwo im Menü die Option diesen einzustellen). Dann kannst Du die Unit CPort verwenden (in der sich alle Klassen befinden).

Gilt nicht für die Beispiele. Wenn Du eine Komponente aus der Palette auf das Form setzt (z.B. einen Button), dann kümmert sich Delphi um die Verwaltung. Das heißt, dass Delphi aut. die entsprechende Unit einbindet, eine Instanz erzeugt und auch irgendwann wieder frei gibt. Du merkst davon dann sehr wenig, Du kannst schon zur Designzeit Einstellungen vornehmen. Ist eine solche Komponente auf der Form platziert, aber kennt Delphi diese Klasse nicht, dann kommt es natürlich zu Fehlern. Hier sollte dann die Komponente auch wirklich installiert sein.

Für das installieren solltest Du wie gesagt eine Package-Datei finden (oder im Menü etwas wie Komponente installieren oder so). Die TComPort Klasse ist dann (wenn sie installiert ist) für native Win32 (nicht .net) Programme gedacht. Möchtest Du lieber mit .net arbeiten, wirst Du eine andere benötigen (da kann ich Dir dann mangels Erfahrung) nicht mehr helfen (aber bestimmt jmd. anderes).

nee um Gottes Willen Win32 ist mir recht!!!, Da ich den Unterschied auch gar net kenne... Aber normalerweise nehm ich eh Win32.

OK dieses packache hab ich nach Anleitung von der Readme versucht zu installieren, komme aber beim letzten Schritt nicht weiter:

"
Use "File/Open" menu item in Delphi/C++ Builder IDE to open
ComPort run-time package source file (see above). Click "Compile"
button in Package window to compile the library. Now move run-time
package library file or files (see above) from ComPort folder to a
folder that is accessible through the search PATH (e.g. WinNT\System32).

Now you have to install design-time package. Use File/Open menu item
to open design-time package source file (see above). Click "Compile"
button in Package window to compile the package and "Install" button
to register ComPort into the IDE. ComPort components appear in
"CPortLib" page of component pallete. If it complains that it
can't install it because it can't find a library, you probably
did not put the run-time package in the search path. You might
not get this error until the next time you try to start
Delphi/C++ Builder."

Wo ist dieser "Install" button um das design time package zu installieren? Ich hab diesen Ordner bei Win32 als Biblithekspfad angegeben, den "run-time package source file " compiliert und mal alle Dateien in system32 von Windows kopiert : "from ComPort folder to a
folder that is accessible through the search PATH (e.g. WinNT\System32)."
So. Dann die "design-time package source file " compiliert, und weiter komm ich nicht.

Aber das mit der Komponente hab ich glaube verstanden, es gibt ja im Prinzip da schon ganz viele in Delphi, so viereckige Kästchen, die man auf die Form zieht...

OK, wenn ichs geschafft habe die komponente zu installieren, kann ich mithilfe der Beispiele auch mal langsam das Zusammenspiel mit dem µC usw. machen.


Gruss und Dank
Moritz

ahhh supi ok ich habs installiert, perfekt jetzt kann man schöne viereckige kästchen auf die form ziehen...
...was so ne sekunde googeln doch hilft...
ok die examples gehen...
der µC sendet ersten text...

ES KANN LOSGEHEN!!!

Vielen Dank Unwissender!!! Das könnte echt noch was werden...!!!

Moritz

OK noch eine Mini-Frage, weils grad so gut klappt (*freu*):

mit ComPort.ReadStr(String,Zahl); lese ich den Com port ab. Das klappt auch, nur wie kann ich sagen, wie lange er lesen soll, bzw. Zeichen empfangen?

Im Moment ist es so: Der µC sendet ununterbrochen Test! 'Zeilenumbruch' Test! 'Zeilenumbruch'...
Der ausgelesene String ist dann mal

st!Test!

oder

Test!

oder

est!Tes

oder oder oder...

ALSO : Wie kann ich eine Bedingung programmieren, ab wann er lesen soll, un dwie kann ich programmieren, das er z.b 8 Zeichen lesen soll und im String speichern. ?????

schönen Abend noch,
Moritz ( inzwischen sehr begeisterter Komponeten-liebhaber )

Das freut mich!

Dazu kannst Du einfach mit der Komponente abfragen, wieviele Zeichen gerade im Puffer liegen. An sich ist die Kommunikation über RS-232 immer Asynchron. Du weißt also nicht wann Daten übertragen werden und/oder wieviele. Auch kannst Du nicht direkt auf ein Datum antworten. Das alles gilt nur für die RS-232 Schnittstelle. Das heißt in diesem Fall insbesondere, dass Du ohne Probleme ein Protokoll auf RS-232 aufsezten kannst, dass Dir all diese Möglichkeiten gibt. In der Regel gibt es zwei Möglichkeiten mit dem µC zu kommunizieren:

1. Endlosschleife (z.B. Messwerte lesen), man stößt das Lesen einmal an und es werden (wie in deinem Test) ständig Daten gesendet und Empfangen
2. Ereignisse, Du stellst gezielt Anfragen und musst ggf. (hängt vom Protokoll ab) auch mal Antworten.

Da die Kommunikation asynchron ist, werden die Daten dabei immer gepuffert. Der Controller weiß nie, ob er ein vollständiges Datum oder nur einen Teil übertragen hat (das Problem hast Du gerade). Deswegen wird häufig ein spezielles Zeichen als EOT (End of Transmission) übertragen (nicht mit gleichnamigem Steuerzeichen verwechseln!). Ich meine hier, dass Du selbst festlegst, dass Zeichen X das Ende eines Datums markiert. Üblicherweise nimmt man das Zeichen CR (Carriage Return/$D/0xD/13/Enter). Es handelt sich um den einfachen Zeilenumbruch (Return/Enter), die Nummern 13, die Hex-Zahl $D (Delphi Syntax) oder 0xD (C/Java Syntax) stellen dabei den Wert des Zeichens dar.
Der TComport bietet Dir die Eigenschaft EventChar. Hier ist etwas wie #0 voreingestellt. Die # steht dafür, dass Du den Buchstaben mit dem Byte-Wert nimmst (entspricht der chr-Funktion). Für CR kannst Du hier also #13 eintragen. Wird nun ein CR empfangen, so wird das Ereignis OnRxFlag ausgelöst (also genauer die Behandlung des Ereignisses). Verwendest Du das allgemeine OnRxChar, wird die Anzahl der Daten im Puffer mit übergeben. Beim OnRxFlag-Event ist das nicht der Fall. Hier kannst Du die Anzahl der Bytes im Puffer (wie auch an jeder anderen Stelle) mit der Funktion InputCount abfragen. Diese Funktion gibt Dir einfach nur die Anzahl der Bytes im Puffer zurück. Diese Anzahl kannst Du also in einen Puffer einlesen.
Das eigentliche Problem bleibt hier noch das Trennen, Du weißt zwar, dass ein Datum mit einem CR endet (man kann natürlich auch ein Startzeichen festlegen!), aber Du weißt eben nicht, ob nicht bereits Teile des nachfolgenden Datums mit im Puffer liegen. Deswegen solltest Du hier einfach die Daten in eine Instanzvariable schreiben. Damit meine ich eine Variable, die innerhalb der Instanz der Klasse global ist (z.B. unter private angelegt). In diese Variable kannst Du einfach den Inhalt des Puffers einlesen und mittels Pos und Copy das erste Datum kopieren. Hier könntest Du dann z.B. in einer Schleife solange weiter machen, bis kein Trennzeichen mehr im String ist. Dafür findest Du aber auch fertige Klassen (such mal nach explode oder so).
Wichtig ist einfach, dass Du den letzten Teil (das noch unfertige Datum) einfach noch behälst, wenn es nicht mit einem Trennzeichen endet.

Letztlich bleibt es aber vollkommen Dir überlassen, wie Du das hier machst. Immerhin kannst Du das komplette Protokoll festlegen. Wie gesagt, eine Möglichkeit besteht in Start- und Endzeichen. Du kannst aber natürlich noch die Anzahl der Bytes / Größe des Datums, eine Checksumme, Bestätigungen und und und verschicken. Wichtig ist nur, dass beide Kommunikationspartner wissen welche Form ein Datum hat (sonst hast Du halt nur eine sinnlose Menge von Bytes).

Ja, was das lesen von 8 Zeichen angeht, so musst Du halt nur prüfen ob InputCount >= 8 ist und das dann bei Count angeben. Wichtig ist halt, dass Du nicht schon liest, wenn nur 3 Zeichen im Puffer liegen. Wieviele Bytes tatsächlich gelesen wurden ist natürlich das Funktionsergebnis (von readStr).

Gruß (und auch Dir 'nen schönen Abend!) Der Unwissende