WICHTIG: Der Betrieb von goMatlab.de wird privat finanziert fortgesetzt. - Mehr Infos...

Mein MATLAB Forum - goMatlab.de

Mein MATLAB Forum

  
Gast > Registrieren       Autologin?   

Partner:




Forum
      Option
[Erweitert]
  • Diese Seite per Mail weiterempfehlen
     


Gehe zu:  
Neues Thema eröffnen Neue Antwort erstellen

Funktion aus einer DLL in Matlab aufrufen
 

Nyquist
Forum-Fortgeschrittener

Forum-Fortgeschrittener

Beiträge: 60
Anmeldedatum: 19.11.07
Wohnort: Laupheim
Version: ---
     Beitrag Verfasst am: 22.11.2007, 16:46     Titel: Funktion aus einer DLL in Matlab aufrufen
  Antworten mit Zitat      
Hallo Leute,

ich würde gerne eine Dll in Matlab einbinden um auf deren Funktionen zugreifen zu können. Ich hab ees schon mit loadlibrary probiert allerdings kommt die Meldung das die .h datei fehlt.
Hat jemand von euch schonmal damit beschäftigt??

Wäre um jeden Rat dankbar Very Happy
_________________

Mit freundlcihem Gruß
Nyquist
Private Nachricht senden Benutzer-Profile anzeigen


outsider
Forum-Meister

Forum-Meister

Beiträge: 806
Anmeldedatum: 03.09.07
Wohnort: München
Version: R2012b
     Beitrag Verfasst am: 22.11.2007, 23:57     Titel:
  Antworten mit Zitat      
Unter H-Datei ist der Header-File von der DLL gemeint.
Dort sind die Funktionen deklariert die in der DLL sich befinden. Ohne des Header-Files kann MATLAB mit der DLL nix anfangen.


MfG
Private Nachricht senden Benutzer-Profile anzeigen
 
oli
Forum-Newbie

Forum-Newbie

Beiträge: 4
Anmeldedatum: 10.03.08
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 10.03.2008, 12:19     Titel:
  Antworten mit Zitat      
Hallo, mir folgendes USB-Board gekauft.

Dazu gibt es eine passende DLL vom Anbieter und dazu Includes für Delphi, Basic und C++.

Ich möchte die DLL in Matlab einbinden. Ich habe die usb2.dll
und die usb2dll.h in ein Verzeichnis gepackt.

In Matlab folgende Term angewendet
Code:
loadlibrary('usb2.dll', 'Usb2Dll.h')


Danach wollte ich überprüfen, ob's funktioniert hat und habe folgendes eingegeben.
Code:
m = libfunctions('usb2.dll')


Ergebnis sieht so aus:
Code:
m =

     []


Das führt mich zu der Annahme, dass Matlab wohl mit dem Headerfile nix anzufangen weiss.

Kann mir jemand einen Hinweis geben, wie ich die DLL in Matlab eingebunden bekomme?

____________________________________

Das Headerfile für das C-Include sieht folgedner Maßen aus:
Code:

#ifndef Usb2Included
#define Usb2Included

// USB2.dll must be present in the curent working directory (cwd) of the compiled
// application. If it is not, update the path of the LoadLibrary function (see below).

HINSTANCE      hUsb2Dll;
//Prototypes for general functions
typedef      BYTE (CALLBACK* pDLLUsbInit)                 (BYTE);
typedef      BYTE (CALLBACK* pDLLUsbGetStatus)            (BYTE);
typedef      BYTE (CALLBACK* pDLLUsbGetError)             ();
typedef      BYTE (CALLBACK* pDLLUsbGetErrorStringByNr)   (BYTE, char**);
typedef      BYTE (CALLBACK* pDLLUsbSetLicense)           (char*);
typedef      BYTE (CALLBACK* pDLLUsbOpen)                 (BYTE);
typedef      BYTE (CALLBACK* pDLLUsbClose)                (BYTE);
typedef       BYTE (CALLBACK* pDLLUsbCheckSpeed)           (BYTE, BYTE*);
typedef      void (CALLBACK* pDLLUsbGetVersion)           (char*);
typedef       BYTE (CALLBACK* pDLLUsbSetTimeout)           (BYTE, WORD);
typedef      BYTE (CALLBACK* pDLLUsbWaituSec)             (DWORD);

