Ejemplos con AFD Moore

contenido

Lampara y boton
Contador 0 a 15
Paro de emergencia
Detector de paridad
Detector de paridad. Version 2
Semáforo ver. 1
Semáforo ver. 2
Molino de café
Frequency divider
Sumador serial
Transmisor serial síncrono
Búfer de recepción

Diseñe una carta ASM para un circuito que usa una señal de reloj para detectar una señal de encendido de una lámapara. Cuando la señal es detectada nuevamente, la lámpara se apaga.

Considere que la lámpara está inicialmente apagada.

library ieee;
use ieee.std_logic_1164.all;

entity lampara is
port (
	clk		: in 	std_logic;
	boton		: in	std_logic;
	lamp		: out	std_logic
);
end entity lampara;

Se usará una variable interna que se declara como:

luz : std_logic:='0';
lamp<=luz; --Conexión entre la señal interna y la salida

library ieee;
use ieee.std_logic_1164.all;

entity lampara is
port (
	clk		: in	std_logic;
	boton		: in	std_logic;
	lamp		: out	std_logic
);
end entity lampara;

architecture behavior of lampara is
	signal luz:std_logic:='0';
begin


	lamp<=luz;

	process (clk)
	begin
		if clk'event and clk='1' then

			if boton='1' then
				luz<=not luz;
			end if;										
		end if;
	end process;

end architecture behavior;

Se requiere un contador 0 a 15.

Se declara una variable interna que se declara como:

R: std_logic_vector(3 downto 0);
Q<=R;

Se debe notar que la carta cuenta con únicamente un estado.

Dado que la carta ASM cuenta con úniamente un estado, no se requiere declarar éste.


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

entity contadorAsc is
port (
	clk     :  in std_logic;
	Q	: out std_logic_vector (3 downto 0)
);
end entity contadorAsc;

architecture behavior of contadorAsc is
signal R : std_logic_vector (3 downto 0);
begin

	Q<=R;

	process (clk)
	begin
		if clk'event and clk='1' then
			if R="1111" then
			   R<="0000";
			else
			   R<=R+1;
			end if;
		end if;
	end process;
end architecture behavior;

El diagrama de tiempos siguiente se generó mediante la aplicación «University Program» que se incluye en «Quartus».

Se está realizando un prototipo de control de un tranvía. De usted se requiere que genere la fracción de código correspondiente a un programa que monitorea la línea entrada: "rojo". Este programa genera en respuesta una señal de "paroTotal". El programa continuará generando esta señal hasta que todo el sistema sea reiniciado.

library ieee;
use ieee.std_logic_1164.all;

entity paradaEmergencia is
port (	clk: in std_logic;
			rojo: in std_logic;
			paroTotal: out std_logic:='0'
		);
end entity paradaEmergencia;

architecture behavior of paradaEmergencia is
	type states is (e0,e1);	--Se define un conjunto de valores
	signal state:states:=e0; --se define una variable sobre ese conjunto
begin

	process (clk)
	begin
		if rising_edge(clk) then

			case state is
				when e0 =>	if rojo='1' then
									paroTotal<='1';
									state<=e1;
								end if;
				when e1 => NULL;
			end case;
			
		end if;
	end process;
	
end architecture behavior;

Diseñe un sistema checador de paridad par de unos. El sistema debe generar una salida para el bit que ingrese. Si el número de unos es par entonces se enciende una señal.

En este caso, el sistema será probado en el simulador y la señal de entrada se sintetiza en el mismo simulador. El lector debe recordar que la señal de entrada generada en el simulador es diferente de la señal que genera un circuito.

La señal de reloj le dice al «Checador de paridad» cuando capturar el bit de entrada.


library ieee;
use ieee.std_logic_1164.all;

entity paridadASM is
port (
	bitIn   :  in std_logic;
	clk     :  in std_logic;
	paridad : out std_logic
);
end entity paridadASM;

