Het ontwerpen van digitale fase-gesloten loops (PLLs) in VHDL is een fundamentele vaardigheid voor ingenieurs die werken aan frequentiesynthese en klokbeheer in digitale systemen. PLL's zijn essentiële componenten die signalen helpen synchroniseren en stabiele frequenties genereren, waardoor ze van vitaal belang zijn in moderne elektronische apparaten zoals draadloze transceivers, dataconverters en digitale processors. In tegenstelling tot analoge PLL's bieden digitale PLL's (DPLL's) meer flexibiliteit, programmeerbaarheid en immuniteit voor het verwerken van variaties, waardoor ze de voorkeur krijgen voor implementaties van systeem-op-chip (SoC) -systemen. Dit artikel biedt een uitgebreide, stap-voor-stap handleiding voor het ontwerpen van DPLL's in VHDL, die theoretische fundamenten, kerncomponentontwerp, simulatietechnieken en praktische overwegingen voor frequentiesynthese omvat. Of u nu een ervaren FPGA-ontwikkelaar bent of een student die nieuw is in digitaal ontwerp, het masteren van DPLL-implementatie van geavanceerde klokgeneratie en de mogelijkheid om de klok terug te winnen in uw projecten.

Digitale PLL's begrijpen

Een digitale PLL is een feedbackbesturingssysteem dat de fase van een ingangsreferentiesignaal vergelijkt met de fase van een gegenereerd uitgangssignaal. Het doel is om de outputfase af te stemmen op de ingang, effectief op de frequentie te vergrendelen. In een gesloten lus past de DPLL continu de frequentie van een digitale numeriek gecontroleerde oscillator (NCO) aan totdat het faseverschil afneemt tot een kleine steady-state fout. Dit proces zorgt ervoor dat het uitgangssignaal gesynchroniseerd blijft met de referentie, zelfs in aanwezigheid van ruis of frequentiedrift. Digitale PLL's hebben de voorkeur in digitale systemen omdat ze volledig kunnen worden geïmplementeerd in hardwarebeschrijving talen zoals VHDL, gesynthetiseerd tot gate-level netlists, en geïntegreerd in FPGA's of ASIC's zonder externe analoge componenten.

De basisarchitectuur van een DPLL bestaat uit vier hoofdblokken: een fasedetector, een loopfilter, een NCO en een feedbackpad. De fasedetector berekent het verschil tussen de referentiefase en de feedbackfase. Dit foutsignaal wordt gefilterd door het loopfilter, dat meestal een proportionele-integrale (PI) controller bevat om de loopdynamica in te stellen. Het gefilterde controlewoord drijft de NCO, die de uitgangsklok of golfvorm genereert. De output wordt teruggevoerd naar de fasedetector, waardoor de lus wordt gesloten. Het begrijpen van de interactie van deze blokken is essentieel voor het ontwerpen van een stabiele en responsieve DPLL.

Sleutelcomponenten van een digitale PLL

Voordat je in VHDL implementeert, is het belangrijk om de functie van elk onderdeel te begrijpen en trade-offs te ontwerpen.

Fasedetector

De fasedetector (PD) genereert een foutsignaal evenredig aan het faseverschil tussen de referentie- en feedbacksignalen. In digitale ontwerpen zijn de XOR gate fasedetector en de fasefrequentiedetector (PFD) de meest voorkomende implementaties.

  • XOR Fasedetector: Een XOR poort vergelijkt twee binaire signalen en geeft een signaal uit waarvan de gemiddelde dienstcyclus evenredig is aan het faseverschil. Het werkt het beste wanneer beide signalen 50% duty cycli hebben en een quadratuurrelatie (90° faseverschuiving). De XOR PD heeft een beperkt lineair bereik (±π/2) en kan frequentieverschillen niet detecteren.
  • Fase-Frequentiedetector (PFD): Een PFD gebruikt sequentiële logica (bv. twee flip-flops en een EN-gate) om zowel fase- als frequentieverschillen te detecteren. Het geeft op- en neerpulsen af die aangeven of de referentie leidt of de feedback vertraagt. De PFD heeft een breder lineair bereik (±2π) en kan zelfs ver van elkaar afgaan wanneer de frequenties ver van elkaar liggen, waardoor het de voorkeur heeft voor frequentiesynthese.

