Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » DLL und serielle Schnittstelle
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ] [ 3 ]
000
08.08.2007, 17:27 Uhr
~Petra4
Gast


Hi

Bastle zurzeit an einer DLL, in der ich verschiedene Funktionen für die serielle Schnittstelle für meine Anwendungen bereitstelle.

Das schreiben und auch das lesen funktioniert im Prinzip. Aber da es sich um eine DLL handelt, weiss ich nicht, wie ich Daten lesen kann ohne einen Funktionsaufruf von der Anwendung aus zu machen. Die DLL sollte selber die Daten von der Seriellen Schnittstelle lesen und sie dan bereitstellen können.

Kann mir jemand sagen wie man da vorgehen muss?
Gibt es einen Interrupt, die die DLL veranlassen kann die Daten zu lesen oder eventuell mit Timer?

Gruss
Petra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
08.08.2007, 18:04 Uhr
Guybrush Threepwood
Gefürchteter Pirat
(Operator)


Eine DLL kann selber nicht ausgeführt werden oder irgendetwas machen. Sie muss immer von einem anderen Programm geladen werden das diese dann nutzt bzw. kannst du ja was in der DllMain unterbringen was dann direkt beim laden der DLL ausgeführt wird wenn du keine Funktion brauchst.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
09.08.2007, 08:32 Uhr
~Petra4
Gast


Die DLL wird schon von einem anderen Programm geladen und benützt.
Meine Applikation lädt die DLL und benutzt die bereitgestellten Funktionen um Daten über die serielle Schnittstelle zu senden. Dabei verpackt die DLL die Daten in ein definiertes Protokoll. Was alles noch kein Problem darstellt.

Wenn nur die andere Seite (uP) Daten sendet liegen die ja im Empfangs-Buffer der seriellen Schnittstelle. Meine DLL sollte nun die Daten danach lesen können und die Nutzdaten der Applikation bereitstellen können.

Aber wie stelle ich es an, dass die DLL die Daten liest (also die Funktion ReadFile aufruft)?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
09.08.2007, 08:45 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


naja du hast 2 Möglichkeiten:

1. Möglichkeit: Du startest in DllMain einen WorkerThread - der auf anliegende Daten prüft und ggf die Anwendung über ein Callback benachrichtigt.
Vorsicht: Du musst dann natürlich alle Lese/Schreibzugriffe serialisieren, damit du nicht versehentlich echt parallel was am I/O machst bzw am gleichen Puffer machst.

2. Möglichkeit: Du "pollst" von deiner Anwendung aus. Da gibts natürlich auch wieder die Möglichkeit per Thread, mit den gleichen Synchronisierungsproblemen - oder wenns eine Windows-Anwendung ist evtl über einen Window-Timer, da sparste dir dann die Synchronisierung, weil der nicht parallel ausgeführt wird.

Die Erste Möglichkeit ist meiner Meinung nach die sinnvollere (weil du dann dem User relativ einfach eine nichtblockierende Schnittstelle anbieten kannst) birgt aber Risiken bzgl Parallelität.
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
09.08.2007, 09:39 Uhr
~Petra4
Gast


@FloSoft und Guybrush Threepwood: Danke für die schnellen Antworten

Die 2. Möglichkeit gefällt mir nicht so. Möchte das nicht dem User übergeben.

Die 1. Möglichkeit hört sich interessant an. Habe aber keine Ahnung wie das mit WorkerThread aussieht. Muss mich da mal schlau machen.. oder hat jemand gerade ein Beispiel?

Warum Soll es Probleme mit Parallelität geben? Ist der Lese- und der Schreibbuffer der Seriellen Schnittstelle nicht getrennt?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
09.08.2007, 10:13 Uhr
Guybrush Threepwood
Gefürchteter Pirat
(Operator)


Also ich würde Möglichkeit 1 in gar keinem Fall anwenden.
Das bedeutet das sobald die Dll geladen wird automatisch ohne weiteres zutun ein Thread anläuft der die Schnittstelle blockiert. Das ist absolut schlechtes Design, selbst wenn man von statischem Linken absähe.