architecture behavior of paridadASM is
type states is (eI,Non,Par);
signal state : states:=eI;
begin

	process (clk)
	begin
		if clk'event and clk='1' then
			case state is
				when eI =>	if bitIn='1' then
							state<=Non;
						end if;
				when Non =>	if bitIn='1' then
							paridad<='1';
							state<=Par;
						end if;
				when Par =>	if bitIn='1' then
							paridad<='0';
							state<=Non;
						end if;	
			end case;
		end if;
	end process;
end architecture behavior;

El diagrama de tiempos siguiente se generó mediante la aplicación «University Program» que se incluye en «Quartus».


library ieee;
use ieee.std_logic_1164.all;

entity paridadASM is
port (
	bitIn   :  in std_logic;
	clk     :  in std_logic;
	paridad : out std_logic
);
end entity paridadASM;

architecture behavior of paridadASM is
type states is (eI,Non,Par);
signal state : states:=eI;
begin

	process (clk)
	begin
		if clk'event and clk='1' then
			case state is
				when eI =>	if bitIn='1' then
							state<=Non;
						end if

				when Non =>	paridad<='0';
                        	            	if bitIn='1' then
							state<=Par;
						end if;

				when Par =>	paridad<='1';
						if bitIn='1' then
							state<=Non;
						end if;	
			end case;
		end if;
	end process;
end architecture behavior;

"Este proyecto se realiza con la finalidad de mostrar un problema con el uso de contadores".

Se requiere realizar el control de un semáforo. Éste control actuará como sigue:

El rojo durára cinco ciclos.
El verde durará cuatro ciclos.
El amarillo durará un ciclo.

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

entity semaforo is
port (clk	:	in 	std_logic;
		R		:	out	std_logic;
		Y		:	out	std_logic;
		G		:	out	std_logic;
		N		:	out	std_logic_vector (2 downto 0)
		);
end entity semaforo;

architecture behavior of semaforo is
	type states is (stop, go, warn);
	signal state:states:=stop;
	signal cnt	:	std_logic_vector(2 downto 0):="000";
begin

	N<=cnt;

	process (clk)
	begin
		if clk'event and clk='1' then
			case state is
			when stop	=>	R<='1';
								Y<='0';
								G<='0';
								if cnt="100" then
									cnt<="000";
									state<=go;
								else
									cnt<=cnt+1;
								end if;
								
			when go		=>	R<='0';
								Y<='0';
								G<='1';
								if cnt=3 then
									cnt<="000";
									state<=warn;
								else
									cnt<=cnt+1;
								end if;
							
			when warn	=>	R<='0';
								Y<='1';
								G<='0';
								state<=stop;
			end case;
		end if;
	end process;
	
end architecture behavior;

El siguiente mapa de tiempos muestra dos ciclos de operación del semáforo. El mapa también ilustra una falla lógica en el uso de un contdor.

Obsérvese que la luz roja dura cinco ciclos como se espera no obstante, el conteo es de "1,2,3,4,0".
Obsérvese que la luz verde dura cinco ciclos como se espera no obstante, el conteo es de "1,2,3,0".
La luz amarilla dura un ciclo y no tiene problemas.

"Este proyecto se realiza con la finalidad de mostrar un problema con el uso de contadores".

Se requiere realizar el control de un semáforo. Éste control actuará como sigue:

El rojo durára cinco ciclos.
El verde durará cuatro ciclos.
El amarillo durará un ciclo.

Lo que se hará es implementar un contador con la cantidad de pulsaciones requerida para un ciclo del semáforo, es decir: rojo-verde-amarillo.

Mediante lógica combnacional se detetan los siguientes intervalos del contador y se enciende la luz correspondiente.

El rojo: de cero a cuatro.
El verde: de cinco a ocho.
El amarillo: nueve.

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

entity semaforo is
port (clk	:	in 	std_logic;
		R		:	out	std_logic;
		Y		:	out	std_logic;
		G		:	out	std_logic;
		N		:	out	std_logic_vector (3 downto 0)
		);
end entity semaforo;


architecture behavior of semaforo is
	signal cnt	:	std_logic_vector(3 downto 0):="0000";
