Synchronous Dual Port RAM:Lattice MACHXO

Een optie is dat je een four way handshake gebruikt om te communiceren voor een domein. Dit wordt veelal gebruikt in asynchrone of klokloze logica en is ook geschikt voor het kruisen van klokdomeinen.

Een "four way handshake" zegt mij nog niet veel.
Hier heb ik even op gegoogled maar werd hier niet veel wijzer van. Misschien kun je deze nader toelichten?
Zelf dacht ik in eerste instantie aan een multiplexer alleen het gevaar is dat je glitches creert op je uitgangs signaal.
In andere woorden je krijgt gauw te maken met metastability in de flip-flops.
Wat betreft de multiplexer is er iemand die ooit iets heeft gemaakt van een glitch free multiplexer in VHDL?
Ik las een artikel op internet over iets dergelijks.

grrr. metastabiliteit is iets anders. je krijgt te maken met setup time violations. metastabieleiteit is het in een analoge toestand drijven van een flipflop.

glitch free multiplexer kan je niet zelf maken. de fpga heeft dat of heeft dat niet. je kan wel zoiets beschrijven in vhdl en dat in gates op een asic laten zetten.

http://www.design-reuse.com/articles/5827/techniques-to-make-clock-swi…

op je fpga lukt dat niet. je hebt daar te maken met dedicated clockpaths. als de fpga daar een mux heeft zitten zijn die glitch free ( bij altera toch. zij hebben speciale clock multiplexer blokken )

