Unit für LibUSB?

[MmVisual]

Hallo,

Ich würde gerne die LinUSB verwenden:
http://sourceforge.net/projects/libusb- ... =directory

Mit im ZIP sind .h Dateien für die Einbindung in ein Projekt.
Weiß jemand von wo ich die aktuelle Unit für Lazarus laden kann?
Ich habe einiges im Netz gefunden, aber alle schon sehr alt.

Grüße Markus.

[carli]

Schreib sie dir doch.

Ich übersetze auch .h-Header nach Pascal. (z.B. Zip oder die Netzwerklib Enet)

[theo]

Weiß jemand von wo ich die aktuelle Unit für Lazarus laden kann?

Mit FPC kommt ein Tool namens "h2pas", das generiert die Interface Unit, aber man muss meistens noch von Hand feilen.
Es erspart einem aber viel Arbeit und zeigt ein gewisses "HowTo"
Hier mal der generierte Code für "libusb-win32-bin-1.2.6.0". Ungetestet, kompiilert wahrsch. nicht.

Code: Alles auswählen

{$mode objfpc}
unit lusb0_usb;
interface
 
{
  Automatically converted by H2Pas 1.0.0 from lusb0_usb.h
  The following command line parameters were used:
    -d
    -P
    -w
    lusb0_usb
}
 
    const
      External_library='kernel32'; {Setup as you need}
 
    Type
    Pchar  = ^char;
{$IFDEF FPC}
{$PACKRECORDS C}
{$ENDIF}
 
 
{$ifndef __USB_H__}
{$define __USB_H__}  
{$include <stdlib.h>}
{$include <windows.h>}
  {
   * 'interface' is defined somewhere in the Windows header files. This macro
   * is deleted here to avoid conflicts and compile errors.
    }
{$ifdef interface}
{$undef interface}
{$endif}
  {
   * PATH_MAX from limits.h can't be used on Windows if the dll and
   * import libraries are build/used by different compilers
    }
 
  const
    LIBUSB_PATH_MAX = 512;    
  {
   * USB spec information
   *
   * This is all stuff grabbed from various USB specs and is pretty much
   * not subject to change
    }
  {
   * Device and/or Interface Class codes
    }
  { for DeviceClass  }
    USB_CLASS_PER_INTERFACE = 0;    
    USB_CLASS_AUDIO = 1;    
    USB_CLASS_COMM = 2;    
    USB_CLASS_HID = 3;    
    USB_CLASS_PRINTER = 7;    
    USB_CLASS_MASS_STORAGE = 8;    
    USB_CLASS_HUB = 9;    
    USB_CLASS_DATA = 10;    
    USB_CLASS_VENDOR_SPEC = $ff;    
  {
   * Descriptor types
    }
    USB_DT_DEVICE = $01;    
    USB_DT_CONFIG = $02;    
    USB_DT_STRING = $03;    
    USB_DT_INTERFACE = $04;    
    USB_DT_ENDPOINT = $05;    
    USB_DT_HID = $21;    
    USB_DT_REPORT = $22;    
    USB_DT_PHYSICAL = $23;    
    USB_DT_HUB = $29;    
  {
   * Descriptor sizes per descriptor type
    }
    USB_DT_DEVICE_SIZE = 18;    
    USB_DT_CONFIG_SIZE = 9;    
    USB_DT_INTERFACE_SIZE = 9;    
    USB_DT_ENDPOINT_SIZE = 7;    
  { Audio extension  }
    USB_DT_ENDPOINT_AUDIO_SIZE = 9;    
    USB_DT_HUB_NONVAR_SIZE = 7;    
  { ensure byte-packed structures  }
{$include <pshpack1.h>}
  { All standard descriptors have these 2 fields in common  }
 
  type
    usb_descriptor_header = record
        bLength : byte;
        bDescriptorType : byte;
      end;
 
  { String descriptor  }
    usb_string_descriptor = record
        bLength : byte;
        bDescriptorType : byte;
        wData : array[0..0] of word;
      end;
 
  { HID descriptor  }
    usb_hid_descriptor = record
        bLength : byte;
        bDescriptorType : byte;
        bcdHID : word;
        bCountryCode : byte;
        bNumDescriptors : byte;
      end;
 
  { Endpoint descriptor  }
 
  const
    USB_MAXENDPOINTS = 32;    
  { Extra descriptors  }
 
  type
    usb_endpoint_descriptor = record
        bLength : byte;
        bDescriptorType : byte;
        bEndpointAddress : byte;
        bmAttributes : byte;
        wMaxPacketSize : word;
        bInterval : byte;
        bRefresh : byte;
        bSynchAddress : byte;
        extra : ^byte;
        extralen : longint;
      end;
 
  { in bEndpointAddress  }
 
  const
    USB_ENDPOINT_ADDRESS_MASK = $0f;    
    USB_ENDPOINT_DIR_MASK = $80;    
  { in bmAttributes  }
    USB_ENDPOINT_TYPE_MASK = $03;    
    USB_ENDPOINT_TYPE_CONTROL = 0;    
    USB_ENDPOINT_TYPE_ISOCHRONOUS = 1;    
    USB_ENDPOINT_TYPE_BULK = 2;    
    USB_ENDPOINT_TYPE_INTERRUPT = 3;    
  { Interface descriptor  }
    USB_MAXINTERFACES = 32;    
  { Extra descriptors  }
 
  type
    usb_interface_descriptor = record
        bLength : byte;
        bDescriptorType : byte;
        bInterfaceNumber : byte;
        bAlternateSetting : byte;
        bNumEndpoints : byte;
        bInterfaceClass : byte;
        bInterfaceSubClass : byte;
        bInterfaceProtocol : byte;
        iInterface : byte;
        endpoint : ^usb_endpoint_descriptor;
        extra : ^byte;
        extralen : longint;
      end;
 
  { Hard limit  }
 
  const
    USB_MAXALTSETTING = 128;    
 
  type
    usb_interface = record
        altsetting : ^usb_interface_descriptor;
        num_altsetting : longint;
      end;
 
  { Configuration descriptor information..  }
 
  const
    USB_MAXCONFIG = 8;    
  { Extra descriptors  }
 
  type
    usb_config_descriptor = record
        bLength : byte;
        bDescriptorType : byte;
        wTotalLength : word;
        bNumInterfaces : byte;
        bConfigurationValue : byte;
        iConfiguration : byte;
        bmAttributes : byte;
        MaxPower : byte;
        interface : ^usb_interface;
        extra : ^byte;
        extralen : longint;
      end;
 
  { Device descriptor  }
    usb_device_descriptor = record
        bLength : byte;
        bDescriptorType : byte;
        bcdUSB : word;
        bDeviceClass : byte;
        bDeviceSubClass : byte;
        bDeviceProtocol : byte;
        bMaxPacketSize0 : byte;
        idVendor : word;
        idProduct : word;
        bcdDevice : word;
        iManufacturer : byte;
        iProduct : byte;
        iSerialNumber : byte;
        bNumConfigurations : byte;
      end;
 
    usb_ctrl_setup = record
        bRequestType : byte;
        bRequest : byte;
        wValue : word;
        wIndex : word;
        wLength : word;
      end;
 
  {
   * Standard requests
    }
 
  const
    USB_REQ_GET_STATUS = $00;    
    USB_REQ_CLEAR_FEATURE = $01;    
  { 0x02 is reserved  }
    USB_REQ_SET_FEATURE = $03;    
  { 0x04 is reserved  }
    USB_REQ_SET_ADDRESS = $05;    
    USB_REQ_GET_DESCRIPTOR = $06;    
    USB_REQ_SET_DESCRIPTOR = $07;    
    USB_REQ_GET_CONFIGURATION = $08;    
    USB_REQ_SET_CONFIGURATION = $09;    
    USB_REQ_GET_INTERFACE = $0A;    
    USB_REQ_SET_INTERFACE = $0B;    
    USB_REQ_SYNCH_FRAME = $0C;    
    USB_TYPE_STANDARD = $00 shl 5;    
    USB_TYPE_CLASS = $01 shl 5;    
    USB_TYPE_VENDOR = $02 shl 5;    
    USB_TYPE_RESERVED = $03 shl 5;    
    USB_RECIP_DEVICE = $00;    
    USB_RECIP_INTERFACE = $01;    
    USB_RECIP_ENDPOINT = $02;    
    USB_RECIP_OTHER = $03;    
  {
   * Various libusb API related stuff
    }
    USB_ENDPOINT_IN = $80;    
    USB_ENDPOINT_OUT = $00;    
  { Error codes  }
    USB_ERROR_BEGIN = 500000;    
  {
   * This is supposed to look weird. This file is generated from autoconf
   * and I didn't want to make this too complicated.
    }
