MAXimator MAX10 - Przetwornik ADC (obsługa dwóch kanałów ANAIN jednocześnie)

[motoman12]

Dzień dobry wszystkim!

Zakładam ten temat gdyż mam pewien problem a mianowicie jak w temacie.

Tworzę pracę inżynierską, w której niezbędna jest obsługa dwóch wejść analogowych (potencjometr i czujnik temperatury). Praca układu ma być zależna od ustawień potencjometru i odczytów z czujnika temperatury. 

Bez problemu tworzę układ z przetwornikiem, który odczytuje i wyświetla temperaturę bądź odczytuje nastawy potencjometru i wyświetla wartość na wyświetlaczach 7-mio segmentowych. Wszystkie zamierzenia układu mam zrealizowane tylko problem mam z tym, żeby zaprogramować układ tak aby zmieniał naprzemiennie kanały i odczytywał z nich wartości gdyż niezbędne są u mnie odczyty z dwóch wejść analogowych żeby wszystkie funkcje działały prawidłowo.

Kod przetwornika wzorowany był na gotowym projekcie udostępnionym na stronie MAXimatora. 

Wiem, że zmiana kanału odbywa się z pomocą multipleksera tylko właśnie pytanie jak go zrealizować i ewentualnie jakie wprowadzić zmiany w kodzie przetwornika. 

Z góry dziękuję za pomoc.

 

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity przetwornikADC is

	port
	(
		clk : in  std_logic;
		dane: out std_logic_vector(11 downto 0)
	);

end przetwornikADC;
	
architecture adc of przetwornikADC is

					signal delay : std_logic_vector(1 downto 0);	
					signal reset_reset_n : std_logic;
					signal command_valid : std_logic;
					signal command_channel : std_logic_vector(4 DOWNTO 0);
					signal command_startofpacket : std_logic;
					signal command_endofpacket : std_logic;
					signal command_ready : std_logic;
					signal response_valid : std_logic;
					signal response_channel : std_logic_vector(4 DOWNTO 0);
					signal response_data : std_logic_vector(11 DOWNTO 0);
					signal response_startofpacket : std_logic;
					signal response_endofpacket : std_logic;

component przetwornik is	
		
					port   (
							 clk_clk                : in  std_logic                   			  := 'X';             
							 reset_reset_n          : in  std_logic                    			  := 'X';             
							 command_valid          : in  std_logic                     			  := 'X';             
							 command_channel        : in  std_logic_vector(4 downto 0) 			  := (others => 'X');
							 command_startofpacket  : in  std_logic                    			  := 'X';             
							 command_endofpacket    : in  std_logic                    			  := 'X';             
							 command_ready          : out std_logic;                                        
							 response_valid         : out std_logic;                                        
							 response_channel       : out std_logic_vector(4 downto 0);                     
							 response_data          : out std_logic_vector(11 downto 0);                    
							 response_startofpacket : out std_logic;                                        
							 response_endofpacket   : out std_logic                                         
							 );
end component;


	
component licznik is

		generic  (bits : integer);
		
		port     ( 
					clk : in  std_logic;
				   wybor : out  std_logic_vector(1 downto 0)
					);
					
end component;


	
begin
	
		u0 : component przetwornik
		port map 		
							(
							clk_clk                => CLK,                
							reset_reset_n          => reset_reset_n,          
							command_valid          => command_valid,          
							command_channel        => command_channel,        
							command_startofpacket  => command_startofpacket,  
							command_endofpacket    => command_endofpacket,    
							command_ready          => command_ready,          
							response_valid         => response_valid,         
							response_channel       => response_channel,       
							response_data          => response_data,          
							response_startofpacket => response_startofpacket, 
							response_endofpacket   => response_endofpacket   
							);
		
	u1: licznik
	
		generic map (bits =>20) 
		port map 
					(
					clk => clk, 
					wybor => delay
					);

					command_channel <= "01111"; 
					reset_reset_n <= '1';
					command_valid <= '1';
					command_startofpacket <= '1';
					command_ready <= '1';
	
	process(clk)
		variable zapis : std_logic := '0';
		
		begin
	
		if rising_edge(clk) and response_valid = '1' then
		
		if delay(1) = '1'   and zapis				= '0' then
			dane <= response_data;
			zapis := '1';
end if;
			
		if delay(1) = '0' 									then
			zapis := '0';
end if;	
end if;	

end process;
		
end adc;

 

[piotr96]

Czy wybór innego kanału ma się dokonywać za pomocą zmiennej command_channel? Nie bardzo rozumiem ten kod, zwłaszcza, że nigdy nie korzystałem z tej płytki.

Najprostszy multiplekser można zrealizować instrukcją with select:

with changeChannel select
  command_channel <=	"01111" when '0',
			"00000" when others;

Gdzie sygnał sterujący byłby przełączany po zakończeniu pomiaru.

Ale nie wiem, czy to wystarczy. Musisz zobaczyć dokumentację/kod wewnętrzny modułu „przetwornik". Jeżeli do zmiany kanału potrzeba wygenerować jakąś sekwencję różnych sygnałów (wystaw jeden sygnał, zaczekaj na odpowiedź, wystaw kolejny, ...), to wtedy warto się zainteresować maszynami stanu (instrukcja case w procesie).