Introduction aux SerDes haute vitesse dans VHDL

Les modules Serialiser/Deserialiser (SerDes) sont des éléments fondamentaux des systèmes modernes de communication de données à grande vitesse. Ils convertissent les flux de données parallèles en format série pour la transmission sur une seule paire différentielle ou fibre optique, puis reconstruisent les données parallèles au récepteur. La mise en œuvre d'un SerDes à grande vitesse robuste en VHDL exige une compréhension approfondie des principes de conception numérique, des architectures d'horlogerie et de l'intégrité du signal. Cet article fournit un guide complet pour concevoir SerDes en VHDL, couvrant l'architecture, le timing, les techniques de codage, la simulation et la validation.

Principes fondamentaux de l'architecture SerDes

Un SerDes complet peut être divisé en quatre sous-systèmes clés : le sérialisateur, le désérialisateur, la récupération de données d'horloge (CDR) et les circuits d'alignement/framation. Bien que le côté émetteur sérialise les données parallèles, le côté récepteur doit récupérer l'horloge bit du flux série entrant et aligner les limites des données. Chaque sous-système impose des contraintes distinctes sur la conception VHDL.

Sérialiseur (convertisseur de parallélisme à série)

Le sérialiste prend un N-bit de large mot parallèle et produit les bits un à la fois à la vitesse de la ligne. L'horloge parallèle ([) est typiquement N fois plus lente que l'horloge série (. Dans VHDL, le sérialiste peut être mis en place comme un registre de changement avec un compteur qui contrôle la sélection des bits. Pour une opération à grande vitesse appropriée, le registre de changement doit être synthétisé en utilisant des flower-flops dédiés avec un retard minimal de l'horloge à l'output, et le timing entre les domaines parallèles et série doit être soigneusement géré pour éviter la métastabilité.

Désactivation (convertisseur série-parallèle)

Le désérialiseur effectue l'opération inverse : il reçoit un flux de bits série et reconstitue le mot parallèle. Les bits entrants sont déplacés dans un registre sur chaque bord de l'horloge série. Lorsque le mot complet est assemblé, il est présenté sur le bus de sortie parallèle avec un drapeau valide associé. Le désérialisateur doit également gérer l'alignement de bits; si le flux de données n'a pas de motif de cadrage connu, l'alignement est réalisé via des caractères virgules ou des en-têtes de paquets.

Récupération de données d'horloge (CDR)

CDR extrait l'horloge série du flux de données entrant. Ceci est critique parce que le récepteur et l'émetteur ne sont pas des fréquences verrouillées dans de nombreux systèmes. Dans SerDes à haute vitesse, CDR est généralement implémenté comme une boucle verrouillée par phase (PLL) ou boucle verrouillée par retard (DLL) qui ajuste un oscillateur local pour correspondre aux transitions de données entrantes. Bien que CDR soit rarement codé dans VHDL pur pour la synthèse au niveau de la porte (il utilise des circuits analogiques ou mixtes dans les SIC, ou des blocs durcis dans les FPGA), la partie numérique comme les détecteurs de fréquence de phase et les filtres de boucle numérique peut être décrite dans VHDL. Comprendre le comportement CDR est essentiel lors de la conception de la logique de contrôle des désérialiseurs.

Alignement et armature des mots

Après CDR, les bits entrants doivent être alignés sur les limites de mots. De nombreux protocoles intègrent un motif distinct (par exemple K28.5 en 8b/10b) que le désérialisateur utilise pour localiser les limites d'octets. La logique d'alignement VHDL comprend une machine d'état qui recherche le motif et déplace ensuite le flux de bits jusqu'à ce que le motif soit assorti.

Défis dans le design de SerDes à haute vitesse

Les SerDes à grande vitesse fonctionnent à des débits multi-gigabits, dépassant souvent 10 Gbps par voie. A ces vitesses, les défis physiques et numériques de conception deviennent prononcés.

Fermeture et métastabilité du calendrier

Le sérializer et le désérializer doivent transférer les données entre les domaines horloge (parallèle et série). La métastabilité peut se produire si les temps de configuration/d'attente sont violés. Les concepteurs VHDL doivent insérer des synchroniseurs et limiter soigneusement l'outil de synthèse pour respecter le timing.

Jitter et Skew

Dans le sérialisateur, le décalage entre les domaines parallèles et série conduit à une commande de bits incorrecte. Pour lutter contre cela, les conceptions SerDes à grande vitesse utilisent souvent la signalisation différentielle, la pré-accentuation et l'égalisation. Du point de vue VHDL, les concepteurs doivent minimiser la logique combinatoire dans le chemin de données série; le retiming (déplacement des tongs pour équilibrer les retards) est une technique courante.

Consommation d'énergie

Les stratégies de réduction de la puissance comprennent le gavage d'horloge, la baisse de la tension d'alimentation (si la technologie cible le permet) et l'utilisation de serialisers avec des largeurs parallèles inférieures (par exemple, en déplaçant 8 bits contre 32 bits) pour réduire la fréquence des horloges série.

Techniques de mise en œuvre de VHDL pour les SerDes à haute vitesse

Pour une utilisation fiable à des taux multigigabits, le code VHDL doit être synthétisé en ressources matérielles dédiées. Les sections suivantes présentent des techniques de codage pratiques et des exemples.

Utilisation de SerDes Hard Macros dédiés

La plupart des FPGA modernes comprennent des émetteurs-récepteurs SerDes durcis (par exemple, Xilinx GTY, Intel E-tile). Ces blocs contiennent des PLL, CDR, dessérialisateurs et circuits d'égalisation. Le code VHDL pour ces appareils permet principalement d'instantaner les primitives des fournisseurs et de les connecter à votre logique de base. Par exemple, dans les appareils Xilinx, le ou transceiver est configuré par des attributs puis accédé à travers un module de roulage. Cette approche est beaucoup plus fiable qu'un SerDes plein à haute vitesse. Le code VHDL pour ces wrappers doit suivre le guide utilisateur du fournisseur pour définir les paramètres corrects pour le taux de ligne, l'horloge de référence et l'encodage.

Mise en œuvre de la série de fréquences douces (vitesses modérées)

Pour des vitesses allant jusqu'à quelques centaines de mégahertz, un SerDes entièrement doux en VHDL peut être viable. La clé est d'utiliser des registres de décalage et des compteurs qui sont implémentés avec des tongs dédiés et éviter les longues chaînes combinatoires. Ci-dessous est un exemple élargi d'un serializer qui comprend un signal de chargement activé et poignée de main.

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;

Ce sérialiste utilise l'horloge série pour toutes les opérations. Le signal doit être synchrone avec ; en pratique, un circuit de croisement de domaine d'horloge du domaine parallèle est nécessaire.

Désérialisateur avec alignement des mots

L'extracteur doit extraire le mot parallèle et identifier les limites. L'exemple suivant comprend une machine simple d'état d'alignement qui recherche un motif connu (p. ex. .

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;

Dans un système réel, la logique d'alignement doit également gérer le glissement de bits et plusieurs caractères de virgules par paquet. L'horloge CDR est supposé récupérée; sinon, un bloc PLL est requis.

Stratégies de croisement de domaines de l'horloge

Les modèles SerDes à grande vitesse se croisent inévitablement de l'horloge parallèle plus lente à l'horloge série rapide. L'approche la plus sûre consiste à utiliser un tampon FIFO (premier en, premier en-sortie) pour découpler les domaines. Dans VHDL, le FIFO peut être implémenté comme une RAM à double port avec des pointeurs de lecture et d'écriture synchronisés sur les horloges.

Simulation et vérification

La simulation d'un SerDes à grande vitesse nécessite une conception minutieuse de testbench. Le testbench devrait générer des profils de données, injecter des jitters (pour évaluer le CDR et les marges de synchronisation) et vérifier que les données transmises correspondent aux données reçues après le cadrage.

  • Génération de données: Utilisez PRBS (pseudo-random bit sequences) pour imiter un trafic réaliste. Les modèles PRBS exposent des sources d'erreurs comme l'interférence inter-symbole et le jeu de motifs.
  • Modèle de verrouillage:[ Modélisez l'horloge série avec un bruit de phase réaliste. La plupart des simulateurs numériques peuvent approximativement amer en utilisant une période variable dans les bancs de test VHDL (p. ex. ] avec de petites variations aléatoires).
  • Vérification basée sur l'évaluation[: Insérer des affirmations VHDL pour vérifier les violations du protocole, comme les codes de caractères invalides en codage ou en désalignement 8b/10b après un nombre défini de cycles d'horloge.
  • Tests effectués avec contrôle:[ Lancez de longues simulations pour s'assurer que la machine d'état d'alignement peut se verrouiller sur le modèle de virgules dans différentes phases initiales. La couverture fonctionnelle peut être enregistrée en utilisant SystemVerilog si disponible, ou via des compteurs VHDL personnalisés.

Les fournisseurs comme Xilinx et Intel fournissent des bibliothèques de simulation pour leurs primitives SerDes. L'utilisation de ces bibliothèques accélère la vérification car elles modélisent le comportement analogique de la PLL et l'égalisation.

Sujets avancés : pré-accentuation, égalisation et considérations relatives aux PCB

Si le code VHDL ne peut pas modifier le comportement physique de la couche, le contrôleur SerDes peut ajuster les paramètres d'égalisation si l'émetteur les supporte. Les émetteurs modernes FPGA ont une pré-accentuation de l'émetteur programmable et une égalisation de récepteur. Dans VHDL, ceux-ci sont configurés en écrivant pour contrôler les registres via un bus interne (par exemple, AXI-Lite). Le concepteur doit comprendre comment la pré-accentuation stimule les composants haute fréquence pour compenser la perte de canal, et comment l'égalisation linéaire continue (CTLE) et l'égalisation de la prise de décision (DFE) corrigent les interférences inter-symboles.

La disposition des PCB est également critique. Les traces de série doivent être contrôlées par impédance (généralement différentielle de 100 γ), et la distribution de l'horloge devrait minimiser le décalage entre l'horloge de référence et l'entrée de l'horloge dédiée du transceiver. Ces contraintes physiques sont en dehors de VHDL, mais le concepteur numérique doit fournir des lignes directrices claires à l'ingénieur de PCB, comme les tolérances de jitter et les spécifications de perte de retour requises.

Étude de cas: Mise en œuvre d'un SerDes Ethernet Gigabit dans VHDL

Gigabit Ethernet (1000BASE-X) utilise un schéma d'encodage 8b/10b et un taux de ligne de 1,25 Gbps. Les SerDes doivent sérialiser un mot parallèle 8 bits plus un bit de contrôle (pour la distinction de caractères K/D) en un flux série 10 bits. Le récepteur effectue la récupération d'horloges à partir des données brouillées et aligne les limites de mots en utilisant la virgule (binaire ] après encodage). Une implémentation VHDL comprendrait :

  1. Un encodeur 8b/10b (peut être implémenté comme une table de recherche) qui convertit les données 8 bits et les signaux de contrôle en groupes de codes 10 bits.
  2. Un sérialisateur qui prend le groupe de code 10 bits et le produit en série à 1,25 Gbps.
  3. Un désérialisateur qui change en bits et recherche le modèle de virgule.
  4. Un bloc CDR (généralement instantané d'un fournisseur primitif) qui génère une horloge récupérée de 125 MHz (pour le côté parallèle) à partir du flux entrant de 1,25 Gbps.
  5. Un FIFO pour transférer les données reçues du domaine de l'horloge récupérée vers le domaine de l'horloge système.

Cette architecture peut être décrite entièrement en VHDL, à l'exception du CDR analogique et du pilote/récepteur de ligne. De nombreux projets open-source fournissent de telles implémentations à des fins éducatives, mais pour la production, les émetteurs-récepteurs durcis sont fortement recommandés.

Conclusion

La mise en œuvre d'un SerDes à haute vitesse en VHDL est une tâche difficile mais enrichissante qui relie la logique numérique et la conception analogique haute fréquence. Le code VHDL doit être écrit avec des contraintes de synthèse, la fermeture du temps et le croisement du domaine horloge. Pour les taux supérieurs à 1 Gbps, il est essentiel de tirer parti des macros de transceiver dédiées; pour des taux plus faibles, un SerDes entièrement souple peut être construit à l'aide de registres de décalage et de compteurs.

Références externes