(* error 
#define USB_LE16_TO_CPU(x)
in define line 241 *)
    {
     * Device reset types for usb_reset_ex.
     * http://msdn.microsoft.com/en-us/library ... 85%29.aspx
     * http://msdn.microsoft.com/en-us/library ... 85%29.aspx
      }
      USB_RESET_TYPE_RESET_PORT = 1 shl 0;      
      USB_RESET_TYPE_CYCLE_PORT = 1 shl 1;      
      USB_RESET_TYPE_FULL_RESET = USB_RESET_TYPE_CYCLE_PORT or USB_RESET_TYPE_RESET_PORT;      
    { Data types  }
    { struct usb_device;  }
    { struct usb_bus;  }
    { Darwin support  }
 
    type
      usb_device = record
          next : ^usb_device;
          prev : ^usb_device;
          filename : array[0..(LIBUSB_PATH_MAX)-1] of char;
          bus : ^usb_bus;
          descriptor : usb_device_descriptor;
          config : ^usb_config_descriptor;
          dev : pointer;
          devnum : byte;
          num_children : byte;
          children : ^^usb_device;
        end;
 
      usb_bus = record
          next : ^usb_bus;
          prev : ^usb_bus;
          dirname : array[0..(LIBUSB_PATH_MAX)-1] of char;
          devices : ^usb_device;
          location : dword;
          root_dev : ^usb_device;
        end;
 
    { Version information, Windows specific  }
      usb_version = record
          dll : record
              major : longint;
              minor : longint;
              micro : longint;
              nano : longint;
            end;
          driver : record
              major : longint;
              minor : longint;
              micro : longint;
              nano : longint;
            end;
        end;
 
      usb_dev_handle = record
          {undefined structure}
        end;
 
    { Variables  }
{$ifndef __USB_C__}
 
    { was #define dname def_expr }
    function usb_busses : longint; { return type might be wrong }
 
{$endif}
{$include <poppack.h>}
  { Function prototypes  }
  { usb.c  }
 
  var
    usb_open : function(var dev:usb_device):^usb_dev_handle;cdecl;
    usb_close : function(var dev:usb_dev_handle):longint;cdecl;
    usb_get_string : function(var dev:usb_dev_handle; index:longint; langid:longint; buf:Pchar; buflen:size_t):longint;cdecl;
    usb_get_string_simple : function(var dev:usb_dev_handle; index:longint; buf:Pchar; buflen:size_t):longint;cdecl;
  { descriptors.c  }
    usb_get_descriptor_by_endpoint : function(var udev:usb_dev_handle; ep:longint; _type:byte; index:byte; var buf:pointer; 
      size:longint):longint;cdecl;
    usb_get_descriptor : function(var udev:usb_dev_handle; _type:byte; index:byte; var buf:pointer; size:longint):longint;cdecl;
  { <arch>.c  }
    usb_bulk_write : function(var dev:usb_dev_handle; ep:longint; bytes:Pchar; size:longint; timeout:longint):longint;cdecl;
    usb_bulk_read : function(var dev:usb_dev_handle; ep:longint; bytes:Pchar; size:longint; timeout:longint):longint;cdecl;
    usb_interrupt_write : function(var dev:usb_dev_handle; ep:longint; bytes:Pchar; size:longint; timeout:longint):longint;cdecl;
    usb_interrupt_read : function(var dev:usb_dev_handle; ep:longint; bytes:Pchar; size:longint; timeout:longint):longint;cdecl;
    usb_control_msg : function(var dev:usb_dev_handle; requesttype:longint; request:longint; value:longint; index:longint; 
      bytes:Pchar; size:longint; timeout:longint):longint;cdecl;
    usb_set_configuration : function(var dev:usb_dev_handle; configuration:longint):longint;cdecl;
    usb_claim_interface : function(var dev:usb_dev_handle; interface:longint):longint;cdecl;
    usb_release_interface : function(var dev:usb_dev_handle; interface:longint):longint;cdecl;
    usb_set_altinterface : function(var dev:usb_dev_handle; alternate:longint):longint;cdecl;
    usb_resetep : function(var dev:usb_dev_handle; ep:dword):longint;cdecl;
    usb_clear_halt : function(var dev:usb_dev_handle; ep:dword):longint;cdecl;
    usb_reset : function(var dev:usb_dev_handle):longint;cdecl;
    usb_reset_ex : function(var dev:usb_dev_handle; reset_type:dword):longint;cdecl;
    usb_strerror : function:^char;cdecl;
    usb_init : procedure;cdecl;
    usb_set_debug : procedure(level:longint);cdecl;
    usb_find_busses : function:longint;cdecl;
    usb_find_devices : function:longint;cdecl;
(* error 
    struct usb_device *usb_device(usb_dev_handle *dev);
in declaration at line 370 *)
(* error 
    struct usb_bus *usb_get_busses(void);
in declaration at line 371 *)
    { Windows specific functions  }
 
    const
      LIBUSB_HAS_INSTALL_SERVICE_NP = 1;      
 
    var
      usb_install_service_np : function:longint;cdecl;
      usb_install_service_np_rundll : procedure(wnd:HWND; instance:HINSTANCE; cmd_line:LPSTR; cmd_show:longint);
 
    const
      LIBUSB_HAS_UNINSTALL_SERVICE_NP = 1;      
 
    var
      usb_uninstall_service_np : function:longint;cdecl;
      usb_uninstall_service_np_rundll : procedure(wnd:HWND; instance:HINSTANCE; cmd_line:LPSTR; cmd_show:longint);
 
    const
      LIBUSB_HAS_INSTALL_DRIVER_NP = 1;      
(* Const before type ignored *)
 
    var
      usb_install_driver_np : function(inf_file:Pchar):longint;cdecl;
      usb_install_driver_np_rundll : procedure(wnd:HWND; instance:HINSTANCE; cmd_line:LPSTR; cmd_show:longint);
 
    const
      LIBUSB_HAS_TOUCH_INF_FILE_NP = 1;      
(* Const before type ignored *)
 
    var
      usb_touch_inf_file_np : function(inf_file:Pchar):longint;cdecl;
      usb_touch_inf_file_np_rundll : procedure(wnd:HWND; instance:HINSTANCE; cmd_line:LPSTR; cmd_show:longint);
 
    const
      LIBUSB_HAS_INSTALL_NEEDS_RESTART_NP = 1;      
 
    var
      usb_install_needs_restart_np : function:longint;cdecl;
 
    const
      LIBUSB_HAS_INSTALL_NP = 1;      
 
    var
      usb_install_npW : function(hwnd:HWND; instance:HINSTANCE; cmd_line:LPCWSTR; starg_arg:longint):longint;cdecl;
      usb_install_npA : function(hwnd:HWND; instance:HINSTANCE; cmd_line:LPCSTR; starg_arg:longint):longint;cdecl;
 
    const
      usb_install_np = usb_install_npA;      
 
    var
      usb_install_np_rundll : procedure(wnd:HWND; instance:HINSTANCE; cmd_line:LPSTR; cmd_show:longint);
(* Const before type ignored *)
      usb_get_version : function:^usb_version;cdecl;
      usb_isochronous_setup_async : function(var dev:usb_dev_handle; var context:pointer; ep:byte; pktsize:longint):longint;cdecl;
      usb_bulk_setup_async : function(var dev:usb_dev_handle; var context:pointer; ep:byte):longint;cdecl;
      usb_interrupt_setup_async : function(var dev:usb_dev_handle; var context:pointer; ep:byte):longint;cdecl;
      usb_submit_async : function(var context:pointer; bytes:Pchar; size:longint):longint;cdecl;
      usb_reap_async : function(var context:pointer; timeout:longint):longint;cdecl;
      usb_reap_async_nocancel : function(var context:pointer; timeout:longint):longint;cdecl;
      usb_cancel_async : function(var context:pointer):longint;cdecl;
      usb_free_async : function(var context:pointer):longint;cdecl;
{ C++ end of extern C conditionnal removed }
{$endif}
    { __USB_H__  }
 
implementation
 
    { was #define dname def_expr }
    function usb_busses : longint; { return type might be wrong }
      begin
        usb_busses:=usb_get_busses;
      end;
 
  uses
    SysUtils, dynlibs;
 
  var
    hlib : tlibhandle;
 
 
  procedure Freelusb0_usb;
    begin
      FreeLibrary(hlib);
      usb_open:=nil;
      usb_close:=nil;
      usb_get_string:=nil;
      usb_get_string_simple:=nil;
      usb_get_descriptor_by_endpoint:=nil;
      usb_get_descriptor:=nil;
      usb_bulk_write:=nil;
      usb_bulk_read:=nil;
      usb_interrupt_write:=nil;
      usb_interrupt_read:=nil;
      usb_control_msg:=nil;
      usb_set_configuration:=nil;
      usb_claim_interface:=nil;
      usb_release_interface:=nil;
      usb_set_altinterface:=nil;
      usb_resetep:=nil;
      usb_clear_halt:=nil;
      usb_reset:=nil;
      usb_reset_ex:=nil;
      usb_strerror:=nil;
      usb_init:=nil;
      usb_set_debug:=nil;
      usb_find_busses:=nil;
      usb_find_devices:=nil;
      usb_install_service_np:=nil;
      usb_install_service_np_rundll:=nil;
      usb_uninstall_service_np:=nil;
      usb_uninstall_service_np_rundll:=nil;
      usb_install_driver_np:=nil;
      usb_install_driver_np_rundll:=nil;
      usb_touch_inf_file_np:=nil;
      usb_touch_inf_file_np_rundll:=nil;
      usb_install_needs_restart_np:=nil;
      usb_install_npW:=nil;
      usb_install_npA:=nil;
      usb_install_np_rundll:=nil;
      usb_get_version:=nil;
      usb_isochronous_setup_async:=nil;
      usb_bulk_setup_async:=nil;
      usb_interrupt_setup_async:=nil;
      usb_submit_async:=nil;
      usb_reap_async:=nil;
      usb_reap_async_nocancel:=nil;
      usb_cancel_async:=nil;
      usb_free_async:=nil;
    end;
 
 
  procedure Loadlusb0_usb(lib : pchar);
    begin
      Freelusb0_usb;
      hlib:=LoadLibrary(lib);
      if hlib=0 then
        raise Exception.Create(format('Could not load library: %s',[lib]));
 
      pointer(usb_open):=GetProcAddress(hlib,'usb_open');
      pointer(usb_close):=GetProcAddress(hlib,'usb_close');
      pointer(usb_get_string):=GetProcAddress(hlib,'usb_get_string');
      pointer(usb_get_string_simple):=GetProcAddress(hlib,'usb_get_string_simple');
      pointer(usb_get_descriptor_by_endpoint):=GetProcAddress(hlib,'usb_get_descriptor_by_endpoint');
      pointer(usb_get_descriptor):=GetProcAddress(hlib,'usb_get_descriptor');
      pointer(usb_bulk_write):=GetProcAddress(hlib,'usb_bulk_write');
      pointer(usb_bulk_read):=GetProcAddress(hlib,'usb_bulk_read');
      pointer(usb_interrupt_write):=GetProcAddress(hlib,'usb_interrupt_write');
      pointer(usb_interrupt_read):=GetProcAddress(hlib,'usb_interrupt_read');
      pointer(usb_control_msg):=GetProcAddress(hlib,'usb_control_msg');
      pointer(usb_set_configuration):=GetProcAddress(hlib,'usb_set_configuration');
      pointer(usb_claim_interface):=GetProcAddress(hlib,'usb_claim_interface');
      pointer(usb_release_interface):=GetProcAddress(hlib,'usb_release_interface');
      pointer(usb_set_altinterface):=GetProcAddress(hlib,'usb_set_altinterface');
      pointer(usb_resetep):=GetProcAddress(hlib,'usb_resetep');
      pointer(usb_clear_halt):=GetProcAddress(hlib,'usb_clear_halt');
      pointer(usb_reset):=GetProcAddress(hlib,'usb_reset');
      pointer(usb_reset_ex):=GetProcAddress(hlib,'usb_reset_ex');
      pointer(usb_strerror):=GetProcAddress(hlib,'usb_strerror');
      pointer(usb_init):=GetProcAddress(hlib,'usb_init');
      pointer(usb_set_debug):=GetProcAddress(hlib,'usb_set_debug');
      pointer(usb_find_busses):=GetProcAddress(hlib,'usb_find_busses');
      pointer(usb_find_devices):=GetProcAddress(hlib,'usb_find_devices');
      pointer(usb_install_service_np):=GetProcAddress(hlib,'usb_install_service_np');
      pointer(usb_install_service_np_rundll):=GetProcAddress(hlib,'usb_install_service_np_rundll');
      pointer(usb_uninstall_service_np):=GetProcAddress(hlib,'usb_uninstall_service_np');
      pointer(usb_uninstall_service_np_rundll):=GetProcAddress(hlib,'usb_uninstall_service_np_rundll');
      pointer(usb_install_driver_np):=GetProcAddress(hlib,'usb_install_driver_np');
      pointer(usb_install_driver_np_rundll):=GetProcAddress(hlib,'usb_install_driver_np_rundll');
      pointer(usb_touch_inf_file_np):=GetProcAddress(hlib,'usb_touch_inf_file_np');
      pointer(usb_touch_inf_file_np_rundll):=GetProcAddress(hlib,'usb_touch_inf_file_np_rundll');
      pointer(usb_install_needs_restart_np):=GetProcAddress(hlib,'usb_install_needs_restart_np');
      pointer(usb_install_npW):=GetProcAddress(hlib,'usb_install_npW');
      pointer(usb_install_npA):=GetProcAddress(hlib,'usb_install_npA');
      pointer(usb_install_np_rundll):=GetProcAddress(hlib,'usb_install_np_rundll');
      pointer(usb_get_version):=GetProcAddress(hlib,'usb_get_version');
      pointer(usb_isochronous_setup_async):=GetProcAddress(hlib,'usb_isochronous_setup_async');
      pointer(usb_bulk_setup_async):=GetProcAddress(hlib,'usb_bulk_setup_async');
      pointer(usb_interrupt_setup_async):=GetProcAddress(hlib,'usb_interrupt_setup_async');
      pointer(usb_submit_async):=GetProcAddress(hlib,'usb_submit_async');
      pointer(usb_reap_async):=GetProcAddress(hlib,'usb_reap_async');
      pointer(usb_reap_async_nocancel):=GetProcAddress(hlib,'usb_reap_async_nocancel');
      pointer(usb_cancel_async):=GetProcAddress(hlib,'usb_cancel_async');
      pointer(usb_free_async):=GetProcAddress(hlib,'usb_free_async');
    end;
 
 
initialization
  Loadlusb0_usb('lusb0_usb');
finalization
  Freelusb0_usb;
 
end.

[MmVisual]

Vielen Dank, theo!

[ErnstVolker]

Hallo zusammen,

ich hab' mal ne Frage in diesem Zusammenhang zur Nutzung von h2pas. Die lusb0_usb.h includiert ja auch wieder zwei Header-Dateien. In diesem Fall windows.h und stdlib.h. Das sind sicher Standard-Header, für die Freepascal entsprechend auch units vorhält. Eine Unit windows gibt es soviel ich weis

Ich hab einen Header, der includiert malloc.h. Gibt es dafür auch eine Pascal-Unit oder muss man dann malloc.h auch mit h2pas übersetzen? Erwächst sich das dann zum "Bauer schickt den Jockel aus"-Prinzip, dass man sich von Header zu Header hangeln muss und diese dann mit h2pas übersetzten?

Viele Grüße

Volker

[Socke]

Ich hab einen Header, der includiert malloc.h. Gibt es dafür auch eine Pascal-Unit oder muss man dann malloc.h auch mit h2pas übersetzen? Erwächst sich das dann zum "Bauer schickt den Jockel aus"-Prinzip, dass man sich von Header zu Header hangeln muss und diese dann mit h2pas übersetzten?

Die Funktion malloc() solltest du in deinen Header-Dateien durch die Free Pascal Funktionen GetMem() oder New().

Prinzipiell musst du natürlich sämtliche genutzte C-Header-Dateien nach Pascal übersetzen, außer du hast sie bereits. Der Free Pascal Compiler bringt einige mit (unter anderem auch die Unit ctypes, die C-Typen direkt auf Pascal-Typen mappt.

ich hab' mal ne Frage in diesem Zusammenhang zur Nutzung von h2pas. Die lusb0_usb.h includiert ja auch wieder zwei Header-Dateien. In diesem Fall windows.h und stdlib.h. Das sind sicher Standard-Header, für die Freepascal entsprechend auch units vorhält. Eine Unit windows gibt es soviel ich weis

Die Unit Windows enthält viele Funktionen der Windows-API; falls du eine Funktion suchst, die dort nicht enthalten ist, schau dich in den Jedi-Dateien um (werden vom FPC mitgeliefert).

Die Datei stdlib.h enthält Funktionen der C-Standard-Bibliothek. Da sind Funktionen enthalten, die mit Sicherheit jedes Programm verwenden wird. Diese Funktionen greifen häufig direkt auf das Betriebssystem zu -- zum Beispiel um Speicher zu reservieren oder eine Datei zu bearbeiten. In Pascal wird diese Aufgabe von der Unit System übernommen, die implizit eingebunden wird (das heißt, du musst/darfst sie nicht unter uses aufführen). Natürlich sind in Pascal die Funktionen nicht eins zu eins aus der C-Standard-Bibliothek übernommen. Beim Übersetzen von C-Header-Dateien musst du dann im Einzelfall prüfen, was du noch brauchst und wo du es herbekommst.

[ErnstVolker]

Vielen Dank für Deine Antwort Socke.

Der Header includiert zum Glück keine Weiteren.

Zwei Fragen hätte ich dann doch noch:

Wie verfährt man mit Doppelzeigern? Also sowas:

Code: Alles auswählen

int **variable

das wird sicher nicht zu

Code: Alles auswählen

variable: ^^integer

oder?
Was ich nachlesen konnte, handelt es sich hier um einen Zeiger auf ein Array von Zeigern. Gibt's sowas in FPC auch?

Wirken sich die Compilerdirektiven aus c auch auf fpc aus? Versteht fpc sie oder kann man sie auskommentieren?

Viele Grüße

Volker

[mschnell]

sowas:

Code: Alles auswählen

int **variable

Was ich nachlesen konnte, handelt es sich hier um einen Zeiger auf ein Array von Zeigern.

Oder z.B- einen Zeiger in ein Array von Zeigern, ...
Oder im Funktions-Kopf auch ein Var-Parameter, der ein Zeiger ist.

Code: Alles auswählen

procedure x(var y: PInteger);

Gibt's sowas in FPC auch?

Klar.

-Michael

[Socke]

Wirken sich die Compilerdirektiven aus c auch auf fpc aus? Versteht fpc sie oder kann man sie auskommentieren?

Der FPC versteht grundsätzliche keine Direktiven des C-Präprozessors.

Wie verfährt man mit Doppelzeigern? Also sowas:

Code: Alles auswählen

int **variable

das wird sicher nicht zu

Code: Alles auswählen

variable: ^^integer

oder?
Was ich nachlesen konnte, handelt es sich hier um einen Zeiger auf ein Array von Zeigern. Gibt's sowas in FPC auch?

Grundsätzlich ist das erst einmal ein Zeiger auf einen Zeiger auf einen Integer, wie mschnell schon schrieb. Ob damit ein Array von Zeigern auf Integer (in Pascal also array of PInteger) gemeint ist, sollte in der Dokumentation stehen (auch wenn etwas anderes bei Integer wenig Sinn hat). In der Regel hat der letzte Zeiger im Array den Wert 0 beziehungsweise nil. Sollte das der Fall sein, kannst du in Free Pascal selbstverständlich einen array of PInteger verwenden. Vergiss dann aber nicht das letzte Element auf nil zu setzen!

[soerensen3]

Mal so ne frage: hast du die schon durchgeguckt? http://wiki.lazarus.freepascal.org/Hard ... ess#libusb
Da haben anscheinend 4 leute die header übersetzt, die eine datei ist vom 23.09.2012, habs aber nicht getestet.

[creed steiger]

ja ich dachte auch,daß was im englischen Forum war:


http://www.lazarus.freepascal.org/index ... 435.0.html

[ErnstVolker]

Hallo,
ich hätte ein eigenes Thema eröffnen sollen, denn es geht mir nicht um die LibUSB. Ich dachte, ich hänge meine Frage einfach mal hier an, weil es mit h2pas zu tun hat.

Ich habe den Header mal angehängt. Wenn ich mit h2pas darangehe, dann gibt es beim anschließenden Einbinden Fehlermeldungen. U.a. weil solche "Doppelstern"-Zeiger in dem Struct vorhanden sind. Ich hab aber rausbekommen, dass man aus z.B. int **variable das evtl. so: variable: ^Pinteger machen kann.

Vielen Grüße

Volker

[Murphy.]

Hi,
ich sitze im Moment an meiner Abschlussarbeit und habe ein Problem. Ich benötige Hilfe bei der Verwendung von LibUSB. Ich möchte eine txt Datei mit Messwerten vom Pi auf einen USB Stick kopieren bzw. perfekt wäre es wenn jeder USB Stick erkannt werden würde.

Da das einfache Kopieren der Datei in das entsprechende Verzeichnis des USB-Sticks nicht funktioniert hat, habe ich nach Alternativen gesucht und LibUSB gefunden.

Hat jemand ein leicht verständliches Beispiel für mich, wie ich die Datei kopieren kann?

[creed steiger]

Hi, Ich möchte eine txt Datei mit Messwerten vom Pi auf einen USB Stick kopieren bzw. perfekt wäre es wenn jeder USB Stick erkannt werden würde.

Das ist schlichtweg die Aufgabe deines Betriebssystems, libusb hilft dir da nicht weiter, es sei denn du willst auch gleich Treiber für die verschiedenen Dateisysteme schreiben.

Wenn einfaches Kopieren nicht funktioniert liegt das Problem wo anders (evtl Zugriffsrechte).

[Murphy.]

Wie kopiere ich die Datei denn am einfachsten ohne das ich Probleme mit den Zugriffsrechten bekomme?