Mudanças entre as edições de "SST20707-2014-2"

De MediaWiki do Campus São José
Ir para: navegação, pesquisa
(17/11: 2ª Avaliação e 1ª Recuperação)
(Limpou toda a página)
(Etiqueta: anulando)
 
Linha 1: Linha 1:
= Síntese de Sistemas de Telecomunicações: Diário de Aula 2014-2 =
 
  
*'''Professor:''' [[Roberto de Matos]]
 
*'''Encontros:''' 2ª e 3ª feira às 7:30h
 
*[https://www.facebook.com/groups/699434770103691/ Grupo no Facebook]
 
 
*[[Síntese de Sistemas de Telecomunicações |Plano de Ensino]]
 
{{collapse top| Cronograma Semestre 2014-2}}
 
{{Cronograma-top}}
 
{{cl | 1 | 04/08 | 2 | Apresentação, Histórico, Introdução a PLDs | Lab. Prog. – Aula Expositiva }}
 
{{cl | 2 | 05/08 | 2 | Laboratório Fluxo Quartus (Exemplo: porta AND) | Computador, Quartus, Kit }}
 
{{cl | 3 | 11/08 | 2 | Exercício Fluxo Quartus (Meio somador) | Computador, Quartus, Kit }}
 
{{cl | 4 | 12/08 | 2 | Introdução à Linguagem VHDL (Entity e Architecture) e a placa DE2-115 (Exemplo: Meio Somador) | Computador, Quartus, Kit }}
 
{{cl | 5 | 18/08 | 2 | Exercício LCD em VHDL | Computador, Quartus, Kit }}
 
{{cl | 6 | 19/08 | 2 | Projeto hierárquico (Components, Port Map e Generic) e Exercício (componente) | Computador, Quartus, Kit }}
 
{{cl | 7 | 25/08 | 2 | Cont. Exercício (componente) | Computador, Quartus, Kit }}
 
{{cl | 8 | 26/08 | 2 | Código Concorrente (When, Select), Comportamental e Estrutural (Execício Mux 1-bit e 4-bit) | Computador, Quartus, Kit }}
 
{{cl | 9 | 01/09 | 2 | Exercício Mux 1-bit e 4-bit (cont.) | Computador, Quartus, Kit }}
 
{{cl | 10 | 02/09 | 2 | Exercício (Modificação Componentes) | Computador, Quartus, Kit }}
 
{{cl | 11 | 08/09 | 2 | Simulação (TCL), Exercícios (Decode 7-Seg) e Virtual function (TCL) | Computador, Quartus, Kit }}
 
{{cl | 12 | 09/09 | 2 | Exercício Decode (cont.) | Computador, Quartus, Kit }}
 
{{cl | 13 | 15/09 | 2 | Exercício UPC | Computador, Quartus, Kit }}
 
{{cl | 14 | 16/09 | 2 | Exercício UPC | Computador, Quartus, Kit }}
 
{{cl | 15 | 22/09 | 2 | 1ª Avaliação – Circuitos Combinacionais em VHD e Fluxo de projeto (Implementação, Simulação e Prototipação) | Computador, Quartus, Kit }}
 
{{cl | 16 | 23/09 | 2 | Correção da Avaliação | Computador, Quartus, Kit }}
 
{{cl | 17 | 29/09 | 2 | Introdução ao Código Seqüencial (Seq. Vs. Comb., Lista de Sensibilidade) | Computador, Quartus, Kit }}
 
{{cl | 18 | 30/09 | 2 | Exercícios (Simulação e Implementação de Circuitos Sequenciais): Registrador e  UPC com Reg. | Computador, Quartus, Kit }}
 
{{cl | 19 | 06/10 | 2 | Conceito de Variável, Variável vs. Sinal e Estruturas de Controle | Computador, Quartus, Kit }}
 
{{cl | 20 | 07/10 | 2 | Exercício: Contador até 10 | Computador, Quartus, Kit }}
 
{{cl | 21 | 13/10 | 2 | Exercício: Temporizador 60s | Computador, Quartus, Kit }}
 
{{cl | 22 | 14/10 | 2 | Introdução a FSM (1, 2 e 3 processos) e Exemplo (implementação e simulação) | Computador, Quartus, Kit }}
 
{{cl | 23 | 20/10 | 2 | Exercícios FSM (contador ASCII) | Computador, Quartus, Kit }}
 
{{cl | 24 | 21/10 | 2 | Exercícios FSM (contador ASCII) | Computador, Quartus, Kit }}
 
{{cl |  | 28/10 |  | NÃO HAVERÁ AULA: Dia do Servidor Público |  }}
 
{{cl | 25 | 03/11 | 2 | Exercício UPC FSM | Computador, Quartus, Kit }}
 
{{cl | 26 | 04/11 | 2 | Exercício UPC FSM | Computador, Quartus, Kit }}
 
{{cl | 27 | 10/11 | 2 | Exercício UPC FSM | Computador, Quartus, Kit }}
 
{{cl | 28 | 11/11 | 2 | 2ª Avaliação – Circuitos Seqüenciais | Computador, Quartus, Kit }}
 
{{cl | 29 | 17/11 | 2 | Correção da Avaliação | Computador, Quartus, Kit }}
 
{{cl | 30 | 18/11 | 2 | Aula Recuperação | Computador, Quartus, Kit }}
 
{{cl | 31 | 24/11 | 2 | Aula Recuperação | Computador, Quartus, Kit }}
 
{{cl | 32 | 25/11 | 2 | Recuperação Final | Computador, Quartus, Kit }}
 
{{cronograma-botton |64}}
 
{{collapse bottom}}
 
 
* [https://docs.google.com/spreadsheet/ccc?key=0AolsLbqpwc8_dHpaWWdRVk1iczF6WVNmcmE3aXRIT0E&usp=sharing Conceitos]
 
 
== Assuntos trabalhados ==
 
*[[Introdução aos dispositivos lógicos programáveis]]
 
*[[Introdução à tecnologia FPGA ]]
 
*[[Introdução a linguagem VHDL]]
 
 
== Apoio Desenvolvimento ==
 
*[http://www.altera.com/education/univ/materials/boards/de2-115/unv-de2-115-board.html Página DE2-115 (Manual, QSF)]
 
<!--
 
<syntaxhighlight lang=text>
 
killall jtagd
 
 
sudo vim /etc/udev/rules.d/51-usbblaster.rules
 
SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="09fb", ATTRS{idProduct}=="6001", MODE="0666"
 
 
sudo groupadd usbblaster
 
sudo usermod -a -G usbblaster aluno
 
sudo usermod -a -G usbblaster root
 
sudo chown root:usbblaster /etc/udev/rules.d/51-usbblaster.rules
 
 
sudo udevadm control --reload-rules
 
</syntaxhighlight>
 
 
*Resolve problema Modelsim
 
sudo apt-get install gnome-session-fallbac
 
 
-->
 
 
== Slides ==
 
*[[Media:Sst-intro.pdf|Slides de Introdução]]
 
*[[Media:Sst-lab1_esquematico_fluxo_quartus.pdf‎|Fluxo de Projeto Quartus]]
 
*[[Media:Sst-lab2_VHDL_fluxo_quartus.pdf‎‎|Introdução à Linguagem VHDL]]
 
*[[Media:Sst-lab3_componentes.pdf‎‎|Componentes em VHDL]]
 
*[[Media:sst-lab4_mux_decode.pdf‎‎|Mux e Decode]]
 
*[[Media:sst-lab5_flipflop.pdf‎‎|Circuitos Seqüênciais]]
 
*[[Media:sst-lab6_fsm.pdf‎‎|Máquinas de Estado]]
 
 
= 04/08: Apresentação =
 
* Apresentação do professor.
 
* Apresentação dos alunos: Nome, perfil, preferências, etc.
 
* Apresentação da disciplina: conteúdo, bibliografia e avaliação.
 
 
= 05/08: Desenvolvimento com PLDs =
 
* Aula Introdutória:
 
** Por que dispositivos lógicos programáveis?
 
** Histórico
 
* Famílias de Componentes Lógicos Programáveis
 
* Arquitetura dos FPGAS
 
* Introdução ao Fluxo de Projeto do Quartus
 
 
= 11/08: Não Houve Aula – Licença Médica =
 
= 12/08: Não Houve Aula – Licença Médica =
 
 
 
= 18/08: Fluxo Quartus II =
 
* Introdução ao Fluxo de Projeto do Quartus
 
* Fluxo de projeto esquemáticos com Quartus e Modelsim (Porta AND)
 
* Exercício [http://en.wikipedia.org/wiki/Adder_%28electronics%29  Meio-Somador]
 
 
= 19/08: Introdução à Linguagem VHDL =
 
* Finalização do fluxo de projeto do Meio somador no Quartus e Modelsim, utilização a entrada de esquemático.
 
* Apresentação da Linguagem VHDL
 
* Conceitos de entidade (entity) e arquitetura (architecture)
 
 
== Exemplos VHDL (Entity e Architecture) ==
 
* Meio Somador
 
 
= 25/08: Linguagem VHDL - Componentes =
 
 
==Exemplos VHDL (Cont.)==
 
* LCD and Switch
 
 
==Componentes (COMPONENT, PORT MAP)==
 
*Sintaxe Simplificada:
 
;:<syntaxhighlight lang=vhdl>
 
--Declaração----------------------------------------------------------
 
 
COMPONENT component_name [IS]
 
[GENERIC (
 
const_name: const_type := const_value;
 
...);]
 
PORT (
 
port_name: port_mode signal_type;
 
...);
 
END COMPONENT [component_name];
 
 
 
--Instanciação----------------------------------------------------------
 
 
label: [COMPONENT] component_name [GENERIC MAP (generic_list) ] PORT MAP (port_list);
 
 
</syntaxhighlight>
 
 
*Exemplo:
 
;:<code>
 
--Declaração----------------------------------------------------------
 
 
COMPONENT nand_gate IS
 
PORT ( a, b: IN STD_LOGIC;
 
c: OUT STD_LOGIC);
 
END COMPONENT;
 
 
 
--Instanciação---------------------------------------------------------
 
 
nand1: nand_gate PORT MAP (x, y, z); --mapeamento posicional
 
nand2: nand_gate PORT MAP (a=>x, b=>y, c=>z); --mapeamento nominal
 
 
</syntaxhighlight>
 
 
*Exemplo GENERIC:
 
;:<code>
 
--Declaração----------------------------------------------------------
 
 
COMPONENT xor_gate IS
 
GENERIC (N: INTEGER := 8);
 
PORT ( a: IN STD_LOGIC(1 TO N);
 
b: OUT STD_LOGIC);
 
END COMPONENT;
 
 
 
--Instanciação----------------------------------------------------------
 
 
xor1: xor_gate GENERIC MAP (16) PORT MAP (x, y);   --map. posicional
 
xor2: xor_gate GENERIC MAP (N=>16) PORT MAP (a=>x, b=>y); --map. nominal
 
 
</syntaxhighlight>
 
 
 
= 26/08: Código Concorrente (WHEN, SELECT) =
 
 
== WHEN ==
 
*Sintaxe Simplificada:
 
;:<code>
 
signal_name <=
 
value_expr_1 when boolean_expr_1 else
 
value_expr_2 when boolean_expr_2 else
 
value_expr_3 when boolean_expr_3 else
 
...
 
value_expr_n
 
</syntaxhighlight>
 
 
*Exemplo:
 
;:<code>
 
x <= a when (s="00") else
 
b when (s="01") else
 
c when (s="10") else
 
d;
 
</syntaxhighlight>
 
 
== SELECT ==
 
*Sintaxe Simplificada:
 
;:<code>
 
with select_expression select
 
    signal_name <= value_expr_1 when choice_1,
 
value_expr_2 when choice_2,
 
value_expr_3 when choice_3,
 
...
 
value_expr_n when choice_n;
 
</syntaxhighlight>
 
 
*Exemplo:
 
;:<code>
 
with s select
 
  x <= "0001" when "00",
 
"0010" when "01",
 
"0011" when "10",
 
"0100" when others;
 
</syntaxhighlight>
 
 
 
= 01/09: Exercícios =
 
 
* Implementação MUX comportamental e estrtural
 
* Verificação
 
 
= 02/09: Exercícios (cont.) =
 
* Integração Mux no projeto hierárquico
 
 
= 08/09: Decodificador =
 
==Decode 7-seg==
 
 
* Implementação Decode IFSC:
 
;:<code>
 
 
library IEEE;
 
use IEEE.Std_Logic_1164.all;
 
 
entity decodIFSC is
 
port (C:  in std_logic_vector(2 downto 0);
 
      F:  out std_logic_vector(6 downto 0)
 
    );
 
end decodIFSC;
 
 
architecture decod_bhv of decodIFSC is
 
Begin
 
  with C select
 
  F <= "1001111" when "000", -- I
 
      "0001110" when "001", -- F
 
      "0010010" when "010", -- S
 
      "1000110" when "011", -- C
 
      "1111111" when others;
 
end decod_bhv;
 
 
</syntaxhighlight>
 
 
 
* "Virtual Function" em arquivo *.do:
 
;:<code>
 
 
vlib work
 
vcom -93 -work work {../../decodIFSC.vhd}
 
vsim work.decodifsc
 
 
virtual type {{0b1001111 seg_I} {0b0001110 seg_F} {0b0010010 seg_S} {0b1000110 seg_C} {0b1111111 seg_others}} d7seg_ifsc_type
 
 
virtual function {(d7seg_ifsc_type)/decodIFSC/F} display_virtual
 
 
add wave -position end  sim:/decodifsc/C
 
add wave -position end  sim:/decodifsc/F
 
add wave display_virtual
 
 
force -freeze sim:/decodifsc/C 000 0
 
run
 
force -freeze sim:/decodifsc/C 001 0
 
run
 
force -freeze sim:/decodifsc/C 010 0
 
run
 
force -freeze sim:/decodifsc/C 011 0
 
run
 
force -freeze sim:/decodifsc/C 100 0
 
run
 
</syntaxhighlight>
 
 
 
= 09/09: Decodificador =
 
==UPC: Unidade de Processamento Combinacional==
 
[[imagem:diagrama_upc2.png|600px|center]]
 
 
 
= 15/09: Continuação UPC =
 
 
= 16/09: Dia de estudo da Turma =
 
 
= 22/09: Prova Combinacional =
 
 
Desenvolver um projeto hierárquico com módulos em VHDL que implemente o circuito abaixo. Esse circuito executa seis instruções de comparação (maior, igual, menor, menor e igual, diferente, menor e igual) a partir de duas entradas (A e B). As instruções de comparação são selecionadas por 3 chaves (SW[17..15]), enquanto o valor dos operandos, com 4 bits cada, são dados pelas chaves SW[3..0] (A) e SW[7..4] (B). As saídas do circuito são o LEDG(0), que indica se a operação selecionada é verdadeira (ligado) ou falsa (desligado), e o Display de 7 segmentos, que indica a operação que está sendo executada pelos códigos apresentados na tabela abaixo.
 
 
Todos os módulos devem ter arquivos de teste (*.do), inclusive o topo. O teste do decodificador deve incluir um “virtual type” para simplificar a simulação.
 
 
[[imagem:comparador.png |800px|center]]
 
 
[[imagem:decoder-2014-2.png|400px|center]]
 
 
= 23/09: Correção da Proval =
 
 
= 29/04: Introdução ao Código Seqüencial =
 
 
* Seqüencial vs. Combinacional
 
* Exemplo [http://commons.wikimedia.org/wiki/File:R-S.gif Flip-Flop RS]
 
* Lista de Sensibilidade
 
* Exercícios:
 
** Registradores de 4 e 8 Bits
 
 
 
= 30/04: Introdução ao Código Seqüencial (cont.) =
 
* Exercícios:
 
**Registrador Genérico
 
**UPC com Registradores
 
 
 
*Lista de sensibilidade avançada
 
 
**Exemplo:
 
::<code>
 
library IEEE;
 
use IEEE.STD_LOGIC_1164.all;
 
entity test_proc is
 
  port(
 
    data_in : in std_logic;
 
    data_out: out std_logic
 
  );
 
end test_proc;
 
 
architecture circuit of test_proc is
 
  signal A,B,C,D: std_logic;
 
begin
 
  A <= data_in;
 
  data_out <= D;
 
 
 
  --Version 1            --Version 2
 
  process(A)              --process (A,C)
 
  begin 
 
    B <= A;
 
    B <= '0';
 
    C <= A and '1';
 
    C <= not A;
 
    D <= C;
 
  end process;
 
end circuit;
 
</syntaxhighlight>
 
 
 
** Lista de Sensibilidade (reentrada no process)
 
** test_proc.vhd (não funciona no Quartus):
 
::<code>
 
library IEEE;
 
use IEEE.STD_LOGIC_1164.all;
 
entity test_proc is
 
  port(
 
    data_in : in std_logic;
 
    data_out: out std_logic
 
  );
 
end test_proc;
 
 
architecture circuit of test_proc is
 
  signal A,B,C,D: std_logic;
 
begin
 
  A <= data_in;
 
  data_out <= D;
 
 
 
  process
 
  begin
 
    wait on A,C;
 
    if A'event then
 
      wait for 1 ns;
 
    elsif C'event then
 
      wait for 3 ns;
 
    end if;
 
 
    B <= A;
 
    B <= '0';
 
    C <= A and '1';
 
    C <= not A;
 
    D <= C;
 
  end process;
 
end circuit;
 
</syntaxhighlight>
 
 
**test.do:
 
::<code>
 
vlib work
 
vcom -93 -work work {test_proc.vhd}
 
vsim work.test_proc
 
 
add wave -noupdate /test_proc/data_in
 
add wave -noupdate /test_proc/A
 
add wave -noupdate /test_proc/B
 
add wave -noupdate /test_proc/C
 
add wave -noupdate /test_proc/D
 
add wave -noupdate /test_proc/data_out
 
 
force -freeze sim:/test_proc/data_in 0 @10ns,1 @20ns,0 @30ns
 
run 40ns
 
</syntaxhighlight>
 
 
 
=06/10: Código Seqüencial =
 
*Exercício (cont.):
 
**UPC com registradores
 
*Conceito de Variável
 
*Variável vs. Signal
 
*Estruturas de Controle
 
 
 
==Variável vs. Sinal==
 
:<code>
 
library ieee;
 
use ieee.std_logic_1164.all;
 
 
entity sig_var is
 
port( d1: in std_logic;
 
    res1, res2: out std_logic);
 
end sig_var;
 
 
architecture behv of sig_var is
 
  signal sig_s1: std_logic;
 
begin
 
 
  proc1: process(d1)
 
    variable var_s1: std_logic;
 
  begin
 
  var_s1 := d1;
 
  res1 <= var_s1;
 
  end process;
 
 
 
  proc2: process(d1)
 
  begin
 
  sig_s1 <= d1;
 
  res2 <= sig_s1;
 
  end process;
 
 
end behv;
 
</syntaxhighlight>
 
 
==Estruturas de Controle==
 
=== IF ===
 
*Sintaxe Simplificada:
 
:<code>
 
[ label: ] if  condition1  then
 
                sequence-of-statements
 
            elsif  condition2  then      \_ optional
 
                sequence-of-statements  /
 
            elsif  condition3  then      \_ optional
 
                sequence-of-statements  /
 
            ...
 
 
            else                        \_ optional
 
                sequence-of-statements  /
 
            end if [ label ] ;
 
</syntaxhighlight>
 
 
*Exemplo:
 
:<code>
 
if a=b then
 
    c:=a;
 
elsif b<c then
 
    d:=b;
 
    b:=c;
 
else
 
    do_it;
 
end if;
 
</syntaxhighlight>
 
 
=== LOOP ===
 
*Sintaxe Simplificada:
 
:<code>
 
[ label: ] loop
 
                sequence-of-statements  -- use "exit statement" or "next statement"
 
            end loop [ label ] ;
 
 
[ label: ] for variable in range loop
 
                sequence-of-statements
 
            end loop [ label ] ;
 
 
[ label: ] while  condition  loop
 
                sequence-of-statements
 
            end loop [ label ] ;
 
</syntaxhighlight>
 
 
*Exemplo:
 
:<code>
 
  loop
 
    input_something;
 
    exit when end_file;
 
  end loop;
 
 
  for I in 1 to 10 loop
 
    AA(I) := 0;
 
  end loop;
 
 
  while not end_test loop
 
    input_something;
 
  end loop;
 
</syntaxhighlight>
 
 
 
=== CASE ===
 
 
*Sintaxe Simplificada:
 
:<code>
 
[ label: ] case  expression  is
 
              when choice1 =>
 
                sequence-of-statements
 
              when choice2 =>            \_ optional
 
                sequence-of-statements  /
 
              ...
 
 
              when others =>            \_ optional if all choices covered
 
                sequence-of-statements  /
 
            end case [ label ] ;
 
</syntaxhighlight>
 
 
 
*Exemplo:
 
:<code>
 
  case  my_val  is
 
    when 1 =>
 
      a:=b;
 
    when 3 =>
 
      c:=d;
 
      do_it;
 
    when others =>
 
      null;
 
  end case;
 
</syntaxhighlight>
 
 
=07/10: Exercícios Código Seqüencial =
 
*Exercícios:
 
**Contador até 10
 
**Temporizador 60 segundos
 
 
 
=13/10: Exercícios (cont.) =
 
*Exercícios :
 
**Contador até 10
 
**Temporizador 60 segundos
 
 
 
=14/10: Não houve aula: Avaliação da Engenharia =
 
 
= 20/10: Introdução a FSM=
 
*Introdução a máquina de estado:
 
**Estado
 
**Transição
 
**Ação
 
*Estrutura de máquinas de estado
 
*Técnicas de implementação (1, 2 e 3 processos)
 
*Exercício de simulação de uma FSM
 
 
 
= 21/10: Exercício UPC Sequencial=
 
 
===Objetivo===
 
Reduzir a quantidade de chaves no projeto combinacional da primeira avaliação, utilizando apenas um conjunto de 8 chaves, SW(7..0), para leitura dos dois operandos. A UPC terá o seguinte funcionamento:
 
#Definir a operação (SW(17..16))
 
#Entrar com o primeiro operando (SW(7..0)), pressionar Enter
 
#Entrar com o segundo operando (SW(7..0)), pressionar Enter (somente para as operações "soma", "xor ou "or")
 
#Mostrar o valor da operação
 
 
A partir do objetivo geral, temos o seguintes objetivos específicos:
 
*Implementar um registrador de tamanho genérico;
 
*Adicionar um registrador para armazenar o primeiro operando;
 
*Adicionar registradores para armazenar o resultado das operações;
 
*Implementar e adicionar uma máquina de estado (FSM) para fazer o controle como descrito abaixo.
 
 
[[imagem:diagrama-seq.png|700px|center]]
 
 
 
*A FSM terá o seguinte funcionamento:
 
**No estado inicial, “Esperando”, as saídas da FSM estão desabilitadas (Enable_1=‘0’, Enable_2=‘0’, Selecao=“XX”). Isso garante que nenhuma atividade ocorrerá na calculadora, enquanto o usuário não fornecer os operandos e a operação.
 
**Quando Enter (Key(1)) for ‘0’, a FSM avança para o próximo estado, para aguardar até o Enter voltar para ‘1’ (botão “não pressionado”).
 
**No estado “Operação” é realizada uma transição para o próximo estado, de acordo com a operação selecionada.
 
**Se a operação for “NOT” (de apenas um operando), a operação é realizada, o resultado é armazenado no registrador de saída (Enable_2=‘1’) e a FSM retorna para o estado inicial “Esperando”.
 
**Para as demais operações, a leitura do segundo operando é realizada em um estado adicional - Enable_1 e Enable_2 precisam ser devidamente controlados em cada estado.Para essas operações, quando o Enter for pressionado pela segunda vez (Key(1) = ‘0’), o resultado é escrito nos registradores de saída (Enable_1=‘1’), e a FSM retorna para o estado inicial “Esperando”.
 
 
 
 
 
= 17/11: 2ª Avaliação e 1ª Recuperação =
 
Um sinal luminoso de garagem é utilizado para alertar pedestres da passagem de veículos. O sinal luminoso alterna o acendimento dos leds amarelo (y) e vermelho (r) e emite um som audível (a) quando percebe que o portão da garagem (d) está aberto. O controle do acendimento dos leds é feito pelo módulo “sign_ctrl” que é síncrono ao sinal de relógio (clk) que possui frequência de 1Hz. A entrada “d” do módulo “sign_ctrl” indica o estado do portão da garagem, aberto ou fechado (1 ou 0, respectivamente). O módulo “sign_ctrl” deve ficar aguardando até que a entrada “d” indique portão aberto para então alternar o acendimento dos leds, de forma que somente um led deve ficar aceso a cada 1s, iniciando sempre pelo acendimento do led vermelho (r). Enquanto o portão estiver aberto (d=1) os leds devem ficar “piscando” e o alerta sonoro deve ser acionado através da porta “a”. As figuras abaixo ilustram a arquitetura e o funcionamento do módulo “sign_ctrl”.
 
 
[[imagem:sinal-luminoso.png|600px|center]]
 
 
 
*Entrega:
 
** Diagrama da máquina de estado
 
** Arquivo *.vhd da FSM (2 processos)
 
** Arquivo *.do testando a FSM
 
 
===Recuperação===
 
 
* Implementar o topo conforme o diagrama abaixo.
 
 
[[imagem:sinal-luminoso-topo.png|600px|center]]
 

Edição atual tal como às 16h11min de 21 de dezembro de 2021