Ansprechen einer GigE Kamera (Prosilica GC2450C)

[BoolString]

Ohne pushen zu wollen, aber wie würde man denn dies Konstrukt:

Delphi-Quellcode:

unsigned long PVDECL PvCameraListEx(tPvCameraInfoEx* pList,
                                            unsigned long ListLength,
                                            unsigned long* pConnectedNum,
                                            unsigned long StructSize);

wohl korrekt übersetzen und aufrufen? Ich glaube ich hab nicht wirklich die Essenz der Zeiger. Einer meiner verschiedenen Versuche war:

Delphi-Quellcode:

Function  PvCameraListEx (pList : Array of tPvCameraInfoEx; ListLength : Cardinal; pConnectedNum : Cardinal; Size : Cardinal) : Cardinal; stdcall; external 'PvAPI.dll';


type tlistAVTGigECams  = Array [0..15] of tPvCameraInfoEx;
Var listAVTGigECams  : tlistAVTGigECams;
valNumberOfCams := PvCameraListEx (listAVTGigECams, High (listAVTGigECams), valAvailableCams, SizeOf (tPvCameraInfoEx));

Mal davon abgesehen, daß meine Arrays im obigen Posting noch alle einen zu lang waren...

jan

[Horst0815]

http://forum.delphi-treff.de/showthr...er-f%FCr-C-DLL

[brechi]

Du darfst es nicht als "array of byte" uebersetzen, da dann zwei intern die Laenge+Groesse des Array uebergeben wird, woduch die Parameter nicht mehr mit dem C header uebereinstimmen. Unter der UniversaAPI koennen maximal 64 Kameras angesprochen werden. Also versuchs mal mit:

Delphi-Quellcode:

type
  tPvCameraInfoExList = array[0..63] of tPvCameraInfoEx;
  PPvCameraInfoEx = ^tPvCameraInfoEx;

Function PvCameraListEx (pList : PPvCameraInfoEx; ListLength: Cardinal; pConnectedNum : Cardinal; Size : Cardinal) : Cardinal; stdcall; external 'PvAPI.dll';

Var listAVTGigECams : tPvCameraInfoExList ;
valNumberOfCams := PvCameraListEx (@listAVTGigECams, Length(listAVTGigECams), valAvailableCams, SizeOf (tPvCameraInfoEx));

oder

Delphi-Quellcode:

type
  tPvCameraInfoExList = array of tPvCameraInfoEx;
  PPvCameraInfoEx = ^tPvCameraInfoEx;

Function PvCameraListEx (pList : PPvCameraInfoEx; ListLength: Cardinal; pConnectedNum : Cardinal; Size : Cardinal) : Cardinal; stdcall; external 'PvAPI.dll';

Var listAVTGigECams : tPvCameraInfoExList ;
setLength(listAVTGigECams , 10);
if Length(listAVTGigECams) > 0 then
  valNumberOfCams := PvCameraListEx (@listAVTGigECams[0], Length(listAVTGigECams), valAvailableCams, SizeOf (tPvCameraInfoEx));

[BoolString]

@horst0815: Danke, aber das sind Punkte, die kommen erst noch deutlich später. Wen ich mal bis zu diesem Schritt gekommen bin, werd ich da sicherlich auch Infos rausziehen können...

@brechi: Der Bezugspunkt bezüglich deiner 'Array of Byte' Anmerkung ist nicht ganz klar geworden. Hatte in den bisherigen Postings keine solche Struktur.


Die Funktion PvCameraListEx der DLL kann ich erstmal fehlerfrei anrufen. Allerdings erzeugt der Aufruf :