Filter verwijderen

Het lusfilter verwerkt het fasefoutsignaal om een regelspanning (of digitale code) te produceren die de NCO aandrijft. In een digitale PLL is het lusfilter meestal een digitaal PI-filter. De proportionele term geeft onmiddellijke correctie op basis van de huidige fout, terwijl de integrale term fout ophoopt in de tijd om steady-state fase offset te elimineren. De coëfficiënten van het filter (Kp en Ki) bepalen de bandbreedte, vergrendelingstijd en stabiliteit van de lus. Een goed ontworpen lusfilter moet snelle verwerving met een lage jitter in evenwicht brengen.

KERNTOOI-TOCILLator (NCO)

De NCO genereert de uitgangsgolfvorm .Vaak een vierkante golf of sinusgolf . Het bevat meestal een fase-accu die een frequentiecontrolewoord (FCW) toevoegt aan elke klokcyclus. De output van de accumulator, die de momentane fase voorstelt, richt zich op een opzoektabel (LUT) die sinus- of cosinuswaarden opslaat. Als alternatief kan de NCO voor de synthese van de klok het belangrijkste bit van de fase-accu leveren om een 50%-eenheidskwadraatgolf te produceren. De resolutie van de NCO wordt bepaald door het aantal bits in de accumulator (bijv. 32-bit), waardoor zeer fijne frequentiestappen mogelijk zijn.

Terugkoppelingspad

Het feedbackpad is eenvoudig: het leidt de NCO-uitvoer terug naar de fasedetector. In sommige ontwerpen kan een frequentieverdeler in het feedbackpad geplaatst worden om de PLL frequenties te laten genereren die veelvouden zijn van de referentie (bv. integer-N synthese). Moderne DPLLs kunnen ook programmeerbare verdelers voor flexibele synthese bevatten.

Een digitale PLL ontwerpen in VHDL

De implementatie van een digitale PLL in VHDL impliceert het coderen van elke component als een afzonderlijke entiteit en het hiërarchisch verbinden ervan. De volgende subsecties geven VHDL ontwerp voorbeelden voor elk blok, met de nadruk op synthesizeerbare constructies en best practices.

Fasedetectorimplementatie

We zullen een PFD implementeren, omdat het robuuster is voor frequentiesynthese. De PFD gebruikt twee D flip-flops, een AND reset gate en op/down uitgangen. De VHDL code voor een eenvoudige PFD wordt hieronder getoond. Merk op dat het ontwerp volledig synchroon is om problemen met de metastability te vermijden.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity pfd is
 port (
 clk_ref : in std_logic;
 clk_fb : in std_logic;
 reset : in std_logic;
 up : out std_logic;
 down : out std_logic
 );
end pfd;

architecture rtl of pfd is
 signal q_ref, q_fb : std_logic;
begin
 process(clk_ref, reset)
 begin
 if reset = '1' then
 q_ref <= '0';
 elsif rising_edge(clk_ref) then
 q_ref <= '1';
 end if;
 end process;

 process(clk_fb, reset)
 begin
 if reset = '1' then
 q_fb <= '0';
 elsif rising_edge(clk_fb) then
 q_fb <= '1';
 end if;
 end process;

 up <= q_ref and not q_fb;
 down <= q_fb and not q_ref;

 reset <= q_ref and q_fb; -- internal reset for both flip-flops
end rtl;

Bij deze implementatie wordt het signaal aangedreven door een combinatie EN van beide flip-flops, zodat de detector na beide randen snel weer in werking treedt. Dit PFD geeft een puls uit op wanneer de referentie de feedback leidt, en een puls op wanneer de feedback leidt. De pulsbreedte is evenredig met het faseverschil.

Filter-implementatie lus

Een digitaal PI-filter kan worden geïmplementeerd met behulp van een accumulator en parallelle multipliers. Voor eenvoud gaan we ervan uit dat de PFD-uitgangen worden omgezet in een ondertekende foutwaarde. De filtercoëfficiënten worden gekozen om een dempingsfactor van 0,7 en een natuurlijke frequentie te leveren die voldoet aan de lock time eis. De VHDL-code hieronder toont een basis PI-filter met 16-bits gesigneerde rekenkundige.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity loop_filter is
 port (
 clk : in std_logic;
 rst : in std_logic;
 phase_err: in signed(15 downto 0);
 freq_ctrl: out signed(15 downto 0)
 );
