Hallo,

ik heb in mijn systeem een klok van 12.5MHz die ik moet delen naar 500kHz. Dit kan niet met een PLL omdat de deelfactor te hoog is.

Nu heb ik volgende VHLD constructie gemaakt, maar die glitcht:


entity CLKDiv12M5_500k is
	port(
		CLK_In			: in std_logic;
		Reset_n			: in std_logic;
		CLK_Out			: out std_logic
	);
end CLKDiv12M5_500k ;

architecture RTL of CLKDiv12M5_500k  is

begin
	process(CLK_In,Reset_n)
	
	variable counter	: integer range 0 to 60;
	begin
		if(Reset_n = '0') then
			counter := 0;
			CLK_Out <= '0';
		elsif (CLK_In'event and CLK_In = '1') then
			if(counter = 0) then CLK_Out <= '1'; counter := counter + 1;
			elsif (counter = 2) then CLK_Out <= '0'; counter := counter + 1; --2
			elsif (counter = 24) then counter := 0; --24 voor 500k, 49 voor 250k
			else counter := counter + 1; end if;
		end if;
	end process;
end RTL;
		

nu weet ik niet of het hieraan ligt dat de klok glitcht, maar ik denk het wel. Is dit een propere manier om een klok te delen, of zijn er betere methoden?

Thx

Maar waarom niet gewoon een 25-deler uit losse poortjes?

Op 4 oktober 2007 13:38:17 schreef (Z)weetvoetje:
Maar waarom niet gewoon een 25-deler uit losse poortjes?

Omdat er nu eenmaal zoiets als een HDL bestaat? En omdat ik dan eevoudig de samplefrequentie kan aanpassen (makkelijker dan met gates), en ook omdat de duty cycle niet 50% is...

Het zou volgens mij niet mogen glitchen.

Maar meestal doe ik zoiets als:


CLK_Out <= CLK_int;

  process(CLK_In)
    if rising_edge(CLK_In) then
      counter := counter + 1;
      if(counter = 12) then 
        counter := 0;
        CLK_int <= NOT CLK_int;         
      end if;
    end if;		  
  end process;			

Zo krijg je een symetrische clock (scheelt weer met setup en hold timing). Je voorbeeld van delen door 25 wordt dan wel weer lastiger, hier moet de deelfactor een veelvoud van 2 zijn namelijk.

welcome to wonderful world of digital design .... where every 'f-ing' thing glitches like crazy and never behaves as you intended'

enfin.

twee dingen : het is altijd best om downcounters te maken. heeft iets te maken met optimalisatie en skew.

in tegenstelling tot wat de meeste mensen denken worden downcounters NIET gemaat door de uitgang van de laatste flipflop aan de ingang van de voorlaatste te knopen...

een counter wordt effectief geimplementeerd als register met daarnaa een adder. bij een afteller van bijvoorbeeld 8 bit wordt er telkens 0xFE opgeteld. als je dergelijke addre maakt minimaliseert dat blijkbaar beter dan dat je 0x01 optelt.

ik maak delers meestal zo.



module divider (input clk, reset,
                output reg out);

parameter x = 5 // delen door de helft van wat je nodig hebt.

reg [15:0] cntr;

always @(posedge clk)
  if (reset)  cntr<=0;
  else begin
      if (|cntr) cntr <=cntr-1; 
      else begin
           cntr<=x;
           output <= !output;
      end;
  end
endmodule

je telt gewoon af. telkens de counte rop nul komt ( het 'niet nul' zijn wordt gedetecteerd door een OR functie van de tellerstand. dus zolang een van de bits in cntr 1 is wordt cntr verminderd.

alsie ie nul bereikt wordt de counter herladen en toggelt de output flipflop.

de duty cycle is dus altijd 50% en je hebt geen glitchen op de output.

Op 4 oktober 2007 19:52:52 schreef free_electron:
welcome to wonderful world of digital design .... where every 'f-ing' thing glitches like crazy and never behaves as you intended'

Bedankt :-)

Nu is het net zo dat ik GEEN duty cycle van 50% wil... Het is namelijk om een CS lijn aan te sturen van een ADC. Als de lijn hoog is dan trackt de ADC, bij laag begint hij te converteren. Om de tijd die er is om de data in te lezen te verlengen gebruik ik dus een korte hoge periode en een langere lage periode.

Maar ik kan inderdaad eens proberen een down counter te bekijken.

Ik ga eens proberen een plaatje te schieten van het scoop beeld... Want ik ben niet 100% zeker dat het een echte glitch is.

Je kunt een glitch proberen op te lossen door een extra buffer (een flipfloppie) aan het eind te synthetiseren, die de boel alsnog synchroon trekt. Dus in plaats van je CLK_Out direct aan te sturen, zet je eerst deze eerst in een tijdelijk signal, en die klok je vervolgens synchroon uit naar CLK_Out. Je hebt dan wel 1 clock extra latency, maar dat maakt toch niks uit in het voorbeeld.

In mijn voorbeeldje:




  process(CLK_In)
    if rising_edge(CLK_In) then
      counter := counter + 1;
      if(counter = 12) then 
        counter := 0;
        CLK_int <= NOT CLK_int;         
      end if;

      CLK_Out <= CLK_int;   -- Nu wordt ie synchroon uitgeklokt

    end if;		  
  end process;		

Maar het is nog steeds raar hoor, wat in principe is jouw eerste voorbeeld al compleet synchroon en zouden er geen glitches op mogen treden. Is het geen meet probleem? groundbounce oid?

Op het einde van de schakeling staat een flipflop, is te zien in de netlist viewers.

Ik ben toch echt niet meer zeker dat het glitches zijn. Ik ga echt eens wat scoop beeldjes proberen maken en ze doorsturen...

Alvast ebdankt voor eht meedenken

Ok, hier het scoopbeeld. Het gaat om D2. Dit is het signaal van de Logic analyser op de rigol, en het gele is het analoge equivalent ervan. Zijn dit glitches, of iets anders?

Foto staat hier: http://www.uploadarchief.net/files/download/glitches.jpg

Nee, dit lijkt niet afkomstig van de FPGA. Dit is overspraak of groundbounce. Zijn er andere schakelende signalen in de buurt?

geef je schema eens??

ik denk nl dat dit botweg voedings rommel kan zijn en dat alle voedingen niet goed ontkoppeld zijn...

Dat ziet er naar mijn idee wel uit als glitching. Ontkoppeling is het denk ik niet, anders zou je wel spike vorming zien met intervals van de master clock.

Op 5 oktober 2007 09:45:27 schreef stecj366:
Op het einde van de schakeling staat een flipflop, is te zien in de netlist viewers.

Ik ben toch echt niet meer zeker dat het glitches zijn. Ik ga echt eens wat scoop beeldjes proberen maken en ze doorsturen...

Alvast ebdankt voor eht meedenken

Als die flipflop als latch is geimplementeerd, dan kan wel degelijk glitching plaatsvinden. Een latch is gewoon een pass-thru wanneer 'ie enabled is.

Feit dat het signaal ver onder ground gaat doet mij vermoeden dat het niet uit de FPGA komt.

En de schakeling is in principe synchroon (flipflops dus) en zou niet mogen glitchen. Hoe heb je de scoop aangesloten op de hardware? Zit je GND aansluiting ook dicht bij de FPGA?

Probeer deze code eens? Deze deelt de clock, de high-period is even breed als de high-period van de input clock.

module ClkDiv25(
  input   wire      RESET,
                    CLKI,
  output  wire      CLKO);
  
          reg [4:0] CNT;
          
  // Divisor, set to wanted divisor - 1.
  parameter DIVISOR = 5'd24;
  
  // Division counter
  always @ (posedge CLKI, posedge RESET) begin
    if (RESET) CNT <= 0;
    else begin
      if (CNT == 0) CNT <= DIVISOR;
      else CNT <= CNT -- 1;
    end    
  end
  
  // Glitch-free clock output
  assign CLKO = (!CLKI && CNT == 0 && !RESET);  
  
  // Initialisation
  initial begin
    CNT = 0;
  end

endmodule

De flipflop is aangesloten als flipflop, mooi met CLK en zo.

Schema: dit is op een FPGA development board van altera (NiosII Cyclone II edition). Op een van de expansieconnectoren hangen 16 ADC's, met hun CS_n lijnen allemaal aan die lijn. Tussen de FPGA en de uitgangen zitten buffers, die een stroom van grofweg 100mA kunnen leveren. Tussen de buffers en de CS pinnen van de ADC's hangt dan nog eens een 25 ohm weerstand, F_E had me dat aangeraden, heb dat gedaan, maar weet niet goed waarom. (dit is dus een verdekte vraag :) )

Aan een van de CS lijnen hangt dan een clip van de logic analyser, en ook aan die clip een probe met BB 250MHz, op 10x ingesteld. De massa van de probe hangt aan het massavlak van mijn opsteekbordje, dat dan via de expansieconnector naar het massavlak op de PCB gaat. Dus de massa is toch wel vrij ver van de FPGA weg.

Nu heb ik gemerkt dat de fenomenen zich ook voordoen op alle andere kanalen, maar in iets mindere mate. Maar allemaal op hetzelfde moment. Daar kan ik eventueel maandag ook eens een plaatje van schieten.

Wat is eigenlijk ground bounce?