Delphi-Quellcode:

 tPvInterface =
      (ePvInterfaceFirewire    = 1,       // Firewire interface
       ePvInterfaceEthernet    = 2,       // Ethernet interface
       __ePvInterface_force_32 = $FFFFFFFF
      );


 tPvCameraInfoEx =  Packed Record
                      StructVer       : Cardinal;                // Version of this structure
                      //---- Version 1 ----
                      UniqueId        : Cardinal;              // Unique value for each camera
                      CameraName      : Array [0..31] of Byte; // People-friendly camera name (usually part name)
                      ModelName       : Array [0..31] of Byte; // Name of camera part
                      PartNumber      : Array [0..31] of Byte; // Manufacturer's part number
                      SerialNumber    : Array [0..31] of Byte; // Camera's serial number
                      FirmwareVersion : Array [0..31] of Byte; // Camera's firmware version
                      PermittedAccess : Cardinal;              // A combination of tPvAccessFlags
                      InterfaceId     : Cardinal;              // Unique value for each interface or bus
                      InterfaceType   : tPvInterface;          // Interface type; see tPvInterface
                    end;


  tPvCameraInfoExList = array of tPvCameraInfoEx;
  pPvCameraInfoExList = ^tPvCameraInfoExList;
  tConnectedCams      = Cardinal;
  pConnectedCams      = ^tConnectedCams;



  Function  PvCameraListEx (pList : pPvCameraInfoExList; ListLength : Cardinal; pConnectedNum : pConnectedCams; Size : Cardinal) : Cardinal; stdcall; external 'PvAPI.dll';

auf folgende Weise:

Delphi-Quellcode:

Var listAVTGigECams  : tPvCameraInfoExList;
    valNumberOfCams  : Cardinal;
    valAvailableCams : Cardinal;
    i: Integer;

begin

  SetLength (listAVTGigECams, 1);

  valNumberOfCams := PvCameraListEx (@listAVTGigECams, Length (listAVTGigECams), @valAvailableCams, SizeOf (tPvCameraInfoEx));

  Sleep (100);

  memo1.Lines.Add ('High   value            : ' + IntToStr(High   (listAVTGigECams)));
  memo1.Lines.add ('Number of cams in list  : ' + IntToStr (valNumberOfCams));
  memo1.Lines.add ('Number of cams available: ' + IntToStr (valAvailableCams));

  For i := 00 to valNumberofCams-1 do
  Begin
    Memo1.Lines.Add (IntToStr (listAVTGigECams[i].UniqueID));
    Memo1.Lines.Add (Chr(listAVTGigECams[i].CameraName[0]));
  end;
end;

ein merkwürdiges Verhalten. wenn man das ganze im Debugger beobachtet, dann beinhaltet das Array listAVTGigECams nach SetLength genau einmal den Record. Nachdem die Funktion PvCameraListEx aufgerufen wurde, besitzen die Variablen valNumberOfCams und valAvailableCams die korrekten Werte (eine Kamera) in der Liste der lokalen Variablen des Dubuggers.
Das Array listAVTGigECams besitzt allerdings plötzlich 131072 (0..131071) Elemente, wovon die ersten 365 (0..364) leer sind. Das Element 366 (Index 365) beinhaltet die erwartete Record Struktur; wenn auch mit komplett unherleitbaren Werten. Gleiches gilt für die folgenden Elemente. Element 752-1093 (Index 751-1092) ist wieder leer und so weiter.

Nach dem Aufruf der Funktion PvCameraListEx kann man auch nicht mehr auf die anderen Variablen zugreifen (oben z.B. in den Memo1.lines.Add); hier werden vermutlich Speicherzuweisungen überschrieben.


Ich habe momentan die Vermutung, daß es an der Definition von tPvCameraInfoEx liegt. Das SizeOf zeigt mit 180 den Wert an, den ich erwarten würde. Allerdings ist mir die Indizierungs des Arrays auffällig mit 2*180+5 verknüpft. Es sind 5 Arrays of Byte da drin. Ich hab versucht an diversen Stelen nachzulesen (unter anderem Asserbads DLL Manual) und hab eine Übersetzungsempfehlung für char CameraName[32] mit CameraName : Array [00..31] of Byte gefunden. Ein Char geht nicht mehr, da es unter DelphiXE dem WideChar entspricht; obgleich man dann ja wohl auch AnsiChar verwenden könnte. Die Größe von tPvInterface scheint durch den $FFFFFFFF Wert korrekt auf 4 Byte aliniert zu werden.

