Inleiding tot High Speed SerDes in VHDL

Serie-/deserializer modules (Serializer) zijn fundamentele bouwstenen in moderne datacommunicatiesystemen met hoge snelheid. Ze zetten parallelle datastromen om in seriële vorm voor transmissie over één enkel differentiaalpaar of optische vezel, en reconstrueren vervolgens de parallelle data bij de ontvanger. De implementatie van een robuuste, snelle SerDes in VHDL vereist een diep begrip van digitale ontwerpprincipes, klokarchitecturen en signaalintegriteit. Dit artikel biedt een uitgebreide gids voor het ontwerpen van SerDes in VHDL, die architectuur, timing, coderingstechnieken, simulatie en validatie omvat. Het is bedoeld voor ingenieurs die SerDes moeten integreren in FPGA of ASIC ontwerpen voor toepassingen zoals Gigabit Ethernet, PCI Express, SATA, en hoge snelheid backplanes.

SerDes Architectuur Fundamentals

Een complete SerDes kan worden onderverdeeld in vier belangrijke subsystemen: de serializer, de deserializer, klok data recovery (CDR) en uitlijning/framing circuits. Terwijl de zender kant serialiseert parallelle gegevens, de ontvanger kant moet de bit klok te herstellen van de binnenkomende seriële stroom en uitlijnen van de data grenzen. Elk subsysteem legt duidelijke beperkingen op het VHDL ontwerp.

Serializer (parallel-to-serieomvormer)

De seriële versleutelaar neemt een N-bit breed parallel woord en geeft de bits één voor één af op de regelsnelheid. De parallelle klok () is typisch N[] keer langzamer dan de seriële klok (). In VHDL kan de seriële verzender worden geïmplementeerd als een shift register met een teller die bitselectie regelt. Voor een goede hoge snelheid moet het shift register worden gesynthetiseerd met behulp van speciale flip-flops met minimale klok-tot-output vertraging, en de timing tussen parallelle en seriële domeinen moet zorgvuldig worden beheerd om metastbaarheid te voorkomen.

Deserializer (Serial-to-Parallel Converter)

De deserializer voert de omgekeerde bewerking uit: het ontvangt een seriële bitstroom en reconstrueren het parallelle woord. De binnenkomende bits worden verplaatst naar een register op elke seriële klokrand. Wanneer het volledige woord is samengesteld, wordt het gepresenteerd op de parallel uitvoerbus met een bijbehorende geldige vlag. De deserializer moet ook bit uitlijning behandelen; als de datastroom geen bekend kaderpatroon heeft, wordt de uitlijning bereikt via komma-tekens of pakketkoppen.

Klokgegevensherstel (CDR)

CDR haalt de seriële klok uit de binnenkomende datastroom. Dit is van cruciaal belang omdat de ontvanger en de zender niet in veel systemen zijn vergrendeld. In high-speed SerDes wordt CDR meestal geïmplementeerd als een fase-gesloten lus (PLL) of vertragingsgesloten lus (DLL) die een lokale oscillator aanpast aan de inkomende datatransities. Hoewel CDR zelden is gecodeerd in pure VHDL voor gate-level synthese (het gebruikt analoge of gemengde-signaalcircuits in ASIC's, of geharde blokken in FPGA's), kan het digitale gedeelte zoals fasefrequentiedetectoren en digitale loopfilters worden beschreven in VHDL. Het begrijpen van het CDR-gedrag is essentieel bij het ontwerpen van de de deserializer control logic.

Uitlijning en framing van woorden

Na CDR moeten de binnenkomende bits worden uitgelijnd met woordgrenzen. Veel protocollen hebben een apart patroon (bijv. K28,5 in 8b/10b) dat de deserializer gebruikt om bytegrenzen te lokaliseren. De VHDL uitlijningslogica bevat een statusmachine die het patroon zoekt en dan de bitstroom verplaatst totdat het patroon is aangepast. Dit zorgt ervoor dat de volgende parallelle woorden correct zijn ingelijst.

Uitdagingen in High-Speed SerDesign

High-speed SerDes werken met meerdere gigabitsnelheden, vaak meer dan 10 Gbps per rijstrook. Bij deze snelheden worden fysieke en digitale ontwerpuitdagingen uitgesproken.