typedef      BYTE (CALLBACK* pDLLUsbRetrieveAllErrors)    (BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbDevicePresent)        (BYTE);
typedef      BYTE (CALLBACK* pDLLUsbDeviceInitialized)    (BYTE);
typedef      BYTE (CALLBACK* pDLLUsbI2CSetTimeout)        (BYTE, WORD);
typedef      BYTE (CALLBACK* pDLLUsbEEpSetTimeout)        (BYTE, WORD);
typedef      BYTE (CALLBACK* pDLLUsbParSetTimeout)        (BYTE, WORD);
typedef      BYTE (CALLBACK* pDLLUsbSpiInit)              (BYTE, BYTE, BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbSpiTransfer)          (BYTE, void*, void*, WORD);
typedef      BYTE (CALLBACK* pDLLUsbSpiTransferByte)      (BYTE, BYTE, BYTE*);
typedef      BYTE (CALLBACK* pDLLUsbParSetWaveforms)      (BYTE, BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbParSetTransferSize)   (BYTE, DWORD);

//Prototypes for io-functions
typedef      BYTE (CALLBACK* pDLLUsbSetIOState)           (BYTE, BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbSetIODir)             (BYTE, BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbGetIOState)           (BYTE, BYTE, BYTE*);
typedef      BYTE (CALLBACK* pDLLUsbSetPortState)         (BYTE, BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbSetPortDir)           (BYTE, BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbGetPortState)         (BYTE, BYTE, BYTE*);

//Prototypes for i2c-functions
typedef      BYTE (CALLBACK* pDLLUsbI2CSetSpeed)          (BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbI2CWriteBytes)        (BYTE, BYTE, WORD, char*);
typedef      BYTE (CALLBACK* pDLLUsbI2CWriteByte)         (BYTE, BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbI2CReadBytes)         (BYTE, BYTE, WORD, char*);
typedef      BYTE (CALLBACK* pDLLUsbI2CReadByte)          (BYTE, BYTE, BYTE*);
typedef     BYTE (CALLBACK* pDLLUsbI2CWriteAndReadBytes) (BYTE, BYTE, WORD, WORD, char*, char*);

//Prototypes for EEProm-functions
typedef      BYTE (CALLBACK* pDLLUsbEEpWriteBytes)        (BYTE, WORD, WORD, char*);
typedef      BYTE (CALLBACK* pDLLUsbEEpWriteByte)         (BYTE, WORD, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbEEpReadBytes)         (BYTE, WORD, WORD, char*);
typedef      BYTE (CALLBACK* pDLLUsbEEpReadByte)          (BYTE, WORD, BYTE*);
typedef      BYTE (CALLBACK* pDLLUsbEEpSetAddr)           (BYTE, BYTE);
//Prototypes for Parallelinterface-functions
typedef      BYTE (CALLBACK* pDLLUsbParInit)              (BYTE, BYTE);
typedef      BYTE (CALLBACK* pDLLUsbParInitUsingArray)    (BYTE, char*);
typedef      BYTE (CALLBACK* pDLLUsbParOut)               (BYTE, char*, DWORD);
typedef      BYTE (CALLBACK* pDLLUsbParIn)                (BYTE, char*, DWORD);
typedef      BYTE (CALLBACK* pDLLUsbGetRdyState)          (BYTE, BYTE*);
typedef      BYTE (CALLBACK* pDLLUsbParSetWaveforms)      (BYTE, BYTE, BYTE);