Wenn die Kamera abgezogen ist, wird das Array nicht bestückt und man kann auch auf die Variablen valNumberOfCams und valAvailableCams zugreifen.

[...]

[brechi]

Ich meinte auch array of tPvCameraInfoEx; Wenn du dynamische Arrays verwendest und diese als Pointer uebergeben willst musst du immmer @Array[0] uebergeben, niemals @Array, denn vor dem 1. Element sind noch andere Daten gespeichert (Laenge).

Also entweder du verwendest ein statisches Array (dann geh @Array aber auch dort ist @Array[0] erlaubt) oder ein dynamisches mit @Array[0].

Delphi-Quellcode:

tPvInterface =
      (ePvInterfaceFirewire = 1, // Firewire interface
       ePvInterfaceEthernet = 2, // Ethernet interface
       __ePvInterface_force_32 = $FFFFFFFF
      );


 tPvCameraInfoEx = Packed Record
                      StructVer : Cardinal;    // Version of this structure
                      //---- Version 1 ----
                      UniqueId : Cardinal; // Unique value for each camera
                      CameraName : array[0..31] of char; // People-friendly camera name (usually part name)
                      ModelName : array[0..31] of char; // Name of camera part
                      PartNumber : array[0..31] of char; // Manufacturer's part number
                      SerialNumber : array[0..31] of char; // Camera's serial number
                      FirmwareVersion : array[0..31] of char; // Camera's firmware version
                      PermittedAccess : Cardinal; // A combination of tPvAccessFlags
                      InterfaceId : Cardinal; // Unique value for each interface or bus
                      InterfaceType : tPvInterface; // Interface type; see tPvInterface
                    end;


  tPvCameraInfoExList = array of tPvCameraInfoEx;
  tConnectedCams = Cardinal;



  Function PvCameraListEx (pList : pPvCameraInfoExList; ListLength : Cardinal; out pConnectedNum : pConnectedCams; Size : Cardinal) : Cardinal; stdcall; external 'PvAPI.dll'; 


Var listAVTGigECams : tPvCameraInfoExList;
    valNumberOfCams : Cardinal;
    valAvailableCams : Cardinal;
    i: Integer;
begin

  SetLength (listAVTGigECams, 1);

  valNumberOfCams := PvCameraListEx (@listAVTGigECams[0], Length (listAVTGigECams), valAvailableCams, SizeOf (tPvCameraInfoEx));

  Sleep (100);

  memo1.Lines.Add ('High value : ' + IntToStr(High (listAVTGigECams)));
  memo1.Lines.add ('Number of cams in list : ' + IntToStr (valNumberOfCams));
  memo1.Lines.add ('Number of cams available: ' + IntToStr (valAvailableCams));

  For i := 0 to valNumberofCams-1 do
  Begin
    Memo1.Lines.Add (IntToStr (listAVTGigECams[i].UniqueID));
    Memo1.Lines.Add (listAVTGigECams[i].CameraName));
  end;
end;

[BoolString]

Theoretisch hätte mir das wohl klar sein sollen; aber praktisch...

Ich hab zumindest über das Wocheende ein wenig weiter dran gearbeitet und komme inzwischen auch an diverse Attribute der Kamera heran.

Ich kann die Kamera inzwischen auch sauber öffnen. Allerdings bekomme ich dabei den PermittedAccess Status 6 zurückgeliefert. Laut SDK Unterlagen sollen aber nur die Statuswerte 2 und 4 (und nicht deren addierte Bitsumme) valide sein. Was könnte das denn wohl bedeuten?

Ich glaube, daß ich schon ein großes Stück weiter bin. Habe mir aus diversen C-Samples jetzt etwas zusammengebastelt. Das muss alles noch in einzelne Procs/Funcs ausgelagert werden, aber für eine Version zum Debuggen ist es ganz praktisch. Derzeit hängt es aber an der Struktur des pFrame (?). Ich versuche das so ähnlich zu machen wie in den C-Samples und im Quellcode, den horst0815 gepostet hat. aber hier stimt irgendwas noch nicht. Ich komme derzeit an kein Bild. Der PvCaptureQueueFrame wirft eine Exception, die ich nicht richtig verfolgt bekomme.

