C++ DLL (Funktion) nach Delphi

[AJ_Oldendorf]

Zitat:

Mathe? 0xF0 = $F0 oder 240 = 0..239

Das ist mir schon klar, ich meine wie das im Delphi aussieht?
Ist das ein Array welches so aussehen würde?

Delphi-Quellcode:

reserved_b_00 : array[0..239] of Byte; //0xF0 = 240
reserved_b_10 : array[0..763] of Byte; //0x2FC = 764

Wenn das richtig wäre, dann müsste ja folgende Deklaration im C++

reserved_b_00[0x8000] im Delphi so aussehen:
reserved_b_00: array[0..32767] of Byte; //0x8000 = 32768 Verdammt großes array oder?

[Neutral General]

So ist es aber.

[AJ_Oldendorf]

ok danke für die Info, mir war nur eben nicht ganz klar, ob die array Übernahme in Delphi so richtig ist. Danke

[AJ_Oldendorf]

Ich muss leider nochmal etwas nachfragen weil das für mich auch nicht verständlich ist und ihr könnt mir das evtl. erklären.

Deklaration in C++:

Delphi-Quellcode:

typedef struct My_Struct_S
{
 Record1 rec1; 
 Record2 rec2; 
 Record3 rec3; 

} PPC_BYTE_PACKED My_Struct_T;

My_Struct_T volatile *global_pRam = NULL;

In der C-Datei wird "global_pRam" an einer Stelle befüllt und an ganz vielen Stellen abgefragt und beschrieben.

Befüllt:
My_get_pointer(MyHandle, TIMEOUT_ms, &global_pRam, &my_ErrStruct); Deklaration der Funktion "My_get_pointer":

Delphi-Quellcode:

My_DWORD My_get_pointer ( 
  My_DWORD    my_handle,  // in 
  My_DWORD    timeout,  // in 
  My_Struct_T  volatile **data,  // out 
  My_ERROR_T    *err);  // out

In der C-Datei wird von "global_pRam" in einer Schleife eine Variable abgefragt und innerhalb der Schleife wird etwas gesetzt von "global_pRam". Das ist eine While Schleife, die sozusagen einen Status abfragt und innerhalb der Schleife wird durch eine andere Funktion etwas gesetzt, was dann den Status ändern müsste, sodass dieser auch wieder abgefragt werden kann.

Delphi-Quellcode:

while(global_pRam->rec1.state != NewState)
{
/* tue irgendwas...

set_modus(myHandle, NewState,&my_ErrStruct);

  while(global_pRam->rec1.state != my_NewSwMode && TimeoutMs < 5000)
  {
    Sleep(50);
    TimeoutMs +=50;
  }

  if(TimeoutMs >= 5000)
  {
  /* state not changed after ms
  }
  else
  {
  /* state successfully changed */
  TimeoutMs = 0;
  }
}

Meine Umsetzung im Delphi sieht jetzt so aus:

Delphi-Quellcode:

global_pRam: PMy_Struct;

New(global_pRam);
My_get_pointer(MyHandle, 5000, global_pRam, @my_ErrStruct);

Meine konkrete Frage ist nun:
Muss ich das "volatile" irgendwie im Delphi berücksichtigen?
Anscheind muss sich innerhalb dieser while Schleife die Werte hinter dem Pointer ändern, sodass ich überhaupt auf Änderung reagieren kann.
Ist das dann so richtig, dass ich vorher einfach das New aufrufe und dann die Funktion "My_get_pointer"? Ändern sich die Werte dann genauso hinter dem Zeiger, denn die Funktion "My_get_pointer" ist in einer DLL, welche ich aufrufe.
Also müsste sich ja der Inhalt der Variablen hinter dem Zeiger ändern obwohl diese aus einer DLL kommen.

Vielleicht habt ihr da noch ein paar Anregungen.

[AJ_Oldendorf]

Folgende Anmerkung noch aus dem Handbuch für die C-Datei:

Der Funktionsaufruf „my_get_pointer“ liefert die Basisadresse (C-Zeiger) auf die
Struktur My_Struct_T. Mit diesem C-Zeiger kann Ihr Programm
hochperformant auf die Daten im zugreifen.

Also muss das ja ein Zeiger sein, den ich von dem Aufruf zurückgemeldet bekomme und worin sich die Daten anscheind immer ändern können.

[Fritzew]

Zeig mal bitt Deine Delphi Deklaration von

My_get_pointer

Wenn ich das richtig verstehe wird der Pointer in der c dll belegt.

Gibt es auch eine function zur freigabe?

[AJ_Oldendorf]

ja es gibt auch eine Funktion für die Freigabe.
Hier die Deklaration:

function My_get_pointer(Handle: LongWord; TimeOut : LongWord; my_struct: PMy_Struct; aError: PERROR): LongWord;stdcall;external DP_DLL;