begin
	N<=cnt;
	
	R<='1' when cnt>="0000" and cnt<="0100" else '0';
	G<='1' when cnt>="0101" and cnt<="1000" else '0';
	Y<='1' when cnt="1001" else '0';
	
	process (clk)
	begin
	if clk'event and clk='1' then
			if cnt="1001" then
				cnt<="0000";
			else
				cnt<=cnt+1;
			end if;	
	end if;
	end process;
	
end architecture behavior;

El siguiente mapa de tiempos muestra dos ciclos de operación del semáforo. El mapa también ilustra una falla lógica en el uso de un contdor.

Se tiene un molino de café formado por una tolva, dos motores (M1 y M2) conectados a los molinetes y un recipiente que recoge el café molido. El sistema funciona deacuerdo al siguiente criterio:

Cuando el nivel de café dentro de la tolva se encuentra entre los niveles S e I sólo debe funcionar uno de los motores.
Si el nivel sobrepasa el detector S deben funcionar los dos motores, simultáneamente.
Si el nivel nosobre pasa el detector I, se deben parar ambos motores.
Suponga inicialmente que el molino está vacío.
No considere las posibles situaciones de error
1. Que la tolva pase mágicamente de vacío a tope.
2. Que la tolva pase mágicamente de tope a vacío.
3. Que los detectores indiquen que la tolva está llena y vacía al mismo tiempo.

El estado inicial del molino es el mismo estado al inicio de la jornada, es decir, la tolva está vacía.

library ieee;
use ieee.std_logic_1164.all;

entity molino is
port (
	clk	: in std_logic;
	S,I	: in std_logic;
	M1	: out std_logic:='0';
	M2	: out std_logic:='0'
);
end entity molino;

architecture behavior of molino is
	type states is (vacio, medio,lleno);
	signal state : states:=vacio;
begin

	process (clk)
	begin
		if rising_edge(clk) then
		
			case state is
			when vacio	=>	M1<='0';
						M2<='0';
						if I='1' then
							state<=medio;
						end if;
								
			when medio	=>	M1<='1';
						M2<='0';
						if I='1' then
							if S='1' then
								state<=lleno;
							end if;
						else
							state<=vacio;
						end if;
								
			when lleno	=>	M1<='1';
						M2<='1';
						if S='0' then
							state<=medio;
						end if;
			end case;
		
		end if;
	end process;

end architecture behavior;

Design and implement a frequency divider for the signal provided by the SDK's clock circuit. The clock frequency is normally 50MHz. Your design must deliver a clock frequency of 1Hz. To test your system, connect the system output to a LED.

The system will use two internal variables:

counter: integer:=0;: this variable will count till 25 millions of clock pulses.
slowClk:std_logic:='0';:this variable represente 1Hz clock pulses. You will must connect it to the putput.

library ieee;
use ieee.std_logic_1164.all;

entity freqDivider is
port (	ck	:	in		std_logic;
			clk :	out	std_logic
		);
end entity freqDivider;

architecture behavior of freqDivider is
	signal counter	:	integer;
	signal slowClk	:	std_logic:='0';
begin
	process (ck)
	begin
		if rising_edge(ck) then
			if counter=25000000 then
				counter<=0;
				slowClk<=not slowClk;
			else
				counter<=counter+1;
			end if;	
		
		end if;
	end process;
end architecture behavior

Diseñe la carta ASM de un circuito que acepte serialmente los dígitos de dos números binarios. El circuito entonces entregará, de forma serial, la suma.

En este caso, el sistema acepta una señal de reloj que le indica cuando se deben leer los bits de los operandos.

El lector puede enotar que se requiere de dos estados:

Suma sin acarreo
Suma con acarreo

Se desea un sistema que acepte una palabra binaria de «size» bits y que los envíe en forma serial a otro dispositivo.

Para este circuito se requiere de un «maestro» que es el circuito que controla la transmisión. El circuito esclavo aceptará el dato, bit a bit. Una señal de reloj generada por el maestro le dirá cuando capturar los bits.