Timingsluiting en metasteerbaarheid

De serializer en deserializer moeten gegevens tussen klokdomeinen (parallel en seriële) overdragen. Metastability kan optreden als de instellingen/hold times worden geschonden. VHDL-ontwerpers moeten synchronisatieapparaten invoegen en het synthesegereedschap zorgvuldig beperken om de timing te kunnen afspelen. Het gebruik van dubbele of drievoudige flop-synchronisaties voor controlesignalen is standaardpraktijk.

Jitter en Skew

Jitter in de herstelde klok kan bitfouten veroorzaken. In de seriële knop leidt de klokkenschommeling tussen de parallelle en seriële domeinen tot onjuiste bitbestelling. Om dit te bestrijden, gebruiken SerDes ontwerpen met hoge snelheid vaak differentiële signalering, voor-elastiek en egalisatie. Vanuit een VHDL-standpunt moeten ontwerpers de combinatorische logica in het seriële datapad minimaliseren; retiming (het verplaatsen van flip-flops om vertragingen in evenwicht te brengen) is een veel gebruikte techniek.

Energieverbruik

Schakelen op gigabit frequenties trekt significant dynamisch vermogen. Power reducation strategieën omvatten klokgating, het verlagen van de voedingsspanning (als de doeltechnologie het toelaat), en het gebruik van serializers met lagere parallelle breedten (bijv. het verschuiven van 8 bits vs. 32 bits) om de seriële klokfrequentie te verminderen. In VHDL, zorgvuldig coderen voorkomt onnodig schakelen van brede bussen.

VHDL Implementatietechnieken voor SerDes met hoge snelheid

Om een betrouwbare werking te bereiken bij multi-gigabitsnelheden, moet de VHDL-code worden gesynthetiseerd tot speciale hardwarebronnen. De volgende secties presenteren praktische coderingstechnieken en voorbeelden.

Gebruik van speciale SerDes Hard Macros

De meeste moderne FPGA's omvatten geharde SerDes transceivers (bijv. Xilinx GTY, Intel E-tiel). Deze blokken bevatten PLL's, CDR, deserializers en egalisatie circuits. VHDL code voor deze apparaten instant designer primitieven en verbindt ze met uw kernlogica. Bijvoorbeeld, in Xilinx apparaten, wordt de of ] transceiver geconfigureerd via attributen en vervolgens toegankelijk via een wrap-around module. Deze benadering is veel betrouwbaarder dan een volledige zachte SerDes bij hoge snelheden. De VHDL code voor dergelijke wikkelaars moet de gebruikershandleiding volgen om de juiste parameters voor lijnsnelheid, referentie klok en codering in te stellen.

Zachte SerDes Implementatie (moderate speeds)

Voor tarieven tot een paar honderd megahertz kan een volledig zachte SerDes in VHDL levensvatbaar zijn. De sleutel is om shift registers en tellers te gebruiken die worden geïmplementeerd met speciale flip-flops en lange combinatorische ketens te vermijden. Hieronder is een uitgebreid voorbeeld van een serializer die een belasting enable en handshake signaal bevat.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Serializer_8to1 is
 Port (
 clk_ser : in STD_LOGIC; -- serial clock
 clk_par : in STD_LOGIC; -- parallel clock (1/8 rate)
 rst : in STD_LOGIC;
 data_in : in STD_LOGIC_VECTOR(7 downto 0);
 load : in STD_LOGIC;
 serial_out : out STD_LOGIC;
 busy : out STD_LOGIC
 );
end Serializer_8to1;

architecture Behavioral of Serializer_8to1 is
 signal shift_reg : STD_LOGIC_VECTOR(7 downto 0);
 signal bit_cnt : integer range 0 to 7;
begin
 process(clk_ser, rst)
 begin
 if rst = '1' then
 shift_reg <= (others => '0');
 bit_cnt <= 0;
 busy <= '0';
 elsif rising_edge(clk_ser) then
 if load = '1' then
 shift_reg <= data_in;
 bit_cnt <= 7;
 busy <= '1';
 elsif bit_cnt > 0 then
 shift_reg <= shift_reg(6 downto 0) & '0';
 bit_cnt <= bit_cnt - 1;
 else
 busy <= '0';
 end if;
 end if;
 end process;

 serial_out <= shift_reg(7);
