VERILOG -> VHDL

S

sameem_shabbir

Guest
Ik heb enkele nuttige code ten aanzien van mijn project

Maar het is in VHDL& I ma verilog gebruikerhoe om te zettenof is er een andere manier die ik moet maken enkele wijzigingen in die code
 
Er zijn commerciële instellingen die er die unidirectioneel / bidirectionele conversies echter het bijproduct / resultaat is niet schoon.De beste aanpak om dit te doen is om de oorspronkelijke VHDL bronnen en behandelen hen als een zwarte doos en alles wat je moet doen is het schrijven van een Verilog wrapper rond de top-level-functie.De synthese en simulatie-instrumenten zijn nu in staat de ondersteuning van beide talen tegelijk.

Sante,
-S

 
Hoi!Ik vond dat een nuttige verilog-code voor mijn project, maar
ik ben een VHDL gebruiker.Ik weet dat de Xilinx Webpack wat
ik gebruik zowel verilog en VHDL.
Maar ik zou graag willen begrijpen alle code, alsjeblieft, kan iemand het vertalen voor mij.
is het niet een lange code.Zelfs als het deel van deze code zal worden vertaald,
ik waardeer,
ik dank u bij voorbaat.

/ / Synchronisatie SCK op de klok FPGA met behulp van een 3-bits verschuiving registreren
reg [2:0] SCKr; altijd @ (posedge clk) SCKr <= (SCKr [1:0], SCK);
draad SCK_risingedge = (SCKr [2:1] == 2'b01); / / Nu kunnen we detecteren SCK oplopende randen
draad SCK_fallingedge = (SCKr [2:1] == 2'b10); / / en dalende randen

/ / Hetzelfde voor SSEL
reg [2:0] SSELr; altijd @ (posedge clk) SSELr <= (SSELr [1:0], SSEL);
draad SSEL_active = ~ SSELr [1]; / / SSEL actief is laag
draad SSEL_startmessage = (SSELr [2:1] == 2'b10); / / bericht begint bij dalende rand
draad SSEL_endmessage = (SSELr [2:1] == 2'b01); / / bericht stopt bij stijgende rand

/ / En voor MOSI
reg [1:0] MOSIr; altijd @ (posedge clk) MOSIr <= (MOSIr [0], MOSI);
draad MOSI_data = MOSIr [1];

/ / Nu ontvangt gegevens van de SPI-bus is eenvoudig.

reg [2:0] bitcnt / / we omgaan met SPI in 8-bits-formaat, dus moeten we een 3-bits teller te tellen de bits als zij komen in
reg byte_received / / hoog wanneer een byte is ontvangen
reg [7:0] byte_data_received;

altijd @ (posedge clk)
beginnen
if (~ SSEL_active)
bitcnt <= 3'b000;
anders
if (SCK_risingedge)
beginnen
bitcnt <= bitcnt 3'b001;
byte_data_received <= (byte_data_received [6:0], MOSI_data); / / uitvoeren van een shift-links register (sinds we ontvangen de gegevens MSB eerste)
eindigen
eindigen

altijd @ (posedge clk) byte_received <= SSEL_active & & SCK_risingedge & & (bitcnt == 3'b111);

/ / We gebruiken de LSB van de ontvangen gegevens te controleren een LED
reg LED;
altijd @ (posedge clk) if (byte_received) LED <= byte_data_received [0];

/ / Tot slot de transmissie deel.

reg [7:0] byte_data_sent;

reg [7:0] CNT;
altijd @ (posedge clk) if (SSEL_startmessage) CNT <= CNT 8' h1 / / tellen de berichten

altijd @ (posedge clk)
if (SSEL_active)
beginnen
if (SSEL_startmessage)
byte_data_sent <= CNT / / eerste byte verzonden in een bericht wordt het bericht tellen
anders
if (SCK_fallingedge)
beginnen
if (bitcnt == 3'b000)
byte_data_sent <= 8'h00 / / na die sturen we 0s
anders
byte_data_sent <= (byte_data_sent [6:0], 1'b0);
eindigen
eindigen

toewijzen MISO = byte_data_sent [7], / / stuurt MSB eerste
/ / We nemen aan dat er slechts een slaaf van de SPI-bus, dus we doen niet lastig met een tri-state buffer voor MISO
/ / We anders zouden moeten tri-state MISO wanneer SSEL is inactief

endmodule

 
sabels,

De Verilog logica is zeer eenvoudig serieel naar parallel conversie (8-bits in dit geval) die leidt tot een begin / einde stellen pols, 3-bits binaire teller en een 8-bit seriële naar parallelle verschuiving registreren.Waarom doe je niet alleen nieuwe code te VHDL of gewoon een black-box rond de Verilog en gebruiken als de bron is.Ik heb veel van modellen met behulp van zowel Verilog en VHDL, Verilog waar is veel eenvoudiger te begrijpen / lezen / volgen.Als u weet heel goed VHDL, Verilog de logica moet ademen.

Sante,
-s

 
helaas
ben ik niet erg goed in VHDL

<img src="http://www.edaboard.com/images/smiles/icon_smile.gif" alt="Lachten" border="0" />

maar ik weet het beter dan dan de Verilog.
wat ik weet is asm en c op PIC microcontrollers.
Wat ik moet doen is een SPI communicatie tussen een PIC18f en een FPGA.En natuurlijk hebben een probleem met de FPGA's deel van de communicatie.

Ik weet wat je bedoelt, met behulp van de verilog-code als een black-box.Het
is een goed idee, maar ik wil niet te gebruiken in dit geval.
Nu probeer
ik te herschrijven dat de code in VHDL.Ik ben beginner op dit gebied hdl dus elke hulp met VHDL-code voor een eenvoudige uitvoering SPI of een vertaling van deze code zal worden gewaardeerd.

sneeuwval: bedankt voor uw antwoord

<img src="http://www.edaboard.com/images/smiles/icon_smile.gif" alt="Lachten" border="0" />
 
gebruik van de instrumenten VHDL te verilog
maar de stijl is niet zo goed

 
Ik was serchin 'voor een tijdje op google maar ik vond het geen enkel vrij bruikbare tool voor Verilog VHDL te converteren.

Kan iemand mij een link voor een gratis, werkt tool.it wordt gewaardeerd, dankzij

 
sabels schreef:

Hoi!
Ik vond dat een nuttige verilog-code voor mijn project, maar ik ben een VHDL gebruiker.
Ik weet dat de Xilinx Webpack wat ik gebruik zowel verilog en VHDL.

Maar ik zou graag willen begrijpen alle code, alsjeblieft, kan iemand het vertalen voor mij.

is het niet een lange code.
Zelfs als het deel van deze code zal worden vertaald, ik waardeer, ik dank u bij voorbaat./ / Synchronisatie SCK op de klok FPGA met behulp van een 3-bits verschuiving registreren

reg [2:0] SCKr; altijd @ (posedge clk) SCKr <= (SCKr [1:0], SCK);

draad SCK_risingedge = (SCKr [2:1] == 2'b01); / / Nu kunnen we detecteren SCK oplopende randen

draad SCK_fallingedge = (SCKr [2:1] == 2'b10); / / en dalende randen/ / Hetzelfde voor SSEL

reg [2:0] SSELr; altijd @ (posedge clk) SSELr <= (SSELr [1:0], SSEL);

draad SSEL_active = ~ SSELr [1]; / / SSEL actief is laag

draad SSEL_startmessage = (SSELr [2:1] == 2'b10); / / bericht begint bij dalende rand

draad SSEL_endmessage = (SSELr [2:1] == 2'b01); / / bericht stopt bij stijgende rand/ / En voor MOSI

reg [1:0] MOSIr; altijd @ (posedge clk) MOSIr <= (MOSIr [0], MOSI);

draad MOSI_data = MOSIr [1];/ / Nu ontvangt gegevens van de SPI-bus is eenvoudig.reg [2:0] bitcnt / / we omgaan met SPI in 8-bits-formaat, dus moeten we een 3-bits teller te tellen de bits als zij komen in

reg byte_received / / hoog wanneer een byte is ontvangen

reg [7:0] byte_data_received;altijd @ (posedge clk)

beginnen

if (~ SSEL_active)

bitcnt <= 3'b000;

anders

if (SCK_risingedge)

beginnen

bitcnt <= bitcnt 3'b001;

byte_data_received <= (byte_data_received [6:0], MOSI_data); / / uitvoeren van een shift-links register (sinds we ontvangen de gegevens MSB eerste)

eindigen

eindigenaltijd @ (posedge clk) byte_received <= SSEL_active & & SCK_risingedge & & (bitcnt == 3'b111);/ / We gebruiken de LSB van de ontvangen gegevens te controleren een LED

reg LED;

altijd @ (posedge clk) if (byte_received) LED <= byte_data_received [0];/ / Tot slot de transmissie deel.reg [7:0] byte_data_sent;reg [7:0] CNT;

altijd @ (posedge clk) if (SSEL_startmessage) CNT <= CNT 8' h1 / / tellen de berichtenaltijd @ (posedge clk)

if (SSEL_active)

beginnen

if (SSEL_startmessage)

byte_data_sent <= CNT / / eerste byte verzonden in een bericht wordt het bericht tellen

anders

if (SCK_fallingedge)

beginnen

if (bitcnt == 3'b000)

byte_data_sent <= 8'h00 / / na die sturen we 0s

anders

byte_data_sent <= (byte_data_sent [6:0], 1'b0);

eindigen

eindigentoewijzen MISO = byte_data_sent [7], / / stuurt MSB eerste

/ / We nemen aan dat er slechts een slaaf van de SPI-bus, dus we doen niet lastig met een tri-state buffer voor MISO

/ / We anders zouden moeten tri-state MISO wanneer SSEL is inactiefendmodule
 
Citaat:Waar is het begin van de SPI-module verklaring?Om ervoor te zorgen dat de vertaler gelukkig, de ingang code moeten vrij van fouten is.
 
Hallo,

eigenlijk ben ik het eens met
de suggestie om sneeuwval instantiëren verilog modules als component in VHDL, zou u geen behoefte aan een bijzonder wrapper in de meeste gevallen.Als een probleem, sommige instellingen kan het nodig een extra gemengde taal licentie optie om dit te doen (denk ik, ModelSim).Maar @ ltera, Xilinx, ongeacht WebTools kunt doen.
it's operation anyhow.

Als u de code te wijzigen of andere manier aan te passen aan uw aanvraag, moet u begrijpen
dat
de werking toch.Ik kan niet zien, dat Verilog is totaal verschillend van VHDL.Ik
ben meestal met behulp van VHDL door traditie, maar begon Verilog voor een aantal projecten op de klanten.Naar mijn mening, het houdt je mentaal wendbaar, hetzelfde als het leren van natuurlijke talen.

Misschien kunnen wij u helpen bij het omzetten van een aantal constructies die zijn niet eenvoudig te begrijpen zijn.Als een fundamenteel verschil, VHDL is getypeerd en ook structurized (en dus meer verbose - of lange adem).

Ik begin met de rand synchrone detectie:
Code:

/ / Synchronisatie SCK op de klok FPGA met behulp van een 3-bits verschuiving registreren

reg [2:0] SCKr; altijd @ (posedge clk) SCKr <= (SCKr [1:0], SCK);

draad SCK_risingedge = (SCKr [2:1] == 2'b01); / / Nu kunnen we detecteren SCK oplopende randen

draad SCK_fallingedge = (SCKr [2:1] == 2'b10); / / en dalende randen
 
[quote = "sameem_shabbir"] Ik heb een aantal nuttige code ten aanzien van mijn project
Maar het is in VHDL
& I ma verilog gebruiker [/ i]
Hoe om te zetten [/ b]
of is er een andere manier die ik moet maken enkele wijzigingen in die code [/ i] [/ quote]

U kunt gebruik maken van XHDL.

 
-------------------------------------------------- --------------------------------------------
--
- VHDL-file gegenereerd door X-HDL
- Za 26 jan 10:27:07 2008
--
- Input file: spi.v
- Design naam: SPI_slave
- Auteur:
- Bedrijf:
--
- Omschrijving:
--
--
-------------------------------------------------- --------------------------------------------
--

PACKAGE SPI_slave_pkg IS
COMPONENT SPI_slave
PORT (
clk: IN bit;
SCK: IN bit;
MOSI: IN bit;
MISO: OUT bit;
SSEL: IN bit;
LED: OUT bit);
END COMPONENT;
EIND SPI_slave_pkg;ENTITY SPI_slave IS
PORT (
clk: IN bit;
SCK: IN bit;
MOSI: IN bit;
MISO: OUT bit;
SSEL: IN bit;
LED: OUT bit);
EIND ENTITY SPI_slave;

ARCHITECTUUR VAN SPI_slave vertaald IS- Sync SCK op de klok FPGA met behulp van een 3-bits verschuiving registreren
SIGNAL SCKr: bit_vector (2 DOWNTO 0);
SIGNAL SCK_risingedge: bit; - nu kunnen we detecteren SCK oplopende randen
SIGNAL SCK_fallingedge: bit; - en de dalende randen
- Hetzelfde voor SSEL
SIGNAL SSELr: bit_vector (2 DOWNTO 0);
SIGNAL SSEL_active: bit; - SSEL actief is laag
SIGNAL SSEL_startmessage: bit; - bericht begint bij dalende rand
SIGNAL SSEL_endmessage: bit; - bericht stopt bij stijgende rand
- En voor MOSI
SIGNAL MOSIr: bit_vector (1 DOWNTO 0);
SIGNAL MOSI_data: bit;
- Nu ontvangt gegevens van de SPI-bus is eenvoudig.
SIGNAL bitcnt: bit_vector (2 DOWNTO 0); - we hanteren SPI in 8-bits-formaat, dus moeten we een 3-bits teller te tellen de bits als zij komen in
SIGNAL byte_received: bit; - hoog wanneer een byte is ontvangen
SIGNAL byte_data_received: bit_vector (7 DOWNTO 0);
- We gebruiken de LSB van de ontvangen gegevens te controleren een LED
SIGNAL byte_data_sent: bit_vector (7 DOWNTO 0);
SIGNAL CNT: bit_vector (7 DOWNTO 0);
SIGNAL MISO_xhdl1: bit; - stuur MSB eerste
SIGNAL LED_xhdl2: bit;

BEGIN
MISO <= MISO_xhdl1;
LED <= LED_xhdl2;

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
SCKr <= SCKr (1 DOWNTO 0) & SCK;
END IF;
Proces beëindigen;
SCK_risingedge <= TO_BIT (SCKr (2 DOWNTO 1) = "01");
SCK_fallingedge <= TO_BIT (SCKr (2 DOWNTO 1) = "10");

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
SSELr <= SSELr (1 DOWNTO 0) & SSEL;
END IF;
Proces beëindigen;
SSEL_active <= NIET SSELr (1);
SSEL_startmessage <= TO_BIT (SSELr (2 DOWNTO 1) = "10");
SSEL_endmessage <= TO_BIT (SSELr (2 DOWNTO 1) = "01");

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
MOSIr <= MOSIr (0) & MOSI;
END IF;
Proces beëindigen;
MOSI_data <= MOSIr (1);

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
ALS (NIET SSEL_active ='1 ') THEN
bitcnt <= "000";
ALSE
IF (SCK_risingedge ='1 ') THEN
bitcnt <= bitcnt "001";
byte_data_received <= byte_data_received (6 DOWNTO 0) & MOSI_data; - uitvoering van een shift-links register (sinds we ontvangen de gegevens MSB eerste)
END IF;
END IF;
END IF;
Proces beëindigen;

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
byte_received <= (SSEL_active EN SCK_risingedge) EN TO_BIT (bitcnt = "111");
END IF;
Proces beëindigen;

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
-
Tot slot de transmissie deel.

IF (byte_received ='1 ') THEN
LED_xhdl2 <= byte_data_received (0);
END IF;
END IF;
Proces beëindigen;

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
IF (SSEL_startmessage ='1 ') THEN
CNT <= CNT "00000001"; - tellen de berichten
END IF;
END IF;
Proces beëindigen;

PROCESS (clk)
BEGIN
ALS (EN clk'EVENT clk ='1 ') THEN
IF (SSEL_active ='1 ') THEN
IF (SSEL_startmessage ='1 ') THEN
byte_data_sent <= CNT; - eerste byte verzonden in een bericht wordt het bericht tellen
ALSE
IF (SCK_fallingedge ='1 ') THEN
IF (bitcnt = "000") THEN
byte_data_sent <= "00000000"; - na dat, sturen we 0s
ALSE
byte_data_sent <= byte_data_sent (6 DOWNTO 0) &'0 ';
END IF;
END IF;
END IF;
END IF;
END IF;
Proces beëindigen;
MISO_xhdl1 <= byte_data_sent (7);
- We gaan ervan uit dat er slechts een slaaf van de SPI-bus, dus we doen niet lastig met een tri-state buffer voor MISO
- Anders zouden we moeten tri-state MISO wanneer SSEL inactief

EIND ARCHITECTUUR vertaald;

 
Hallo,

dank u voor het aantonen van de tool.Ten minste met dit voorbeeld, het resultaat is gelijk aan een handmatige vertaling als ik voor een fragment.

Groeten,

Frank

 
Bedankt

<img src="http://www.edaboard.com/images/smiles/icon_smile.gif" alt="Lachten" border="0" />

Ik waardeer th '.

Regards, Sabres

 
de software die ik kan raden is de X-HDL3, die kunnen helpen u te besparen veel tijd.

 
You must log in or register to reply here.

Welcome to EDABoard.com

Sponsor

Back
Top