end loop_filter;

architecture rtl of loop_filter is
 -- Coefficients: Kp = 0.25, Ki = 0.03125 (example values)
 constant Kp : signed(15 downto 0) := to_signed(8192, 16); -- 0.25 in Q14
 constant Ki : signed(15 downto 0) := to_signed(1024, 16); -- 0.03125 in Q14
 signal integral : signed(31 downto 0) := (others => '0');
 signal prop_term, int_term : signed(31 downto 0);
begin
 process(clk, rst)
 begin
 if rst = '1' then
 integral <= (others => '0');
 elsif rising_edge(clk) then
 integral <= integral + (phase_err * Ki); -- saturated accumulation
 end if;
 end process;

 prop_term <= phase_err * Kp;
 int_term <= integral(31 downto 16); -- truncate to 16-bit
 freq_ctrl <= prop_term(15 downto 0) + int_term(15 downto 0);
end rtl;

In dit voorbeeld worden coëfficiënten weergegeven in een Q14-formaat met een vaste punt. De geïntegreerde accumulator is 32 bits om overflow te voorkomen, en de output wordt ingekort tot 16 bits. Dit filter drijft het frequentiecontrolewoord van de NCO.

Uitvoeringsfase NCO

De NCO genereert de output klok. Voor frequentiesynthese hebben we vaak een vierkante golf nodig met 50% duty cyclus. De faseaccuctor benadering werkt goed. De volgende VHDL code implementeert een 32-bit NCO met een klokuitgang (de MSB van de accumulator).

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity nco is
 port (
 clk : in std_logic;
 rst : in std_logic;
 freq_word: in unsigned(31 downto 0);
 out_clk : out std_logic
 );
end nco;

architecture rtl of nco is
 signal accumulator : unsigned(31 downto 0) := (others => '0');
begin
 process(clk, rst)
 begin
 if rst = '1' then
 accumulator <= (others => '0');
 elsif rising_edge(clk) then
 accumulator <= accumulator + freq_word;
 end if;
 end process;

 out_clk <= accumulator(31); -- MSB toggles at half the NCO frequency
end rtl;

De outputfrequentie wordt gegeven door . Met behulp van een 32-bit accumulator geeft een frequentieresolutie van . Voor sinusgolfsynthese, vervang de output door een opzoektabel die wordt behandeld door de hoge-orde bits van de accumulator. Gebruik bijvoorbeeld de bovenste 8 bits om een 256-punt sinus LUT te indexeren die is opgeslagen in een ROM-blok.

Integratie en topniveauontwerp

Zodra de individuele modules zijn ontworpen, creëren we een top-level entiteit die het PFD, loopfilter en NCO intrigeert. Het feedbackpad verbindt de NCO-uitvoer terug naar de feedback-input van de PFD. Hieronder wordt een eenvoudig VHDL-ontwerp op topniveau getoond.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity digital_pll is
 port (
 ref_clk : in std_logic;
 rst : in std_logic;
 pll_out : out std_logic
 );
end digital_pll;

architecture rtl of digital_pll is
 signal up, down : std_logic;
 signal phase_err_signed : signed(15 downto 0);
 signal freq_ctrl : signed(15 downto 0);
 signal fb_clk : std_logic;
begin
 -- Convert up/down to signed error
 phase_err_signed <= (to_signed(1, 16) when up='1') else
 (to_signed(-1, 16) when down='1') else
 (others => '0');

 u_pfd : entity work.pfd
 port map (
 clk_ref => ref_clk,
 clk_fb => fb_clk,
 reset => rst,
 up => up,
 down => down
 );

 u_loop_filter : entity work.loop_filter
 port map (
 clk => ref_clk,
 rst => rst,
 phase_err => phase_err_signed,
 freq_ctrl => freq_ctrl
 );

 u_nco : entity work.nco
 port map (
 clk => ref_clk,
 rst => rst,
 freq_word => unsigned(freq_ctrl),
 out_clk => fb_clk
 );

 pll_out <= fb_clk;