FARPROC      lpfnUsbInit;
FARPROC      lpfnUsbGetStatus;
FARPROC      lpfnUsbGetError;
FARPROC      lpfnUsbGetErrorStringByNr;
FARPROC      lpfnUsbRetrieveAllErrors;
FARPROC      lpfnUsbDevicePresent;
FARPROC      lpfnUsbDeviceInitialized;
FARPROC      lpfnUsbI2CSetTimeout;
FARPROC      lpfnUsbEEpSetTimeout;
FARPROC      lpfnUsbParSetTimeout;
FARPROC      lpfnUsbSpiInit;
FARPROC      lpfnUsbSpiTransfer;
FARPROC      lpfnUsbSpiTransferByte;
FARPROC      lpfnUsbParSetWaveforms;
FARPROC      lpfnUsbParSetTransferSize;
FARPROC      lpfnUsbGetVersion;
FARPROC      lpfnUsbSetTimeout;
FARPROC      lpfnUsbWaituSec;
FARPROC      lpfnUsbEEpSetAddr;
FARPROC      lpfnUsbGetRdyState;
FARPROC      lpfnUsbSetLicense;
FARPROC      lpfnUsbSetIOState;
FARPROC      lpfnUsbSetIODir;
FARPROC      lpfnUsbGetIOState;
FARPROC      lpfnUsbSetPortState;
FARPROC      lpfnUsbSetPortDir;
FARPROC      lpfnUsbGetPortState;
FARPROC      lpfnUsbI2CSetSpeed;
FARPROC      lpfnUsbI2CWriteBytes;
FARPROC      lpfnUsbI2CWriteByte;
FARPROC      lpfnUsbI2CReadBytes;
FARPROC      lpfnUsbI2CReadByte;
FARPROC      lpfnUsbEEpWriteBytes;
FARPROC      lpfnUsbEEpWriteByte;
FARPROC      lpfnUsbEEpReadBytes;
FARPROC      lpfnUsbEEpReadByte;
FARPROC      lpfnUsbParInit;
FARPROC      lpfnUsbParInitUsingArray;
FARPROC      lpfnUsbParOut;
FARPROC      lpfnUsbParIn;
FARPROC     lpfnUsbCheckSpeed;
FARPROC      lpfnUsbOpen;
FARPROC      lpfnUsbClose;
FARPROC      lpfnUsbI2CWriteAndReadBytes;

pDLLUsbInit                     UsbInit;
pDLLUsbGetStatus               UsbGetStatus;
pDLLUsbGetVersion             UsbGetVersion;
pDLLUsbRetrieveAllErrors       UsbRetrieveAllErrors;
pDLLUsbDevicePresent          UsbDevicePresent;
pDLLUsbDeviceInitialized       UsbDeviceInitialized;
pDLLUsbI2CSetTimeout          UsbI2CSetTimeout;
pDLLUsbEEpSetTimeout          UsbEEpSetTimeout;
pDLLUsbParSetTimeout          UsbParSetTimeout;
pDLLUsbSpiInit                UsbSpiInit;
pDLLUsbSpiTransfer             UsbSpiTransfer;
pDLLUsbSpiTransferByte          UsbSpiTransferByte;
pDLLUsbParSetWaveforms          UsbParSetWaveforms;
pDLLUsbParSetTransferSize       UsbParSetTransferSize;
pDLLUsbEEpSetAddr             UsbEEpSetAddr;
pDLLUsbGetRdyState            UsbGetRdyState;
pDLLUsbGetError               UsbGetError;
pDLLUsbGetErrorStringByNr      UsbGetErrorStringByNr;
pDLLUsbWaituSec               UsbWaituSec;
pDLLUsbSetLicense               UsbSetLicense;
pDLLUsbSetIOState               UsbSetIOState;
pDLLUsbSetIODir               UsbSetIODir;
pDLLUsbGetIOState               UsbGetIOState;
pDLLUsbSetPortState            UsbSetPortState;
pDLLUsbSetPortDir               UsbSetPortDir;
pDLLUsbGetPortState            UsbGetPortState;
pDLLUsbI2CSetSpeed            UsbI2CSetSpeed;
pDLLUsbI2CWriteBytes            UsbI2CWriteBytes;
pDLLUsbI2CWriteByte            UsbI2CWriteByte;
pDLLUsbI2CReadBytes            UsbI2CReadBytes;
pDLLUsbI2CReadByte            UsbI2CReadByte;
pDLLUsbEEpWriteBytes            UsbEEpWriteBytes;
pDLLUsbEEpWriteByte            UsbEEpWriteByte;
pDLLUsbEEpReadBytes            UsbEEpReadBytes;
pDLLUsbEEpReadByte            UsbEEpReadByte;
pDLLUsbParInit                  UsbParInit;
pDLLUsbParInitUsingArray      UsbParInitUsingArray;
pDLLUsbParOut                  UsbParOut;
pDLLUsbParIn                  UsbParIn;
pDLLUsbCheckSpeed               UsbCheckSpeed;
pDLLUsbOpen                     UsbOpen;
pDLLUsbClose                  UsbClose;
pDLLUsbI2CWriteAndReadBytes   UsbI2CWriteAndReadBytes;
pDLLUsbSetTimeout             UsbSetTimeout;