Ich habe derzeit die Header-Datei folgendermassen übersetzt (Ausschnitte):

Delphi-Quellcode:

  tPvImageFormat =
      (ePvFmtMono8         = 0,            // Monochrome, 8 bits
        ePvFmtMono16        = 1,            // Monochrome, 16 bits, data is LSB aligned
        ePvFmtBayer8        = 2,            // Bayer-color, 8 bits
        ePvFmtBayer16       = 3,            // Bayer-color, 16 bits, data is LSB aligned
        ePvFmtRgb24         = 4,            // RGB, 8 bits x 3
        ePvFmtRgb48         = 5,            // RGB, 16 bits x 3, data is LSB aligned
        ePvFmtYuv411        = 6,            // YUV 411
        ePvFmtYuv422        = 7,            // YUV 422
        ePvFmtYuv444        = 8,            // YUV 444
        ePvFmtBgr24         = 9,            // BGR, 8 bits x 3
        ePvFmtRgba32        = 10,           // RGBA, 8 bits x 4
        ePvFmtBgra32        = 11,           // BGRA, 8 bits x 4
        ePvFmtMono12Packed  = 12,           // Monochrome, 12 bits,
        ePvFmtBayer12Packed = 13,           // Bayer-color, 12 bits, packed
        __ePvFmt_force_32   = $FFFFFFFF
       );


//
// Bayer pattern.  Applicable when a Bayer-color camera is sending raw bayer
// data.
//
  tPvBayerPattern =
      (ePvBayerRGGB        = 0,            // First line RGRG, second line GBGB...
       ePvBayerGBRG        = 1,            // First line GBGB, second line RGRG...
        ePvBayerGRBG        = 2,            // First line GRGR, second line BGBG...
       ePvBayerBGGR        = 3,            // First line BGBG, second line GRGR...
       __ePvBayer_force_32 = $FFFFFFFF
       );


  tPvFrame = Packed Record
               //----- In -----
                ImageBuffer          : Pointer;                  // Buffer for image/pixel data.
               ImageBufferSize      : Cardinal;                 // Size of ImageBuffer in bytes
               AncillaryBuffer      : Pointer;                  // Camera Firmware >= 1.42 Only.
                                                                              // Buffer to capture ancillary chunk mode data. See ChunkModeActive attr.
                                                                   // This MUST be 0 if not in use.
                                                                              // Chunk mode format:
                                                                              //   [Bytes 1 - 4]   acquisition count.
                                                                              //   [Bytes 5 - 8]   user value. Not currently implemented. 0.
                                                                              //     [Bytes 9 - 12]  exposure value.
                                                                   //     [Bytes 13 - 16] gain value.
                                                                              //     [Bytes 17 - 18] sync in levels.
                                                                   //     [Bytes 19 - 20] sync out levels.
                                                                              //     [Bytes 21 - 40] not implemented. 0.
                                                                   //     [Bytes 41 - 44] chunk ID. 1000.
                                                                              //     [Bytes 45 - 48] chunk length.
                AncillaryBufferSize  : Cardinal;                 // Size of your ancillary buffer in bytes. See NonImagePayloadSize attr.
                                                                   //   Set to 0 for no buffer.
               Context              : Array [0..3] of Pointer;  // For your use. Possible application: unique ID
                                                                              //   of tPvFrame for frame-done callback.
               _reserved1           : Array [0..7] of Cardinal;
                //----- Out -----
               Status               : tPvErr;                   // Status of this frame
                ImageSize            : Cardinal;                 // Image size, in bytes
               AncillarySize        : Cardinal;                 // Ancillary data size, in bytes
               Width                : Cardinal;                 // Image width
               Height               : Cardinal;                 // Image height
                RegionX              : Cardinal;                 // Start of readout region (left)
                RegionY              : Cardinal;                 // Start of readout region (top)
                Format               : tPvImageFormat;           // Image format
               BitDepth             : Cardinal;                 // Number of significant bits
                BayerPattern         : tPvBayerPattern;          // Bayer pattern, if bayer format
                FrameCount           : Cardinal;                 // Frame counter. Uses 16bit GigEVision BlockID. Rolls at 65535.
                TimestampLo          : Cardinal;                 // Time stamp, lower 32-bits
                TimestampHi          : Cardinal;                 // Time stamp, upper 32-bits
               _reserved2           : Array [0..31] of Cardinal;
             end;



  tPvCameraInfoExList = array of tPvCameraInfoEx;
  pPvCameraInfoExList = ^tPvCameraInfoExList;
  tConnectedCams      = Cardinal;
  pConnectedCams      = ^tConnectedCams;
  pPvFrame            = ^tPvFrame;