end rtl;

Merk op dat in dit eenvoudige voorbeeld de fasefout wordt gequantiseerd tot ±1. In de praktijk kan een meer geavanceerde fasedetector (bijvoorbeeld time-to-digitale converter) een fijnere resolutie bieden. Het loopfilter en NCO draaien op dezelfde referentieklok, die het ontwerp vereenvoudigt maar de maximale uitgangsfrequentie beperkt. Voor hogere uitgangsfrequenties kan een apart hoog-snelheidsklokdomein worden gebruikt.

Simulatie en verificatie

Een digitale PLL simuleren is cruciaal om de vergrendelingstijd, stabiliteit en jitterprestaties te verifiëren. Een VHDL testbank moet een referentieklok toepassen, de PLL laten vergrendelen en vervolgens de fasefout meten. Gebruik de procedure om de simulatie na een redelijke tijd te stoppen. Hieronder staat een skelettestbank.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity tb_digital_pll is
end tb_digital_pll;

architecture sim of tb_digital_pll is
 signal ref_clk : std_logic := '0';
 signal rst : std_logic := '0';
 signal pll_out : std_logic;
 constant T : time := 20 ns; -- 50 MHz reference
begin
 ref_clk <= not ref_clk after T/2;
 rst <= '1', '0' after 100 ns;

 dut : entity work.digital_pll
 port map (ref_clk, rst, pll_out);

 -- verification process
 process
 begin
 wait until rising_edge(rst);
 wait for 1 us; -- allow lock
 -- check frequency and phase
 report "Simulation complete";
 std.env.finish;
 end process;
end sim;

Simulatietools zoals ModelSim, Vivado Simulator of GHDL kunnen worden gebruikt. Het is ook aan te raden om uitgebreide hoek-case simulaties uit te voeren met geschifte referentieklokken en power-up transients. Een nuttige hulpbron voor PLL simulatietechnieken is het white paper op PLL simulatie best practices van RF Centers.

Frequentiesynthese met digitale PLL

Zodra de DPLL is vergrendeld, kunnen we het gebruiken voor frequentiesynthese door het veranderen van het NCO frequentie controle woord. In een typische toepassing, de referentie klok is een stabiele kristal oscillator, en de DPLL genereert een hoge frequentie output die een veelvoud van de referentie is. Voor integer-N synthese, een scheidingslijn kan worden toegevoegd in het feedback pad. Voor fractionele-N synthese, de feedback divider is gemoduleerd (bijv., met behulp van een sigma-delta modulator) om niet-integer vermenigvuldigingsfactoren te bereiken. Digitale PLLs blinken uit bij fractionele-N synthese omdat de NCO frequentie controle woord kan worden bijgewerkt in real time met hoge resolutie.

De relatie tussen de uitgangsfrequentie en het controlewoord wordt gegeven door f out = (FCW / 2N) * f clk, waarbij N het aantal accumulatorbits is. Door verschillende FCLT-frequenties te variëren kan de DPLL een breed spectrum van frequenties produceren. In frequentiehoppende spread spectrum (FHSS) systemen kan de DPLL binnen enkele klokcycli schakelen door FCW te updaten, mits de lusbandbreedte snel kan worden afgewikkeld.

Voor meer informatie over digitale frequentiesynthese, zie de klassieke tekst Fase-Locked Loops: Design, Simulatie, and Applications door Roland E. Best (McGraw-Hill, 2007). Daarnaast biedt het IEEE-papier over all-digitale PLL architectuur door Staszewski et al. een geavanceerd perspectief.

Praktische overwegingen

Het ontwerpen van een DPLL die betrouwbaar werkt in hardware vereist zorgvuldige aandacht voor verschillende praktische kwesties.

Vergrendel tijd en bandbreedte

