Borland, MC und PC

Hallo,
ich bin dabei mit dem Borland Builder eine Bedienoberfläche zu basteln, um einen Spielzeugkran mit Microcontroller zu steuern. An diesem Kran habe ich auch eine Lichtschranke mit Schlitzscheibe, um zunächst nur die Position des Auslegers zu ermitteln (insgesamt nur 8 Positionen). Den Zähler habe ich über das C-Programm des MC's realisiert. jetzt möchte ich den Zählerinhalt des MC's an den PC schicken und in der Bedienoberfläche auslesen, bzw. sichtbar machen, weiß allerdings im Moment nicht, wie ich das machen soll(auch wie ich den Zählerinhalt bei jeder Position neu auslese)??

Grüße
Sven

Schau dich nach einer Komponente für die RS-232 Schnittstelle
um:

http://www.swissdelphicenter.ch/torry/
http://delphi.icm.edu.pl/

Die Komponente Tcomport
http://sourceforge.net/projects/comport/
kann ich Dir empfehlen.

Habe sie mit Delphi erfolgreich eingesetzt.

also die kommunikation steht. Es geht vielmehr um die umsetzung mit dem builder und c++ zum übertragen einer variablen vom mc zur bedienoberfläche.

Über C++ kannst du auf die serielle Schnittstelle zugreifen, in einer alten Version von Builder hatte ich das mal gemacht, um einen Eprommer zu proggen. Schau mal nach, was an help-Files dabei ist. Da gibt es auch Helf-Files zur Windows-API (man such sich nen Wolf dabei) , wo das beschrieben ist.

Den COM öffnet man wie einen File mit speziellem Namen, und hat auch Zugriff auf die einzelnen Leitungen wie RTS, CTS, DTR, ...

Schau mal in der Doc zu CreateFile, von da kann man sich weiterhangeln mit der Win32-API-Hilfe.

Hallo,
schon einmal danke für die Antworten.

Wahrscheinlich habe ich mich ein bißchen verkehrt ausgedrückt.
Es gehrt eigentlich darum, daß ich in meinem Microcontroller durch ein C-Programm eine Variable erzeuge, die ich über die serielle Schnittstelle an den PC schicken will, um sie dann über den Borland C++ Builder anzeigen kann. Die Kommunikation steht, denn ich steuer über die erstellte Bedienoberfläche am PC schon einen Kran. Jetzt habe ich hierzu am Kran eine Lichtschranke, die durch eine Schlitzscheibe Impulse an den Microcontroller gibt. Diese Impulse sollen gezählt werden und in dieser Variablen festgehalten werden und immer wenn ein neuer Impuls gezählt wird soll der Wert der Variablen an den PC geschickt werden und angezeigt werden. Da ich im Moment auch noch Probleme mit der Umsetzung des C und des C++ Programms habe, kann mir dazu vielleicht auch noch jemand einen Tipp geben.

Viele Grüße
Sven

Also geht es um die µC-Seite des C-Codes?

Ist Wiki->Kategorien->Kommunikation->UART mit avr-gcc das, was du suchst?

Ja, in gewisser Hinsicht schon.
Um es ganz klar zu sagen: Ich bin anscheinend einfach zu blöd mir da was auszudenken. Ich möchte die Impulse von der Schlitzscheibe zählen und anhand dessen die Kranposition ermitteln. Für den Ausleger habe ich zunächst 8 Positionen (schlitze) festgelegt. Der Kran fängt bei Position 0 null an sich zu drehen, bis er max. die 8te, also Position7 erreicht hat.
Dreht der Kran in die andere Richtung soll der Zähler von 7 wieder abwärts zählen, bis er bei Position 0 angekommen ist. Diese Positionen möchte ich nun auch auslesen und an den PC schicken. Wie schon gesagt steuern kann ich den Kran schon, also die Kommunikation PC<-> Microcontroller steht.Am PC sollen die Positionen dann in einem C++ Programm, mit der selbsterstellten Oberfläche (mit Borland C++ Builder) steuer ich schon den Kran, angezeigt werden. Da ich mich mit allem seit relativ kurzer Zeit damit beschäftige habe ich Schwierigkeiten mit dem Verständnis einiger Artikel, da ich mich auch mit C und C++ noch nicht so gut auskenne. Deswegen wäre ich auch schon für konkrete Lösungsvorschläge dankbar, gerne auch schon mit Lösungsansätzen für den C-Code, da ich noch Probleme mit dem Syntax und Realisierungsmöglichkeiten habe.

1. Du kopierst aus dem obigen Artikel die uart.h und uart.c in dein avr-Projekt. Die uart.c wird wie die anderen Dateien compilert und dazugelinkt, muss also evtl in dein Makefile eingetragen werden.
2. Du passt die F_CPU und BAUDRATE an deine erfordernisse an.
3. Direkt nach dem Programmstart ruft du einmal die uart_init() auf.
4. Jedesmal, wenn du ein Byte wert übertragen willst, rufst du uart_putc(wert) auf. Der Aufruf aollte möglichst nicht in einer ISR stehen.

Vielen Dank, werde ich mal probieren.
kannst Du mir noch erklären was Du mit Makefile und ISR meinst, wie gesagt ... absoluter Beginner...

Gruß
Sven

