hab schon mal was wegen labview gepostet, aber mittlerweile ein anderes problem.

ich habe eine DLL geschrieben kurz gesagt folgendes macht (bzw. machen sollte).

1. eine dll laden
2. eine funktion aus dieser mit einer callbackfunktion aufrufen
3. immer wenn die callbackfunktion genutzt wird (wenn ein drahtlosmodul das sendet sollte es so sein) sollen die daten als event an labview geschickt werden.

so schauts aus:

// ant_sendevent.cpp : Definiert die exportierten Funktionen für die DLL-Anwendung.
//

#include "stdafx.h"
#include "stdio.h"
#include "ant_sendevent.h"
#include "extcode.h" //labview inlcude
#include <cstdlib>

#define STRING_LENGHT 256	

//definitonen für ANT_Load und UnLoad
static HMODULE hANTdll;
static BOOL bLoaded = FALSE;
UCHAR aucResponseBuffer[MESG_DATA_SIZE];
UCHAR aucChannelEventBuffer[MESG_DATA_SIZE];
char myresponsebuffer[64];
char myeventbuffer[64];
LStrHandle responseStringHandle;
LStrHandle eventStringHandle;
UCHAR ucChannel_;
LVUserEventRef antResponse;
LVUserEventRef antEvent;

//Functionen der ANT DLL
P_ANT_ARF         ANT_AssignResponseFunction;
P_ANT_AEF         ANT_AssignChannelEventFunction;

// DLL Laden.
///////////////////////////////////////////////////////////////////////
ANT_SENDEVENT_API BOOL ANT_Load(void)
{
   if (bLoaded)
      return TRUE;

   hANTdll = LoadLibraryA("ANT_DLL.dll");
   if (hANTdll == NULL)
      return FALSE;

   ANT_AssignResponseFunction = (P_ANT_ARF) GetProcAddress(hANTdll, "ANT_AssignResponseFunction");
   ANT_AssignChannelEventFunction = (P_ANT_AEF) GetProcAddress(hANTdll, "ANT_AssignChannelEventFunction");

   if (ANT_AssignResponseFunction == NULL)
      return FALSE;
   if (ANT_AssignChannelEventFunction == NULL)
      return FALSE;

   bLoaded = TRUE;
   return TRUE;
}

// DLL freigeben
///////////////////////////////////////////////////////////////////////
ANT_SENDEVENT_API BOOL ANT_UnLoad(void)
{
   if (hANTdll != NULL)
   {
      FreeLibrary(hANTdll);

   }
   bLoaded = FALSE;
   return FALSE;
}

// Diese Funktion soll er bei einem ChannelEvent nutzen: Den Bufferinhalt 
// in myeventbuffer kopieren und mittels der Funktion SendEvent, den Event
// an Labview weitergeben - unabhänging von der Event (ucEvent) Art - wird dann
// in Labview gemanaged.
///////////////////////////////////////////////////////////////////////
BOOL ANT_ChannelEventFunction(UCHAR ucChannel, UCHAR ucEvent)
{

	strcpy((char*)myeventbuffer,(char*)aucChannelEventBuffer);
	SendEvent(&antEvent);
	return TRUE;

}

// Diese Funktion soll zum Antworten nutzen: Den Bufferinhalt 
// in myresponsebuffer kopieren und mittels der Funktion SendResponse, den Event
// an Labview weitergeben.
BOOL ANT_ResponseFunction(UCHAR ucChannel, UCHAR ucResponseMesgID)
{
	//Speichergröße für myeventbuffer an aucChannelEventBuffer anpassen
	//myresponsebuffer=(char*)malloc(strlen((char*)aucResponseBuffer)+1);
	strcpy((char*)myresponsebuffer,(char*)aucResponseBuffer);
	SendResponse(&antResponse);
	return TRUE;
}
// Die Funktion ruft die Funktionen aus der ANT Dll auf und führt sie mit meinen Buffern 
// und den Callbackfunktionen aus
ANT_SENDEVENT_API BOOL functioncaller(UCHAR ucChannel_)
{
    if(ANT_AssignResponseFunction != NULL  && ANT_AssignChannelEventFunction != NULL)
	{
		ANT_AssignResponseFunction(&ANT_ResponseFunction, aucResponseBuffer);
		ANT_AssignChannelEventFunction(1, &ANT_ChannelEventFunction, aucChannelEventBuffer);
		return TRUE;

	}
		return FALSE;
}
// Benachrichtigt LabView über den Event und gibt den Inhalt von myeventbuffer weiter (wird in Labview gepoolt)
ANT_SENDEVENT_API void SendEvent(LVUserEventRef *antEvent)
{

	//Allocate memory for a LabVIEW string handle using LabVIEW's
	//memory manager functions.
	eventStringHandle=(LStrHandle)DSNewHandle(sizeof(int32)+STRING_LENGHT*sizeof(uChar));

	PopulateStringHandle(eventStringHandle,(char*)&myeventbuffer);

	PostLVUserEvent(*antEvent,(char *)&eventStringHandle);
	return;
}

// Benachrichtigt LabView über den Response und gibt den Inhalt von myresponsebuffer weiter (wird in Labview gepoolt)
ANT_SENDEVENT_API void SendResponse(LVUserEventRef *antResponse)
{
		//Allocate memory for a LabVIEW string handle using LabVIEW's
	//memory manager functions.
	responseStringHandle=(LStrHandle)DSNewHandle(sizeof(int32)+STRING_LENGHT*sizeof(uChar));

	PopulateStringHandle(responseStringHandle,(char*)&myresponsebuffer);

	PostLVUserEvent(*antResponse,(char*)&responseStringHandle);
	return;
}
void PopulateStringHandle(LStrHandle lvStringHandle,char* stringData)
{
	//Empties the buffer
	memset(LStrBuf(*lvStringHandle),'\0',STRING_LENGHT);

	//Fills the string buffer with stringData
	sprintf((char*)LStrBuf(*lvStringHandle),"%s",stringData);

	//Informs the LabVIEW string handle about the size of the size
	LStrLen(*lvStringHandle)=strlen(stringData);

	return;
}

mein problem ist nun fogendes: das erste mal, wenn ich mein labview vi mit der dll aufrufe passiert nix, beim zweiten mal wird einmal ein event ausgelöst und die richtigen daten nur einmal geschickt.

ich gehe mal davon aus, dass die callbackfunktion nur einmal - bei functioncaller aufruf genutzt wird... aber wieso sonst nicht? ich habe mir gedacht, dass die einmal aufgerufene funktion sowieso im speicher bleibt - oder muss ich dass irgendwie in eine schleife packen?

danke für die hilfe
martin

So könntest Du feststellen obs am LabView <> Deine Wrapper DLL Teil liegt, oder am Deine Wrapper DLL <> Unterliegende DLL Teil liegt.

Edit:
Bzw. könntest Du auch jedesmal etwas auf den Debug Output (schreiben mit OutputDebgString(..) und dem DebugView von Sysinternals anschaubar) wenn der Callback ausgeführt wird (in deiner Wrapper DLL). So stellst Du fest, ob wirklich alle Callbacks in deiner Wrapper DLL ankommen.

Simon