De vergrendelingstijd van een DPLL is omgekeerd evenredig met de bandbreedte van de lus. Een grotere bandbreedte vergrendelt sneller, maar maakt meer referentie-doorvoer en jitter mogelijk. Een smalle bandbreedte vermindert het geluid maar duurt langer om te vergrendelen. De lusfiltercoëfficiënten moeten worden afgestemd op de toepassingseisen. Begin met een dempingsfactor van 0,707 (kritieke demping) en pas de natuurlijke frequentie aan op basis van de aanvaardbare vergrendelingstijd. Gebruik de formule ω n dienen dienen te worden ingesteld op een HPLC 2 * π * (bandbreedte) om af te wisselen.

Jitter en fasegeluid

Digitale PLL's hebben last van quantization jitter vanwege de eindige resolutie van de NCO en fasedetector. De verhoging van de accumulatorbreedte vermindert het frequentiekwantiseringsgeluid. Met behulp van een multi-bit fasedetector (bijvoorbeeld een time-to-digitale converter met 10 ps resolutie) verbetert faselawaai. Voor high-performance toepassingen, overwegen om een bang-bang (binary) fasedetector met een high-speed digitale loopfilter te implementeren. Externe verwijzingen met lage faselawaai, zoals ovengestuurde kristaloscillatoren (OCXO's), verbeteren ook de algehele jitter.

Energieverbruik

DPLLs die in FPGA's of ASIC's zijn geïmplementeerd, verbruiken dynamisch vermogen evenredig met de klokfrequentie en het aantal schakelpoorten. Om stroom te verminderen, gebruik je gated klokken of schakel je signalen in voor de NCO wanneer frequentieherconfiguratie niet nodig is. Moderne DPLL-architecturen met een laag vermogen, zoals die welke gebruik maken van tijd-domeinverwerking, worden besproken in het onderzoekspapier van Chen et al.

Proces, spanning, temperatuur (PVT) variaties

Digitale ontwerpen zijn meer immuun voor PVT variaties dan analoge circuits, maar de lus filter gain en NCO frequentie nog steeds afhankelijk van het systeem klok, die kan variëren tussen hoeken. Met behulp van een kleine marge in lus filter coëfficiënten en het uitvoeren van statische timing analyse zorgt ervoor dat de DPLL voldoet aan de timing onder alle voorwaarden. Simulatie met SDF (standaard vertraging formaat) back-annotatie wordt aanbevolen voor het aanmelden.

Geavanceerde onderwerpen

Voor ingenieurs die klaar zijn om verder te gaan dan de basis, bestaan er verschillende geavanceerde DPLL topologieën.

PLL (ADPLL)

Een ADPLL vervangt alle analoge componenten door digitale equivalenten, waaronder een time-to-digitale converter (TDC) als fasedetector en een digitaal gecontroleerde oscillator (DCO). Deze benadering wordt op grote schaal gebruikt in nanometer CMOS voor RF-toepassingen. De VHDL ontwerpmethodologie breidt zich natuurlijk uit tot ADPLLs door toevoeging van een TDC IP blok en een oscillator control interface.

Fractational-N PLL met Sigma-Delta-modulatie

Fractional-N synthesis allows arbitrary frequency ratios, enabling fine frequency steps without reducing the phase detector frequency. The feedback divider's modulus is modulated by a sigma-delta modulator (SDM) to shape quantization noise away from the loop bandwidth. The SDM can be implemented in VHDL as a third-order error feedback structure. A tutorial on SDM-based fractional-N PLLs is available from Analog Devices.

Conclusie

Het ontwerpen van digitale gefaseerde loops in VHDL voor frequentiesynthese is een uitdagende maar lonende taak die digitale signaalverwerking, controletheorie en hardwareontwerp combineert. Dit artikel heeft betrekking op de fundamentele componenten phase detector, loopfilter en NCO . Met synthesizeerbare VHDL-voorbeelden en simulatiestrategieën. Door het begrijpen van deze bouwstenen, kunt u robuuste DPLLs creëren die in staat zijn om stabiele, hoogfrequente klokken te genereren voor een breed scala aan toepassingen. Vergeet niet om altijd uw ontwerp te controleren door simulatie, praktische trade-offs zoals lock time en jitter, en geavanceerde architecturen te verkennen om te voldoen aan strenge prestatievereisten. Mastery of DPLL ontwerp zal uw mogelijkheden als digitale ontwerpingenieur aanzienlijk verbeteren.