Const PVINFINITE      = $FFFFFFFF;  // Never timeout


//-------------------------------------------------------------------------------------
// define DLL-calls:
    Function  PvAttrEnumSet             (pCamera: tPvHandle; Name: PAnsiChar; Value: PAnsiChar): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvAttrUint32Get           (pCamera: tPvHandle; Name: PAnsiChar; Out pValue: Cardinal) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCameraListEx            (pList: pPvCameraInfoExList; ListLength : Cardinal; Out ConnectedNum : tConnectedCams; Size : Cardinal) : Cardinal; stdcall; external 'PvAPI.dll';
    Function  PvCameraClose             (pCamera: tPvHandle) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCameraOpen              (UniqueID: Cardinal; AccessFlag: tPvAccessFlags; Out pCamera: tPvHandle) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCaptureStart            (pCamera: tPvHandle) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCaptureQueueFrame       (pCamera: tPvHandle; pFrame: pPvFrame; FrameCallBack: Pointer ): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCaptureWaitForFrameDone (pCamera: tPvHandle; pFrame: pPvFrame; Timeout: Cardinal): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCommandRun              (pCamera: tPvHandle; Name : PAnsiChar): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvInitialize              : tPvErr;        stdcall; external 'PvAPI.dll';
    Function  PvInitializeNoDiscovery   : tPvErr;        stdcall; external 'PvAPI.dll';
    Procedure PvUnInitialize;                            stdcall; external 'PvAPI.dll';
    Procedure PvVersion                 (Var Major, Minor: Cardinal); stdcall; external 'PvAPI.dll';

Auf der anderen seite steckt erst einmal alles in einem ButtonClick:

Delphi-Quellcode:

procedure TForm1.Button6Click(Sender: TObject);
Var aFrame       : tPvFrame;
    aFrameBuffer : Array of Byte;
    aBitMap      : tBitmap;
    aErrValue    : tPvErr;

Begin
  aErrValue := PvAttrUint32Get (CamHandle, 'TotalBytesPerFrame', aFrame.ImageBufferSize);
  If aErrValue = ePvErrSuccess then
  Begin
    SetLength (aFrameBuffer, aFrame.ImageBufferSize);
    aFrame.ImageBuffer := @aFrameBuffer[0];
  end
  Else
  Begin
    Exit;
  end;

  aErrValue := PvCaptureStart (CamHandle);
  If aErrValue = ePvErrSuccess THen
  Begin

    aErrValue := PvAttrEnumSet (CamHandle, 'FrameStartTriggerMode', 'Freerun');
    If aErrValue = ePvErrSuccess Then
    Begin

      aErrValue := PvCommandRun (CamHandle, 'AcquisitionStart');
      If aErrValue = ePvErrSuccess Then
      Begin

        aErrValue := PvCaptureQueueFrame (CamHandle, @aFrame, 0) ;
        If aErrValue = ePvErrSuccess Then
        Begin

          aErrValue := PvCaptureWaitForFrameDone (CamHandle, @aFrame, PVINFINITE);
          If aErrValue = ePvErrSuccess Then
          Begin
