Hi liebe Mikrocotroller-user und Gäste,
ich habe jetzt schon ein paar Monate Erfahrung in FPGA-Programmierung
(hauptsächlich bei Altera und Lattice Produkten). Leider ist mir die
Kommunikation zwischen meinen Boards und eines Hosts (PC) ziemliech
unbekannt. Ich benutze USB und meine Boards haben alle FTDIs (ua
ft2232hl). Ich habe jedoch leider nicht das grundlegende Wissen über USB
und FTDIs. Ich weiss, dass es so verschiedene Modi gibt, wie z.B: UART,
FIFO, JTAG, BitBang. Aber wie funktioniert denn überhaupt die
Datenübertragung vom Host über USB zum FTDI-Chip? Schließlich hat der
USB doch nur zwei Datenleitungen, wie kann man damit denn gescheit Daten
übertragen? Empfängt der FTDI die Daten und wandelt das ganze in ein
anderes Prokoll um (wie JTAG, wenn das eins ist)?
Wie schon gesagt, ich verstehe das alles nicht, wäre super, wenn mir da
jemand die ganze Sache erklären könnte!
Gruß,
Alexx
USB ist ein recht simples Protokoll, auf den zwei Leitungen wird im
Halbduplex Betrieb gearbeitet. Da der Host immer Master und das Device
immer Slave ist und an einem Kabel immer nur genau ein Slave ist, ist
die Sache recht einfach vom Master steuerbar. Bis USB 2.0 ist das auch
alles im Polling, das Device darf von sich aus keine Daten schicken.
Das hat dich beim FTDI aber alles nicht zu interessieren. Du wählst ein
für sich am besten passendes Protokoll (am FPGA sinnvollerweise ein
FIFO-basiertes) und auf der Host-Seite sprichst du den FTDI Triber über
die DLL an. Da kannst du dann angeben, welches Protokoll auf der
Device-Seite gefahren wird, und der rest läuft dann im Treiber bzw. in
den DLLs ab.
Alexx schrieb:> Leider ist mir die Kommunikation zwischen meinen Boards und eines Hosts> (PC) ziemliech unbekannt.
Welche "Kommunikation"?
Es gibt da grundsätzlich 2 Pfade, die nötig/möglich sind:
1. die Programmierschnittstelle und
2. ein Kommunikationspfad zur Datenübertragung?
Auf deutsch: willst du selber einen Programmer bauen,
oder willst du irgendwelche Daten ans FPGA schicken?
Moin,
guck mal nach Stichwort "MPSSE" - der FTDI hat eine simple Engine um
USB-Kommandoströme in SPI, JTAG, oder ähnliche Protokolle zu wandeln.
Also vereinfacht: Um eine gewisse JTAG-Sequenz "rauszuclocken" schickst
Du einfach die entsprechenden Befehle per ftdi-API und liest u.U. auch
wieder Daten zurück.
Da das ganze mit FIFO-Puffern und nicht duplex arbeitet (USB), musst Du
Dir Gedanken machen, wie Du die Daten pufferst (Stichwort "Queueing"),
damit a) der Link nicht lahm wird (Ping-Pong-Transfers sind schlecht),
oder b) interne FIFOs vollaufen.
Gibt aber für den FTDI schon ne Menge fertige Programme, z.B. xilprg,
xcs3prog, etc.
Zusätzlich kann der FTDI ja noch als FIFO arbeiten um richtig schnell
Daten ans FPGA zu streamen. Aber den meintest Du vermutlich weniger?
Der Vorteil des FT2232H gegenüber dem FX2 ist allerdings, neben der viel
einfacherern Programmierung, dass man sich nicht von der usb.org
abzocken lassen muss, wenn man Hardware auf den Markt bringen will.
FTDIchip.com teilt einem relativ unbürokratisch auf Anfrage einen Satz
PIDs zu.
Grüsse,
- Strubi
SuperWilly schrieb:> Wenn dem so WÄRE, bräuchte man keine FTDI-Chips ;-)
Naja, es ist wirklich simpel. Allerdings mit strengen
Timing-Anforderungen. Daher die Spezial-Chips. Das Protokoll an sich ist
wesentlich einfacher als beispielsweise FireWire oder PCIe. Bei
Antwortzeitfenster im ns-Bereich ist es allerdings schon ratsam einen
speziellen Controller zu nehmen, sonst artet das in Gefrickel wie V-USB
aus.
Danke Leute, jetzt ist schon alles etwas klarer!
Lothar Miller schrieb:> Auf deutsch: willst du selber einen Programmer bauen,> oder willst du irgendwelche Daten ans FPGA schicken?
Eigentlich möchte ich erstmal irgendwelche Daten schicken. Das ganze
sollte eben vom Host über USB zum FTDI geschickt werden und vom FPGA
über FTDI zurück an den Host.
Über MPSSE hab ich schon auf der FTDI-Herstellerseite was gelesen, aber
welches Prokoll eignet sich denn am besten? Also welches ist denn
einfach und schnell und auch einfach und zu als HDL Code zu schreiben?
Ich hab gar nicht gewusst, dass man den FTDI auch als FIFO benutzen
kann, eigentlich schreibe ich immer für den FPGA ein Modul. Ich hab mir
nochmal das Datasheet angesehen
(http://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT2232H.pdf)
und tatsächlich gibt es einen FIFO!
Ich sehe mir jetzt mal die libFTDI an, die sieht ganz vielversprechend
aus:) Mit welcher Frequenz muss ich eigentlich den FTDI auf dem Board
tackten?
Gruß
-Alexx
Hallo @Alexx.
Ich würde erst einmal einen UARTCORE via RS232 auf dem FPGA machen.
Mit dem Host-Pc via FTDI2232 den FPGA-UART COM:xx B-Port damit koppeln.
Beispiel hier:
Xilinx VHDL UART Example
FT2232 USB chip. UART mit 3Mbit/Sek via FPGA SPARTAN 6
VIDIO Tutorial 1 bis 3.
######################################################################
Board-base Clock @32MHz 3* @96Mhz @48MHz. a*16 via DCM…
bit-Samples
http://www.gadgetfactory.net/2010/11/xilinx-vhdl-uart-example/?main_page=wordpress
------------------------------------------------------------------
VHDL UART STATE ENGINE hat der mit dem VHDL-Uart erweitert.
http://www.youtube.com/watch?v=-ysAlp-Lt5Q&context=C47343b2ADvjVQa1PpcFM0mMck76RlrUG_CdgcMq5heRFfkcqG91U=
…………
Alternativ:
FTDI FT2232H als MPSSE: (FT245 ,SPI, I2CBUS, JTAG… )
Ich muss mal checken ob ich die aktuelle libftd2xx.a mit meinem CHIP
Rev.
FT2232H von ELV Elektronik auch geht.
Zitat:
The MPSSE mode needs a different open/init sequence, thus ftdi_open()
was split into ftdi_generic_open() and ftdi_std_open():
------------------------------------------------------------------------
------------------------------------------------------------
libftd2xx.a and ftd2xx.h
When comes it with a Progammable CPU as Micro Seqencer Protocol Cammand
Engine.
http://sourceforge.net/apps/mediawiki/urjtag/index.php?title=FT2232_cable_driver#ftdi_Parport_Driver
Stichwort:
new ftdi_mpsse_connect() calls ftdi_parport_alloc() with specific driver
and outbuf length for MPSSE mode
ftdi_mpsse_open
ftdi_parport_free( parport_t *port )
libftdi-config
ftdi_write_data
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++
Für MPSSE mode muss ich das EEPROM vom FT2232H auch noch
Mit dem MSProg Tool umproggen.
Was ein USB3.0 Chip von Cypress mit ARM 3 Core angeht sind damit noch
Reserven * 10 drin.
Das JTAG:
http://www.fpga4fun.com/JTAG2.htmlhttps://github.com/makestuff/libfpgalink/blob/master/firmware/jtag.c
Viel Erfolg.
Gruss Holger.
Was die diversen JTAG Sourcen von dem github.com/makestuff/…. Betrifft
Habe ich bemerkt das da was faul mit dem TMS im vorletzten Bit ist.
TMS und CLOCK sind now „COMMON“, und da ist „kein“ CLOCK mehr noetig.
(Vorher adequaten TDI Bit-Pegel anlegen …)
Da das der TMS Pegel „Flip-back to High“ in diesem Moment macht.
Hier ist das richtig:
while ( i && leftOver ) {
leftOver--;
if ( (m_flagByte & bmISLAST) && !leftOver ) {
TMS = 1; // Exit Shift-DR state on next clock
}
TDI = tdiByte & 1;
tdiByte >>= 1;
TCK = 1;
TCK = 0;
i <<= 1;
}
} else {
// This is not the last chunk, so we've to 512 bytes to shift
blockShiftOut();
}
Gruss Holger.
Um schnell Daten zwischen PC und FPGA mit den FTDI Chips auszutauschen
dient der FIFO Modus. Asynchronous FIFO kann bei den nicht -H Typen
vielleicht bis zu 1 MByte/s, bei den -H Typen ist 8 MByte angegeben.
Single channel synchronous FIFO ist mit > 25 MByte angegeben. Wenn es
langsamer sein kann, darf man auch an die seriellen Protokolle denken.
Was dann zwischen FTDI, USB Stecker, USB Kabel und PC passiert,
interessiert Dich in erster Naeherung nicht. Erst wieder, wie Du die
Daten in deinem Programmen bereitstellst/abholst.
@uwebonnes:
Ich denke, dass ich den FIFO-Mode für meinen FTDI (FT2232HL) benutzen
werde, die Geschwindigkeit ist jedenfalls beachtlich!
Kennst du dich zufällig auch mit der FTDI-Programmierung in C auf der
Seite des Hosts aus? Ich benutze den Treiber bzw. die D2XX.dll, um den
Chip anzusprechen. Ich würde jetzt gerne ein kleines Tool schreiben, das
den FIFO des FTDIs ausließt, wenn er voll ist (er wird nur vom FPGA
gefüllt und der Host ließt nur). Dazu setze ich den FTDI mit
"FT_SetBitmode" mit dem ucMode-Parameter 0x40 (für Single Channel
Synchronous 245 FIFO Mode) in den FIFO Mode. Dann muss ich ihn noch mit
FT_Read auslesen, oder wie? Vorher muss ich den EEPROM natürlich noch
mit "FT_EEPROM_Program" programmieren, sodass Channel A für den FT245
FIFO-Mode konfiguriert wird. Wie mache ich das denn genau?
Gruß,
Alex
Ich habe einigen Code fuer libftdi
http://www.intra2net.com/en/developer/libftdi/repository.php
geschrieben, darunter streamtest fuer den synchronen Fifo Modus im 1.0
branch. Wenn Du dass fuer FTD2XX umschreiben willst, dann schau Dir das
mal an, oder benutrze gleich libftdi. Bei Interesse kann ich auch meinen
Verilog Code fuer das Fifo im FPGA bereitstellen.
Um die hohen Raten zu erreichen, muss das Betriebssystem Leseanfragen in
ausreichender Rate an den FTDI schicken. Eine "Warte auf xxx" ist das
kontraproduktiv.
EEPROM Programmieren geht auch mit libftdi.Nur braucht libftdi1 libusb1,
und das ist unter Windows nicht ohne...
Tschuess
Ich kenne die libftdi, die benutze ich immer unter Linux. Ich möchte
aber auch mal was für Windows coden, deswegen hab ich das D2XX benutzt
(libftdi unter Windows ist schwer zu benutzen).
Ich schau mir mal den Code von libftdi an, mal sehen, ob ich das
einigermaßen umschreiben kann...
Wäre wirklich super, wenn du mir den Verilog-Code geben könntest!
Handelt es sich dabei auch um ein Design, das den ft2232h(l) im
FIFO-Mode benutzt?
Gruß,
Alex
Wie ist denn der FTDI am FPGA angeschlossen ?
Wird er schon als JTAG programmieradapter benutzt und hängt am JTAG des
FPGAs ? Mußt dir halt mal den Schaltplan angucken.
Wie gesagt: bei mir wird er als USB zu JTAG-Wandler benutzt, aber ich
möchte ihn jetzt auch in seinem FIFO Modus nutzen.
Ich hoffe, dass das mit meinem Board funktioniert (ob die dazu nötigen
Pins des FTDI am FPGA angeschlossen sind)...
Übrigens vielen Dank für den source, den du mir gemailt hast! Sieht
schonmal vielversprechend aus, am Wochenende kann ich ihn mir dann mal
genauer ansehen.
Gruß,
Alex
Leider benutzt mein Board den FT2232H nur als Schnittstellen-Wandler.
Ich kann den FIFO-Mode leider so nicht nutzen! Ganz einfach, weil die
Pins vom FTDI nicht ans FPGA angeschlossen sind:/
Ich kann jetzt leider nur das JTAG-output vom FTDI benutzen. Ansonsten
müsste ich mich mal nach einem anderen Board umschauen oder eins selber
entwickeln (das habe ich aber noch nie gemacht)...