Ach ja, hast Du vielleicht auch eine Idee, wie ich auf der anderen Seite die Werte sichtbar machen kann(mit c++)?
Ich kann in den Aufruf sicherlich auch eine Variable statt einen Wert eingeben,oder?

Gruß
Sven

Das kommt drauf an, was es für eine Variable ist. So wie es da steht geht es nur für 8-Bit-Werte. Ist der Wert breiter, muss man alle Bytes übertragen und am PC wieder richtig zusammensetzen.

Code:

---

unsigned int wert;
uart_putc (Kennung, daß ein unsigned int kommt);
uart_putc ((unsigned char) wert); // unteres Byte
uart_putc ((unsigned char) (wert>>8)); // oberes Byte

---

Ich habe es bis jetzt nicht geschafft, habe zu viele Syntaxfehler. Mir fehlt eben noch die Erfahrung und vor allem das Wissen, wie ich damit umzugehen habe. Wäre es zuviel verlangt, wenn ich Dir meinen bisherigen C-Code zuschicke und Du das einmal einfügen würdest? Damit würdest Du mir wirklich sehr helfen.

Gruß
Sven
--

Oh, habe eben erst gesehen, daß das für Keil ist. Ich dachte, das ist für gcc.

Was macht denn das getchar()? Das benutzt doch bestimmt schon den UART? Wenn das so ist, dann geht es so nicht, weil sich die Sachen sonst in die Quere kommen.
Es gibt bestimmt auch ein putchar oder putc, das du ohne weiteres verwenden kannst.

das getchar() ist für die Buchstaben, die durch das C++ Programm bei einem Buttonclick übermittelt werden

Und putchar gibt's keins zum Senden deiner Positon?

habe ich gerade nachgeguckt, gibt es.
Wenn ich in meinem Fall dann einfach die Zeile:
"putchar(zaehler)" meinem Programm anfüge, wird dann der Inhalt der Variablen "zaehler" gesendet?
Hast Du dann vielleicht noch eine Idee, wie ich das in dem Borland Builder einbinden kann, dass ich die variable am PC sichtbar machen kann?

Genauso geht's.

Kommt drauf an, wie du die Daten sichtbar machen willst. Als Zahl: binär, Dezimal-> Edit-Feld oder Label, als Radio-Group mit anclickbaren Positionen, als Gauge oder was auch immer

Eigentlich einfach nur als Dezimalzahl, ob Label oder Edit-Feld ist egal.
wie oft "aktualisiere" ich dann eigentlich dann, also ich meine,wird die Variable dann immer gesendet, wenn sie sich ändert, weil ich ja immer die aktuelle Position anzeigen will.

1. In regelmässigen Abständen schickst du ein Kommando an den µC, so daß er die Position übermittelt
2. Wenn sich die Position ändert, wird sie an den PC gesandt. Dort lässt du den UART-Empfang einen Event auslösen, der die Anzeige aktualisiert bzw. die Daten speichert und die Aktualisierung veranlasst (GUI-Aktualisierung muss teilweise im Haupt-Thread erfolgen)

Oha, hört sich alles gut an, ich kann es auch nachvollziehen, aber es wird an der Umsetzung scheitern. Wie kann ich das von Dir gesagte umsetzen? Entschuldige bitte meine Begriffsstutzigkeit, aber ich habe damit kaum gearbeitet und muss mich da Stück für Stück vortasten. Ohne konkrete Beispiele tue ich mich da leider sehr schwer.

Meine Boland-Zeit ist auch schon länger her...

Und Quellcode in dem Sinne gibt's ja nicht, zumindest kann man nicht viel damit anfangen, weil man den ja erzeugt, indem man auf einzelne bunte Bildchen clickt. Wie man ein ankommendes Zeichen ein Ereignis auslösen lässt dürfte das schwierigste sein (bzw ne gescheite Doku dazu zu finden).
Für Timer gibt (oder gab es immer) unsichtbare Objekte wie TTimer, die man einfach auf ne TForm klatscht und einstellt in welchen Zeitabständen er was macht.

Zum Emfang könnte man evtl auch einen Thread niedriger Priorität machen, der nix anderes tut (evtl auch via TTimer) als auf den UART zu lauschen bzw "hängt", bis das nächte Byte da ist. In einer Variablen oder Obj-Member mekt/zählt man dann was angekommen ist und verarbeitet es mit einem andern Fred äh Thread.

@basehit:

Also ich kenn mich mit C-Builder ja nicht so aus aber...

wenn ich Dich richtig verstanden habe dann:
1.Steht deine Kommunikation zwischen PC und uC
2.Du kannst Befehle an den uC senden und damit deinen Kran steuern.

Jetzt musst du nur noch deine "Variable" vom uC an den PC senden und dort in deinem Programm anzeigenlassen.

Dafür würde ich mir ein Protokoll bzw. einen Befehl ausdenken.
Z.Bsp. 'RP0' (ohne Hochkommas) --> Report Position

Du implementierst also im uC dass er wenn er diesen Befehl erhält
den Wert deiner Variable an den PC zurückschickt. Dieses würde ich in
ASCII machen, sozusagen als String oder Array of Char (Byte).

Nun kannst Du das ganze dann in deinem Programm z.Bsp.
in einem Tedit oder Tlabel anzeigen.

Für Fragen spezifisch zu C-Builder würde ich im Netz zu den besagten Seiten mit FAQ's, Tutorials etc. gehen oder bei den Borland Newsgroups vorbeischauen.