Die einzige Vernünftige Möglichkeit ist eine Mischung aus Punkt 1 und 2
Du stellst in der Dll eine Funktion zur Verfügung welche neben den anderen benötigten Daten eine Callback Methode von dir erhält und dann einen Thread startet (ohner auf eventuell Asynchrone APIs zurückgreift) und dann mit den gewonnenen Daten deine Callback Methode aufruft.
Damit ist das ganze sehr übersichtlich und es ist sichergestellt das nicht jemand "aus versehen" einen Threadstartet der die Schnittstelle blockiert oder zumindest andauernd unnötig abfragt.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
09.08.2007, 10:37 Uhr
~Petra4
Gast


Meine DLL enthält eine Init-Funktion die von der Applikation aus aufgerufen werden muss. In dieser Funktion würde ich dann den Thread starten. Werden Daten empfangen wird eine PostMessage ausgelöst (PostMessage funktioniert bereits) und die Applikation kann die Werte abfragen.

@Guybrush Threepwood: Meinst du das?

Aber wie Funktioniert das mit dem Thread? Läuft das Parallel zur DLL, so dass sie nicht blockiert wird? Kenne mich auf dem gebiet gar nicht aus. :-(
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
09.08.2007, 10:52 Uhr
Guybrush Threepwood
Gefürchteter Pirat
(Operator)



Zitat von ~Petra4:
Meine DLL enthält eine Init-Funktion die von der Applikation aus aufgerufen werden muss. In dieser Funktion würde ich dann den Thread starten. Werden Daten empfangen wird eine PostMessage ausgelöst (PostMessage funktioniert bereits) und die Applikation kann die Werte abfragen.

@Guybrush Threepwood: Meinst du das?

Ja so kannst du das machen und mit dem PostMessage ist auch erstmal ok wenn du keine Callback Methode verwenden möchtest.

Zitat von ~Petra4:

Aber wie Funktioniert das mit dem Thread? Läuft das Parallel zur DLL, so dass sie nicht blockiert wird?

Ein Thread läuft immer parallel (bzw. Pseudoparallel wenn du nur einen Prozessorkern hast weil der dann ja nur eine Sache gleichzeitig machen kann).
Wenn du eine neue Anwendung startest wird für diese ein Thread erstellt der einfach gesagtdie ganzen Befehle abarbeitet. Dieser erste Thread heiß Prozess. Wenn du jetzt unter einem Multitaskingfähigem Betriebssystem (wie Windows) eine zweite Anwendung startest wird für diese auch ein eigener Prozess erstellt und der CPU springt immer zwischen diesen beiden hin- und her und arbeitet die ab so dass es für dich al Benutzer aussieht als würden die gleichzeitig laufen.
Wenn du jetzt in einem Prozess eine Funktion aus einer DLL aufrufst dann wird diese ganz normal von deinem Prozess ausgeführt. Das heißt wenn die Funktion blockiert weil sie auf etwas wartet dann ist auch dein Prozess blockiert, es macht also keinen Unterschied woher die Funktion kommt.
Wenn du aber jetzt in deinem Prozess einen 2. Thread erzeugst dann kann dieser wieder (Pseudo)Parallel zu deinem Prozess arbeiten das heißt wenn in dem Thread auf irgendetwas gewartet wird dann läuft der Prozess trotzdem normal weiter, dabei ist es dann auch wieder egal ob der Thread jetzt auf eine Funktion aus einer DLL oder sonst was wartet.
Dieser Post wurde am 09.08.2007 um 10:53 Uhr von Guybrush Threepwood editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
09.08.2007, 11:14 Uhr
~Petra4
Gast


@Guybrush Threepwood: Vielen herzlichen Dank für deine Erklärung.

Also muss ich jetzt einen Thread vorbereiten (deklarieren/initialisieren), den ich dann im Init starten kann. Der Thread hat dann eine Funktion die andauernd die serielle Schnittstelle abfragt und die Daten dann bereitstellt. -> So in etwa?

Hat jemand ein Beispiel wie man so einen Thread aufbaut?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
09.08.2007, 11:33 Uhr
Blubber2063



 Also vielleicht hab ich ja hier was verpasst, aber soweit ich mich erinnere kann man serielle Schnittstellen dazu veranlassen per Interrupt zu melden das neue Daten vorliegen, was Windows auch bestimmt zum Buffern nutzt und es würde mich schwer wundern wenn es da nicht eine synchrone Funktion zum lesen auf dem Puffer gibt. Dann doch ein schöner Thread in der Anwendung der hier die Funktion aufruft und die Daten sammelt, ein Thread der beim Start einer DLL anläuft ist ja wohl ganz hässlich.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ] [ 3 ]     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: