|
|
| 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]]
| |