int LoadUsb2Dll() {
   hUsb2Dll = LoadLibrary("usb2.dll"); // change path here
   if (hUsb2Dll==NULL) {
      MessageBox(NULL, "Usb2Dll could not be opened", "Error", MB_OK);
      return false;
   }
   lpfnUsbInit                = GetProcAddress(HMODULE(hUsb2Dll), "UsbInit");
   lpfnUsbGetVersion          = GetProcAddress(HMODULE(hUsb2Dll), "UsbGetVersion");
   lpfnUsbEEpSetAddr          = GetProcAddress(HMODULE(hUsb2Dll), "UsbEEpSetAddr");
   lpfnUsbParSetWaveforms     = GetProcAddress(HMODULE(hUsb2Dll), "UsbParSetWaveforms");
   lpfnUsbGetRdyState         = GetProcAddress(HMODULE(hUsb2Dll), "UsbGetRdyState");
   lpfnUsbGetError            = GetProcAddress(HMODULE(hUsb2Dll), "UsbGetError");
   lpfnUsbGetErrorStringByNr  = GetProcAddress(HMODULE(hUsb2Dll), "UsbGetErrorStringByNr");

   lpfnUsbRetrieveAllErrors   = GetProcAddress(HMODULE(hUsb2Dll), "UsbRetrieveAllErrors");
   lpfnUsbDevicePresent       = GetProcAddress(HMODULE(hUsb2Dll), "UsbDevicePresent");
   lpfnUsbDeviceInitialized   = GetProcAddress(HMODULE(hUsb2Dll), "UsbDeviceInitialized");
   lpfnUsbI2CSetTimeout       = GetProcAddress(HMODULE(hUsb2Dll), "UsbI2CSetTimeout");
   lpfnUsbEEpSetTimeout       = GetProcAddress(HMODULE(hUsb2Dll), "UsbEEpSetTimeout");
   lpfnUsbParSetTimeout       = GetProcAddress(HMODULE(hUsb2Dll), "UsbParSetTimeout");
   lpfnUsbSpiInit             = GetProcAddress(HMODULE(hUsb2Dll), "UsbSpiInit");
   lpfnUsbSpiTransfer         = GetProcAddress(HMODULE(hUsb2Dll), "UsbSpiTransfer");
   lpfnUsbSpiTransferByte     = GetProcAddress(HMODULE(hUsb2Dll), "UsbSpiTransferByte");
   lpfnUsbParSetWaveforms     = GetProcAddress(HMODULE(hUsb2Dll), "UsbParSetWaveforms");
   lpfnUsbParSetTransferSize  = GetProcAddress(HMODULE(hUsb2Dll), "UsbParSetTransferSize");

   lpfnUsbWaituSec            = GetProcAddress(HMODULE(hUsb2Dll), "UsbWaituSec");
   lpfnUsbSetLicense            = GetProcAddress(HMODULE(hUsb2Dll), "UsbSetLicense");
   lpfnUsbSetIOState            = GetProcAddress(HMODULE(hUsb2Dll), "UsbSetIOState");
   lpfnUsbSetIODir            = GetProcAddress(HMODULE(hUsb2Dll), "UsbSetIODir");
   lpfnUsbGetIOState            = GetProcAddress(HMODULE(hUsb2Dll), "UsbGetIOState");
   lpfnUsbSetPortState         = GetProcAddress(HMODULE(hUsb2Dll), "UsbSetPortState");
   lpfnUsbSetPortDir            = GetProcAddress(HMODULE(hUsb2Dll), "UsbSetPortDir");
   lpfnUsbGetStatus            = GetProcAddress(HMODULE(hUsb2Dll), "UsbGetStatus");
   lpfnUsbGetPortState         = GetProcAddress(HMODULE(hUsb2Dll), "UsbGetPortState");
   lpfnUsbI2CSetSpeed         = GetProcAddress(HMODULE(hUsb2Dll), "UsbI2CSetSpeed");
   lpfnUsbI2CWriteBytes         = GetProcAddress(HMODULE(hUsb2Dll), "UsbI2CWriteBytes");
   lpfnUsbI2CWriteByte         = GetProcAddress(HMODULE(hUsb2Dll), "UsbI2CWriteByte");
   lpfnUsbI2CReadBytes         = GetProcAddress(HMODULE(hUsb2Dll), "UsbI2CReadBytes");
   lpfnUsbI2CReadByte         = GetProcAddress(HMODULE(hUsb2Dll), "UsbI2CReadByte");
   lpfnUsbEEpWriteBytes         = GetProcAddress(HMODULE(hUsb2Dll), "UsbEEpWriteBytes");
   lpfnUsbEEpWriteByte         = GetProcAddress(HMODULE(hUsb2Dll), "UsbEEpWriteByte");
   lpfnUsbEEpReadBytes         = GetProcAddress(HMODULE(hUsb2Dll), "UsbEEpReadBytes");
   lpfnUsbEEpReadByte         = GetProcAddress(HMODULE(hUsb2Dll), "UsbEEpReadByte");
   lpfnUsbParInit               = GetProcAddress(HMODULE(hUsb2Dll), "UsbParInit");
   lpfnUsbParInitUsingArray   = GetProcAddress(HMODULE(hUsb2Dll), "UsbParInitUsingArray");
   lpfnUsbParOut               = GetProcAddress(HMODULE(hUsb2Dll), "UsbParOut");
   lpfnUsbParIn               = GetProcAddress(HMODULE(hUsb2Dll), "UsbParIn");
   lpfnUsbCheckSpeed          = GetProcAddress(HMODULE(hUsb2Dll), "UsbCheckSpeed");
   lpfnUsbOpen                = GetProcAddress(HMODULE(hUsb2Dll), "UsbOpen");
   lpfnUsbClose               = GetProcAddress(HMODULE(hUsb2Dll), "UsbClose");
   lpfnUsbI2CWriteAndReadBytes= GetProcAddress(HMODULE(hUsb2Dll), "UsbI2CWriteAndReadBytes");
   lpfnUsbSetTimeout          = GetProcAddress(HMODULE(hUsb2Dll), "UsbSetTimeout");

   UsbInit = pDLLUsbInit(lpfnUsbInit);

   UsbRetrieveAllErrors    = pDLLUsbRetrieveAllErrors(lpfnUsbRetrieveAllErrors);
   UsbDevicePresent        = pDLLUsbDevicePresent(lpfnUsbDevicePresent);
   UsbDeviceInitialized    = pDLLUsbDeviceInitialized(lpfnUsbDeviceInitialized);
   UsbI2CSetTimeout        = pDLLUsbI2CSetTimeout(lpfnUsbI2CSetTimeout);
   UsbEEpSetTimeout        = pDLLUsbEEpSetTimeout(lpfnUsbEEpSetTimeout);
   UsbParSetTimeout        = pDLLUsbParSetTimeout(lpfnUsbParSetTimeout);
   UsbSpiInit              = pDLLUsbSpiInit(lpfnUsbSpiInit);
   UsbSpiTransfer          = pDLLUsbSpiTransfer(lpfnUsbSpiTransfer);
   UsbSpiTransferByte      = pDLLUsbSpiTransferByte(lpfnUsbSpiTransferByte);
   UsbParSetWaveforms      = pDLLUsbParSetWaveforms(lpfnUsbParSetWaveforms);
   UsbParSetTransferSize   = pDLLUsbParSetTransferSize(lpfnUsbParSetTransferSize);

   UsbSetTimeout           = pDLLUsbSetTimeout(lpfnUsbSetTimeout);
   UsbGetVersion           = pDLLUsbGetVersion(lpfnUsbGetVersion);
   UsbWaituSec             = pDLLUsbWaituSec(lpfnUsbWaituSec);
   UsbEEpSetAddr           = pDLLUsbEEpSetAddr(lpfnUsbEEpSetAddr);
   UsbParSetWaveforms      = pDLLUsbParSetWaveforms(lpfnUsbParSetWaveforms);
   UsbGetRdyState          = pDLLUsbGetRdyState(lpfnUsbGetRdyState);
   UsbGetStatus            = pDLLUsbGetStatus(lpfnUsbGetStatus);
   UsbGetError             = pDLLUsbGetError(lpfnUsbGetError);
   UsbGetErrorStringByNr   = pDLLUsbGetErrorStringByNr(lpfnUsbGetErrorStringByNr);
   UsbSetLicense           = pDLLUsbSetLicense(lpfnUsbSetLicense);
   UsbSetIOState           = pDLLUsbSetIOState(lpfnUsbSetIOState);
   UsbSetIODir             = pDLLUsbSetIODir(lpfnUsbSetIODir);
   UsbGetIOState           = pDLLUsbGetIOState(lpfnUsbGetIOState);
   UsbSetPortState         = pDLLUsbSetPortState(lpfnUsbSetPortState);
   UsbSetPortDir           = pDLLUsbSetPortDir(lpfnUsbSetPortDir);
   UsbGetPortState         = pDLLUsbGetPortState(lpfnUsbGetPortState);
   UsbI2CSetSpeed          = pDLLUsbI2CSetSpeed(lpfnUsbI2CSetSpeed);
   UsbI2CWriteBytes        = pDLLUsbI2CWriteBytes(lpfnUsbI2CWriteBytes);
   UsbI2CWriteByte         = pDLLUsbI2CWriteByte(lpfnUsbI2CWriteByte);
   UsbI2CReadBytes         = pDLLUsbI2CReadBytes(lpfnUsbI2CReadBytes);
   UsbI2CReadByte          = pDLLUsbI2CReadByte(lpfnUsbI2CReadByte);
   UsbEEpWriteBytes        = pDLLUsbEEpWriteBytes(lpfnUsbEEpWriteBytes);
   UsbEEpWriteByte         = pDLLUsbEEpWriteByte(lpfnUsbEEpWriteByte);
   UsbEEpReadBytes         = pDLLUsbEEpReadBytes(lpfnUsbEEpReadBytes);
   UsbEEpReadByte          = pDLLUsbEEpReadByte(lpfnUsbEEpReadByte);
   UsbParInit              = pDLLUsbParInit(lpfnUsbParInit);
   UsbParInitUsingArray    = pDLLUsbParInitUsingArray(lpfnUsbParInitUsingArray);
   UsbParOut               = pDLLUsbParOut(lpfnUsbParOut);
   UsbParIn                = pDLLUsbParIn(lpfnUsbParIn);

   UsbCheckSpeed           = pDLLUsbCheckSpeed(lpfnUsbCheckSpeed);
   UsbOpen                 = pDLLUsbOpen(lpfnUsbOpen);
   UsbClose                = pDLLUsbOpen(lpfnUsbClose);
   UsbI2CWriteAndReadBytes = pDLLUsbI2CWriteAndReadBytes(lpfnUsbI2CWriteAndReadBytes);
   return true;
}

