Forum: PC-Programmierung DLL für Cypress CyUSB Treiber erstellen

Das könnte gehen, allerdings nicht als "Umformung der LIB in eine
DLL".

Du bist aber nicht allein mit dieser Idee:
http://forum.hardware.fr/hardwarefr/Programmation/creer-partir-librairie-statique-sujet-83307-1.htm
http://forums.ni.com/ni/board/message?board.id=170&message.id=143300

Ein möglicher Weg könnte sein, die LIB statisch an eine zuschreibende
DLL zu binden und über Interfacefunktionen in der DLL zu nutzen.

Zu beachten wäre, dass die Codeseiten einer DLL bei mehreren Aufrufern
pysikalisch auf einen Bereich abgebildet werden, d.h. der Code (und
falls erwünscht auch Daten) geshared werden. Daten würde ich erst mal
nicht sharen, denn das erfordert im Gegensatz zu der statischen
Library, dass die DLL und die dazugebundene LIB reentrant geschrieben
sind.

Eine weitere Falle lauert auf die DLL, wenn du ein Mulithread-Programm
hast. Es kann in dem Fall notwendig sein, entsprechenden Platz für
Daten beim Threadwechsel anzufordern (bei explizitem
Loadlibrary-Aufruf) bzw. vom Linker in der DLL bereitzustellen (beim
imlpiziten Aufruf).

s/pysikalisch/physikalisch/

Danke für deine Antwort, die mir schonmal sehr weiterhilft (vor allem
die beiden links), auch wenn ich nicht wirklich alles davon verstanden
habe.

Soweit ich das jetzt glaube zu verstehen, muss ich also ein sog.
"Wrapper" in Form einer *.def Datei erzeugen.
Bei dem französischen Link von oben hat dies ja auch schon jemand
getan. Was mach ich aber anschließend mit dieser *.def Datei in Visual
C++ um mir die DLL erzeugen zu lassen? Das geht irgendwie nicht so
richtig aus diesem Link hervor, da die dann irgendwie zu Visual Basic
abschweifen.

Vielelicht kann mir ja jemand die Vorgehensweise dazu etwas näher
erläutern. Ich hoffe meine Frage ist nicht zu trivial, aber ich bin in
Visual C++ leider nicht all zu konform.

Nee, du musst schon noch Code selbst schreiben.

Im Prinzip musst du für jede Funktion aus der stat. Library eine
Wrapperfunktion schreiben, die vom Hauptprogramm aufgerufen wird, die
Parameter an die stat. Libraryfunktion übergibt und den Rückgabewert an
das Hauptprogramm übergibt.

Also in etwa (obacht: C++ Laie!!!)

CCyUSBConfig my_CCyUSBDevice_GetUSBConfig(CCyUSBDevice my_CCyUSBDevice,
int index)
{
   return my_CCyUSBDevice.GetUSBConfig(index);
}

als Wrapper für die Libraryfunktion

CCyUSBDevice::GetUSBConfig(index)

Aufwändig wird dies dadurch, dass du eine C++ Library hast und du
ausser den Funktionen (Methoden) auch das Anlegen/Zerstören der Objekte
berücksichtigen musst.

Im Prinzip stellt deine DLL ein eigenständiges USB Steuerprogramm dar,
das über die Wrapperfunktionen ein Interface nach aussen hat.

Das ist definitiv kein Projekt für einen Abend.

Hallo,

ich beschäftige mich auch gerade damit, für diesen Cypress Bausteine 
eine DLL zu kodieren, allerdings in Delphi.

darin will ich den CyUSB Treiber ansprechen. also den CyAPI weglassen, 
da sonst folgende Konstruktion hätte:

CyUsb <- CyApi <- CyPas <- Applikation

ich will aber

CyUsb <- CyPas <- Applikation


Bin ich da der Einzige oder gibts noch andere die an dieser Baustelle 
arbeiten?


mfg


derDan

Nein! Du bist nicht der einzige!

Ich brüte derzeit gleichermaßen auch an einer solchen Wrapper-DLL für 
Delphi, nur binde ich die CyApi.lib mit ein.

Bisher bekomme ich einen Zugriff auf das Davice und lasse mir erstmal 
Vendor- und Product-ID anzeigen.

Der Zugriff auf die Read/Write-Funktionen des EP0 bereitet mir jetzt 
Probleme.
Ich bekomme eine Zugriffsverletzung beim USB-Device-Request, vermutlich 
gibt es ein Problem wenn die Lib-Funktion auf meinen Delphi-Buffer 
zugreift. Bin kein Informatiker, daher tue ich mir beim debuggen schwer, 
zumal ich net in die lib sehen kann.

Wie komme ich da am besten weiter bzw. hat jemand nen guten Rat auf 
Lager?

Hallo,
ich bin gerade auf diesen Beitrag gestossen und habe zur Zeit das 
gleiche Problem.
Ich möchte auch per Delphi irgendwie auf den CY7C68013A zugreifen 
können.
Habt ihre dort schon eine Lösung gefunden , oder etwas angearbeitet wo 
man die Struktur erkennen kann ?
Das wäre echt super ...