Este acepta una palabra binaria.
Una señal de reloj externa sincroniza las operaciones internas.
El terminal «start» indica el inicio el proceso de transmisión.
El terminal «ss» es la indiación del maestro hacia al esclavo de que la transmisión inicia: «ss=1».
Los bits pueden verse en la salida, «Q»
Se provee una señal de reloj, «sclk» que indica cuando pueden capturarse los bits entregados. Los bits deben capturarse sólo en la transición positiva de «sclk»
Cuando termina la transmisión, el terminal «ss» se apaga: «ss=0».

El lector debe considerar que la señal «sclk» es diferente de la señal «clk».

La figura derecha ilustra los bits que salen del «Transmisor Serial Síncrono» así como la señal de reloj generada

Condiciones iniciales:

Q<='0';
sclk<='0';
ss<='0'


library ieee;
use ieee.std_logic_1164.all;

entity serial is
generic (size : integer:=8);
port (
	clk	:  in std_logic;
	Data	:  in std_logic_vector (size-1 downto 0);
	start	:  in std_logic;
	Q	: out std_logic;
	sclk	: out std_logic;
	ss	: out std_logic
	);
end entity serial;

architecture behavior of serial is
	type states is (starting,sendBit, sendClk,ending);
	signal state: states:=starting;
	signal w : std_logic_vector (size-1 downto 0);
begin

	process (clk)
		variable n : integer range 0 to size-1;
	begin
		if clk'event and clk='1' then
			case state is
				when starting	=>	if start='1' then
								n:=0;
								w<=Data;
								ss<='1';
								state<=sendBit;
							end if;
				
				when sendBit	=> sclk<='0';
						   q<=w(n);
						   state<=sendClk;
										
				when sendClk	=>	sclk<='1';
							if n=(size-1) then
								state<=ending;
							else
								n:=n+1;
								w<=w(0) & w(size-1 downto 1);
								state<=sendBit;
							end if;
										
				when ending	=> ss<='0';
						   sclk<='0';
						   state<=starting;
			end case;
		end if;
	end process;

end architecture behavior;

La siguiente simulación fue realizada en Quratus. La entrada fue alimentada desde el simulador.

Se tiene un circuito que es un búfer de recepción para datos tipo byte. Este circuito recibe una cantidad fija de datos, la cual por ahora es de 8 bytes.También por ahora no se plantea la lectura de datos recibidos pero si se plantea la generación de una señal de lleno.

Como objeto de este ejercicio, se espera que el lector comprenda:

Como construir un búfer.

Observe como se usa y actualiza a una variable dentro de un mismo estado.

El puerto que representa al bufer se muestra en la figura de la derecha

Por ahora solo se plantea la recepción de datos. Un contador (cnt) es utilizado para determinar la cantidad de datos ingresados
Un arreglo (buf) se utiliza para almacenar los datos recibidos

Condiciones iniciales:

No hay

El lector puede notar el uso de la variable ĺcnt&laqute;:

Esta no se inicializa en «0» sino más bien en «1»
En el último estado, se usa como índice «buf(cnt)» y se actualiza luego de una consicionante «cnt<=cnt+1»

library ieee;
use ieee.std_logic_1164.all;

entity myBuffer is
generic ( constant bufferSize : integer :=8);
port (
	clk		:  in std_logic;
	start		:  in std_logic;
	DataIn		:  in std_logic_Vector (7 downto 0);
	fullBuff	: out std_logic
);
end entity myBuffer;

architecture behavior of myBuffer is
	type states is (starting, receiving);
	signal state : states:=starting;
	
	type mem is array (0 to bufferSize-1) of std_logic_vector ( 7 downto 0);
	signal buff: mem;
	
	signal cnt : integer range 0 to bufferSize-1;
	
begin
	process (clk)
	begin
		case state is
		when starting =>	fullBuff<='0';
					if start='1' then
						cnt<=1;
						buff(0)<=DataIn;
						state<=receiving;
					end if;
								
		when receiving =>	buff(cnt)<=DataIn;
					if cnt=bufferSize-1 then
						cnt<=cnt+1;
					else
						fullBuff<='1';
						state<=starting;
					end if;	
									
		end case;
	end process;
end architecture behavior;