void UnloadUsb2Dll () {
   FreeLibrary(hUsb2Dll);
}
#endif
 
Private Nachricht senden Benutzer-Profile anzeigen
 
student
Forum-Anfänger

Forum-Anfänger

Beiträge: 25
Anmeldedatum: 10.03.08
Wohnort: ---
Version: 7.0
     Beitrag Verfasst am: 10.03.2008, 23:44     Titel:
  Antworten mit Zitat      
Hallo

vieleicht, hast du genau DAS gesucht
http://www.gomatlab.de/einbinden-vo.....n-t405,highlight,mex.html

Gruss
Private Nachricht senden Benutzer-Profile anzeigen
 
oli
Forum-Newbie

Forum-Newbie

Beiträge: 4
Anmeldedatum: 10.03.08
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 11.03.2008, 11:15     Titel:
  Antworten mit Zitat      
Leider nicht. Ich habe wie gesagt nur die dll und das c-Headerfile. In diesem Thread wird mit Hilfe der Mex-Funktion eine DLL erzeugt.

Eine DLL habe ich wie gesat bereits. Nur kein Headerfile, welches Matlab verarbeiten kann. (Meine Vermutung)
Private Nachricht senden Benutzer-Profile anzeigen
 
oli
Forum-Newbie

Forum-Newbie