Gruß

Roy

Delphianer, schaut euch doch mal das an:

http://www.braintechnology.de/braintechnology/usb2dll_help17_en.html#wasistusb2dll

Das sieht ja vom Prinzip her nicht schlecht aus.
Doch wenn ich das richtig verstehe kann man damit nur Daten vom Parallen 
bzw. i2c Port lesen bzw. schreiben.
Was ich suche ist ein Bulk Transfer ....
Hast du schon was an der oben beschriebenen Wrapper dll gemacht ?

Mais non! Isch 'abe gar kein Cypress ;-)

oh, ich dachte.
Schade ...

DLL ist schön, aber es geht doch auch ohne!

Unter Delphi kann man auch auf Treiber wie z.B. EzUsb.sys von Cypress 
zugreifen. Habs probiert und es geht!

Hallo,

ich hab schon eine Portion der Funktionen für delphi erstellt. Ich kann 
schon einen FPGA über den Cypress Chip konfigurieren. Die daten werden 
dabei über den EP0 an den Cypress geschickt und dann seriell auf die 
JTAG Pins. Dazu muss natürlich die richtige SW im Cypress stehen, die 
ich über eine Download Funktion hineinlade.

Die Transfers über die anderen Endpoints scheint zu funktionieren. Ich 
kann die Bulkloop Demo von Cypress reinladen und die Daten hin und her 
schicken.

Ich hänge an dem Punkt an dem der FPGA die Daten liefert und über den 
Cypress an den PC schicken kann.


ist halt alles ein haufen Arbeit.


mfg

@Svenski

Wie hast du das gemacht ?
Kannst du mir da source code für geben ??
Das wäre super

thx schon mal

Roy

Die Quellen sind etwas umfangreich geworden. Muß selbst mal sehen, ist 
schon wieder ne weile her:
Hab dazu das Header-File mit nem Tool nach Delphi portiert, hier und da 
waren dann noch Anpassungen nötig, egal. Aufwendiger ist da schon die 
Portierung ainiger Beispielfunktionen von Cypress, besser ist es schon 
das selbst zu programmieren.

Die Zauberfunktion ist "DeviceIoControl", zu finden in der Delphi SDK. 
Um Zugriff auf Treiberfunktionen zu bekommen wird mit "CreateFile 
('\\.\Ezusb-0', .....);" ein Handle auf das Device geholt. Gesendet und 
empfangen wird dann mit Hilfe eigener Threads und DeviceIOControl.

DerDan hat verdammt recht: Ist alles ein riesen Haufen Arbeit!

@DerDan: CyUsb <- CyPas <- Applikation    --> so mach ich das auch

Das sind drei Baustellen auf einmal, lässt man das FPGA mal aussen vor!

Über diese Cypress geschichten hab ich nur mal am Rande gelesen. Gibt es 
einen Grund, warum es der Treiber vom Hersteller sein muss? Ich habe 
ganz brauchbare Erfahrungen mit der libUSB gemacht. Vielleicht gibts 
dafür ja schon was fertiges.

Man muss unterscheiden welches OS mit der USB zusammenarbeiten soll:

es gibt da
http://www.thesycon.de/deu/usbio_de.shtml
http://libusb.sourceforge.net/download.html
http://javax-usb.org/
http://www.sun.com/download/products.xml?id=411be89d
Müller, Markus und Ehmer, Christian : „USB für Alle I“ in: Elektor 
Ausgabe 10/02, Elektor Verlag,
Müller, Markus und Ehmer, Christian : „USB für Alle II“ in: Elektor 
Ausgabe 11/02, Elektor Verlag,

Programmbeispiel einer Wrapper-Klasse:
public class JNIWrapper {
static {
System.loadLibrary("USBDRV");
}
public JNIWrapper() {
}
private native void open_method();
private native void close_method();
private native int readRam_method(int adresse);
private native void writeRamBytes_method(int startadresse,int 
numberofbytes, byte[]
bytes);
public void open()
{
open_method();
}
public void close()
{
close_method();
}
public int readRam(int adresse)
{
return readRam_method(adresse);
}
public void writeRamBytes(int startadresse,int numberofbytes, byte[] 
bytes)
{
writeRamBytes_method(startadresse,numberofbytes,bytes);
}
public void reset() {
byte eins[] = { (byte)1 };
writeRamBytes_method (0x7f92, 1, eins);
}
public void prg_start() {
byte _null[] = { (byte)0 };
writeRamBytes_method (0x7f92, 1, _null);
}
}
Ich bin speziell auf der Suche nach einer Möglichkeit mit Java unter 
Windows XP mir die übertragenden Daten anzuschauen. Wenn jemand eine 
Lösung gefunden hat bitte mich kontaktieren

isch doch ein Cypress 7c68013, und warum Bulk wenns schon alles gibt ?
oder fehlt was ?

mfg
kai