als je dpram cell maar 1 clock heeft kan je er geen 2 in proppen. waarschijnlijk zijn de dprams niet gemaakt om met verschillende clockdomeinen te werken. Altera heeft dat wel ( ook alleen maar in bepaalde devices0 daar zijn zelfs concurrent read/writes mogelijk.

Op 22 december 2008 15:23:25 schreef Daryl_F:
Een "four way handshake" zegt mij nog niet veel.
Hier heb ik even op gegoogled maar werd hier niet veel wijzer van. Misschien kun je deze nader toelichten?
Zelf dacht ik in eerste instantie aan een multiplexer alleen het gevaar is dat je glitches creert op je uitgangs signaal.
In andere woorden je krijgt gauw te maken met metastability in de flip-flops.
Wat betreft de multiplexer is er iemand die ooit iets heeft gemaakt van een glitch free multiplexer in VHDL?
Ik las een artikel op internet over iets dergelijks.

In dit soort situaties is het het handigste / eenvoudigste om de 'externe' interface (=de logica om het ram heen) zodanig te maken dat deze met de verschillende klokfrequenties overweg kan. Het dual-port ram en de logica eromheen laat je op de clock met de hoogste frequentie lopen (of als beide frequenties gelijk zijn, de clock die het beste uitkomt).
Wil je de externe interface 'asynchroon' maken, dan zal de interne controle logica op een veel hogere frequentie moeten werken zodat er binnen de toegangstijd tijd is om zowel een woord te schrijven als een woord te lezen.

Op 22 december 2008 17:39:33 schreef free_electron:
grrr. metastabiliteit is iets anders. je krijgt te maken met setup time violations. metastabieleiteit is het in een analoge toestand drijven van een flipflop.

Ik dacht juist dat je door de glitches je setup en hold tijden niet waar kunt maken die uit eindelijk tot metastabiele toestanden van je flip flops kan leiden.

Wat betreft de schakeling die in free_electron's link wordt weergegeven voor unrelated clocks. Betekent dit dat het geen zin heeft om deze te gaan implementeren in een FPGA?
Ik heb gewoon een eenvoudige AND OR multiplxer gemaakt in VHDL en deze gesimuleerd in ModelSim en ik krijg inderdaad de glitches te zien.
Wat de synthese tool ervan maakt is natuurlijk wat anders dan je VHDL code simuleren.

je kan een flipflop metstabiel krijgen door setup en holdtime violations , maar het kan ook door voedingsschommelingen...

Je kan proberen dat circuit te maken ( ik zou dat dan als schematic doen , het zou anders wel eens kunnen weggesynthetiseerd worden ) maar dan nog. het kan moeilijk zijn om dat een clocknet te laten driven.
ik weet dat altera dergelijke blokken klaar heeft zitten. elke PLL heeft een paar van die glitchloze clockmultiplexer. het zit ook als los blok in de library.
misschien is er wel zo ene blok in de lattice chip ook. je moet eens in de library gaan zien van standard lbokken

Ik heb inmiddels de schakeling opgebouwd zoals gegeven in de link, lijkt ook wel te werken.

http://www.design-reuse.com/articles/5827/techniques-to-make...-free.h…

Zie ook wel het idee erachter, echter wordt verteld dat je metastabiliteit niet altijd kunt voorkomen met deze schakeling maar je "MTBF" wordt een stuk lager.

Bij de synthese ziet de schakeling er ook wel goed uit.

Het is jammer dat ik gelimiteerd ben aan "Lattice" echter zijn het wel mooie low cost devices alleen soms schiet je met de mogelijkheden net te kort.
Altera is voor mij geen mogelijkheid
(om politieke redenen vraag me geen details verder!), Xilinx verder wel alleen waren de kosten voor een vergelijkbare device hoger en dan heb ik het over de Spartan 3AN serie.
Tevens is hun kleinste device met interne flash in een te grote package voor op mijn PCB.
Echter krijg je bij de xilinx devices wel veel meer distributed RAM en block RAM ter beschikking.
Maar goed de vraag is of we nog verder gaan met deze DPRAM in een FPGA.
Echter voor mij geen verspilide tijd want ik heb mooi de kans gekregen om VHDL te leren met mijn eerste project.

Tevens voor de geintereseerden de VHDL source van de glitch free clock multiplexer:

----------------------------------------------
library ieee;
use ieee.std_logic_arith.all;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity MACHXO is
port
(
CLK_SEL :in std_logic;
OUT_CLK ut std_logic;
L_CLK :in std_logic;
C_CLK :in std_logic;
);

end entity;

architecture Behaviour of MACHXO is

signal D1_L_CLK: std_logic; --1st D-FF input (depends on L_CLK rising edge)
signal Q1_L_CLK: std_logic; --1st D-FF output
signal D2_L_CLK: std_logic; --2nd D-FF input (depends on inverted L_CLK rising edge)
signal Q2_L_CLK: std_logic; --2nd D-FF output
signal L_CLK_INV: std_logic; --Inverted L_CLK signal for 2nd D-FF
signal L_CLK_OUT: std_logic; --L_CLK output

signal D1_C_CLK: std_logic; --1st D-FF input (depends on C_CLK rising edge)
signal Q1_C_CLK: std_logic; --1st D-FF output
signal D2_C_CLK: std_logic; --2nd D-FF input (depends on inverted C_CLK rising edge)
signal Q2_C_CLK: std_logic; --2nd D-FF output
signal C_CLK_INV: std_logic; --Inverted C_CLK signal for 2nd D-FF
signal C_CLK_OUT: std_logic; --C_CLK output

begin
--------------------L_CLK:1st flip-flop----------------------
--1st D-FF is set when CLK_SEL '1' and at the rising edge of L_CLK
process (D1_L_CLK, L_CLK) begin
if (rising_edge (L_CLK)) then
Q1_L_CLK <= D1_L_CLK;
end if;
end process;

D1_L_CLK <= (CLK_SEL and not Q2_C_CLK);
--------------------L_CLK:2nd flip-flop----------------------
--2nd D-FF is set at the rising edge of inverted L_CLK
process (D2_L_CLK, L_CLK_INV) begin
if (rising_edge (L_CLK_INV)) then
Q2_L_CLK <= D2_L_CLK;
end if;
end process;

D2_L_CLK <= Q1_L_CLK;
--------------------C_CLK:1st flip-flop----------------------
--1st D-FF is set when CLK_SEL '0' and at the rising edge of C_CLK
process (D1_C_CLK, C_CLK) begin
if (rising_edge (C_CLK)) then
Q1_C_CLK <= D1_C_CLK;
end if;
end process;

D1_C_CLK <= (not CLK_SEL and not Q2_L_CLK);
--------------------C_CLK:2nd flip-flop----------------------
--2nd D-FF is set at the rising edge of inverted C_CLK
process (D2_C_CLK, C_CLK_INV) begin
if (rising_edge (C_CLK_INV)) then
Q2_C_CLK <= D2_C_CLK;
end if;
end process;

D2_C_CLK <= Q1_C_CLK;
---------------------------------------------------------------
L_CLK_OUT <= (L_CLK and Q2_L_CLK);
C_CLK_OUT <= (C_CLK and Q2_C_CLK);

C_CLK_INV <= not C_CLK;
L_CLK_INV <= not L_CLK;

OUT_CLK <= (C_CLK_OUT or L_CLK_OUT);

end architecture;