Hallo
Ich bin auf dem Gebiet der Softcores relativ neu. Habe etwas Erfahrung
mit VHDL und will nun fertige Interfaces nutzen und konfigurieren.
Angefangen mit dem I2C Softcore von OpenCores.org, der Softcore ist ja
laut Webseite sehr populär, vielleicht nutzt ihn ja auch jemand von
euch.
Ich habe mir mal einen Tag Zeit genommen um mich einzuarbeiten und nun
habe ich eine Hand voll fragen bezüglich des Cores an sich und dem
WISHBONE Interface. Die Dokumente zu beiden habe ich natürlich im
Vorfeld gelesen ;)
Ich hoffe ihr könnt mir weiterhelfen!
1. Bezogen auf WISHBONE:
So wie ich das verstanden habe ist WISHBONE ein standardisiertes
Interface zur Verbindung unterschiedlicher Module und (auf VHDL bezogen)
unterschiedlicher Entitys? An sich eine tolle Sache. Wie verbreitet ist
denn WISHBONE? Lohnt es sich das genauer kennenzulernen oder ist das
mehr so eine Randerscheinung?
2. Bezogen auf den I2C Softcore:
Man arbeitet mit dem Softcore ja indem man bestimmte Register beschreibt
und liest. Soviel ist mir klar.
Funktioniert das dann so, wie ab Seite 47 der WISHBONE Spezification (
http://www.opencores.org/projects.cgi/web/wishbone/wbspec_b3.pdf )
beschrieben? Kann ich damit mit [wb_adr_i] die Register des Softcores
auswählen und dann lesen oder beschreiben (unter Einhaltung des gesamten
Schreib/Lese Ablaufs)?
Und welche Register ich schreiben/lesen muss damit was zustande kommt
kann ich ja dem Datenblatt für dem i2c-Softcore entnehmen, letzte 2
Seiten.
3. Bezogen auf den I2C Softcore:
Im Konkreten binde ich die Top-Entity des Cores als Komponente in meine
"Master"-Entity ein und steuere den Core dann über diese Entity und über
das WISHBONE-Interface?
Ich glaube wenn das soweit stimmt hab ichs geschnallt und kann loslegen
;)
Ich nutze den I2C-Softcore zwar (noch) nicht, aber vielleicht trotzdem
zwei Sätze:
1. Richtig Wishbone ist für FPGAs sowas wie ISA bzw. PCI für PCs. Also
eine standardisierte Busschnittstelle. Genutzt wird das wohl in vielen
Projekten auf OpenCores. Im kommerziellen Umfeld wird es wohl u.a. vom
Microblaze unterstützt.
Also wenn Du vorhast ein paar OpenCores-Sachen zu nutzen, ist ein
bisschen Einarbeitung nicht verkehrt.
2. Ganz genau.
3. Genau. Und wenn etwas C-Quelltext dabei ist, kannst Du den gleich in
Dein Programmverzeichniss verlinken/kopieren. Ein paar Anpassungen, an
welcher Hardware-Adresse Dein Core zu finden ist und die Sache sollte
laufen.
Rick
Also ich hab das jetzt mal ausprobiert aber irgendwie funktioniert das
überhaupt nicht so wie gewünscht.
Hier mal der Code für den Simulator:
1
--Taktgenerator (50 MHz)
2
clock:PROCESS
3
BEGIN
4
wb_clk_i<='1';
5
waitfor10ns;
6
wb_clk_i<='0';
7
waitfor10ns;
8
ENDPROCESS;
9
10
--Reset Impuls zu Beginn erzeugen
11
reset:PROCESS
12
BEGIN
13
waitfor20ns;
14
wb_rst_i<='1';
15
waitfor20ns;
16
wb_rst_i<='0';
17
wait;
18
ENDPROCESS;
19
20
--Prozess für das Schreiben von Daten
21
data_write:PROCESS
22
BEGIN
23
waitfor100ns;
24
25
--Erster Schreibprozess
26
--Clock Edge 0
27
wb_adr_i<="000";-- Prescale-Register für SCL Takt
28
wb_dat_i<=X"63";-- Presclae Wert Hex 63
29
wb_we_i<='1';
30
wb_cyc_i<='1';
31
wb_stb_i<='1';
32
33
waitfor20ns;-- Eine Clock-Periode warten
34
--Clock Edge 1
35
wb_stb_i<='0';
36
wb_cyc_i<='0';
37
38
waitfor40ns;-- Etwas warten...
39
40
--Zweiter Schreibprozess
41
--Clock Edge 0
42
wb_adr_i<="011";-- Transmit Register für Byte senden
43
wb_dat_i<=X"A2";-- Zu sendendes Byte (Slave Addr.)
44
wb_cyc_i<='1';
45
wb_stb_i<='1';
46
47
waitfor20ns;-- Eine Clock-Periode warten
48
49
--Clock Edge 1
50
wb_stb_i<='0';
51
wb_cyc_i<='0';
52
53
waitfor40ns;-- Etwas warten...
54
55
--Dritter Schreibprozess
56
--Clock Edge 0
57
wb_adr_i<="100";-- Command Register, STA u. WR Bit
58
wb_dat_i<=X"90";
59
wb_cyc_i<='1';
60
wb_stb_i<='1';
61
62
waitfor20ns;-- Eine Clock-Periode warten
63
64
--Clock Edge 1
65
wb_stb_i<='0';
66
wb_cyc_i<='0';
67
68
wait;
69
70
ENDPROCESS;
Und im Anhang findet sich die dazu entpsrechende Simulation.
Und dazu gehört wieder die WISHBONE Spezifikation Seite 49:
http://www.opencores.org/projects.cgi/web/wishbone/wbspec_b3.pdf
Außerdem folgendes Beispiel aus dem I2C-Softcore Datenblatt
(Ausschnitt), das oben in Code umgesetzt wurde. Ab 100ns wird dieses
Beispiel umgesetzt:
1
Commands:
2
1) write 0xA2 (address + write bit) to Transmit Register, set STA bit, set WR bit.
3
-- wait for interrupt or TIP flag to negate --
4
2) read RxACK bit from Status Register, should be ‘0’.
Nun mir ist da jetzt einiges unklar...
1. Das ACK vom I2C Softcore dürfte eigentlich erst im 2. Takt (Clock
Edge 1) kommen, es kommt aber immer schon beim 1. Takt (Clock Edge
0)...??
2. Warum sendet der I2C Softcore bei [wb_dat_o] Daten?? Ich lese
nirgends, dass es das tun soll, es würde mir auch nicht einleuchten
warum. Zudem sind die Werte X"FF" und X"00" stark fehlerverdächtig.
3. Der Wert X"A2", der zu dem I2C-Softcore übertragen wird ist die
Slave-Adresse (+ Write Bit). Diese sollte eigentlich über die
I2C-Leitungen gesendet werden, aber diese bleiben total regungslos.
zu 3.:
Wie lange simulierst Du?
Dir ist schon klar das I2C mit 100 kHz oder 400kHz abläuft und Du bei 50
MHz Systemtakt etwas warten musst, eh da was rauskommt.
Hast Du eine echte Hardware zum Testen? Mit Oszi?
Rick
Guten Abend
Meinst du dass es soweit von der Programmierung stimmen müsste?
Ich habe eine echte Hardware zum Testen, habs an der aber noch nicht
ausprobiert, da müsste ich das ganze erst synthesefähig machen, das habe
ich noch nicht.
Wenn ich das machen würde ja, Logic Analyzer hätte ich da, Oszi könnte
ich besorgen wenn nötig. Aber es muss ja auch durch die Simulation
gehen, kann ja nicht sein.
Ich habe die Simulation sehr lange laufen lassen. Wie lange weis ich
nicht aber ich glaube ca. 1,5s und es kam nichts. Binnen 1,5s sollte
sich aber auf jeden Fall was regen.
Hat vielleicht jemand einen Codeschnippsel wie ihr das WISHBONE
Interface ansteuert? Ich habe leider noch nie so eine Referenz gesehen
und weis gar nicht ob das was ich hier mache stimmt oder grottenfalsch
ist.
Echte Hardware ist schon mal gut. Ich würde es einfach ausprobieren.
Man kann nämlich auch zu viel simulieren. Und eine Testbench ist zwar
wichtig und gut, aber "echte" Signale sind manchmal eben doch anders,
als die von der Testbench generierten.
Wer stößt bei Dir eigentlich die I2C-Kommunikation an? Eine
State-Machine? Ein uC-SoftCore? Simulierst Du die mit?
Rick
Hallo
Das I2C Interface sollte nur testweise implementiert werden. Es gibt
dazu weder Softcore noch eine FSM oder sowas in der Art.
Ich wollte gerade den Umgang mit Softcores und auch dem WISHBONE
Interface lernen. Desshalb habe ich mir einen Core rausgesucht, dessen
Tun ich bereits verstehe (in dem Fall das I2C Interface).
Wenn ich jetzt einen zusätzlichen Softcore einbinde komme ich keinen
Schritt weiter, dann habe ich 2 Cores, die nicht funktionieren.
Evtl. werde ich mal eine FSM programmieren sobald ich wieder die
Hardware vor mir habe. Aber ich glaube einfach nicht, dass es daran
liegt. Vielmehr glaube ich, dass ich irgendetwas nicht beachtet habe und
einen groben Denkfehler drin hab.
Desswegen wäre so ein "Referenzcodeschnippsel" zum WISHBONE auch so
hilfreich. Damit ich zumindest das mal ausschließen kann. Bin immer noch
auf der Suche danach ;)
Hi,
der Thread ist zwar schon etwas älter, ich stehe momentan aber vor dem
selben Problem, dass ich nicht weiß, ob ich das WISHBONE Interface
richtig ansteuere oder sonst einen Fehler mache.
Hat mittlerweile jmd. ein Codeschnipsel für die Ansteuerung des I2C
Cores von opencores.org?
Ein Dankeschön im Voraus!
MFG
Thomas
Hi Thomas,
bei Lattice (www.latticesemi.com) kannst Du kostenfrei den MICO32
runterladen. Dieses Paket enthält den I2C Opencores Core mit Wishbone
inkl, Doku und einigen Codebeispielen. Habe diese Komponenten dort auch
benutzt, um den Wishbone näher kennenzulernen ;-)
Viele Grüße
Arndt
Eine eigene Frage?
Dieser Thread ist über 18 Jahre alt.
Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.