//            CreateDIBitmap (@aBitmap,...?????)
            Beep;Beep;Beep;
          end;

        end;
      end;

    end;


  end;
end;

Soweit ich es der SDK-Doku entnehme sollte so eine Aufrufreihenfolge zum Erfolg führen. Aber momentan ist dem noch nicht so...

Jan

PS: Was sind denn wohl erfahrungsgemäß gute Werte für ein TimeOut der Kamera im Debugmodus?

[BoolString]

Update...

ich bin inzwischen so weit, daß ich ein einzelnes Frame (theoretisch) per DLL einfangen kann. Hier scheint im Debug der Timeout ein Problem gewesen zu sein und schlechte Lötstellen von einem nicht spezifiziertes Unterwasser-Kabel. Nachdem ich diese erstmal ausgetauscht habe, habe ich auch keine 'Camera was unplugged' mehr.

Das Kommando PvCaptureWaitForFrameDone liefert nun ein Success zurück. Leider hat der entsprechend zurückgelieferte Frame keine Daten und das Status sagt, daß einige Daten verloren gingen (Error Code 16). Das ist charmant untertrieben, da Image Size 0 besagt. Die anderen Werte (die mir logisch nachvollziehbar erscheinen, wie FrameCount, FrameWidth, und FrameHeight) scheinen korrekt zu sein. Mit der BitDepth von 8 bin ich mir nicht sicher; das ist doch garantiert nicht pro RGB Kanal gemeint? Auch ist mir noch nicht ganz klar, wie ich die Daten aus dem Pointer mit den anderen Infos zu einem korrekten Bitmap zusammenstelle, welches ich dann speichern und darstellen kann.

Ich versuche es in der DLL Anbindung jetzt so:

Delphi-Quellcode:

    Function  PvAttrBooleanGet          (pCamera: tPvHandle; Name: PAnsiChar; Out pValue: Boolean) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvAttrBooleanSet          (pCamera: tPvHandle; Name: PAnsiChar; pValue: Boolean) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvAttrEnumGet             (pCamera: tPvHandle; Name: PAnsiChar; Out pBuffer : PAnsiChar; BufferSize: Cardinal; Out pSize: Cardinal): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvAttrEnumSet             (pCamera: tPvHandle; Name: PAnsiChar; Value: PAnsiChar): tPvErr; stdcall; external 'PvAPI.dll';
//geht noch nicht://    Function  PvAttrUint32Get           (pCamera: tPvHandle; Name: PAnsiChar; Out pValue: Cardinal) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCameraListEx            (pList: pPvCameraInfoExList; ListLength : Cardinal; Out ConnectedNum : tConnectedCams; Size : Cardinal) : Cardinal; stdcall; external 'PvAPI.dll';
    Function  PvCameraClose             (pCamera: tPvHandle) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCameraCount             : Cardinal; stdcall; external 'PvAPI.dll';
    Function  PvCameraOpen              (UniqueID: Cardinal; AccessFlag: tPvAccessFlags; Out pCamera: tPvHandle) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCaptureEnd              (pCamera: tPvHandle) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCaptureStart            (pCamera: tPvHandle) : tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCaptureQueueFrame       (pCamera: tPvHandle; pFrame: pPvFrame; FrameCallBack: Pointer ): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCaptureWaitForFrameDone (pCamera: tPvHandle; pFrame: pPvFrame; Timeout: Cardinal): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvCommandRun              (pCamera: tPvHandle; Name : PAnsiChar): tPvErr; stdcall; external 'PvAPI.dll';
    Function  PvInitialize              : tPvErr;        stdcall; external 'PvAPI.dll';
    Function  PvInitializeNoDiscovery   : tPvErr;        stdcall; external 'PvAPI.dll';
    Procedure PvUnInitialize;                            stdcall; external 'PvAPI.dll';
    Procedure PvVersion                 (Var Major, Minor: Cardinal); stdcall; external 'PvAPI.dll';

implementation


