Hallo,

Voor mijn thesis probeer ik een MAX1305 ADC te interfacen met een FPGA. De thesis is een FFT beamformer, maar voor dat ik kan gaan "beamformen" moet eerst de data op de FPGA geraken, en daar gaat het compleet mis. Ik heb nu al 2 maanden verspeeld om een manier te vinden om de data erop te krijgen, maar het wil maar niet lukken... Omdat ik de hoop bijna begin op te geven wou ik hier mijn vraag eens voorleggen.

De MAX1305 is een multichannel, simultaneous sampling, parallel ADC, met een gemultiplexte databus. Het systeem waarin de data gebruikt wordt bestaat uit het volgende:

Er zijn dus 4 kanalen waar informatie uit komt (van 4 transducers in een array). Per kanaal is er een appart datapad, en dat bestaat uit: shift register, FIR filter, downsampler, ram controller, en een RAM. De RAMs zijn memory mapped voor de PowerPC cores die op de FPGA zitten (Het gaat om Xilinx VirtexIIpro's).

Elk datapad is synchroon, en de 4 paden worden samen gestuurd door 1 entity, de ADC controller. Deze stuurt de ADC aan, neemt de data binnen, demultiplext de data en geeft de data door aan de datapaden. Nu gaat het hier mis. Als ik "dummy data" in de datapaden prop, gaat alles goed. De data komt mooi in de RAM van de powerPC, en ik kan deze mooi mem. mapped uitlezen. Als ik nu de echte data van de ADC wil doorspelen, gaat het echter totaal fout. Soms krijg ik constantes, en andere keren totaal irrelevante zaken.

Nu is mijn vraag of toevallig iemand al ervaring heeft met deze ADC, of al een HDL beschrijving gemaakt heeft om deze ADC uit te lezen (lieft VHDL, maar Verilog leer ik wel als iemand dat in Verilog heeft).

De datasheet van de ADC staat hier: http://www.ortodoxism.ro/datasheets/maxim/MAX1304-MAX1314.pdf en de timing diagrammas die voorgeschreven zijn staan op pag. 21 en 22.

Momenteel doe ik het Ik heb een klok met een duty cycle van ongeveer 80%, freq 500kHz. Op de dalende flank zal de ADC dus tracken, op de stijgende flank samplen en converteren. Ik hang die klok dus aan CONVST.

Als dan EOC_n laag gaat, dus dat de eerste conversie klaar is, trek ik RD_n laag, neem de data binnen, en laat RD_n weer hoog als EOC_n hoog gaat. Dit wordt 4 keer herhaald, voor elk kanaal dus 1 keer. Dit gebeurt allemaal asynchroon, omdat ik dit niet synchroon kan doen.

Mijn code is de volgende: (de overhead is weggelaten)


    process(delayer,CLKin,EOC_n,Reset_nint,ADC_Counter,CLKFast, SR1_I, SR2_I, SR3_I, SR4_I, ChanCounter) --Combinatorisch Process
    variable flag1:std_logic;
    begin
        if(Reset_nint='0') then
            RD_n<='1'; --Dit moet hier om de RD_n te kunnen sturen
            ChanCounter<=0;
            flag1:='0';
            CLK_SR1<='0';
            CLK_SR2<='0';
            CLK_SR3<='0';
            CLK_SR4<='0';              
        elsif(delayer=10 and ADC_Counter<2*c_Nr_Of_Sps) then 
           CONVST<=CLKin;
           CLK_SR1<=CLKin;
           CLK_SR2<=CLKin;
           CLK_SR3<=CLKin;
           CLK_SR4<=CLKin;            
           if(EOC_n='0' and CLKin='1') then --Hier komt de datastream van de conversie
              if(flag1='0') then 
                 RD_n<='0';
                 flag1:='1';
                 case ChanCounter is
                   when 0 => SR1<=ADC_Data; ChanCounter<=1;
                   when 1 => SR2<=ADC_Data; ChanCounter<=2;
                   when 2 => SR3<=ADC_Data; ChanCounter<=3;
                   when 3 => SR4<=ADC_Data; ChanCounter<=4; --To end conversion in this run
                   when others =>
                 end case;
              end if;
           elsif(CLKin='0') then --TRACKING   
              ChanCounter<=0;
           else --EOC_n=1 and CLKin=1
              if(flag1='1') then
                 flag1:='0'; 
              end if;                  
              RD_n<='1';      
           end if;
        else CONVST<='0'; 
        end if;
    end process;
    
    process(Reset_nint, CLKin) --Geklokt process
    begin
        if(Reset_nint='0') then 
           delayer<=0;
           CS_n<='0';
           WR_n<='1';
           ADC_Counter<=0; 
           SR1_I2<=(others=>'0');
           SR2_I2<=(others=>'0');
           SR3_I2<=(others=>'0');
           SR4_I2<=(others=>'0');                                 
           
        elsif(CLKin'event and CLKin='1') then
           if(delayer<10) then delayer<=delayer+1; end if;
           if(ADC_Counter<2*c_Nr_Of_Sps) then 
              if(delayer>9) then ADC_Counter<=ADC_Counter+1; end if;
           end if;
       end if;        
    end process;                           
end;

Beetje uitleg: SR* zijn de uitgangen, de databussen naar de shiftregisters. ADC_Data is de databus die van de ADC komt. De delayer dient ervoor de ADC een opstarttijd te geven. Chancounter is een systeem-wide bus die aangeeft aan welke sample we bezig zijn (tssn 0 en 100ms*250ksps/s). Dit dient voor de ram controller om ze goed weg te schrijven.

Alvast bedankt!