end Behavioral;

Deze seriële schakelaar gebruikt de seriële klok voor alle bewerkingen. Het signaal moet synchroon zijn met ; in de praktijk is een klokdomeinkruising van het parallelle domein nodig.

Deserializer met Word-uitlijning

De deserializer moet het parallelle woord extraheren en grenzen identificeren. Het volgende voorbeeld bevat een eenvoudige uitlijningsstaatmachine die een bekend patroon zoekt (bv. ).

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Deserializer_8b10b is
 Port (
 clk_ser : in STD_LOGIC;
 rst : in STD_LOGIC;
 serial_in : in STD_LOGIC;
 data_out : out STD_LOGIC_VECTOR(9 downto 0);
 aligned : out STD_LOGIC
 );
end Deserializer_8b10b;

architecture Behavioral of Deserializer_8b10b is
 signal shift_reg : STD_LOGIC_VECTOR(9 downto 0);
 signal bit_cnt : integer range 0 to 10;
 signal lock : STD_LOGIC := '0';
begin
 process(clk_ser, rst)
 begin
 if rst = '1' then
 shift_reg <= (others => '0');
 bit_cnt <= 0;
 lock <= '0';
 aligned <= '0';
 elsif rising_edge(clk_ser) then
 shift_reg <= shift_reg(8 downto 0) & serial_in;
 if bit_cnt < 10 then
 bit_cnt <= bit_cnt + 1;
 end if;
 -- check for alignment pattern at any bit position
 if lock = '0' then
 if bit_cnt = 10 then
 if shift_reg = "1111000010" then -- comma pattern
 lock <= '1';
 aligned <= '1';
 end if;
 end if;
 else
 -- After locked, output parallel word every 10 clocks
 if bit_cnt = 10 then
 data_out <= shift_reg;
 bit_cnt <= 0;
 end if;
 end if;
 end if;
 end process;
end Behavioral;

In een echt systeem moet de uitlijningslogica ook bit slipping en meerdere komma's per pakket behandelen. De CDR klok wordt verondersteld hersteld te zijn; zo niet, dan is een PLL blok vereist.

Klokdomein Crossing Strategies

High-speed SerDes ontwerpt onvermijdelijk kruis van de langzamere parallelle klok naar de snelle seriële klok. De veiligste aanpak is om een FIFO (first-in, first-out) buffer te gebruiken om de domeinen te ontkoppelen. In VHDL kan de FIFO worden geïmplementeerd als een dual-port RAM met lees- en schrijfpointers gesynchroniseerd over klokken. Voor minimale latentie kunnen handshake-gebaseerde synchronisaties (zoals een aanvraag-annuleringsschema) worden gebruikt voor besturingssignalen.

Simulatie en verificatie

Een SerDes met hoge snelheid simuleren vereist een zorgvuldig testbankontwerp. De testbank moet datapatronen genereren, jitter injecteren (om CDR en timingmarges te beoordelen), en controleren of verzonden gegevens overeenkomen met ontvangen gegevens na het inlijsten.

  • Datageneratie: Gebruik PRBS (pseudo-random bit sequenties) om realistisch verkeer na te bootsen. PRBS patronen bloot foutbronnen zoals inter-symbol interferentie en patroon-afhankelijke jitter.
  • Klokmodellering: Modelleer de seriële klok met realistische fasegeluiden. De meeste digitale simulatoren kunnen de jitter benaderen door gebruik te maken van een variabele periode in VHDL testbanken (bv. met kleine willekeurige variaties).
  • Assertie-gebaseerde verificatie: VHDL-aantijgingen invoegen om te controleren op protocolovertredingen, zoals ongeldige tekens in 8b/10b-codering of verkeerde afstemming na een bepaald aantal klokcycli.
  • Coverage-gedreven testen: Voer lange simulaties uit om ervoor te zorgen dat de uitlijningsstaat machine zich kan vergrendelen op het kommapatroon in verschillende beginfasen. Functionele dekking kan worden geregistreerd met behulp van SystemVerilog indien beschikbaar, of via aangepaste VHDL-tellers.