Function PvReturnErrorString (aErrCode: tPvErr) : String;
Begin
  Case aErrCode of
     ePvErrSuccess        : Result := 'Code 0000: No error';
     ePvErrCameraFault    : Result := 'Code 0001: Unexpected camera fault';
     ePvErrInternalFault  : Result := 'Code 0002: Unexpected fault in PvApi or driver';
     ePvErrBadHandle      : Result := 'Code 0003: Camera handle is invalid';
     ePvErrBadParameter   : Result := 'Code 0004: Bad parameter to API call';
     ePvErrBadSequence    : Result := 'Code 0005: Sequence of API calls is incorrect';
     ePvErrNotFound       : Result := 'Code 0006: Camera or attribute not found';
     ePvErrAccessDenied   : Result := 'Code 0007: Camera cannot be opened in the specified mode';
     ePvErrUnplugged      : Result := 'Code 0008: Camera was unplugged';
     ePvErrInvalidSetup   : Result := 'Code 0009: Setup is invalid (an attribute is invalid)';
     ePvErrResources      : Result := 'Code 0010: System/network resources or memory not available';
     ePvErrBandwidth      : Result := 'Code 0011: 1394 bandwidth not available';
     ePvErrQueueFull      : Result := 'Code 0012: Too many frames on queue';
     ePvErrBufferTooSmall : Result := 'Code 0013: Frame buffer is too small';
     ePvErrCancelled      : Result := 'Code 0014: Frame cancelled by user';
     ePvErrDataLost       : Result := 'Code 0015: The data for the frame was lost';
     ePvErrDataMissing    : Result := 'Code 0016: Some data in the frame is missing';
     ePvErrTimeout        : Result := 'Code 0017: Timeout during wait';
     ePvErrOutOfRange     : Result := 'Code 0018: Attribute value is out of the expected range';
     ePvErrWrongType      : Result := 'Code 0019: Attribute is not this type (wrong access function)';
     ePvErrForbidden      : Result := 'Code 0020: Attribute write forbidden at this time';
     ePvErrUnavailable    : Result := 'Code 0021: Attribute is not available at this time';
     ePvErrFirewall       : Result := 'Code 0022: A firewall is blocking the traffic (Windows only)';
     __ePvErr_force_32    : Result := 'Code $FFFFFFFF: Codon forcing Error codes to be 32bit';
  end;
end;

Und im eigentlichen Programm rufe ich die Funktionen wie nachfolgend auf. Es ist vorläufig eine Testversion, die auf jeden Fall dringender Überarbeitung bedarf. Wenn das ganze mal Bilder liefert denke ich, daß die komplette Unit mit Beispiel hier Veröffentlichung finden sollte. Dafür das in der FeatureMatrix des Herstellers die Delphi-Option gelistet ist, finde ich die reale Umsetzung für ein SDK doch etwas unumgänglich:

Delphi-Quellcode:

procedure TForm1.Button6Click(Sender: TObject);
Var aFrame       : tPvFrame;
    aFrameBuffer : Array of Byte;
    aBitMap      : tBitmap;
    aErrValue    : tPvErr;
    aString      : PAnsiChar;
    aValue       : Cardinal;
    bmp_BMI      : BITMAPINFO;
    bmp_Bitmap   : tBitmap;

Begin
  aErrValue := PvAttrUint32Get (CamHandle, 'TotalBytesPerFrame', aFrame.ImageBufferSize);
  If aErrValue = ePvErrSuccess then
  Begin
    SetLength (aFrameBuffer, aFrame.ImageBufferSize);
    aFrame.ImageBuffer := @aFrameBuffer[0];
  end
  Else
  Begin
    Exit;
  end;

  aErrValue := PvCaptureStart (CamHandle);
  If aErrValue = ePvErrSuccess THen
  Begin

    aErrValue := PvAttrEnumSet (CamHandle, 'FrameStartTriggerMode', 'Freerun');
    Memo1.Lines.Add ('Set FrameStartTriggerMode   : ' + PvReturnErrorString (aErrValue));

    If aErrValue = ePvErrSuccess Then
    Begin