Beiträge: 4
Anmeldedatum: 10.03.08
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 11.03.2008, 14:38     Titel:
  Antworten mit Zitat      
Ich meine auch gelesen zu haben, dass man entweder ein Headerfile braucht, oder eine Liste der Funktionen der DLL.

Eine solche Liste existiert für die DLL.

Ein Bsp.-Eintrag:

Code:
UsbGetVersion
         
procedure UsbGetVersion(VersionStr : PChar);

Returns the Versionnumber of usb2dll as String in VersionStr. VersionStr has to point to a memory area of at least 8 Byte length.


Ist damnit etwas anzufangen?
Private Nachricht senden Benutzer-Profile anzeigen
 
oli
Forum-Newbie

Forum-Newbie

Beiträge: 4
Anmeldedatum: 10.03.08
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 17.03.2008, 13:27     Titel:
  Antworten mit Zitat      
Also ich versteh's wirklich nicht.

Es heisst, man kann mit loadlibrary DLLs einbinden. Ich frage mich langsam, ob man damit nur von Matlab erstellte DLLs einbinden kann?

ich habe ja nun eine DLL und ein Headerfile, mit dem man die DLL in einer C++ einbinden kann.

Geht das vielleicht garnicht in Matlab, ohne dass man die DLL umschreibt? Was ich leider nicht kann, da ich keinen Zugang zu den Quelldateien habe.
Private Nachricht senden Benutzer-Profile anzeigen
 
Gast

Gast

Beiträge: ---
Anmeldedatum: ---
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 20.10.2008, 16:53     Titel: libname nicht vergessen
  Antworten mit Zitat      
Versuch mal das folgende:

Code:
libname = loadlibrary('usb2.dll', 'Usb2Dll.h');
m=libfunctions('libname');
 
Neues Thema eröffnen Neue Antwort erstellen



Einstellungen und Berechtigungen
Beiträge der letzten Zeit anzeigen:

 Du kannst Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
Du kannst Dateien in diesem Forum posten
Du kannst Dateien in diesem Forum herunterladen
.





 Impressum  | Nutzungsbedingungen  | Datenschutz | FAQ | goMatlab RSS Button RSS

Hosted by:


Copyright © 2007 - 2024 goMatlab.de | Dies ist keine offizielle Website der Firma The Mathworks

MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, SimBiology, SimHydraulics, SimEvents, and xPC TargetBox are registered trademarks and The MathWorks, the L-shaped membrane logo, and Embedded MATLAB are trademarks of The MathWorks, Inc.