Leveranciers als Xilinx en Intel bieden simulatiebibliotheken voor hun SerDes primitieven. Met behulp van deze bibliotheken versnelt verificatie omdat ze het analoge gedrag van de PLL en egalisatie modelleren. Neem deze modellen altijd op in uw simulatietestbank.

Geavanceerde onderwerpen: voorstreping, egalisatie en PCB-overwegingen

Hoewel de VHDL-code het fysieke laaggedrag niet kan veranderen, kan de SerDes controller de egalisatie-instellingen aanpassen als de transceiver ze ondersteunt. Moderne FPGA transceivers hebben programmeerbare zender pre-epressuur en ontvanger egalisatie. In VHDL worden deze ingesteld door te schrijven naar registers te sturen via een interne bus (bijv. AXI-Lite). De ontwerper moet begrijpen hoe pre-epressure high-frequency componenten stimuleert om kanaalverlies te compenseren, en hoe continu-time lineaire egaliser (CTLE) en decision-feedback equaliser (DFE) inter-symbolinterferenties correct zijn. Deze kennis beïnvloedt de trade-offs in de digitale ontvangen state machine, zoals de beslissingsdrempel voor gegevensbemonstering.

De print-indeling is even kritisch. De seriële sporen moeten worden gecontroleerd door impedantie (typisch 100 Ω differentiaal), en de klokverdeling moet de schuine kant tussen de referentieklok en de transceiver . Deze fysieke beperkingen zijn buiten VHDL, maar de digitale ontwerper moet duidelijke richtlijnen aan de PCB-ingenieur, zoals de vereiste afwijking van de jitter en het terugsturen verlies specificaties.

Case Study: Een Gigabit Ethernet SerDes implementeren in VHDL

Gigabit Ethernet (1000BASE-X) gebruikt een 8b/10b coderingsschema en een regelsnelheid van 1,25 Gbps. De SerDes moeten een 8-bit parallel woord plus een controle bit (voor K/D karakter onderscheiding) in een 10-bit seriestroom in seriele stroom in serie. De ontvanger voert klokherstel uit van de vervormde gegevens en richt woordgrenzen uit met behulp van de komma (binaire ) na codering). Een VHDL implementatie zou omvatten:

  1. Een 8b/10b encoder (kan worden geïmplementeerd als een opzoektabel) die 8-bits data en controlesignalen omzet in 10-bit codegroepen.
  2. Een serieverwerker die de 10-bit code groep neemt en het serieel uitvoert op 1,25 Gbps.
  3. Een deserializer die in bits verschuift en op zoek gaat naar het kommapatroon.
  4. Een CDR-blok (meestal gestanst van een leverancier primitief) dat een 125 MHz herstelde klok (voor de parallelle zijde) genereert uit de binnenkomende 1,25 Gbps stroom.
  5. Een FIFO om ontvangen gegevens van het herstelde klokdomein naar het systeemklokdomein over te dragen.

Deze architectuur kan volledig worden beschreven in VHDL, met uitzondering van de analoge CDR en lijn driver/receiver. Veel open-source projecten bieden dergelijke implementaties voor educatieve doeleinden, maar voor de productie, geharde zenders worden sterk aanbevolen.

Conclusie

Een snelle SerDes in VHDL is een uitdagende maar belonende taak die de digitale logica en het hogefrequentie analoge ontwerp overbrugt. De VHDL-code moet geschreven worden met synthesebeperkingen, timingsluiting en klokdomeinoversteek in het achterhoofd. Voor snelheden boven 1 Gbps is het inzetten van speciale transceiver macro's essentieel; voor lagere snelheden kan een volledig zachte SerDes gebouwd worden met behulp van shift registers en tellers. Ongeacht de aanpak, zorgt grondige simulatie met realistische jitter- en datapatronen voor robuustheid. Door de onderliggende SerDes architectuur te begrijpen, kunnen ingenieurs betrouwbare SerDes implementaties ontwikkelen die moderne communicatiesystemen aansturen.

Buitenlandse referenties