//      SetLength (aString, 20);
      aErrValue := PvAttrEnumGet (CamHandle, 'FrameStartTriggerMode', aString, SizeOf (aString[0]), aValue);
      Memo1.Lines.Add ('Get FrameStartTriggerMode   : ' + PvReturnErrorString (aErrValue)+ ' ; String:' + aString + ';(' + IntToStr (aValue) + ')');


      aErrValue := PvCommandRun (CamHandle, 'AcquisitionStart');
      Memo1.Lines.Add ('CommandRun AcquisitionStart : ' + PvReturnErrorString  (aErrValue));

      If aErrValue = ePvErrSuccess Then
      Begin

        aErrValue := PvCaptureQueueFrame (CamHandle, @aFrame, 0) ;
        Memo1.Lines.Add ('CaptureQueueFrame           : ' + PvReturnErrorString (aErrValue));

        If aErrValue = ePvErrSuccess Then
        Begin

          aErrValue := PvCaptureWaitForFrameDone (CamHandle, @aFrame, PVINFINITE);
          Memo1.Lines.Add ('Capture Wait For Frame Done : ' + PvReturnErrorString  (aErrValue));

          If aErrValue = ePvErrSuccess Then
          Begin
            Memo1.Lines.Add ('Frame count                 : ' + IntToStr (aFrame.FrameCount));
            Memo1.Lines.Add ('Bit depth                   : ' + IntToStr (aFrame.BitDepth));
            Memo1.Lines.Add ('Frame width                 : ' + IntToStr (aFrame.Width));
            Memo1.Lines.Add ('Frame height                : ' + IntToStr (aFrame.Height));
            Memo1.Lines.Add ('Image size                  : ' + IntToStr (aFrame.ImageSize));
            Memo1.Lines.Add ('Frame status                : ' + PvReturnErrorString (aFrame.Status));


            bmp_BMI.bmiHeader.biSize          := SizeOf (bmp_BMI.bmiHeader);
            bmp_BMI.bmiHeader.biWidth         := aFrame.Width;
            bmp_BMI.bmiHeader.biHeight        := aFrame.Height;
            bmp_BMI.bmiHeader.biPlanes        := 1;
            bmp_BMI.bmiHeader.biBitCount      := aFrame.BitDepth;
            bmp_BMI.bmiHeader.biCompression   := BI_RGB;
            bmp_BMI.bmiHeader.biSizeImage     := 0;
            bmp_BMI.bmiHeader.biXPelsPerMeter := 0;
            bmp_BMI.bmiHeader.biYPelsPerMeter := 0;
            bmp_BMI.bmiHeader.biClrUsed       := 0;
            bmp_BMI.bmiHeader.biClrImportant  := 0;


//            CreateDIBitmap (@aBitmap,...?????)
//createDIBSection

//            image1.Picture.Bitmap.Handle
          end;

          aErrValue := PvCaptureEnd (CamHandle);
          Memo1.Lines.Add ('Capture end                 : ' + PvReturnErrorString (aErrValue));

        end;
      end;
    end;
  end;
end;

Liebe Grüße aus dem Norden

Jan

[brechi]

Du solltest den Buffer mal clearen.

Delphi-Quellcode:

ZeroMemory(@aFrame, SizeOf(aFrame);
aErrValue := PvAttrUint32Get (CamHandle, 'TotalBytesPerFrame', totalbytes);
  If aErrValue = ePvErrSuccess then
  Begin
    SetLength (aFrameBuffer, totalbytes);
    aFrame.ImageBufferSize := totalbytes;
    aFrame.ImageBuffer := @aFrameBuffer[0];
  end;

Den Mode kann man vorher einstellen (8bit gray, 16bitgray, rgb, etc.).

Du musst dir dann ein Bitmap erstellen und die Pixel z.B. mit SetBitmapBits setzen. Als alternative zum Testen gehts auch erstmal mit nem Bitmap und Scanline.