ADC Daten zwischenspeichern

[Christian (Gast)]

Hallo zusammen,

habe mich an die Verarbeitung des ADC Signals gemacht. Gearbeitet wird 
mit dem LTC1407 wie er auch üblicherweise auf den XILINX TestBoard 
eingesetzt wird.
Ich lege die SPI_MISO Daten in 2x14 I/Os, vom Prinzip her funktioniert 
die ganze Sache, nur habe ich das Problem das ich mit dem XC3S100E TQ144 
arbeite. Für das Projekt benötige ich aber noch mehr I/Os - gibt es also 
eine Lösung die Daten intern zu speichern?

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity adc_spi is
    Port ( clk50 : in  STD_LOGIC;
           start_conv : in  STD_LOGIC;
           SPI_MISO : in std_logic;
           CONV : out  STD_LOGIC;
           ADC1 : out std_logic_vector(13 downto 0) := (others => '0');
           ADC2 : out std_logic_vector(13 downto 0) := (others => '0');
           SCK : out  STD_LOGIC);
end adc_spi;

architecture Behavioral of adc_spi is

   type state_type is (IDLE, START,HI,LO,FINE);
   signal next_state, state : state_type;   
   signal counter : integer range 0 to 35 :=0;  
   signal sample : std_logic;
begin

process(start_conv,state,counter)

begin
    case state is
      when IDLE =>
        if start_conv ='1' then
          next_state <= START;  
        else
          next_state <= IDLE;
        end if;        
      when START =>
        next_state <= HI;          
      when HI =>    
        next_state <= LO;
      when LO =>
        if counter = 34 then
          next_state <= FINE;
        else
          next_state <= HI;
        end if;
      when FINE =>
        next_state <= IDLE;
      when others =>        
        next_state <= IDLE;    
    end case;

end process;

process(clk50)
begin
  if clk50'event and clk50 ='1' then
            state <= next_state;
  end if;
end process;

process (clk50)
variable index1 : integer range 0 to 15;
variable index2 : integer range 0 to 15;
begin 

if clk50'event and clk50 ='1' then

  case state is 
    when IDLE =>
      SCK <= '0';
      CONV <= '0';
      sample <='0';
    when START =>
      SCK <= '0';
      CONV <= '1';
      counter <= 0;
      sample <='0';
      index1 := 13;
      index2 := 13;
    when HI =>
      SCK <= '1';
      CONV <= '0';      
      counter <= counter +1;
      sample <='0';
    when LO =>
      SCK <= '0';
      CONV <= '0';  
      
      if(counter >2 and counter < 17) then    
        if index1 = 13 then
          ADC1(index1)  <= not SPI_MISO;
        else
          ADC1(index1)  <= SPI_MISO;
        end if;        
        index1 := index1 -1;
        sample <='1';
      elsif(counter > 18 and counter < 33) then
        if index2 = 13 then
          ADC2(index2)  <= not SPI_MISO;
        else
          ADC2(index2)  <= SPI_MISO;
        end if;
        index2 := index2 -1;
        sample <='1';      
      else
        sample <='0';
      end if;
    when FINE =>
      counter <= 0;
      sample <='0';
      SCK <= '0';
      CONV <= '0';      
    when others =>
      SCK <= '0';
      CONV <= '0';      
  end case;
end if;
end process;
end Behavioral;

[Mike (Gast)]

Du kannst die Daten intern in einem Blockram ablegen. Allerdings ist mir 
dein Problem nicht ganz klar. Vielleicht solltest du noch sagen was du 
mit den Daten vor hast.

[Christian (Gast)]

Eigentlich möchte ich die Daten auf dem FPGA ablegen, über eine Logic 
auswerten und an ein LCD Display ausgeben.

signal ADC1 : std_logic_vector(13 downto 0) := (others => '0');
signal ADC2 : std_logic_vector(13 downto 0) := (others => '0');

so wird das ganze wohl nicht funktionieren, oder?

[Christian (Gast)]

...geht wohl leider echt nicht - zumindest wird mein SPI_MISO von dem 
ich mir die Daten hole nicht mehr als Eingang erkannt!

Wäre über eure Hilfe sehr dankbar!

[Christian R. (supachris)]

Ich verstehe nicht, wieso du die ADC-Daten auf I/Os legen willst/musst. 
Die werden doch vom ADC seriell ausgegeben. Dann musst du die intern 
lediglich durch ein Schieberegister auf ein Signal legen bzw. gleich 
in einen Block-RAM FIFO speichern. Und wie gibts du die an die Anzeige 
aus? Doch sicherlich nicht alle parallelen ADC Werte gleichzeitig, 
oder?

[Jörg (Gast)]

Erstens: Du bekommst ein signed geliefert; zu dessen Verarbeitung
musst Du auch entsprechend handeln und nicht einfach Bit13 invertieren.

Zweitens: Ich hoffe ich liege richtig, Du willst einfach die Werte
des ADC einlesen und dann ohne Pufferung am LCD ausgeben. Also müsste
es ja im Prinzip so funktionieren.

Ob Dein Code funktioniert, kann ich leider in meiner Kaffeepause so
schnell nicht feststellen. Habe aber ebenfalls ein Xilinx-Testboard.
Dort hängen am SPI-Bus noch andere Bausteine, die vor der Komunikation
ausgeschaltet werden müssen. Ist das bei Dir der Fall?

Bei mir ist dem ADC noch ein Verstärker vorgeschaltet (LTC6912). Der
muss dann abwechselnd mit dem ADC betrieben werden. Ist das bei Dir
der Fall?

[Christian (Gast)]

Die Daten auf die I/Os zu legen war für mich die eimfachste Möglichkeit, 
bzw. zum testen auch sehr hilfreich. Leider fehler mit die Grundlagen 
diese Daten im Block-RAM FIFO abzuspeichern - außerdem möchte ich mit 
der schon erwähnten Logik die Daten nicht nur ausgeben sondern auch 
vergleichen und damit Regeln. Wenn ich also den Block-RAM in mehrere 
14Bit große Stücke unterteilen kann wäre das hilfreich.

[Christian (Gast)]

@Jörg ich arbeite gar nicht mit dem Spartan Testboard - ich habe 
lediglich gesagt das ich den selben Baustein wie auf dem Board 
verwende...

[Christian (Gast)]

Leider noch keine Antwort - will das Thema noch mal anwerfen. Wie kann 
ich meine daten im RAM speichern? Bzw. welche Valiablen kann ich im RAM 
ablegen?

[Rick Dangerus (Gast)]

Vielleicht schaust Du Dir im XST-Guide an, wie Du einen RAM beschreibst. 
Dann baust Dine State-Machine, die die Daten vom ADC abholt und eine die 
es in den RAM speichert. Und ja, ein RAM ist nur eine Matrix von Bits: 
Adresstiefe mal Datenbreite. Da kannst Du Speichern was und wie Du 
willst.

FPGAs sind keine Mikrocontroller, dass muss Dir klar werden.

Rick