Mudanças entre as edições de "ELD129002-Engtelecom (Diário) - Prof. Marcos Moecke"

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
 
(105 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 2: Linha 2:
 
===Unidade 1 - Aula inicial, Introdução a disciplina===
 
===Unidade 1 - Aula inicial, Introdução a disciplina===
 
* 1 ENCONTRO
 
* 1 ENCONTRO
{{collapse top | Unidade 1 - Aula inicial, Introdução a disciplina}}
+
{{collapse top | expand=true | Unidade 1 - Aula inicial, Introdução a disciplina}}
  
;Encontro 1 (27 jul):
+
;Encontro 1 (15 fev):
* O [[ELD1-EngTel (Plano de Ensino) | PLANO DE ENSINO DA DISCIPLINA]]
+
* A '''[[ELD1-EngTelecom (Página) | página da UC]]''' contém os materiais que não alteram entre semestre.
* A [[ELD1-EngTel (Página) | PÁGINA DA DISCIPLINA]] contém os materiais que não alteram entre semestre.
 
 
* Relação com as outras UCs do '''Eixo Sistemas Computacionais (Marrom)'''. Ver [https://docente.ifsc.edu.br/moecke/ppc-engtelecom/PPC2023/ grafo do curriculo]
 
* Relação com as outras UCs do '''Eixo Sistemas Computacionais (Marrom)'''. Ver [https://docente.ifsc.edu.br/moecke/ppc-engtelecom/PPC2023/ grafo do curriculo]
 
:*'''ELD129002 - ELETRÔNICA DIGITAL I (ELD1)''': Sistema de numeração e códigos. Lógica booleana. Circuitos combinacionais. Circuitos aritméticos. Linguagem de descrição de hardware. Implementação e teste de circuitos digitais. Projeto de circuitos lógicos.  
 
:*'''ELD129002 - ELETRÔNICA DIGITAL I (ELD1)''': Sistema de numeração e códigos. Lógica booleana. Circuitos combinacionais. Circuitos aritméticos. Linguagem de descrição de hardware. Implementação e teste de circuitos digitais. Projeto de circuitos lógicos.  
Linha 14: Linha 13:
 
:*'''STE129008 - STE - SISTEMAS EMBARCADOS (STE)''': Conceitos em Sistemas Embarcados. Metodologia de Desenvolvimento de Sistemas Embarcados. Sistemas Operacionais para Sistemas Embarcados. Ferramentas de desenvolvimento e depuração. Barramentos e dispositivos de acesso a redes. Desenvolvimento de Projeto.
 
:*'''STE129008 - STE - SISTEMAS EMBARCADOS (STE)''': Conceitos em Sistemas Embarcados. Metodologia de Desenvolvimento de Sistemas Embarcados. Sistemas Operacionais para Sistemas Embarcados. Ferramentas de desenvolvimento e depuração. Barramentos e dispositivos de acesso a redes. Desenvolvimento de Projeto.
  
* Nesta página está o [[ELD129002-Engtelecom (Diário) - Prof. Marcos Moecke | REGISTRO DIÁRIO E AVALIAÇÕES]].
+
* Nesta página está o '''[[ELD129002-Engtelecom (Diário) - Prof. Marcos Moecke | Registro diário dos encontros e avaliações]]'''.
* A entrega de atividades e avaliações será através da [https://moodle.ifsc.edu.br/course/view.php?id=700 plataforma Moodle]. A inscrição dos alunos é automática a partir do SIGAA.  
+
* A entrega de atividades e avaliações será através da '''[https://moodle.ifsc.edu.br/course plataforma Moodle]'''. A inscrição dos alunos é automática a partir do SIGAA.  
* Para a comunicação entre professor-aluno, além dos avisos no SIGAA, utilizaremos o [https://mail.google.com/chat/u/0/#chat/space/AAAAvYEyz7I chat institucional]. A princípio todos os alunos já estão previamente cadastrados pelo seu email institucional.  Confiram enviando uma mensagem de apresentação.
+
* Para a comunicação entre professor-aluno, além dos avisos no SIGAA, utilizaremos o '''[https://mail.google.com/chat chat institucional]'''. A princípio todos os alunos já estão previamente cadastrados pelo seu email institucional.  Confiram enviando uma mensagem de apresentação.
 
*Utilizaremos durante as aulas algumas ferramentas computacionas como o site do [https://www.falstad.com/circuit/circuitjs.html Falstad] para entender circuitos digitais e fazer simulações básicas.
 
*Utilizaremos durante as aulas algumas ferramentas computacionas como o site do [https://www.falstad.com/circuit/circuitjs.html Falstad] para entender circuitos digitais e fazer simulações básicas.
*Também utilizaremos os softwares '''Quartus Light''' e '''ModelSim''' instalados nas maquinas do laboratório para praticar a parte de programação de hardware (descrição de hardware).  Esses softwares também podem ser usados através da [[Acesso ao IFSC-CLOUD (NUVEM)|NUVEM do IFSC]]..
+
*Também utilizaremos os softwares '''Quartus Light''' e '''ModelSim''' instalados nas maquinas do laboratório para praticar a parte de programação de hardware (descrição de hardware).  Esses softwares também podem ser usados através da '''[[Acesso ao IFSC-CLOUD (NUVEM)|Nuvem do IFSC]]'''..
 
    
 
    
 
;LER PARA O PRÓXIMO ENCONTRO:
 
;LER PARA O PRÓXIMO ENCONTRO:
*Capítulo 1. Do Zero ao Um, seções 1.1 a 1.3 do livro [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf David Money Harris, B., & Harris Morgan Kaufman, S. L. (2013). Projeto Digital e Arquitetura de Computadores], diponibilizado gratuitamente pela www.imgtec.com.
+
*Capítulo 1. Do Zero ao Um, seções 1.1 a 1.3 do livro [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=27 David Money Harris, B., & Harris Morgan Kaufman, S. L. (2013). Projeto Digital e Arquitetura de Computadores], diponibilizado gratuitamente pela www.imgtec.com.
 
{{collapse bottom}}
 
{{collapse bottom}}
  
 
===Unidade 2 - Sistema de numeração e códigos===
 
===Unidade 2 - Sistema de numeração e códigos===
 
* 4 ENCONTROS
 
* 4 ENCONTROS
{{collapse top | Unidade 2 - Sistema de numeração e códigos}}
+
{{collapse top | expand=true |Unidade 2 - Sistema de numeração e códigos}}
;Encontro 2 (1 ago) - Sistemas numéricos:
+
;Encontro 2 (20 fev) - Sistemas numéricos:
 
O ser humano precisa contar para determinar quantidades de coisas, com as quantidades ele pode fazer operações matemáticas e comparações.
 
O ser humano precisa contar para determinar quantidades de coisas, com as quantidades ele pode fazer operações matemáticas e comparações.
 
*Os números permitem representar quantidades de forma simbólica.
 
*Os números permitem representar quantidades de forma simbólica.
Linha 61: Linha 60:
 
:*Exemplo: o número representado 111, corresponde a 1 quadra (2² = 4), 1 dupla (2¹ = 2) e 1 unidade (2⁰ = 1).
 
:*Exemplo: o número representado 111, corresponde a 1 quadra (2² = 4), 1 dupla (2¹ = 2) e 1 unidade (2⁰ = 1).
 
:: <big>  1*2²  + 1*2¹  + 1*2⁰  =  1*4  + 1*2  + 1*1  =  4    + 2    + 1    = 7  </big>
 
:: <big>  1*2²  + 1*2¹  + 1*2⁰  =  1*4  + 1*2  + 1*1  =  4    + 2    + 1    = 7  </big>
 
;LER PARA O PRÓXIMO ENCONTRO:
 
*Capítulo 1. Do Zero ao Um, seção 1.4 do livro [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf David Money Harris, B., & Harris Morgan Kaufman, S. L. (2013). Projeto Digital e Arquitetura de Computadores], diponibilizado gratuitamente pela www.imgtec.com.
 
*Começe a resolver os exercícios 1.7 ao 1.49
 
*Ver [https://moodle.ifsc.edu.br/pluginfile.php/194612/mod_resource/content/1/Sistemas%20Num%C3%A9ricos.pdf Slides - Sistemas Numéricos]
 
 
;Encontro 3 (3 ago) - Sistemas numéricos:
 
  
 
*O que são bits,  nibbles, bytes e word (palavra) de bits
 
*O que são bits,  nibbles, bytes e word (palavra) de bits
Linha 104: Linha 96:
 
*Note no quadro acima:
 
*Note no quadro acima:
 
:*o '''nibble''' corresponde ao grupo de 4 bits (meio byte)
 
:*o '''nibble''' corresponde ao grupo de 4 bits (meio byte)
:*o '''byte''' corresponde ao grupo de 8 bits
+
:*o '''byte''' corresponde ao grupo de 8 bits.  Este grupo de 8 bits também é denominado de forma mais exata de '''octeto'''.
 
:*a '''word''' corresponde ao grupo de 16 bits (as vezes 32 bits)
 
:*a '''word''' corresponde ao grupo de 16 bits (as vezes 32 bits)
 
:*a '''double word''' corresponte ao grupo de 32 bits (as vezes 64 bits)
 
:*a '''double word''' corresponte ao grupo de 32 bits (as vezes 64 bits)
Linha 153: Linha 145:
 
|}
 
|}
  
Ler mais sobre [https://pt.wikipedia.org/wiki/Byte Byte] e os [https://pt.wikipedia.org/wiki/Prefixo_bin%C3%A1rio prefixos binários] na Wikipedia
+
;PARA O PRÓXIMO ENCONTRO:
 +
* Ler capítulo 1. Do Zero ao Um, seção 1.4 do livro [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=34 Projeto Digital e Arquitetura de Computadores], diponibilizado gratuitamente pela www.imgtec.com.
 +
* Ver [https://moodle.ifsc.edu.br/pluginfile.php/311786/mod_resource/content/2/Sistemas%20num%C3%A9ricos.pdf Slides - Sistemas Numéricos]
 +
* Ver mais sobre [https://pt.wikipedia.org/wiki/Byte Byte] ou [https://en.wikipedia.org/wiki/Byte Byte.en] e os [https://pt.wikipedia.org/wiki/Prefixo_bin%C3%A1rio prefixos binários] na Wikipedia
 +
 
 +
;Encontro 3 (22 fev):
 +
;Conversão de bases entre sistemas numéricos:
 +
*Conversão entre os sistemas de numeração '''decimal - binário - hexadecimal'''.
 +
:*ver os [https://moodle.ifsc.edu.br/pluginfile.php/311786/mod_resource/content/2/Sistemas%20num%C3%A9ricos.pdf#page=15 slides - Sistemas Numéricos (conversão entre sistemas)]
 +
 +
*Regra geral de conversão de valor para qualquer sistema de numeração
 +
:* Dividir o valor (número) pela base e obter o '''quociente''' e o '''resto'''.
 +
:* Dividir sucessivas vezes o quociente anterior até obter um quociente nulo. 
 +
:* Os restos obtidos são os digitos que representam o valor (número) no novo sistema de numeração.
 +
:* O primeiro resto obtido é o '''dígito menos significativo'''. 
 +
:* O último resto obtido é o '''dígito mais significativo'''.
 +
 
 +
*Regra geral de conversão de um sistema de numeração qualquer de base N para decimal
 +
:* Verifique a posição do ponto decimal.
 +
:* Os dígitos a esquerda do ponto decimal correspondem as posições 0, 1, 2, … .
 +
:* Se houver dígitos a direita do ponto decimal, eles correspondem as posições -1, -2, -3, … .
 +
:* A cada dígito é dado um peso correspondente ao valor da base elevada ao expoente N<sup>posição</sup>.
 +
:* Multiplique os pesos pelos dígitos correspondentes.
 +
:* O valor final (em decimal) é a soma dos valores obtidos.
 +
{| class="wikitable" style="text-align:center;"
 +
|- style="font-weight:bold;"
 +
!style="width: 15%;" | posição
 +
!style="width: 10%;" | k
 +
!style="width: 7%;" | …
 +
!style="width: 10%;" | 2
 +
!style="width: 10%;" | 1
 +
!style="width: 10%;" | 0
 +
!style="width: 3%;" | ,
 +
!style="width: 10%;" | -1
 +
!style="width: 10%;" | -2
 +
!style="width: 7%;" | …
 +
!style="width: 10%;" | -l
 +
|-
 +
| style="font-weight:bold;" | dígito
 +
| d<sub>k</sub>
 +
|
 +
| d<sub>2</sub>
 +
| d<sub>1</sub>
 +
| d<sub>0</sub>
 +
|
 +
| d<sub>-1</sub>
 +
| d<sub>-2</sub>
 +
|
 +
| d<sub>-l</sub>
 +
|-
 +
| style="font-weight:bold;" | peso
 +
| N<sup>k</sup>
 +
|
 +
| N<sup>2</sup>
 +
| N<sup>1</sup>
 +
| N<sup>0</sup>
 +
|
 +
| N<sup>-1</sup>
 +
| N<sup>-2</sup>
 +
|
 +
| N<sup>-l</sup>
 +
|-
 +
| style="font-weight:bold;" | somar
 +
| d<sub>k</sub> × N<sup>k</sup>
 +
|
 +
| d<sub>2</sub> × N<sup>2</sup>
 +
| d<sub>1</sub> × N<sup>1</sup>
 +
| d<sub>0</sub> × N<sup>0</sup>
 +
|
 +
| d<sub>-1</sub> × N<sup>-1</sup>
 +
| d<sub>-2</sub> × N<sup>-2</sup>
 +
|
 +
| d<sub>-l</sub> × N<sup>-l</sup>
 +
|-
 +
| style="font-weight:bold;" | valor
 +
| colspan="10" style="font-weight:bold;" |  d<sub>k</sub> × N<sup>k</sup> + d<sub>2</sub> × N<sup>2</sup> + d<sub>1</sub> × N<sup>1</sup> + d<sub>0</sub> × N<sup>0</sup> + d<sub>-1</sub> × N<sup>-1</sup> + d<sub>-2</sub> × N<sup>-2</sup> + d<sub>-l</sub> × N<sup>-l</sup>
 +
|}
  
 
;Códigos numéricos binários:
 
;Códigos numéricos binários:
*Número sem sinal (UNSIGNED)
+
*Número sem sinal ('''UNSIGNED''')
 
:Neste caso apenas números inteiros naturais podem ser representados.  
 
:Neste caso apenas números inteiros naturais podem ser representados.  
 
:Usando  <math> N  </math> bits é possível representar números inteiros no intervalo de <math> [0, 2^{N}-1] </math>.  
 
:Usando  <math> N  </math> bits é possível representar números inteiros no intervalo de <math> [0, 2^{N}-1] </math>.  
Linha 299: Linha 367:
 
|}
 
|}
  
*Número com sinal (Complemento de 2 ou SIGNED)
+
*Número com sinal (Complemento de 2 ou '''SIGNED''')
 
:Neste caso o msb corresponde ao peso negativo, de modo que ao colocar 1 no msb o número inteiro passa a ser negativo, e se o msb for 0, o número será positivo.
 
:Neste caso o msb corresponde ao peso negativo, de modo que ao colocar 1 no msb o número inteiro passa a ser negativo, e se o msb for 0, o número será positivo.
 
:Usando  <math> N  </math> bits é possível representar números inteiros no intervalo de <math> [-2^{N-1}, 2^{N-1}-1] </math>. Nesta representação existem apenas um zero.  
 
:Usando  <math> N  </math> bits é possível representar números inteiros no intervalo de <math> [-2^{N-1}, 2^{N-1}-1] </math>. Nesta representação existem apenas um zero.  
Linha 408: Linha 476:
  
  
Comparação das representações
+
;Comparação das representações:
 +
O quadro abaixo mostra as representações em binário dos valores de +15 a -8 no sistema sem sinal ('''UNSIGNED'''), com signal-magnitude , com sinal em complemento de um , com sinal em complemento de dois ('''SIGNED''').  No quadro é importante notar que sempre os números negativos tem o msb = 1.  Adicionalmente alguns sistemas possuem dois zeros (+0 e -0).  No tipo SIGNED note que o valor máximo positivo será menor que o valor absoluto do mínimo negativo, por uma unidade. 
 +
 
 
{| class="wikitable" style="text-align:center;"
 
{| class="wikitable" style="text-align:center;"
 
|- style="font-weight:bold;"
 
|- style="font-weight:bold;"
Linha 578: Linha 648:
 
*Para obter o número negativo em complemento de um deve-se complementar (inverter) todos os bits do número binário positivo.
 
*Para obter o número negativo em complemento de um deve-se complementar (inverter) todos os bits do número binário positivo.
 
*Para obter o número negativo em complemento de dois deve-se: a) obter o complemento de um (complementar (inverter) todos os bits do número binário positivo ); b) somar 1 ao resultado.
 
*Para obter o número negativo em complemento de dois deve-se: a) obter o complemento de um (complementar (inverter) todos os bits do número binário positivo ); b) somar 1 ao resultado.
*Para obter o número negativo em sinal-magnitude é necessário apenas adicionar um bit 1 a esquerda do lsb.
+
*Para obter o número negativo em sinal-magnitude é necessário apenas adicionar um bit 1 a esquerda do msb.
 
*Note que em todos os casos a representação de números com sinal, sempre implica na necessidade de um bit a mais.
 
*Note que em todos os casos a representação de números com sinal, sempre implica na necessidade de um bit a mais.
  
   13 (decimal) = 01101 (binário sem sinal)
+
   13 (decimal) = 1101 (binário sem sinal)
  -13 (decimal) = 10010 (binário em complemento de um)
+
  +13 (decimal) = '''0'''1101 (binário em sinal-magnitude)
  -13 (decimal) = 10010 + 1 = 10011 (binário em complemento de dois)
+
-13 (decimal) = '''1'''1101 (binário em sinal-magnitude)
  -13 (decimal) = 11101 (binário em sinal-magnitude)
+
+13 (decimal) = '''0'''1101 (binário em complemento de um)
 +
  -13 (decimal) = '''10010''' (binário em complemento de um)
 +
+13 (decimal) = '''0'''1101 (binário em complemento de dois)
 +
  -13 (decimal) = '''10011''' =  10010 + 1  (binário em complemento de dois)
 +
 
 +
;PARA O PRÓXIMO ENCONTRO:
 +
* Iniciar a resolução dos [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=74 Exercícios 1.7 ao 1.49 Capítulo 1 - Projeto Digital e Arquitetura de Computadores]
 +
 
  
 +
;Encontro 4 (27 fev):
 
;Código ASCII:
 
;Código ASCII:
 
O código '''ASCII''' (''American Standard Code for Information Interchange''), é um padrão de codificação de caracteres para comunicação digital. Ele tem apenas 128 pontos de código, sendo 95 são caracteres imprimíveis e os demais são não imprimíveis (em azul no quadro abaixo), sendo usados para diversos controles de equipamentos eletrônicos. Atualmente esse código está sendo substituido pelos códigos '''UNICODE''', que tem milhões de pontos de código, mas nos UNICODE os primeiros 128 são iguais ao conjunto ASCII.
 
O código '''ASCII''' (''American Standard Code for Information Interchange''), é um padrão de codificação de caracteres para comunicação digital. Ele tem apenas 128 pontos de código, sendo 95 são caracteres imprimíveis e os demais são não imprimíveis (em azul no quadro abaixo), sendo usados para diversos controles de equipamentos eletrônicos. Atualmente esse código está sendo substituido pelos códigos '''UNICODE''', que tem milhões de pontos de código, mas nos UNICODE os primeiros 128 são iguais ao conjunto ASCII.
Linha 783: Linha 861:
 
*A letra "a" é representado pelo número hexadecimal 61, o que corresponde a 01100001 em binário
 
*A letra "a" é representado pelo número hexadecimal 61, o que corresponde a 01100001 em binário
 
*O espaço "SP" é representado pelo número hexadecimal 20, o que corresponde a 00100000 em binário
 
*O espaço "SP" é representado pelo número hexadecimal 20, o que corresponde a 00100000 em binário
Descubra o que está escrito em:
+
 
45 6e 67 74 65 6c 65 63 6f 6d 20 64 6f 20 49 46 53 43 20
+
Descubra o que está escrito neste código binário onde cada 8 bits correspondem a um simbolo ASCII:
 
  01000010 01101111 01101101 00100000 01100100 01101001 01100001 00100000 01110000 01100101 01110011 01110011 01101111 01000001 01001100 01001100
 
  01000010 01101111 01101101 00100000 01100100 01101001 01100001 00100000 01110000 01100101 01110011 01110011 01101111 01000001 01001100 01001100
 
  
 
;Código UNICODE:
 
;Código UNICODE:
Linha 796: Linha 873:
 
*O processo reverso pode ser feito usando [https://onlineutf8tools.com/convert-code-points-to-utf8 code points to utf8 converter]
 
*O processo reverso pode ser feito usando [https://onlineutf8tools.com/convert-code-points-to-utf8 code points to utf8 converter]
  
 
;Encontro 4 (8 ago) - Sistemas numéricos:
 
 
*Outros códigos binários:
 
*Outros códigos binários:
 
:* '''Gray''' - É um código em que dois valores consecutivos diferem em apenas um bit. Isso é útil para minimizar erros de leitura em sistemas eletrônicos, já que a transição entre estados ocorre com uma única mudança de bit, facilitando a detecção de erros.
 
:* '''Gray''' - É um código em que dois valores consecutivos diferem em apenas um bit. Isso é útil para minimizar erros de leitura em sistemas eletrônicos, já que a transição entre estados ocorre com uma única mudança de bit, facilitando a detecção de erros.
Linha 803: Linha 878:
 
::*Em código binário convencional o número adjacente a 0111 (7) é o 1000 (8), mudança em 4 bits.
 
::*Em código binário convencional o número adjacente a 0111 (7) é o 1000 (8), mudança em 4 bits.
 
::*Em código Gray o número adjacente a 0100 (7) é o 1100 (8), mudança de apenas 1 bit.
 
::*Em código Gray o número adjacente a 0100 (7) é o 1100 (8), mudança de apenas 1 bit.
 +
 
:* '''One-hot''' - Neste código cada valor é representado por uma única posição ativa (ALTO) dentro do conjunto de bits, enquanto todas as outras posições estão inativas (BAIXO).  Esse código é frequentemente usado em sistemas digitais para representar estados discretos, como em máquinas de estados finitos, e também na geração de sinais de seleção de múltiplos circuitos tais como memórias. A vantagem principal reside na simplicidade da detecção de um único estado ativo, evitando ambiguidades e permitindo uma implementação eficiente em hardware.
 
:* '''One-hot''' - Neste código cada valor é representado por uma única posição ativa (ALTO) dentro do conjunto de bits, enquanto todas as outras posições estão inativas (BAIXO).  Esse código é frequentemente usado em sistemas digitais para representar estados discretos, como em máquinas de estados finitos, e também na geração de sinais de seleção de múltiplos circuitos tais como memórias. A vantagem principal reside na simplicidade da detecção de um único estado ativo, evitando ambiguidades e permitindo uma implementação eficiente em hardware.
 +
 
:* '''Johnson''' - Neste código é gerado deslocando-se sucessivamente todos os bits para a esquerda e colocando o bit complementar do msb como lsb. A codificação normalmente começa com todos bits "0". Devido a sua simplicidade, ele é utilizado para contadores utilizados em controle de sistemas digitais simples de alta velocidade. Por sempre ter apenas 1 bit de diferença entre números adjacentes, ele fornece boa proteção contra erros, mas necessita de mais bits para representar a mesma faixa de valores que um binário sequencial.
 
:* '''Johnson''' - Neste código é gerado deslocando-se sucessivamente todos os bits para a esquerda e colocando o bit complementar do msb como lsb. A codificação normalmente começa com todos bits "0". Devido a sua simplicidade, ele é utilizado para contadores utilizados em controle de sistemas digitais simples de alta velocidade. Por sempre ter apenas 1 bit de diferença entre números adjacentes, ele fornece boa proteção contra erros, mas necessita de mais bits para representar a mesma faixa de valores que um binário sequencial.
 +
 
:* '''BCD''' (''Binary-coded decimal'') - Esse código basicamente consiste em representar cada digito decimal de 0 a 9 por um grupo de 4 bits (0 -> 0000, 1 -> 0001, ... 8 -> 1000 e 9 -> 1001).  Ele é utilizado em mostradores de sete segmentos, onde cada um deles indica um dígito.
 
:* '''BCD''' (''Binary-coded decimal'') - Esse código basicamente consiste em representar cada digito decimal de 0 a 9 por um grupo de 4 bits (0 -> 0000, 1 -> 0001, ... 8 -> 1000 e 9 -> 1001).  Ele é utilizado em mostradores de sete segmentos, onde cada um deles indica um dígito.
 +
 
<center>
 
<center>
 
{| class="wikitable" style="text-align:center;"
 
{| class="wikitable" style="text-align:center;"
Linha 963: Linha 1 042:
 
|}
 
|}
 
</center>
 
</center>
*Resolução de exercícios:
 
:*Exercícios 1.9 a 1.40
 
;Encontro 5 (10 ago) - Sistemas numéricos:
 
  
 
;Extensão de bits de um número inteiro sem sinal:
 
;Extensão de bits de um número inteiro sem sinal:
Linha 986: Linha 1 062:
 
  Número estendido: 10001101  = (-13 em decimal), pois -(+8 + 4 + 1) = -13
 
  Número estendido: 10001101  = (-13 em decimal), pois -(+8 + 4 + 1) = -13
 
   
 
   
;Ponto Fixo:  
+
;Números binário fracionários em Ponto Fixo:  
*É um número binário que permite representares números fracionários.  Os valores são todos escalonados por um fator constante para transformar em um número inteiro.  Assim, o número 5,25 pode ser escalonado por 2² => 5,25 x 4 = 21, e portanto 5,25 = 21 / 2².  Assim, usando dois bits fracionarios, o número 5,25 pode ser escrito em binário como 10101, onde o separador fracionário esta em 101,01.
+
*A representaçaõ de '''Ponto Fixo''' é um número binário que permite representares números fracionários.  Os valores são todos escalonados por um fator constante para transformar em um número inteiro.  Assim, o número 5,25 pode ser escalonado por 2² => 5,25 x 4 = 21, e portanto 5,25 = 21 / 2².  Assim, usando dois bits fracionarios, o número 5,25 pode ser escrito em binário como 10101, onde o separador fracionário esta em 101,01.
 
*Usando  <math> M  </math> bits para representar um número de ponto fixo Q(M,F) com F bits fracionários, é possível representar números fracionários no intervalo de <math> [0, 2^{M-F}-2^{-F}] </math>. Neste caso a resolução (menor quantidade que se pode representar) é de <math> 2^{-F} </math>
 
*Usando  <math> M  </math> bits para representar um número de ponto fixo Q(M,F) com F bits fracionários, é possível representar números fracionários no intervalo de <math> [0, 2^{M-F}-2^{-F}] </math>. Neste caso a resolução (menor quantidade que se pode representar) é de <math> 2^{-F} </math>
 
:Por exemplo usando Q(8,3) =>  <math> [0; 2^{5}-2^{-3}] = [ 0; 31,875] = [00000,000_2; 11111,111_2] </math>, e a resolução é de <math> 2^{-3} = 0,125 </math>.
 
:Por exemplo usando Q(8,3) =>  <math> [0; 2^{5}-2^{-3}] = [ 0; 31,875] = [00000,000_2; 11111,111_2] </math>, e a resolução é de <math> 2^{-3} = 0,125 </math>.
Linha 1 047: Linha 1 123:
 
*Note que que é possível obter rapidamente o valor de um número de ponto fixo, obtendo o valor do seu número inteiro correspondente, dividindo-o por 2<sup>-F</sup>. No exemplo acima, 10100111, corresponde ao inteiro 167, ou seja se o número é do tipo Q(8,3), o valor é de 167/2<sup>-F</sup> = 20,875.
 
*Note que que é possível obter rapidamente o valor de um número de ponto fixo, obtendo o valor do seu número inteiro correspondente, dividindo-o por 2<sup>-F</sup>. No exemplo acima, 10100111, corresponde ao inteiro 167, ou seja se o número é do tipo Q(8,3), o valor é de 167/2<sup>-F</sup> = 20,875.
 
*Assim como nos números inteiros, é possível representar também números em ponto fixo negativos usando complemento de 2 ou sinal-magnitude.
 
*Assim como nos números inteiros, é possível representar também números em ponto fixo negativos usando complemento de 2 ou sinal-magnitude.
;Ponto Flutuante (''floating point''):
+
 
Os números de ponto flutuante são agrupados da esquerda para a direita:1) bit de sinal, 2) expoente e 3) mantissa. Para os formatos binários IEEE 754 (básico e estendido) que possuem implementações de hardware existentes, eles são distribuídos da seguinte forma:
+
;PARA O PRÓXIMO ENCONTRO:
 +
*Resolução dos [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=74 Exercícios 1.7 ao 1.49 Capítulo 1 - Projeto Digital e Arquitetura de Computadores]
 +
*Ler Capítulo 2 - Representações Binárias em [http://biblioteca.ifsc.edu.br/index.asp?codigo_sophia=30631 Eletrônica digital moderna e VHDL / Volnei A. Pedroni; tradução de Arlete Simille Marques]
 +
*Ver exercícios 2.2 a 2.13, 2.16 a 2.18, 2.21 a 2.26, 2.29 a 2.32, 2.39 a 2.41 de [http://biblioteca.ifsc.edu.br/index.asp?codigo_sophia=30631]
 +
 
 +
;Encontro 5 (29 fev):
 +
;Ponto Flutuante (''floating point''):Os números de ponto flutuante são agrupados da esquerda para a direita:1) bit de sinal, 2) expoente e 3) mantissa. Para os formatos binários IEEE 754 (básico e estendido) que possuem implementações de hardware existentes, eles são distribuídos da seguinte forma:
  
 
{| class="wikitable" style="text-align:center; background-color:#F8F9FA; color:#202122;"
 
{| class="wikitable" style="text-align:center; background-color:#F8F9FA; color:#202122;"
Linha 1 057: Linha 1 139:
 
! Mantissa
 
! Mantissa
 
! Total<br />bits
 
! Total<br />bits
! style="background-color:#FFF; font-weight:normal;" |  
+
! style="background-color:#FFF; font-weight:normal;"| 
 
! Viés do <br />exponente
 
! Viés do <br />exponente
 
! Precisão <br />em bits
 
! Precisão <br />em bits
 
|-
 
|-
| Half-precision  
+
| Half-precision
| style="vertical-align:middle;" | 1
+
| style="vertical-align:middle;"|1
| style="vertical-align:middle;" | 5
+
| style="vertical-align:middle;"|5
| style="vertical-align:middle;" | 10
+
| style="vertical-align:middle;"|10
| style="vertical-align:middle;" | 16
+
| style="vertical-align:middle;"|16
| style="vertical-align:middle; background-color:#FFF;" |  
+
| style="vertical-align:middle; background-color:#FFF;"| 
| style="vertical-align:middle;" | 15
+
| style="vertical-align:middle;"|15
| style="vertical-align:middle;" | 11
+
| style="vertical-align:middle;"|11
 
|-
 
|-
 
| Single-precision
 
| Single-precision
| style="vertical-align:middle;" | 1
+
| style="vertical-align:middle;"|1
| style="vertical-align:middle;" | 8
+
| style="vertical-align:middle;"|8
| style="vertical-align:middle;" | 23
+
| style="vertical-align:middle;"|23
| style="vertical-align:middle;" | 32
+
| style="vertical-align:middle;"|32
| style="vertical-align:middle; background-color:#FFF;" |  
+
| style="vertical-align:middle; background-color:#FFF;"| 
| style="vertical-align:middle;" | 127
+
| style="vertical-align:middle;"|127
| style="vertical-align:middle;" | 24
+
| style="vertical-align:middle;"|24
 
|-
 
|-
 
| Double-precision
 
| Double-precision
| style="vertical-align:middle;" | 1
+
| style="vertical-align:middle;"|1
| style="vertical-align:middle;" | 11
+
| style="vertical-align:middle;"|11
| style="vertical-align:middle;" | 52
+
| style="vertical-align:middle;"|52
| style="vertical-align:middle;" | 64
+
| style="vertical-align:middle;"|64
| style="vertical-align:middle; background-color:#FFF;" |  
+
| style="vertical-align:middle; background-color:#FFF;"| 
| style="vertical-align:middle;" | 1023
+
| style="vertical-align:middle;"|1023
| style="vertical-align:middle;" | 53
+
| style="vertical-align:middle;"|53
 
|}
 
|}
  
Linha 1 097: Linha 1 179:
 
<center>[[Arquivo:PontoFlutuante64.png]]</center>
 
<center>[[Arquivo:PontoFlutuante64.png]]</center>
  
*Como converter de decimal para floating point?
+
;Como converter de decimal para floating point?:
:*[https://www.wikihow.com/Convert-a-Number-from-Decimal-to-IEEE-754-Floating-Point-Representation How to Convert a Number from Decimal to IEEE 754 Floating Point Representation]
+
# Identifique quantos bits serão usados e obtenha o viés (veja na tabela acima)
*Como converter de floating point para decimal?
+
# Converta o número decimal para binário ponto fixo:
#Identifique se o número é de 16, 32 ou 64 bits.
+
# Normalize a mantissa, movendo o ponto decimal para que haja apenas um um dígito à esquerda do ponto decimal.
#Obtenha o sinal do número a partir do ''msb'' (S = 0 => +; S = 1 => -)
+
# Determine o sinal, o expoente e a mantissa: 1) O número é positivo, então o bit de sinal é 0. 2) O expoente é o deslocamento necessário para normalizar a mantissa. 3) A mantissa é a parte fracionária normalizada.
#Obtenha o número correspondente ao expoente (E).
+
# Converta o expoente para binário com bias: Adicionamos o viés ao expoente para obter o valor final.
#Considerando o viés, calcule o exponente (e = E - vies)
+
# Junte os bits na ordem: sinal, expoente e mantissa, e obtenha o número em IEEE 754 Floating Point
#Obtenha o valor da mantissa (M) e acrescente o 1 inteiro (se o numero estiver normalizado) (1.M)
+
 
#O resultado em decimal é <math> (-)^S \times 1.M \times 2^{E-vies} </math>
+
'''Exemplo:''' Dado o número '''85,125''' converta para a representação floating point de 32 bits
  Exemplo: Dado o número floating point de 32 bits = 01000000111000000000000000000000
+
'''P1:''' 32 bits, portanto o viés é 127.
Sinal (msb): 0 => positivo
+
'''P2:''' 85 em binário é 1010101. 0.125 em binário é 0.001. Portanto, 85,125 em binário é 1010101.001
  Viés: (2<sup>8-1</sup> - 1) = -127
+
'''P3:''' 1010101.001 => <span style="color:red;">1</span>.<span style="color:blue;">010101001</span> × 2^6
  Expoente (8 bits): 10000001 = 129 - 127 = 2
+
'''P4:''' O número é positivo, então o bit de sinal é 0. O expoente é o deslocamento necessário para normalizar a mantissa. No caso, 6. A mantissa é a parte fracionária normalizada, que é <span style="color:blue;">010101001</span>.(note que o <span style="color:red;">1</span> a esquerda do ponto decimal não será representado.
  Mantissa: (23 bits): 11000000000000000000000
+
'''P5:''' Expoente = 6 + 127 = 133 em binário é <span style="color:green;">10000101</span>.
  Valor (24 bits): 1.11000000000000000000000 = 1,75
+
'''P6:''' Sinal: 0, Expoente: <span style="color:green;">10000101</span>, Mantissa: <span style="color:blue;">010101001</span>00000000000000 (completar com zeros até 23 bits), portanto 0 10000101 <span style="color:blue;">010101001</span>00000000000000
  Resultado: (-) 1,75 x 2<sup>2</sup> = 7
+
: FONTE: [https://www.wikihow.com/Convert-a-Number-from-Decimal-to-IEEE-754-Floating-Point-Representation How to Convert a Number from Decimal to IEEE 754 Floating Point Representation]
 +
 
 +
;Como converter de floating point para decimal?:
 +
# Identifique o número de bits e obtenha o número de bits do expoente e o viés (veja na tabela acima),
 +
# Obtenha o sinal do número a partir do ''msb'' (S = 0 => +; S = 1 => -)
 +
# Obtenha o número correspondente ao Expoente (E).
 +
# Considerando o viés, calcule o expoente (e = E - viés)
 +
# Obtenha o valor da mantissa (M) e  
 +
# Obtenha o valor decimal correspondente, acrescentando o 1 inteiro (se o numero estiver normalizado) antes da conversão
 +
# O resultado em decimal é <math> (-)^S \times 1.M \times 2^{E-vies} </math>  
 +
  '''Exemplo:''' Dado o número representado em floating point de 32 bits = 1<span style="color:green;">10000001</span><span style="color:blue;">11000000000000000000000</span>  
 +
  '''P1:''' Expoente tem 8 bits => viés = 127 (2<sup>8-1</sup>-1)
 +
'''P2:''' Sinal (msb): 1 => é um número negativo (-)
 +
  '''P3:''' Expoente (8 bits): <span style="color:green;">10000001</span> = 129
 +
'''P4:''' expoente (e = E - vies) 129 - 127 = 2
 +
  '''P5:''' Mantissa: (23 bits): <span style="color:blue;">11000000000000000000000</span>
 +
  '''P6:''' Valor (24 bits):1.<span style="color:blue;">11000000000000000000000</span> = 1,75
 +
  '''P7:''' Resultado: (-) 1,75 x 2<sup>2</sup> = -7
  
*Números denormalizados.
+
;Números sub_normais:
Os números denormalizados não usam um "1" implícito no início da mantissa, ao contrário dos números normalizados. Isso significa que a mantissa dos números denormalizados começa com um "0" explícito antes da parte fracionária, permitindo representar valores muito pequenos que não podem ser normalizados devido à limitação dos bits do expoente.
+
Os números sub_normais são indicados pelo Expoente = 00000000.  Esse Expoente será interpretado como  2<sup>-126</sup>. Eles, ao contrário dos números normalizados, não usam um "1" implícito no início da mantissa. Isso significa que a mantissa desses números começa com um "0" explícito antes da parte fracionária, permitindo representar valores muito pequenos que não podem ser normalizados devido à limitação dos bits do expoente.
 +
Exemplos:
 +
0 00000000 00000000000000000000000  corresponde ao número +0
 +
1 00000000 00000000000000000000000  corresponde ao número -0
 +
0 00000000 10000000000000000000000  corresponde ao número 0,5 x 2<sup>-126</sup> = 5.877472E-39
 +
1 00000000 00000000000000000000001  corresponde ao número -2<sup>-23</sup> x 2<sup>-126</sup>  = -0.00000011920928955078125 x 2<sup>-126</sup> = -1.40129846432481707092373E-45 (2<sup>-149</sup>
  
*Números especiais.
+
;Números especiais:
:*Infinito Positivo (Inf):
+
* Infinito Positivo (Inf): Bit de sinal: 0 (positivo) Expoente: Todos os bits definidos como 1 (8 bits)
Bit de sinal: 0 (positivo)
 
Expoente: Todos os bits definidos como 1 (8 bits)
 
 
  Mantissa: Todos os bits definidos como 0 (23 bits)
 
  Mantissa: Todos os bits definidos como 0 (23 bits)
 
  Representação em 32 bits: 0 11111111 00000000000000000000000
 
  Representação em 32 bits: 0 11111111 00000000000000000000000
 
+
* Infinito Negativo (-Inf): Bit de sinal: 1 (negativo) Expoente: Todos os bits definidos como 1 (8 bits)
:*Infinito Negativo (-Inf):
 
Bit de sinal: 1 (negativo)
 
Expoente: Todos os bits definidos como 1 (8 bits)
 
 
  Mantissa: Todos os bits definidos como 0 (23 bits)
 
  Mantissa: Todos os bits definidos como 0 (23 bits)
 
  Representação em 32 bits: 1 11111111 00000000000000000000000
 
  Representação em 32 bits: 1 11111111 00000000000000000000000
 
+
* NaN (''Not a Number''): Bit de sinal: Pode ser 0 ou 1 (geralmente usado para sinalizar erros ou operações indefinidas) Expoente: Todos os bits definidos como 1 (8 bits)
:* NaN (''Not a Number''):
 
Bit de sinal: Pode ser 0 ou 1 (geralmente usado para sinalizar erros ou operações indefinidas)
 
Expoente: Todos os bits definidos como 1 (8 bits)
 
 
  Mantissa: Pelo menos um bit não nulo (23 bits)
 
  Mantissa: Pelo menos um bit não nulo (23 bits)
 
  Representação: x 11111111 yyyyyyyyyyyyyyyyyyyyyyy (onde "x" é o bit de sinal e "y" são bits da mantissa)
 
  Representação: x 11111111 yyyyyyyyyyyyyyyyyyyyyyy (onde "x" é o bit de sinal e "y" são bits da mantissa)
  
*Exemplos de conversores online.
+
;Exemplos de conversores online:
:*[http://weitz.de/ieee/ IEEE 754 Calculator] 16-bits & 32-bits & 64-bits & 128-bits
+
* [http://weitz.de/ieee/ IEEE 754 Calculator] 16-bits & 32-bits & 64-bits & 128-bits
:*[https://www.h-schmidt.net/FloatConverter/IEEE754.html IEEE-754 Floating Point Converter] 32-bits
+
* [https://www.h-schmidt.net/FloatConverter/IEEE754.html IEEE-754 Floating Point Converter] 32-bitsVer [[Media: PontoFixoFlutuante.pdf| Ponto Fixo e Flutuante]] - prof. Odilson  
 
+
* Ver [https://en.wikipedia.org/wiki/Floating-point_arithmetic Floating-point arithmetic] - wikipedia
*Ver [[Media: PontoFixoFlutuante.pdf| Ponto Fixo e Flutuante]] - prof. Odilson  
+
* Ver [https://en.wikipedia.org/wiki/IEEE_754 IEEE 754] - wikipedia
*Ver [https://en.wikipedia.org/wiki/Floating-point_arithmetic Floating-point arithmetic] - wikipedia
+
* Ler sobre os hardware de microprocessadores [https://en.wikipedia.org/wiki/History_of_computing_hardware_(1960s%E2%80%93present)#Microprocessors]. Para ver o número de bits de cada arquitetura, clique no link correspondente na tabela.{{collapse bottom}}
*Ver [https://en.wikipedia.org/wiki/IEEE_754 IEEE 754] - wikipedia
 
*Ler sobre os hardware de microprocessadores [https://en.wikipedia.org/wiki/History_of_computing_hardware_(1960s%E2%80%93present)#Microprocessors]. Para ver o número de bits de cada arquitetura, clique no link correspondente na tabela.
 
 
 
{{collapse bottom}}
 
  
 
===Unidade 3 - Funções, portas lógicas e álgebra booleana===
 
===Unidade 3 - Funções, portas lógicas e álgebra booleana===
 
* 10 ENCONTROS
 
* 10 ENCONTROS
{{collapse top | Unidade 3 - Funções, portas lógicas e álgebra booleana }}
+
{{collapse top |expand=true | Unidade 3 - Funções, portas lógicas e álgebra booleana }}
;Encontro 6-8 (15,17,22 ago) - Funções e portas lógicas:
+
;Encontro 6 (5 mar.)
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/244758/mod_resource/content/1/Fun%C3%A7%C3%B5es%20%20e%20portas%20l%C3%B3gicas.pdf  Funções e portas lógicas]
+
;Funções e portas lógicas:
*Ler pag 49 a 69 de [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=49 Projeto Digital e Arquitetura de Computadores]
+
*[https://moodle.ifsc.edu.br/pluginfile.php/311787/mod_resource/content/1/Fun%C3%A7%C3%B5es%20%20e%20portas%20l%C3%B3gicas.pdf Funções e portas lógicas]
*Consumo de energia de circuitos digitais.
+
;PARA O PRÓXIMO ENCONTRO:
::<math> P_{Estatica} = I_{DD} \times V_{DD} </math>
+
*Rever [https://moodle.ifsc.edu.br/pluginfile.php/311787/mod_resource/content/1/Fun%C3%A7%C3%B5es%20%20e%20portas%20l%C3%B3gicas.pdf  Funções e portas lógicas]
::<math> P_{Dinamica} = 1/2 \times C \times V_{DD}^2 \times f </math>
+
*Ler pag 49 a 69 de [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=49 Projeto Digital e Arquitetura de Computadores]
::<math> P_{Total} = P_{Estatica} + P_{Dinamica} </math>
 
  
*Ler pag 69 a 70 de [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=69 Projeto Digital e Arquitetura de Computadores]
+
;Encontro 7 (7 mar.)
 +
;Funções e portas lógicas:
 +
*[https://moodle.ifsc.edu.br/pluginfile.php/311787/mod_resource/content/1/Fun%C3%A7%C3%B5es%20%20e%20portas%20l%C3%B3gicas.pdf Funções e portas lógicas]
 +
;PARA O PRÓXIMO ENCONTRO:
 +
*[[Como as portas lógicas são implementadas com transistores CMOS]]
  
;Encontro 9 (24  ago) - Álgebra booleana:
 
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/247987/mod_resource/content/1/Algebra%20de%20Boole.pdf Álgebra de Boole]
 
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=107 Projeto Digital e Arquitetura de Computadores]
 
  
;Encontro 10 (29  ago) - Projeto de circuitos combinacionais:
+
;Encontro 8 (12 mar.)
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/250687/mod_resource/content/1/Projeto%20de%20circuitos%20combinacionais.pdf Projeto de circuitos combinacionais]
+
*[https://moodle.ifsc.edu.br/pluginfile.php/311788/mod_resource/content/2/Algebra%20de%20Boole.pdf Álgebra de Boole] - slides
*Ler a seção '''2.1.INTRODUÇÃO, 2.2.EQUAÇÕES BOOLEANAS''' nas pag 99 a 107 e 114 a 115 de [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=99 Projeto Digital e Arquitetura de Computadores]
+
;PARA O PRÓXIMO ENCONTRO:
*Exercícios 2.1, 2.2, 2.5-7, 2.13-18
+
*Rever slides 1 a 15 de [https://moodle.ifsc.edu.br/pluginfile.php/311788/mod_resource/content/2/Algebra%20de%20Boole.pdf Álgebra de Boole]  
 +
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=107 Projeto Digital e Arquitetura de Computadores]
 +
*Ler a seção '''4-2 LEIS E REGRAS DA ÁLGEBRA BOOLEANA''' nas pag 201 a 206 de [https://app.minhabiblioteca.com.br/reader/books/9788577801077/pageid/200 FLOYD, Thomas. Sistemas digitais. Grupo A, 2011. E-book. ISBN 9788577801077] na [[Minha Biblioteca]]
  
;Encontro 11 (31  ago) - Exercícios de álgebra de Boole:
+
;Encontro (14 mar.)
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/252198/mod_resource/content/1/Exercicios%20de%20algebra%20de%20boole.pdf Exercícios de álgebra de Boole]
+
*[https://moodle.ifsc.edu.br/pluginfile.php/311788/mod_resource/content/2/Algebra%20de%20Boole.pdf Álgebra de Boole]
*Ler a seção '''2.3.4. A Verdade por Detrás de Tudo e 2.3.5. Simplificando Equações''' nas pag 87 a 90 de  [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=113 Projeto Digital e Arquitetura de Computadores]
+
;Teoremas de De Morgan:
 +
*O complemento do produto é igual a soma dos complementos: <math> \overline{X \cdot Y} = \overline{X} + \overline{Y} </math>
 +
*O complemento da soma é igual ao produto dos complementos: <math> \overline{X+Y} = \overline{X} \cdot \overline{Y} </math>
  
;Encontro 12 (5 set) - Expressão booleana - Tabela verdade - Circuito com portas lógicas:
+
Para provar os teoremas, podemos obter a tabela verdade de ambos lados de cada equação booleana.
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/254019/mod_resource/content/1/Portas%20-%20Tabela%20verdade%20-%20Express%C3%B5es.pdf Expressão booleana - Tabela verdade - Circuito com portas lógicas]
 
*Ler a seção '''2.4. DA LÓGICA ÀS PORTAS e 2.5.LÓGICA COMBINATÓRIO MULTI-NÍVEL''' nas pag 90 a 95 de  [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=116 Projeto Digital e Arquitetura de Computadores]
 
*Avaliação A1b (55 minutos)
 
  
;Encontro 13 a 15 (12, 14 e 19  set) - Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch:
+
{| class="wikitable" style="text-align:center;"
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/260765/mod_resource/content/2/Simplifica%C3%A7%C3%A3o%20de%20express%C3%B5es%20l%C3%B3gicas%20-%20Mapas%20de%20Karnaugh-Veitch.pdf Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch]
+
|- style="text-align:left;"
*Ler a seção '''2.7.MAPAS DE KARNAUGH''' nas pag 99 a 108 de  [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=125 Projeto Digital e Arquitetura de Computadores]
+
! colspan="2" | Entradas
*Ler [https://en.wikipedia.org/wiki/Quine%E2%80%93McCluskey_algorithm#:~:text=The%20Quine%E2%80%93McCluskey%20algorithm%20is,to%20as%20the%20tabulation%20method Quine–McCluskey algorithm]
+
! colspan="2" | Saídas
*Teste em [https://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/qmc/ Quine–McCluskey algorithm]
+
|- style="font-weight:bold; background-color:#EAECF0; color:#202122;"
*Ler [https://en.wikipedia.org/wiki/Espresso_heuristic_logic_minimizer Espresso heuristic logic minimizer]
+
| style="vertical-align:middle; width: 25%;" | X
*Ler [https://wiki.sj.ifsc.edu.br/index.php/Mapas_de_Karnaugh_2D_e_3D Mapas de Karnaugh 2D e 3D]
+
| style="vertical-align:middle; width: 25%;" | Y
*K-Map online [https://www.docjava.com/cpe210/kmapExplorer.html docjava.com], [https://ictlab.kz/extra/Kmap/ ICT laboratory], [https://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/karnaughmap/ uni-marburg.de] e  [https://atozmath.com/KMap.aspx?q=kmap atozmath.com]
+
| style="font-weight:normal; width: 25%;" | <math> \overline{X \cdot Y}  </math>
{{collapse bottom}}
+
| style="font-weight:normal; width: 25%;" |  <math> \overline{X} + \overline{Y} </math>
 +
|- style="vertical-align:middle;
 +
| 0
 +
| 0
 +
| 1
 +
| 1
 +
|-
 +
| 0
 +
| 1
 +
| 1
 +
| 1
 +
|-
 +
| 1
 +
| 0
 +
| 1
 +
| 1
 +
|-
 +
| 1
 +
| 1
 +
| 0
 +
| 0
 +
|}
  
===Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim===
+
{| class="wikitable" style="text-align:center;"
* 6 ENCONTROS
+
|- style="text-align:left;"
{{collapse top | Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim }}
+
! colspan="2" | Entradas
 
+
! colspan="2" | Saídas
;Encontro 16 (21 set) - Linguagem VHDL:
+
|- style="font-weight:bold; background-color:#EAECF0; color:#202122;"
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/262427/mod_resource/content/1/Introdu%C3%A7%C3%A3o%20a%20linguagem%20de%20descri%C3%A7%C3%A3o%20de%20hardware.pdf Introdução a linguagem de descrição de hardware (DHL)]
+
| style="vertical-align:middle; width: 25%;" | X
*Ler [https://pt.wikipedia.org/wiki/VHDL VHDL], [https://en.wikipedia.org/wiki/VHDL alguns exemplos de VHDL] na Wikipedia
+
| style="vertical-align:middle; width: 25%;" | Y
 
+
| style="font-weight:normal; width: 25%;" | <math> \overline{X + Y}  </math>
;Encontro 17 (26  set) - Avaliação A1b:
+
| style="font-weight:normal; width: 25%;" |  <math> \overline{X} \cdot \overline{Y} </math>
 
+
|- style="vertical-align:middle;
;Encontro 18 (28 set) - Linguagem VHDL (cont):
+
| 0
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/262427/mod_resource/content/1/Introdu%C3%A7%C3%A3o%20a%20linguagem%20de%20descri%C3%A7%C3%A3o%20de%20hardware.pdf Introdução a linguagem de descrição de hardware (DHL)]
+
| 0
 +
| 1
 +
| 1
 +
|-
 +
| 0
 +
| 1
 +
| 0
 +
| 0
 +
|-
 +
| 1
 +
| 0
 +
| 0
 +
| 0
 +
|-
 +
| 1
 +
| 1
 +
| 0
 +
| 0
 +
|}
 +
 
 +
Ou utilizar os postulados e teoremas da algebra de boole.
 +
Considerando que <math> \overline{X+Y} = \overline{X} \cdot \overline{Y} </math> seja verdade, então
 +
:'''PASSO 1:''' pelo postulado do complemento <math> \overline{A} + A = 1 </math>, podemos afirmar que
 +
::<math>(X+Y) + (\overline{X}\cdot\overline{Y}) = 1 </math>
 +
:'''PASSO 2:''' pelo teorema da distribuição <math> A + (B \cdot C) = (A + B) \cdot (A + C) </math>, podemos afirmar que 
 +
::<math> (X + Y) + (\overline{X}\cdot\overline{Y})=(X + Y + \overline{X})\cdot(X + Y + \overline{Y}) </math>
 +
:'''PASSO 3:''' pelo teorema da comutação <math> A + B = B + A </math>, podemos afirmar que 
 +
::<math>(X + Y + \overline{X})\cdot(X + Y + \overline{Y}) = (Y + X + \overline{X})\cdot(X + Y + \overline{Y}) </math>
 +
:'''PASSO 4:''' pelo postulado do complemento <math> A + \overline{A}  = 1 </math>, podemos afirmar que 
 +
::<math>(Y + X + \overline{X})\cdot(X + Y + \overline{Y}) = (Y + 1) \cdot (X + 1) </math>
 +
:'''PASSO 5:''' pelo postulado do elemento absorvente <math> A + 1  = 1 </math>, podemos afirmar que 
 +
::<math> (Y + 1) \cdot (X + 1) = 1 \cdot 1 </math>
 +
:'''PASSO 6:''' pelo postulado da multiplicação (AND) <math> 1 \cdot 1  = 1 </math>, podemos afirmar que 
 +
::<math> 1 \cdot 1 = 1 </math>
 +
: Portanto a consideração inicial é verdadeira <math> \overline{X+Y} = \overline{X} \cdot \overline{Y} </math>.
 +
 
 +
:'''Nota:''' O teorema também pode ser provado usando o postulado do complemento <math> \overline{A} \cdot A = 0 </math>, pois neste caso, podemos afirmar que
 +
::<math>(X+Y) . (\overline{X}\cdot\overline{Y}) = 0 </math>.
 +
:Tente desenvolver o restante da prova usando apenas os postulados e teoremas.
 +
 
 +
Os teoremas de De Morgam são validos para qualquer número (N) de entradas, podem ser escritos como:
 +
: <math> \overline{X_1 \cdot X_2 \cdot ... \cdot X_N} = \overline{X_1} + \overline{X_2} + ... + \overline{X_N} </math>
 +
: <math> \overline{X_1 + X_2 + ... + X_N} = \overline{X_1} \cdot \overline{X_2} \cdot ... \cdot \overline{X_N}</math>
 +
 
 +
;Exercícios:
 +
Simplifique as expressões lógicas (''caso seja possível''). Indique os Postulados ou Teoremas utilizado em cada passo. Para simplificar as notações os códigos A1 a A5  e T1 a T12 ou T1' a T12' indicado na [https://moodle.ifsc.edu.br/pluginfile.php/372852/mod_resource/content/1/Folha%20de%20consulta%20-%20%C3%A1lgebra%20booleana.pdf Folha de consulta - álgebra booleana].
 +
:a) ABC + A + BC
 +
:b) A.B + A.B’ + A’.B
 +
:c) X.Y + X.Y’ + X’.Y + X.Y
 +
:d) X.Y + X.Z + Z.Y 
 +
:e) D.B’+D.(D.B+C.D’)
 +
   
 +
Ver também exemplos em 4-4 ANÁLISE BOOLEANA DE CIRCUITOS LÓGICOS [[https://app.minhabiblioteca.com.br/reader/books/9788577801077/pageid/206 FLOYD, Thomas. Sistemas digitais. Grupo A, 2011. E-book. ISBN 9788577801077]
  
* Estrutura do código VHDL
+
;PARA O PRÓXIMO ENCONTRO:
:* Declaração das bibliotecas e pacotes '''LIBRARY''' / '''PACKAGE'''
+
*Rever slides 16 até fim de [https://moodle.ifsc.edu.br/pluginfile.php/311788/mod_resource/content/2/Algebra%20de%20Boole.pdf Álgebra de Boole]
<syntaxhighlight lang=vhdl>
+
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=107 Projeto Digital e Arquitetura de Computadores]
library library_name;
+
*Ler a seção '''4-3 TEOREMAS DE DEMORGAN e 4-4 ANÁLISE BOOLEANA DE CIRCUITOS LÓGICOS ''' nas pag 207 a 216 de [https://app.minhabiblioteca.com.br/reader/books/9788577801077/pageid/206 FLOYD, Thomas. Sistemas digitais. Grupo A, 2011. E-book. ISBN 9788577801077] na [[Minha Biblioteca]]
use library_name.package_name.all;
 
</syntaxhighlight>
 
  
:* '''ENTITY'''
+
;Encontro 10  (21 mar.)
<syntaxhighlight lang=vhdl>
+
*Expressão booleana - Tabela verdade - Circuito com portas lógicas:
  entity entity_name is
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311791/mod_resource/content/1/Portas%20-%20Tabela%20verdade%20-%20Express%C3%B5es.pdf Expressão booleana - Tabela verdade - Circuito com portas lógicas]
  [generic (
+
*Ler a seção '''2.4. DA LÓGICA ÀS PORTAS e 2.5.LÓGICA COMBINATÓRIO MULTI-NÍVEL''' nas pag 90 a 95 de [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=116 Projeto Digital e Arquitetura de Computadores]
    cons_name1: const_type const_value;
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311790/mod_resource/content/1/Exercicios%20de%20algebra%20de%20boole.pdf Exercícios de álgebra de Boole]
    cons_name2: const_type const_value;
+
*Ler a seção '''2.3.4. A Verdade por Detrás de Tudo e 2.3.5. Simplificando Equações''' nas pag 87 a 90 de [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=113 Projeto Digital e Arquitetura de Computadores]
    ...
 
    cons_nameN: const_type const_value);]
 
  [port (
 
    signal_name1: mode signal_type;
 
    signal_name2: mode signal_type;
 
    ...
 
    signal_nameN: mode signal_type);]
 
  [declarative_part]
 
  [begin
 
  statement_part]
 
end [entity] [entity_name];
 
</syntaxhighlight>
 
  
:* '''ARCHITECTURE'''
+
;Encontro 11 (26  mar.):
<syntaxhighlight lang=vhdl>
+
*Expressão booleana - Tabela verdade - Circuito com portas lógicas:
  architecture arch_name of entity_name is
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311791/mod_resource/content/1/Portas%20-%20Tabela%20verdade%20-%20Express%C3%B5es.pdf Expressão booleana - Tabela verdade - Circuito com portas lógicas]
  [declarative_part]
+
*Ler a seção '''2.4. DA LÓGICA ÀS PORTAS e 2.5.LÓGICA COMBINATÓRIO MULTI-NÍVEL''' nas pag 90 a 95 de [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=116 Projeto Digital e Arquitetura de Computadores]
begin
+
*Avaliação A1b (50 minutos)
  statement_part
 
end [architecture] [arch_name];
 
</syntaxhighlight>
 
  
* Exemplo - Declaração de uma porta NAND em VHDL
+
;Encontro 12  (28 mar.)
 +
*Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch:
 +
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311792/mod_resource/content/2/Simplifica%C3%A7%C3%A3o%20de%20express%C3%B5es%20l%C3%B3gicas%20-%20Mapas%20de%20Karnaugh-Veitch.pdf Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch]
 +
*Ler a seção '''2.7.MAPAS DE KARNAUGH''' nas pag 99 a 108 de  [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=125 Projeto Digital e Arquitetura de Computadores]
  
<syntaxhighlight lang=vhdl>
+
;Encontro 13  (2 abr.)
library std;
+
*Ler [https://en.wikipedia.org/wiki/Quine%E2%80%93McCluskey_algorithm#:~:text=The%20Quine%E2%80%93McCluskey%20algorithm%20is,to%20as%20the%20tabulation%20method Quine–McCluskey algorithm]
use std.standard.all;
+
*Teste em [https://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/qmc/ Quine–McCluskey algorithm]
 +
*Ler [https://en.wikipedia.org/wiki/Espresso_heuristic_logic_minimizer Espresso heuristic logic minimizer]
 +
*Ler [https://wiki.sj.ifsc.edu.br/index.php/Mapas_de_Karnaugh_2D_e_3D Mapas de Karnaugh 2D e 3D]
 +
*K-Map online [https://www.docjava.com/cpe210/kmapExplorer.html docjava.com], [https://ictlab.kz/extra/Kmap/ ICT laboratory], [https://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/karnaughmap/ uni-marburg.de]
  
entity nand_gate is
+
;Encontro 14  (4 abr.)
port (a, b: in bit; x: out bit);
+
*Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch:
end entity;
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311792/mod_resource/content/2/Simplifica%C3%A7%C3%A3o%20de%20express%C3%B5es%20l%C3%B3gicas%20-%20Mapas%20de%20Karnaugh-Veitch.pdf Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch]
 +
*Ler a seção '''2.7.MAPAS DE KARNAUGH''' nas pag 99 a 108 de  [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=125 Projeto Digital e Arquitetura de Computadores]
  
architecture nome_arch of nand_gate is
 
begin
 
x <= a nand b;
 
end architecture;
 
</syntaxhighlight>
 
  
*Uso do ambiente EDA - QUARTUS Prime para programação em VHDL.
+
;Encontro 15 (9  abr.) - Projeto de circuitos combinacionais:
;PASSO 0:  
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311789/mod_resource/content/1/Projeto%20de%20circuitos%20combinacionais.pdf Projeto de circuitos combinacionais]
[[Acesso ao IFSC-CLOUD (NUVEM) | Acesse a nuvem do IFSC]] usando um terminal via ssh:
+
*Multiplexadores e Decodificadores:
USER=LOGIN_SIGAA
+
*Ler a seção '''2.8.BLOCOS COMBINATÓRIOS''' nas pag 109 a 114 [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=135 Projeto Digital e Arquitetura de Computadores]
ssh $USER@quartus.sj.ifsc.edu.br -XC 
+
 
Insira a senha do SIGAA
+
;Encontro 16 (11 abr.)
LOGIN_SIGAA@quartus.sj.ifsc.edu.br's password:
+
*Exercícios 2.1, 2.2, 2.5-7, 2.13-18, 2.22-25, 2.28-29, 2.31-32, 2.34, 2.35, 2.36-37, 2.39-40 ver [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=151]
 +
*Pergunta 2.2, 2.3, 2.4 ver [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=163]
 +
 
 +
;Encontro 18 (23  abr.) - Avaliação A1c (6 pontos):
 +
*Simplificação de expressões lógicas e mapa de Karnaugh
 +
*Representação de circuitos lógicos - '''Diagrama de portas lógicos = Tabela Verdade = Expressão lógica'''
 +
 
 +
<!--
  
;PASSO 1:  
+
*Consumo de energia de circuitos digitais.
Abra o Quartus Prime digitando no terminal
+
::<math> P_{Estatica} = I_{DD} \times V_{DD} </math>
quartus20.1.sh
+
::<math> P_{Dinamica} = 1/2 \times C \times V_{DD}^2 \times f </math>
Em seguida abra um arquivo para inserir o código VHDL.  No menu superior selecione '''[File > New > Design Files: VHDL File]''' e '''[OK]'''
+
::<math> P_{Total} = P_{Estatica} + P_{Dinamica} </math>
  
;PASSO 2:
+
*Ler pag 69 a 70 de [https://moodle.ifsc.edu.br/pluginfile.php/311785/mod_resource/content/1/DDCA_portugues.pdf#page=69 Projeto Digital e Arquitetura de Computadores]
*Copie o código VHDL acima para o espaço de edição e salve o arquivo com o nome da '''entity''': ''nand_gate.vhd'', em um pasta exclusiva para este projeto.
 
*Ao ser perguntado se deseja criar um novo projeto, responda [Yes]. Os próximos passos podem ser realizados da seguinte forma:
 
:*Na tela '''Introduction''' [Next >]
 
:*Na tela '''Directory, Name, Top-Level Entity'''
 
::*Note onde o projeto será salvo.
 
  /home/USER/PASTA_DO_PROJETO/
 
::*Note o nome do projeto. Se quiser pode mudá-lo
 
nand_gate
 
::*Note  o nome da '''top-level design entity'''
 
nand_gate
 
::*Em seguida [Next >]
 
:*Na tela '''Project Type''' [Next >]
 
:*Na tela '''Add Files''' [Next >], pois seu arquivo já está na lista dos arquivos.
 
:*Na tela '''Family, Device & Board Settings''', escolha a Family = ['''Cyclone IV E'''] e o Device = ['''EP4CE6E22A7'''] e [Next >]
 
:*Na tela '''EDA Tool Setting''' [Next >]
 
:*Note na tela Summary os dados do projeto e clique [Finish]
 
  
;PASSO 3:
 
Realize a '''Analysis & Synthesis''' ['''Processing > Start > Start Analysis & Synthesis'''], ou use um dos botões que o professor mostrou em aula.
 
:*Note o '''Compilation Report'''
 
  
;PASSO 4:
+
;Encontro 11 (31  ago) - Exercícios de álgebra de Boole:
*Use o [[RTL Viewer]] para ver a descrição RTL do circuito. Selecione '''[Tools > Netlist Vieweres > RTL Viewer]'''.
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/252198/mod_resource/content/1/Exercicios%20de%20algebra%20de%20boole.pdf Exercícios de álgebra de Boole]
*Use o [[Technology Map Viewer]] para ver a como o circuito foi mapeado para os elementos lógicos disponíveis no dispositivo FPGA selecionado. Selecione '''[Tools > Netlist Vieweres > Technology Map Viewer]'''.
+
*Ler a seção '''2.3.4. A Verdade por Detrás de Tudo e 2.3.5. Simplificando Equações''' nas pag 87 a 90 de [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=113 Projeto Digital e Arquitetura de Computadores]
  
;PASSO 5:  
+
;Encontro 12 (5 set) - Expressão booleana - Tabela verdade - Circuito com portas lógicas:
*Modifique a descrição do circuito para implementar o circuito da função  Y = (A.B)' + C.D'B', salve o projeto Ckt2.vhd e de o mesmo nome para a entity.
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/254019/mod_resource/content/1/Portas%20-%20Tabela%20verdade%20-%20Express%C3%B5es.pdf Expressão booleana - Tabela verdade - Circuito com portas lógicas]
 +
*Ler a seção '''2.4. DA LÓGICA ÀS PORTAS e 2.5.LÓGICA COMBINATÓRIO MULTI-NÍVEL''' nas pag 90 a 95 de  [https://moodle.ifsc.edu.br/pluginfile.php/159985/mod_resource/content/1/DDCA_portugues.pdf#page=116 Projeto Digital e Arquitetura de Computadores]
 +
*Avaliação A1b (55 minutos)
  
;Encontro 19 (3  out.) - Simulador ModelSim:
+
-->
*Abra o circuito que foi salvo na aula anterior.  Após abrir o Quartus, clique em [File > Open Project] e selecione a pasta onde salvou o projeto.  Depois clique sobre o arquivo '''nand_gate.qpf'''.  Note que abrir um projeto é diferente de abrir um arquivo, pois todos os arquivos de configuração estão associados a esse .qpf.
+
{{collapse bottom}}
  
;Encontro 20 (5  out.):
+
===Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim===
*Avaliação A1c - Simplificação de expressões lógicas:
+
* 6 ENCONTROS
 +
{{collapse top | expand=true |Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim }}
  
  
;Encontro 21 (10 out.):
+
;Encontro 17 (18 abr.) - Linguagem VHDL:
*Escreva o código VHDL e faça a simulação para o circuito correspondente a expressão lógica:
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311793/mod_resource/content/2/Introdu%C3%A7%C3%A3o%20a%20linguagem%20de%20descri%C3%A7%C3%A3o%20de%20hardware.pdf Introdução a linguagem de descrição de hardware (DHL)]
Y = AB + AC'
 
Z = A'BC + C'
 
{{collapse bottom}}
 
  
===Unidade 5 - Circuitos lógicos combinacionais (com VHDL)===
+
;Encontro 19 (25  abr.) - Linguagem VHDL:
* 12 ENCONTROS
+
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311793/mod_resource/content/2/Introdu%C3%A7%C3%A3o%20a%20linguagem%20de%20descri%C3%A7%C3%A3o%20de%20hardware.pdf Introdução a linguagem de descrição de hardware (DHL)]
{{collapse top | Unidade 5 - Circuitos lógicos combinacionais (com VHDL)}}
 
  
;Encontro 22, 23 (17 e 20 out.)
+
* Estrutura do código VHDL
*[[Preparando para gravar o circuito lógico no FPGA]]
+
:* Declaração das bibliotecas e pacotes '''LIBRARY''' / '''PACKAGE'''
* Configurar uma porta nand no kit.
+
<syntaxhighlight lang=vhdl>
*[[Laboratório - Projeto e implementação de um conversor BCD para SSD | AE1 - Atividade de Laboratório 1 ]]
+
library library_name;
 +
  use library_name.package_name.all;
 +
</syntaxhighlight>
  
;Encontro 24 (24  out.)
+
:* '''ENTITY'''
* Conhecer o [[Código Gray]]
 
* Implementação de conversor Binário para Gray  (bin2gray)
 
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
-------------------------
+
entity entity_name is
-- File: bin2gray_v1.vhd  --
+
  [generic (
-------------------------
+
    cons_name1: const_type const_value;
entity bin2gray_v1 is
+
    cons_name2: const_type const_value;
port
+
    ...
(
+
    cons_nameN: const_type const_value);]
b0, b1, b2, b3  : in bit;
+
  [port (
g0, g1, g2, g3  : in bit
+
    signal_name1: mode signal_type;
);
+
    signal_name2: mode signal_type;
end entity;
+
    ...
--Exemplo implementando o circuito diretamente com as portas lógicas
+
    signal_nameN: mode signal_type);]
architecture ifsc_v1 of ____ is
+
  [declarative_part]
begin
+
[begin
 +
  statement_part]
 +
end [entity] [entity_name];
 +
</syntaxhighlight>
  
end architecture;
+
:* '''ARCHITECTURE'''
 +
<syntaxhighlight lang=vhdl>
 +
architecture arch_name of entity_name is
 +
  [declarative_part]
 +
begin
 +
  statement_part
 +
end [architecture] [arch_name];
 
</syntaxhighlight>
 
</syntaxhighlight>
  
Como o circuito de um conversor bin2gray, possui uma certa quantidade de bits de entrada e a mesma quantidade de saída, não é adequado descrever esse circuito utilizando o tipo '''bit'''.  O VHDL dispõe do tipo '''bit_vector'''; de vetores para descrever esse tipo de entrada e saída.
+
* Exemplo - Declaração de uma porta NAND em VHDL
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
-------------------------
+
library std;
-- File: bin2gray_v2.vhd  --
+
use std.standard.all;
-------------------------
+
 
entity bin2gray_v2 is
+
entity nand_gate is
port
+
port (a, b: in bit; x: out bit);
(
 
b : in bit_vector(3 downto 0);
 
: out bit_vector(3 downto 0)
 
);
 
 
end entity;
 
end entity;
--Exemplo implementando o circuito diretamente com as portas lógicas
+
 
architecture ifsc_v2 of ____ is
+
architecture nome_arch of nand_gate is
 
begin
 
begin
 
+
x <= a nand b;
 
end architecture;
 
end architecture;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
Caso se deseje aumentar o número de bits da entrada, na abordagem acima é necessário aumentar o número de operações ou exclusivo, e para cada quantidade de bits é necessário ter uma nova descrição. Usando corretamente a instrução '''generic''', e a instrução '''for generate''', é possível escrever um código único (genérico) para qualquer numero de bits.
+
*Uso do ambiente EDA - QUARTUS Prime para programação em VHDL.
* O GENERIC permite parametrizar um circuito, definindo os valores que se deseja alterar em um circuito em diferentes soluçõesUm exemplo comum é alterar o número de bits das entradas e saídas do circuito. Essa instrução é declarada na ENTITY, antes da declaração das PORT.
+
;PASSO 0:
 +
[[Acesso ao IFSC-CLOUD (NUVEM) | Acesse a nuvem do IFSC]] usando um terminal via ssh:
 +
USER=LOGIN_SIGAA
 +
ssh $USER@quartus.sj.ifsc.edu.br -XC  
 +
Insira a senha do SIGAA
 +
LOGIN_SIGAA@quartus.sj.ifsc.edu.br's password:
  
<syntaxhighlight lang=vhdl>
+
;PASSO 1:  
  [generic (
+
Abra o Quartus Prime digitando no terminal
    cons_name1: const_type const_value;
+
quartus20.1.sh
    cons_name2: const_type const_value;
+
Em seguida abra um arquivo para inserir o código VHDL. No menu superior selecione '''[File > New > Design Files: VHDL File]''' e '''[OK]'''
    ...
 
    cons_nameN: const_type const_value);]
 
</syntaxhighlight>  
 
 
 
* Uso da instrução FOR-GENERATE
 
<syntaxhighlight lang=vhdl>  
 
label: FOR identificador IN faixa GENERATE
 
  [Parte_Declarativa
 
BEGIN]
 
  Instruções_concorrentes
 
  ...
 
END GENERATE [label];
 
</syntaxhighlight>
 
  
 +
;PASSO 2:
 +
*Copie o código VHDL acima para o espaço de edição e salve o arquivo com o nome da '''entity''': ''nand_gate.vhd'', em um pasta exclusiva para este projeto.
 +
*Ao ser perguntado se deseja criar um novo projeto, responda [Yes].  Os próximos passos podem ser realizados da seguinte forma:
 +
:*Na tela '''Introduction''' [Next >]
 +
:*Na tela '''Directory, Name, Top-Level Entity'''
 +
::*Note onde o projeto será salvo. 
 +
  /home/USER/PASTA_DO_PROJETO/
 +
::*Note o nome do projeto. Se quiser pode mudá-lo
 +
nand_gate
 +
::*Note  o nome da '''top-level design entity'''
 +
nand_gate
 +
::*Em seguida [Next >]
 +
:*Na tela '''Project Type''' [Next >]
 +
:*Na tela '''Add Files''' [Next >], pois seu arquivo já está na lista dos arquivos.
 +
:*Na tela '''Family, Device & Board Settings''', escolha a Family = ['''Cyclone IV E'''] e o Device = ['''EP4CE6E22A7'''] e [Next >]
 +
:*Na tela '''EDA Tool Setting''' [Next >]
 +
:*Note na tela Summary os dados do projeto e clique [Finish]
  
 +
;PASSO 3:
 +
Realize a '''Analysis & Synthesis''' ['''Processing > Start > Start Analysis & Synthesis'''], ou use um dos botões que o professor mostrou em aula.
 +
:*Note o '''Compilation Report'''
 +
 +
;PASSO 4:
 +
*Use o [[RTL Viewer]] para ver a descrição RTL do circuito. Selecione '''[Tools > Netlist Vieweres > RTL Viewer]'''.
 +
*Use o [[Technology Map Viewer]] para ver a como o circuito foi mapeado para os elementos lógicos disponíveis no dispositivo FPGA selecionado.  Selecione '''[Tools > Netlist Vieweres > Technology Map Viewer]'''.
 +
 +
;PASSO 5:
 +
*Modifique a descrição do circuito para implementar o circuito da função  Y = (A.B)' + C.D'B', salve o projeto Ckt2.vhd e de o mesmo nome para a entity.
 +
 +
;PARA O PRÓXIMO ENCONTRO
 +
*Escreva em VHDL o circuito do [https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE1_-_Projeto_de_um_conversor_de_bin.C3.A1rio_para_mostrador_de_7_segmentos AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos]
 +
:*Use como modelo:
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
-------------------------
+
-- A bibliteca std e o pacote standard são autodeclarados, então as linhas abaixo podem ser comentadas com "--"
-- File: bin2gray_v3.vhd  --
+
--library std;
-------------------------
+
--use std.standard.all;
entity bin2gray_v3 is
+
 
generic (N : natural := 4 );
+
entity BCD2SSD is
port
+
port (
(
+
-- Entradas ABCD do circuito
: in bit_vector(N-1 downto 0);
+
A, B, C, D: in bit;  
g : out bit_vector(N-1 downto 0)
+
-- Saidas para os leds do mostrador de 7 segmentos. Note que o nome a, b, .. g foi mudado para ssd_a, ssd_b, ... ssd_g pois o VHDL é insensível a caixa                           
 +
ssd_a, ssd_b, ssd_c, ssd_d, ssd_e, ssd_f, ssd_g : out bit
 
);
 
);
 
end entity;
 
end entity;
architecture ifsc_v3 of ____ is
+
 
 +
architecture ifsc_v1 of BCD2SSD is
 
begin
 
begin
 +
-- descreva a expressão lógica obtida para cada uma das saídas;
 +
-- Por exemplo: se for a = A + C + (B'.D') + (B.D)
 +
ssd_a <= A or C or (not B and not D) or (B and D);
  
 +
ssd_g <=    ;             
 
end architecture;
 
end architecture;
 
</syntaxhighlight>
 
</syntaxhighlight>
* Após cada implementação analise o diagrama RTL e verifique se as 3 soluções apresentadas resultam no mesmo circuito.
 
* Efetua a simulação com o Modelsim para verificar se as entradas em código binário sequêncial de "0000" até "1111" resultam corretamente nas saídas em [[Código Gray]].
 
* Verifique se a versão bin2gray_v3 pode ser alterada para 10 bits e continua gerando o circuito correto. 
 
* Descubra quantas portas ou exclusivo seriam necessárias para o caso de N bits.
 
  
 +
*Ler [https://pt.wikipedia.org/wiki/VHDL VHDL] na Wikipedia.
 +
*Guardar [[Folha de consulta de VHDL]]
 +
 +
;Encontro 20 (30 abr.) [https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE2_-_Conhecendo_os_dispositivos_l.C3.B3gicos_program.C3.A1veis AE2 - Conhecendo os dispositivos lógicos programáveis]
 +
 +
====ATUAL====
 +
;Encontro 21 (2  mai.) [https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE2_-_Conhecendo_os_dispositivos_l.C3.B3gicos_program.C3.A1veis AE2 - Conhecendo os dispositivos lógicos programáveis]:
 +
:*(Continuação)
 +
;Encontro 22 (7  mai.) AE3:
 +
[[Preparando para gravar o circuito lógico no FPGA]]
 +
 +
<!--
 +
;Encontro 18 (18  abr.) - Avaliação A1c (6 pontos):
 +
*Simplificação de expressões lógicas e mapa de Karnaugh
 +
*Representação de circuitos lógicos - '''Diagrama de portas lógicos = Tabela Verdade = Expressão lógica'''
 +
 +
;Encontro 18 (28  set) - Linguagem VHDL (cont):
 +
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/262427/mod_resource/content/1/Introdu%C3%A7%C3%A3o%20a%20linguagem%20de%20descri%C3%A7%C3%A3o%20de%20hardware.pdf Introdução a linguagem de descrição de hardware (DHL)]
  
* DESAFIO: Implementação de conversor Gray para Binário (gray2bin)
 
Considerando o que aprendeu com as duas versões do conversor '''bin2gray''', descreva o circuito do conversor '''gray2bin'''.
 
<syntaxhighlight lang=vhdl>
 
-------------------------
 
-- File: gray2bin.vhd  --
 
-------------------------
 
entity gray2bin is
 
generic (N : natural := 4 )
 
port
 
(
 
g  : in std_logic_vector(____)
 
b  : out std_logic_vector(____)
 
)
 
end entity
 
  
architecture ifsc_v1 of ____ is
+
;Encontro 19 (3  out.) - Simulador ModelSim:
begin
+
*Abra o circuito que foi salvo na aula anterior.  Após abrir o Quartus, clique em [File > Open Project] e selecione a pasta onde salvou o projeto.  Depois clique sobre o arquivo '''nand_gate.qpf'''.  Note que abrir um projeto é diferente de abrir um arquivo, pois todos os arquivos de configuração estão associados a esse .qpf.
  
end architecture
+
;Encontro 20 (5  out.):
architecture ifsc_v2 of ____ is
+
*Avaliação A1c - Simplificação de expressões lógicas:
begin
 
  
end architecture
 
</syntaxhighlight>
 
  
;Encontro 25 e 26 (26 e 31 out.)  
+
;Encontro 21 (10 out.):
* Conhecer o multiplexador digital.
+
*Escreva o código VHDL e faça a simulação para o circuito correspondente a expressão lógica:
Um multiplexador digital de N entradas e 1 saída, frequentemente abreviado como MUX N:1, é um circuito digital muito utilizado para rotear sinais digitais Ele desempenha a função de selecionar uma das entradas para ser encaminhada para a saída com base em um sinal de seleção (ou controle).
+
Y = AB + AC'
*'''MUX2:1'''
+
Z = A'BC + C'
A tabela verdade que descreve um MUX2:1 é mostrada abaixo:
+
-->
<center>
+
{{collapse bottom}}
{| class="wikitable" style="text-align:center;"
+
 
|- style="font-weight:bold;"
+
===Unidade 5 - Circuitos lógicos combinacionais (com VHDL)===
! X1
+
* 12 ENCONTROS
! X0
+
{{collapse top | expand=true |Unidade 5 - Circuitos lógicos combinacionais (com VHDL)}}
! Sel
+
<!--
! style="background-color:#c0c0c0;" | Y
+
;Encontro 22, 23 (17 e 20  out.)
|-
+
*[[Preparando para gravar o circuito lógico no FPGA]]
| 0
+
* Configurar uma porta nand no kit.
| 0
+
*[[Laboratório - Projeto e implementação de um conversor BCD para SSD | AE1 - Atividade de Laboratório 1 ]]
| 0
+
 
| style="background-color:#c0c0c0;" | 0
+
;Encontro 24 (24  out.)
|-
+
* Conhecer o [[Código Gray]]
| 0
+
* Implementação de conversor Binário para Gray  (bin2gray)
| 0
+
<syntaxhighlight lang=vhdl>
| 1
+
-------------------------
| style="background-color:#c0c0c0;" | 0
+
-- File: bin2gray_v1.vhd  --
|-
+
-------------------------
| 0
+
entity bin2gray_v1 is
| 1
+
port
| 0
+
(
| style="background-color:#c0c0c0;" | 1
+
b0, b1, b2, b3  : in bit;
|-
+
g0, g1, g2, g3  : in bit
| 0
+
);
| 1
+
end entity;
| 1
+
--Exemplo implementando o circuito diretamente com as portas lógicas
| style="background-color:#c0c0c0;" | 0
+
architecture ifsc_v1 of ____ is
|-
+
begin
| 1
+
 
| 0
+
end architecture;
| 0
+
</syntaxhighlight>
| style="background-color:#c0c0c0;" | 0
+
 
|-
+
Como o circuito de um conversor bin2gray, possui uma  certa quantidade de bits de entrada e a mesma quantidade de saída, não é adequado descrever esse circuito utilizando o tipo '''bit'''.  O VHDL dispõe do tipo '''bit_vector'''; de vetores para descrever esse tipo de entrada e saída.
| 1
 
| 0
 
| 1
 
| style="background-color:#c0c0c0;" | 1
 
|-
 
| 1
 
| 1
 
| 0
 
| style="background-color:#c0c0c0;" | 1
 
|-
 
| 1
 
| 1
 
| 1
 
| style="background-color:#c0c0c0;" | 1
 
|}
 
</center>
 
  
O MUX2:1 também pode ser representado de forma resumida por:
+
<syntaxhighlight lang=vhdl>
<center>
+
-------------------------
{| class="wikitable" style="text-align:center;"
+
-- File: bin2gray_v2.vhd  --
|- style="font-weight:bold;"
+
-------------------------
! X1
+
entity bin2gray_v2 is
! X0
+
port
! Sel
+
(
! style="background-color:#c0c0c0;" | Y
+
: in bit_vector(3 downto 0);
|-
+
g  : out bit_vector(3 downto 0)
| -
+
);
| X0
+
end entity;
| 0
+
--Exemplo implementando o circuito diretamente com as portas lógicas
| style="background-color:#c0c0c0;" | X0
+
architecture ifsc_v2 of ____ is
|-
+
begin
| X1
 
| -
 
| 1
 
| style="background-color:#c0c0c0;" | X1
 
|}
 
</center>
 
Onde o X0 e X1 na entrada podem assumir os valores 0 ou 1, e o simbolo "-" corresponde ao ''don't care'' (em VDHL)
 
  
A função booleana que descreve a operação de um MUX 2:1 pode ser representada da seguinte forma:
+
end architecture;
 +
</syntaxhighlight>
  
 +
Caso se deseje aumentar o número de bits da entrada, na abordagem acima é necessário aumentar o número de operações ou exclusivo, e para cada quantidade de bits é necessário ter uma nova descrição.  Usando corretamente a instrução '''generic''', e a instrução '''for generate''', é possível escrever um código único (genérico) para qualquer numero de bits.
 +
* O GENERIC permite parametrizar um circuito, definindo os valores que se deseja alterar em um circuito em diferentes soluções.  Um exemplo comum é alterar o número de bits das entradas e saídas do circuito. Essa instrução é declarada na ENTITY, antes da declaração das PORT.
  
<math> Y =  \overline{Sel} . X0 + Sel . X1 </math>
+
<syntaxhighlight lang=vhdl>  
 +
  [generic (
 +
    cons_name1: const_type const_value;
 +
    cons_name2: const_type const_value;
 +
    ...
 +
    cons_nameN: const_type const_value);]
 +
</syntaxhighlight>  
  
 +
* Uso da instrução FOR-GENERATE
 +
<syntaxhighlight lang=vhdl>
 +
label: FOR identificador IN faixa GENERATE
 +
  [Parte_Declarativa
 +
BEGIN]
 +
  Instruções_concorrentes
 +
  ...
 +
END GENERATE [label];
 +
</syntaxhighlight>
  
Onde Y é a saída; Sel é o sinal de seleção; X0 e X1 são as entradas.
 
*'''MUX4:1'''
 
O MUX4:1 pode ser representado de forma resumida pela tabela verdade:
 
  
<center>
+
<syntaxhighlight lang=vhdl>
{| class="wikitable" style="text-align:center;"
+
-------------------------
|- style="font-weight:bold;"
+
-- File: bin2gray_v3.vhd  --
! colspan="4" | Entradas
+
-------------------------
! colspan="2" | Seleção
+
entity bin2gray_v3 is
! Saída
+
generic (N : natural := 4 );
|- style="font-weight:bold;"
+
port
| X3
+
(
| X2
+
b  : in bit_vector(N-1 downto 0);
| X1
+
g  : out bit_vector(N-1 downto 0)
| X0
+
);
| Sel1
+
end entity;
| Sel0
+
architecture ifsc_v3 of ____ is
| style="background-color:#c0c0c0;" | Y
+
begin
|-
+
 
| -
+
end architecture;
| -
+
</syntaxhighlight>
| -
+
* Após cada implementação analise o diagrama RTL e verifique se as 3 soluções apresentadas resultam no mesmo circuito.
| X0
+
* Efetua a simulação com o Modelsim para verificar se as entradas em código binário sequêncial de "0000" até "1111" resultam corretamente nas saídas em [[Código Gray]].
| 0
+
* Verifique se a versão bin2gray_v3 pode ser alterada para 10 bits e continua gerando o circuito correto. 
| 0
+
* Descubra quantas portas ou exclusivo seriam necessárias para o caso de N bits.
| style="background-color:#c0c0c0;" | X0
+
 
|-
+
 
| -
+
* DESAFIO: Implementação de conversor Gray para Binário (gray2bin)
| -
+
Considerando o que aprendeu com as duas versões do conversor '''bin2gray''', descreva o circuito do conversor '''gray2bin'''.
| X1
+
<syntaxhighlight lang=vhdl>
| -
+
-------------------------
| 0
+
-- File: gray2bin.vhd  --
| 1
+
-------------------------
| style="background-color:#c0c0c0;" | X1
+
entity gray2bin is
|-
+
generic (N : natural := 4 )
| -
+
port
| X2
+
(
| -
+
: in std_logic_vector(____)
| -
+
: out std_logic_vector(____)
| 1
+
)
| 0
+
end entity
| style="background-color:#c0c0c0;" | X2
+
 
|-
+
architecture ifsc_v1 of ____ is
| X3
+
begin
| -
 
| -
 
| -
 
| 1
 
| 1
 
| style="background-color:#c0c0c0;" | X3
 
|}
 
</center>
 
A função booleana que descreve a operação de um MUX 4:1 pode ser representada da seguinte forma:
 
  
 +
end architecture
 +
architecture ifsc_v2 of ____ is
 +
begin
  
<math> Y = X0 . \overline{Sel1} . \overline{Sel0} + X1 . \overline{Sel1} . Sel0 +  X2 . Sel1 . \overline{Sel0} + X3 . Sel1 . Sel0  </math>
+
end architecture
 +
</syntaxhighlight>
  
 +
;Encontro 25 e 26  (26 e 31 out.)
 +
* Conhecer o multiplexador digital.
 +
Um multiplexador digital de N entradas e 1 saída, frequentemente abreviado como MUX N:1, é um circuito digital muito utilizado para rotear sinais digitais Ele desempenha a função de selecionar uma das entradas para ser encaminhada para a saída com base em um sinal de seleção (ou controle).
 +
*'''MUX2:1'''
 +
A tabela verdade que descreve um MUX2:1 é mostrada abaixo:
 +
<center>
 +
{| class="wikitable" style="text-align:center;"
 +
|- style="font-weight:bold;"
 +
! X1
 +
! X0
 +
! Sel
 +
! style="background-color:#c0c0c0;" | Y
 +
|-
 +
| 0
 +
| 0
 +
| 0
 +
| style="background-color:#c0c0c0;" | 0
 +
|-
 +
| 0
 +
| 0
 +
| 1
 +
| style="background-color:#c0c0c0;" | 0
 +
|-
 +
| 0
 +
| 1
 +
| 0
 +
| style="background-color:#c0c0c0;" | 1
 +
|-
 +
| 0
 +
| 1
 +
| 1
 +
| style="background-color:#c0c0c0;" | 0
 +
|-
 +
| 1
 +
| 0
 +
| 0
 +
| style="background-color:#c0c0c0;" | 0
 +
|-
 +
| 1
 +
| 0
 +
| 1
 +
| style="background-color:#c0c0c0;" | 1
 +
|-
 +
| 1
 +
| 1
 +
| 0
 +
| style="background-color:#c0c0c0;" | 1
 +
|-
 +
| 1
 +
| 1
 +
| 1
 +
| style="background-color:#c0c0c0;" | 1
 +
|}
 +
</center>
  
Dada a função booleana do MUX4:1 é simples para descreve-lo em VHDL utilizando apenas operadores lógicos.
+
O MUX2:1 também pode ser representado de forma resumida por:
 
+
<center>
<syntaxhighlight lang=vhdl>
+
{| class="wikitable" style="text-align:center;"
entity mux4x1 is
+
|- style="font-weight:bold;"
port
+
! X1
(
+
! X0
-- Input ports
+
! Sel
X: in  bit_vector (3 downto 0);
+
! style="background-color:#c0c0c0;" | Y
                Sel : in bit_vector (1 downto 0);
+
|-
-- Output ports
+
| -
Y : out bit
+
| X0
);
+
| 0
end entity;
+
| style="background-color:#c0c0c0;" | X0
 
+
|-
-- Implementação com lógica pura
+
| X1
architecture v_logica_pura of mux4x1 is
+
| -
 
+
| 1
begin
+
| style="background-color:#c0c0c0;" | X1
Y <= (X(0) and (not Sel(1)) and (not Sel(0))) or
+
|}
      ...
+
</center>
end architecture;
+
Onde o X0 e X1 na entrada podem assumir os valores 0 ou 1, e o simbolo "-" corresponde ao ''don't care'' (em VDHL)
</syntaxhighlight>
 
 
 
No entanto, o MUX4:1 também pode ser descrito utilizando a instrução '''WHEN-ELSE'''
 
<syntaxhighlight lang=vhdl>
 
<optional_label>: <target> <=
 
<value> when <condition> else
 
<value> when <condition> else
 
<value> when <condition> else
 
...
 
<value>;
 
</syntaxhighlight>
 
 
 
*Importante: O último ELSE deve cobrir todos os demais valores para evitar a criação de LATCHES.
 
Warning (13012): Latch ... has unsafe behavior
 
 
 
* No QuartusII existe um template pronto para ser utilizado em: '''[Edit > Insert Template >  Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Conditional Signal Assignment]'''
 
 
 
No caso do MUX4:1 ele poderia ser descrito como: 
 
<syntaxhighlight lang=vhdl>
 
-- Implementação com WHEN ELSE
 
architecture v_WHEN_ELSE of mux4x1 is
 
 
 
begin
 
Y <= X(0) when Sel = "00" else
 
      X(1) when Sel = "01" else
 
      X(2) when Sel = "10" else
 
      X(3);
 
end architecture;
 
</syntaxhighlight>
 
  
Outra forma de descrever o MUX4:1 seria utilizando a instrução '''WITH-SELECT'''
+
A função booleana que descreve a operação de um MUX 2:1 pode ser representada da seguinte forma:
  
<syntaxhighlight lang=vhdl>
 
<optional_label>: with <expression> select
 
<target> <=
 
<value> when <choices>,
 
<value> when <choices>,
 
<value> when <choices>,
 
...
 
<value> when others;
 
</syntaxhighlight>
 
  
*Importante: Para cobrir todas as demais possibilidades deve ser utilizado o WHEN OTHERS evitando novamente a criação de LATCHES, ou erros de análise.
+
<math>  Y =  \overline{Sel} . X0 + Sel . X1 </math>
  
Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression
 
  
* No QuartusII existe um template pronto para ser utilizado em: '''[Edit > Insert Template >  Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Selected Signal Assignment]'''. '''Mas ATENÇÃO, faltam as virgulas após cada escolha'''.
+
Onde Y é a saída; Sel é o sinal de seleção; X0 e X1 são as entradas.
 +
*'''MUX4:1'''
 +
O MUX4:1 pode ser representado de forma resumida pela tabela verdade:
  
<syntaxhighlight lang=vhdl>
+
<center>
-- Implementação com WITH SELECT
+
{| class="wikitable" style="text-align:center;"
architecture v_WITH_SELECT of mux4x1 is
+
|- style="font-weight:bold;"
 
+
! colspan="4" | Entradas
begin
+
! colspan="2" | Seleção
with Sel select
+
! Saída
Y <= X(0) when "00",    -- note o uso da ,
+
|- style="font-weight:bold;"
      X(1) when "01",
+
| X3
      X(2) when "10",
+
| X2
      X(3) when others;  -- note o uso de others, para todos os demais valores. 
+
| X1
                        -- Não pode ser substituido por "11" mesmo que o signal seja bit_vector.
+
| X0
end architecture;
+
| Sel1
</syntaxhighlight>
+
| Sel0
 
+
| style="background-color:#c0c0c0;" | Y
* Note que para associar uma entre várias arquiteturas com a sua ENTITY pode-se utilizar a instrução CONFIGURATION. No exemplo abaixo a ARCHITECTURE que está descomentada é a que será associada a ENTITY mux4x1. 
+
|-
* Caso não se use a instrução CONFIGURATION, a última ARCHITECTURE será associada a ENTITY. 
+
| -
* Apesar de apenas uma das ARCHITECTUREs ser associada, todas elas devem estar sintaticamente corretas, pois passarão pelo processo de ANÁLISE E SINTESE.
+
| -
 
+
| -
<syntaxhighlight lang=vhdl>
+
| X0
-- Design Unit que associa a architecture com a entity
+
| 0
configuration cfg_ifsc of mux4x1 is
+
| 0
for v_logica_pura end for;
+
| style="background-color:#c0c0c0;" | X0
-- for v_WHEN_ELSE end for;
+
|-
-- for v_WITH_SELECT end for;
+
| -
end configuration;
+
| -
</syntaxhighlight>
+
| X1
 
+
| -
* Faça a análise e sintese do mux4x1, associando a architecture v_logica_pura, depois v_WITH_SELECT, depois v_WHEN e por último v_IF_ELSE. 
+
| 0
* Note a diferença entre os RTL Viewer obtidos para cada architecture.
+
| 1
{{fig|2.1|Código RTL do mux4x1 v_logica_pura| RTL_mux4x1v1.png| 300 px |}}
+
| style="background-color:#c0c0c0;" | X1
{{fig|2.2|Código RTL do mux4x1 v_WHEN_ELSE| RTL_mux4x1v2.png| 400 px |}}
+
|-
{{fig|2.3|Código RTL do mux4x1 v_WITH_SELECT| RTL_mux4x1v3.png| 200 px |}}
+
| -
:'''OBS''': [https://en.wikipedia.org/wiki/Register-transfer_level Register Transfer-Level] (RTL) é uma abstração na qual o circuito é descrito em termos de fluxo de sinais entre os registradores presentes no hardware e as operações combinacionais realizadas com esses dados.
+
| X2
 +
| -
 +
| -
 +
| 1
 +
| 0
 +
| style="background-color:#c0c0c0;" | X2
 +
|-
 +
| X3
 +
| -
 +
| -
 +
| -
 +
| 1
 +
| 1
 +
| style="background-color:#c0c0c0;" | X3
 +
|}
 +
</center>
 +
A função booleana que descreve a operação de um MUX 4:1 pode ser representada da seguinte forma:
  
* Note a que ao verificar o Technology Map Viewer, nos 3 primeiros casos serão usados os mesmos elementos lógicos.
 
{{fig|2.4|Technology Map do mux4x1 para a família Cyclone | TM_mux4x1.png| 400 px |}}
 
  
* Note que o elemento lógico acima possui uma LUT (LookUp Table) que basicamente implementa o circuito combinacional através de uma tabela de consulta (Tabela Verdade), a qual pode ser visualizada clicando com o botão Direito do Mouse e selecionando Properties, juntamente com Mapa de Karnaugh e seu Circuito Lógico representado por portas. Todas as representações são equivalentes.
+
<math> Y = X0 . \overline{Sel1} . \overline{Sel0} + X1 . \overline{Sel1} . Sel0 +  X2 . Sel1 . \overline{Sel0} + X3 . Sel1 . Sel0  </math>
  
{{fig|2.5|Elemento Lógico usado no mux4x1 para a família Cyclone (node properties) | LE_mux4x1.png| 400 px |}}
 
  
*Dependendo da família de FPGA que se estiver usando, o compilador implementar o circuito descrito com um número diferente de elementos lógicos (LEs). No caso da '''família Cyclone''', na qual a LUT tem 4 entradas, são necessários 2 LEs para mapear uma lógica combinacional com 6 entradas e 1 saída (Mux4x1).
+
Dada a função booleana do MUX4:1 é simples para descreve-lo em VHDL utilizando apenas operadores lógicos.
No entanto se utilizarmos um dispositivo FPGA da '''família Aria 10''', que tem LUT tem 6 entradas, será necessário apenas 1 LE, conforme ilustrado a seguir.
 
  
{{fig|2.5|Technology Map do mux4x1 para a família Aria 10 | TM_mux4x1_S3.png| 400 px |}}
+
<syntaxhighlight lang=vhdl>
 
+
entity mux4x1 is
*Realize a simulação das 3 arquiteturas do MUX4:1 no Modelsim
+
port
*Crie um arquivo tb_mux4x1_v1.do que repita a simulação da arquitetura v1
+
(
*Crie um arquivo tb_mux4x1_v2.do que repita a simulação da arquitetura v2
+
-- Input ports
*Crie um arquivo tb_mux4x1_v3.do que repita a simulação da arquitetura v1
+
X: in  bit_vector (3 downto 0);
*Inclua todos os arquivos .do no projeto do Quartus e salve o arquivo QAR
+
                Sel : in bit_vector (1 downto 0);
 +
-- Output ports
 +
Y : out bit
 +
);
 +
end entity;
  
;Encontro 27 e 28  (ANP e 7 nov.)
+
-- Implementação com lógica pura
*[[Laboratório - Implementação de um MUX4:1 em protoboard | AE2 - Atividade de Laboratório 2 ]] Passos 1 e 2
+
architecture v_logica_pura of mux4x1 is
;Encontro 29  (9 nov.)
 
*[[Laboratório - Implementação de um MUX4:1 em protoboard | AE2 - Atividade de Laboratório 2 ]] Passos 3 e 4
 
*Entrega do relatório no Moodle (até 14 dias).
 
;Encontro 30  (14 nov.)
 
*Decodificador de 4 endereços [https://tinyurl.com/ytnbc2qq]
 
:*Implementar em VHDL usando with-select e portas lógicas
 
:*Implementar a implementar em VHDL de um decodificador de 32 endereços
 
  
 +
begin
 +
Y <= (X(0) and (not Sel(1)) and (not Sel(0))) or
 +
      ...
 +
end architecture;
 +
</syntaxhighlight>
  
;Encontro 31 e 32  (16 e 21 nov.)
+
No entanto, o MUX4:1 também pode ser descrito utilizando a instrução '''WHEN-ELSE'''
*Demultiplexador de 1 para 4 [https://tinyurl.com/yrvmxgq7]
+
<syntaxhighlight lang=vhdl>
:*Implementar a implementar em VHDL
+
<optional_label>: <target> <=
*Demultiplexador com enable. [https://tinyurl.com/yqnaz3sl]
+
<value> when <condition> else
:*Implementar a implementar em VHDL
+
<value> when <condition> else
;NOTA: ''No dia 16 nov. ocorreram fortes chuvas na grande Florianópolis, e em virtude disso muitos alunos não puderam comparecer. As 8h50 faltou energia no campus e as aulas foram suspensas.''
+
<value> when <condition> else
 +
...
 +
<value>;
 +
</syntaxhighlight>
 +
 
 +
*Importante: O último ELSE deve cobrir todos os demais valores para evitar a criação de LATCHES.
 +
Warning (13012): Latch ... has unsafe behavior
  
;Encontro 33  (23 nov.)
+
* No QuartusII existe um template pronto para ser utilizado em: '''[Edit > Insert Template >  Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Conditional Signal Assignment]'''
*Comentários no código (duplo traço --)
 
-- Isso eh uma linha de comentario
 
y <= a * b ; --o sinal y recebe o resultado da multiplicacao a x b
 
*Representação de caracteres, strings e números em VHDL.  No circuito, os caracteres são representados através de bits de acordo com a [https://www.lookuptables.com/text/ascii-table tabela ASCII] básica (00 a 7F). A definição dessa tabela é feita o pacote '''[[standard.vhd]]''' da biblioteca '''std'''.
 
:*Caracteres (entre aspas simples)
 
caracter:  'A' 'x' '#' (com aspas simples)
 
  
:*Palavras (entre aspas duplas), é definida no VHDL como um vetor de caracteres.
+
No caso do MUX4:1 ele poderia ser descrito como
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
  type string is array (positive range <>) of character;
+
-- Implementação com WHEN ELSE
</syntaxhighlight>
+
architecture v_WHEN_ELSE of mux4x1 is
 
string: "IFSC" "teste" "teste123"
 
  
:*Números em geral
+
begin
  elemento ("bit") único:  '0' '1' 'Z' (entre aspas simples)
+
  Y <= X(0) when Sel = "00" else
vetor de elementos ("bits"): "0110"  "101001Z" (entre aspas duplas)
+
      X(1) when Sel = "01" else
vetor de 1 elemento ("bit"): "0" "1" (entre aspas duplas)
+
      X(2) when Sel = "10" else
inteiros: 5 1101 1102  (sem aspas)
+
      X(3);
 +
end architecture;
 +
</syntaxhighlight>
 +
 
 +
Outra forma de descrever o MUX4:1 seria utilizando a instrução '''WITH-SELECT'''
  
:*Números binários:
+
<syntaxhighlight lang=vhdl>
0 -> '0'
+
<optional_label>: with <expression> select
7 (em base 2) -> "0111" ou b"0111" ou B"0111"
+
<target> <=
1023 (em base 2) -> "001111111111" ou b"1111111111"  ou B"1111111111"
+
<value> when <choices>,
 +
<value> when <choices>,
 +
<value> when <choices>,
 +
...
 +
<value> when others;
 +
</syntaxhighlight>
  
:*Números octais:
+
*Importante: Para cobrir todas as demais possibilidades deve ser utilizado o WHEN OTHERS evitando novamente a criação de LATCHES, ou erros de análise.
44  (em base 8) ->  5*8^1 + 4*8^0  -> O"54" ou o"54"
 
1023 (em base 8)->  1*8^3 + 7*8^2 + 7*8^1 + 7*8^0 -> o"1777" 8#1777#
 
  
:*Números Hexadecimais:
+
  Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression
  1023 (em base 16) -> 3*16^2 + 15*16^1 + 15*16^0 = X"3FF" ou x"3FF" 16#3FF#
 
  
:*Números decimais:
+
* No QuartusII existe um template pronto para ser utilizado em: '''[Edit > Insert Template Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Selected Signal Assignment]'''. '''Mas ATENÇÃO, faltam as virgulas após cada escolha'''.
1023 -> 1023 ou 1_023
 
1000 -> 1000 ou 1_000 ou 1E3 ou 10#1000#
 
::Cuidado ao usar o "_" pois algumas ferramentas não o reconhecem.
 
 
 
:*Números em outras bases (de 2 a 16)
 
85 (em base 5) ->  (3*5^2 + 2*5^1 + 0*5^0) -> 5#320#
 
1539 (em base 3) -> (2*3^2+0*3^1+1*3^0)*3^4 -> 3#201#E4
 
 
 
*Tipos de dados em VHDL.
 
:*Objetos de VHDL: '''CONSTANT''', '''SIGNAL''', '''VARIABLE''', '''FILE'''.
 
  
O objeto '''CONSTANT''' pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, PACKAGE_BODY, BLOCK, GENERATE, PROCESS, FUNCTION e PROCEDURE.
 
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
 +
-- Implementação com WITH SELECT
 +
architecture v_WITH_SELECT of mux4x1 is
  
constant <constant_name> : <type> := <constant_value>;
+
begin
 +
with Sel select
 +
Y <= X(0) when "00",    -- note o uso da ,
 +
      X(1) when "01",
 +
      X(2) when "10",
 +
      X(3) when others;  -- note o uso de others, para todos os demais valores. 
 +
                        -- Não pode ser substituido por "11" mesmo que o signal seja bit_vector.
 +
end architecture;
 +
</syntaxhighlight>
  
-- Declarações comuns de constantes
+
* Note que para associar uma entre várias arquiteturas com a sua ENTITY pode-se utilizar a instrução CONFIGURATION. No exemplo abaixo a ARCHITECTURE que está descomentada é a que será associada a ENTITY mux4x1. 
 +
* Caso não se use a instrução CONFIGURATION, a última ARCHITECTURE será associada a ENTITY. 
 +
* Apesar de apenas uma das ARCHITECTUREs ser associada, todas elas devem estar sintaticamente corretas, pois passarão pelo processo de ANÁLISE E SINTESE.
  
constant GND : std_logic := '0';
+
<syntaxhighlight lang=vhdl>
constant VCC : std_logic := '1';
+
-- Design Unit que associa a architecture com a entity
constant SSD_0 : std_logic_vector(0 to 6) := "1111110";
+
configuration cfg_ifsc of mux4x1 is
constant MAX : natural := 44;
+
for v_logica_pura end for;
 +
-- for v_WHEN_ELSE end for;
 +
-- for v_WITH_SELECT end for;
 +
end configuration;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
O objeto '''SIGNAL''' pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, BLOCK, GENERATE.  Os sinais não podem ser declarados no código sequencial (PROCESS, FUNCTION e PROCEDURE), mas podem ser usados.
+
* Faça a análise e sintese do mux4x1, associando a architecture v_logica_pura, depois v_WITH_SELECT, depois v_WHEN e por último v_IF_ELSE. 
 +
* Note a diferença entre os RTL Viewer obtidos para cada architecture.
 +
{{fig|2.1|Código RTL do mux4x1 v_logica_pura| RTL_mux4x1v1.png| 300 px |}}
 +
{{fig|2.2|Código RTL do mux4x1 v_WHEN_ELSE| RTL_mux4x1v2.png| 400 px |}}
 +
{{fig|2.3|Código RTL do mux4x1 v_WITH_SELECT| RTL_mux4x1v3.png| 200 px |}}
 +
:'''OBS''': [https://en.wikipedia.org/wiki/Register-transfer_level Register Transfer-Level] (RTL) é uma abstração na qual o circuito é descrito em termos de fluxo de sinais entre os registradores presentes no hardware e as operações combinacionais realizadas com esses dados.
 +
 
 +
* Note a que ao verificar o Technology Map Viewer, nos 3 primeiros casos serão usados os mesmos elementos lógicos.
 +
{{fig|2.4|Technology Map do mux4x1 para a família Cyclone | TM_mux4x1.png| 400 px |}}
  
<syntaxhighlight lang=vhdl>
+
* Note que o elemento lógico acima possui uma LUT (LookUp Table) que basicamente implementa o circuito combinacional através de uma tabela de consulta (Tabela Verdade), a qual pode ser visualizada clicando com o botão Direito do Mouse e selecionando Properties, juntamente com Mapa de Karnaugh e seu Circuito Lógico representado por portas. Todas as representações são equivalentes.
-- Signal sem valor default
 
-- Para atribuir um valor a um signal use  "<=" como operador.  
 
  
signal <name> : <type>;
+
{{fig|2.5|Elemento Lógico usado no mux4x1 para a família Cyclone (node properties) | LE_mux4x1.png| 400 px |}}
  
-- Signal com valor default
+
*Dependendo da família de FPGA que se estiver usando, o compilador implementar o circuito descrito com um número diferente de elementos lógicos (LEs). No caso da '''família Cyclone''', na qual a LUT tem 4 entradas, são necessários 2 LEs para mapear uma lógica combinacional com 6 entradas e 1 saída (Mux4x1).
signal <name> : <type> := <default_value>;
+
No entanto se utilizarmos um dispositivo FPGA da '''família Aria 10''', que tem LUT tem 6 entradas, será necessário apenas 1 LE, conforme ilustrado a seguir.
  
-- Declarações comuns de signals
+
{{fig|2.5|Technology Map do mux4x1 para a família Aria 10 | TM_mux4x1_S3.png| 400 px |}}
  
signal <name> : std_logic;
+
*Realize a simulação das 3 arquiteturas do MUX4:1 no Modelsim
signal <name> : std_logic_vector(<msb_index> downto <lsb_index>);
+
*Crie um arquivo tb_mux4x1_v1.do que repita a simulação da arquitetura v1
signal <name> : integer;
+
*Crie um arquivo tb_mux4x1_v2.do que repita a simulação da arquitetura v2
signal <name> : integer range <low> to <high>;
+
*Crie um arquivo tb_mux4x1_v3.do que repita a simulação da arquitetura v1
</syntaxhighlight>
+
*Inclua todos os arquivos .do no projeto do Quartus e salve o arquivo QAR
  
O objeto '''VARIABLE''' (variável) só pode ser declarada e usada dentro do escopo no código sequencial (PROCESS, FUNCTION e PROCEDURE).
+
;Encontro 27 e 28  (ANP e 7 nov.)
 +
*[[Laboratório - Implementação de um MUX4:1 em protoboard | AE2 - Atividade de Laboratório 2 ]] Passos 1 e 2
 +
;Encontro 29 (9 nov.)  
 +
*[[Laboratório - Implementação de um MUX4:1 em protoboard | AE2 - Atividade de Laboratório 2 ]] Passos 3 e 4
 +
*Entrega do relatório no Moodle (até 14 dias).
 +
;Encontro 30  (14 nov.)
 +
*Decodificador de 4 endereços [https://tinyurl.com/ytnbc2qq]
 +
:*Implementar em VHDL usando with-select e portas lógicas
 +
:*Implementar a implementar em VHDL de um decodificador de 32 endereços
  
<syntaxhighlight lang=vhdl>
 
-- Variables devem ser declarada em process ou subprogramas.
 
-- Para atribuir um valor a um variable use  ":=" como operador.
 
  
-- Variable sem valor default.
+
;Encontro 31 e 32  (16 e 21 nov.)
variable <name> : <type>;
+
*Demultiplexador de 1 para 4 [https://tinyurl.com/yrvmxgq7]
 +
:*Implementar a implementar em VHDL
 +
*Demultiplexador com enable. [https://tinyurl.com/yqnaz3sl]
 +
:*Implementar a implementar em VHDL
 +
;NOTA:  ''No dia 16 nov. ocorreram fortes chuvas na grande Florianópolis, e em virtude disso muitos alunos não puderam comparecer.  As 8h50 faltou energia no campus e as aulas foram suspensas.''
  
-- Variable com valor default.
+
;Encontro 33  (23 nov.)
variable <name> : <type> := <default_value>;
+
*Comentários no código (duplo traço --)
 +
-- Isso eh uma linha de comentario
 +
y <= a * b ; --o sinal y recebe o resultado da multiplicacao a x b
 +
*Representação de caracteres, strings e números em VHDL.  No circuito, os caracteres são representados através de bits de acordo com a [https://www.lookuptables.com/text/ascii-table tabela ASCII] básica (00 a 7F). A definição dessa tabela é feita o pacote '''[[standard.vhd]]''' da biblioteca '''std'''.
 +
:*Caracteres (entre aspas simples)
 +
caracter: 'A' 'x' '#' (com aspas simples)
  
-- Declarações comuns de variables
+
:*Palavras (entre aspas duplas), é definida no VHDL como um vetor de caracteres.
variable <name> : std_logic;
+
<syntaxhighlight lang=vhdl>
variable <name> : std_logic_vector(<msb_index> downto <lsb_index>);
+
  type string is array (positive range <>) of character;
variable <name> : integer;
 
variable <name> : integer range <low> to <high>;
 
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
 +
string: "IFSC" "teste" "teste123"
  
:*Palavra chave '''OTHERS''' para formação de agregados
+
:*Números em geral
Exemplos de declaração de CONSTANT, SIGNAL, VARIABLE, inicializando o valor usando o agregados
+
elemento ("bit") único:  '0' '1' 'Z' (entre aspas simples)
 +
vetor de elementos ("bits"): "0110"  "101001Z" (entre aspas duplas)
 +
vetor de 1 elemento ("bit"): "0" "1" (entre aspas duplas)
 +
inteiros: 5 1101 1102  (sem aspas)
  
<syntaxhighlight lang=vhdl>
+
:*Números binários:
CONSTANT a: BIT_VECTOR(5 DOWNTO 0) := (OTHERS => '0'); -- "000000"
+
0 -> '0'
 +
7 (em base 2) -> "0111" ou b"0111" ou B"0111"
 +
  1023 (em base 2) -> "001111111111" ou b"1111111111" ou B"1111111111"  
  
CONSTANT b: BIT_VECTOR(7 DOWNTO 0) := (7 => '0', OTHERS => '1'); -- "01111111"
+
:*Números octais:
CONSTANT c: BIT_VECTOR(7 DOWNTO 0) := (7 => '0', 6 DOWNTO 0 => '1');  -- "01111111"
+
44  (em base 8) -> 5*8^1 + 4*8^0  -> O"54" ou o"54"
CONSTANT d: BIT_VECTOR(7 DOWNTO 0) := "01111111";
+
1023 (em base 8)->  1*8^3 + 7*8^2 + 7*8^1 + 7*8^0 -> o"1777" 8#1777#
  
SIGNAL e: STD_LOGIC_VECTOR(7 DOWNTO 0)-- Not initialized
+
:*Números Hexadecimais:
SIGNAL f: STD_LOGIC_VECTOR(1 TO 8) := (2|3|8 => '1', 4 => 'Z', OTHERS => '0' ); -- "011Z0001"
+
1023 (em base 16) -> 3*16^2 + 15*16^1 + 15*16^0 = X"3FF" ou x"3FF" 16#3FF#
  
VARIABLE g: BIT_VECTOR(1 TO 16); -- Not initialized
+
:*Números decimais:
VARIABLE h: BIT_VECTOR(1 TO 16) := (1 TO 8 => '1', OTHERS => '0');  -- "1111111100000000"
+
  1023 -> 1023 ou 1_023
 +
1000 -> 1000 ou 1_000 ou 1E3 ou 10#1000#
 +
::Cuidado ao usar o "_" pois algumas ferramentas não o reconhecem.
  
</syntaxhighlight>
+
:*Números em outras bases (de 2 a 16)
 +
85 (em base 5) -> (3*5^2 + 2*5^1 + 0*5^0) -> 5#320#
 +
1539 (em base 3) -> (2*3^2+0*3^1+1*3^0)*3^4 -> 3#201#E4
  
:: Ver pag. 31 a 35 de <ref name="PEDRONI2010b"/>
+
*Tipos de dados em VHDL.
 +
:*Objetos de VHDL: '''CONSTANT''', '''SIGNAL''', '''VARIABLE''', '''FILE'''.
  
:* Bibliotecas padrão IEEE ('''[[Std logic 1164.vhd]]''', '''[[Numeric std.vhd]]''').
+
O objeto '''CONSTANT''' pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, PACKAGE_BODY, BLOCK, GENERATE, PROCESS, FUNCTION e PROCEDURE.
::* '''ATENÇÃO!!! Não use as bibliotecas que não são padrão (''std_logic_arith, std_logic_unsigned, std_logic_signed''''')
+
<syntaxhighlight lang=vhdl>
  
* Classificação dos tipos de dados.
+
constant <constant_name> : <type> := <constant_value>;
  
A biblioteca [[standard.vhd]] define os tipos BIT, BIT_VECTOR, BOOLEAN, INTEGER, NATURAL, POSITIVE, CHARACTER, STRING.
+
-- Declarações comuns de constantes
  
<syntaxhighlight lang=vhdl>
+
constant GND : std_logic := '0';
package standard is
+
constant VCC : std_logic := '1';
type boolean is (false,true);
+
constant SSD_0 : std_logic_vector(0 to 6) := "1111110";
type bit is ('0', '1');
+
constant MAX : natural := 44;
type severity_level is (note, warning, error, failure);
 
type integer is range -2147483647 to 2147483647;
 
type real is range -1.0E308 to 1.0E308;
 
type time is range -2147483648 to 2147483647
 
units
 
fs;
 
ps = 1000 fs;
 
ns = 1000 ps;
 
us = 1000 ns;
 
ms = 1000 us;
 
sec = 1000 ms;
 
min = 60 sec;  
 
hr = 60 min;
 
end units;
 
subtype natural is integer range 0 to integer'high;
 
subtype positive is integer range 1 to integer'high;  
 
type string is array (positive range <>) of character;  
 
type bit_vector is array (natural range <>) of bit;  
 
 
</syntaxhighlight>
 
</syntaxhighlight>
  
A biblioteca [[Std logic 1164.vhd]] define os tipos STD_(U)LOGIG, STD_(U)LOGIG_VECTOR.
+
O objeto '''SIGNAL''' pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, BLOCK, GENERATE. Os sinais não podem ser declarados no código sequencial (PROCESS, FUNCTION e PROCEDURE), mas podem ser usados.
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
PACKAGE std_logic_1164 IS
+
-- Signal sem valor default
TYPE std_ulogic IS ( 'U',  -- Uninitialized
+
-- Para atribuir um valor a um signal use "<=" como operador.
                        'X',  -- Forcing Unknown
+
 
                        '0',  -- Forcing  0
+
signal <name> : <type>;
                        '1',  -- Forcing  1
+
 
                        'Z',  -- High Impedance 
+
-- Signal com valor default
                        'W',  -- Weak    Unknown
+
signal <name> : <type> := <default_value>;
                        'L',  -- Weak    0     
+
 
                        'H',  -- Weak    1     
+
-- Declarações comuns de signals
                        '-'  -- Don't care
+
 
                      );
+
signal <name> : std_logic;
TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic;
+
signal <name> : std_logic_vector(<msb_index> downto <lsb_index>);
SUBTYPE std_logic IS resolved std_ulogic;
+
signal <name> : integer;
TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic;
+
signal <name> : integer range <low> to <high>;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
A biblioteca [[Std logic 1164.vhd]] ainda define algumas funções importantes como a '''rising_edge''' que determina se um sinal está na borda de subida (usado em sinais de clock).
+
O objeto '''VARIABLE''' (variável) só pode ser declarada e usada dentro do escopo no código sequencial (PROCESS, FUNCTION e PROCEDURE).
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
    -------------------------------------------------------------------
+
-- Variables devem ser declarada em process ou subprogramas.
    -- conversion functions
+
-- Para atribuir um valor a um variable use  ":=" como operador.
    -------------------------------------------------------------------
 
    FUNCTION To_bit            ( s : std_ulogic;        xmap : BIT := '0') RETURN BIT;
 
    FUNCTION To_bitvector      ( s : std_logic_vector ; xmap : BIT := '0') RETURN BIT_VECTOR;
 
    FUNCTION To_StdULogic      ( b : BIT              ) RETURN std_ulogic;
 
    FUNCTION To_StdLogicVector  ( b : BIT_VECTOR        ) RETURN std_logic_vector;
 
  
    -------------------------------------------------------------------   
+
-- Variable sem valor default.
    -- edge detection
+
variable <name> : <type>;
    -------------------------------------------------------------------   
 
    FUNCTION rising_edge  (SIGNAL s : std_ulogic) RETURN BOOLEAN;
 
    FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
 
  
  -------------------------------------------------------------------   
+
-- Variable com valor default.
    -- edge detection
+
variable <name> : <type> := <default_value>;
    -------------------------------------------------------------------   
 
    FUNCTION rising_edge  (SIGNAL s : std_ulogic) RETURN BOOLEAN IS
 
      -- altera built_in builtin_rising_edge
 
    BEGIN
 
        RETURN (s'EVENT AND (To_X01(s) = '1') AND
 
                            (To_X01(s'LAST_VALUE) = '0'));
 
    END;
 
  
 +
-- Declarações comuns de variables
 +
variable <name> : std_logic;
 +
variable <name> : std_logic_vector(<msb_index> downto <lsb_index>);
 +
variable <name> : integer;
 +
variable <name> : integer range <low> to <high>;
 
</syntaxhighlight>
 
</syntaxhighlight>
A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED.
+
 
 +
:*Palavra chave '''OTHERS''' para formação de agregados
 +
Exemplos de declaração de CONSTANT, SIGNAL, VARIABLE, inicializando o valor usando o agregados
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
package NUMERIC_STD is
+
CONSTANT a: BIT_VECTOR(5 DOWNTO 0) := (OTHERS => '0');  -"000000"
  type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
 
  type SIGNED is array (NATURAL range <>) of STD_LOGIC;
 
</syntaxhighlight>
 
 
 
A biblioteca [[Numeric std.vhd]] ainda define os operadores (abs, "+", "-", "*", "/", rem, mod, sll, slr, ror, rol), comparações ("=", '/=', ">", ">=", "<", "<=") e operadores lógicos (not, and, nand, or, nor, xor, xnor)  para os tipos SIGNED e UNSIGNED.  Além disso também define algumas funções muito utilizadas como:
 
  
<syntaxhighlight lang=vhdl>
+
CONSTANT b: BIT_VECTOR(7 DOWNTO 0) := (7 => '0', OTHERS => '1');  -- "01111111"
  --============================================================================
+
CONSTANT c: BIT_VECTOR(7 DOWNTO 0) := (7 => '0', 6 DOWNTO 0 => '1');  -- "01111111"
   --   RESIZE Functions
+
CONSTANT d: BIT_VECTOR(7 DOWNTO 0) := "01111111";
  --============================================================================
+
 
  function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;
+
SIGNAL e: STD_LOGIC_VECTOR(7 DOWNTO 0);   -- Not initialized
  function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED;
+
SIGNAL f: STD_LOGIC_VECTOR(1 TO 8) := (2|3|8 => '1', 4 => 'Z', OTHERS => '0' ); -- "011Z0001"
 +
 
 +
VARIABLE g: BIT_VECTOR(1 TO 16); -- Not initialized
 +
VARIABLE h: BIT_VECTOR(1 TO 16) := (1 TO 8 => '1', OTHERS => '0'); -- "1111111100000000"
  
  --============================================================================
 
  -- Conversion Functions
 
  --============================================================================
 
  function TO_INTEGER (ARG: UNSIGNED) return NATURAL;
 
  function TO_INTEGER (ARG: SIGNED) return INTEGER;
 
  function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED;
 
  function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED;
 
 
 
</syntaxhighlight>
 
</syntaxhighlight>
  
:: Ver pag. 73 a 78 de <ref name="PEDRONI2010b"/>
+
:: Ver pag. 31 a 35 de <ref name="PEDRONI2010b"/>
 +
 
 +
:* Bibliotecas padrão IEEE ('''[[Std logic 1164.vhd]]''', '''[[Numeric std.vhd]]''').
 +
::* '''ATENÇÃO!!! Não use as bibliotecas que não são padrão (''std_logic_arith, std_logic_unsigned, std_logic_signed''''')
  
:* Resumo dos Tipos predefinidos.
+
* Classificação dos tipos de dados.
{| class="wikitable sortable"  border="1" cellpadding="3" cellspacing="0" style="text-align:left; font-size:100%" bgcolor="#efefef"
+
 
! scope="col" width=15% align="left"| Tipo de Dado
+
A biblioteca [[standard.vhd]] define os tipos BIT, BIT_VECTOR, BOOLEAN, INTEGER, NATURAL, POSITIVE, CHARACTER, STRING.
! scope="col" width=10% align="left"| Package
 
! scope="col" width=7%  align="left"| Library
 
! scope="col" width=50% align="left"| Valores
 
! scope="col" width=15% align="left"| Observações
 
|-
 
| BOOLEAN || standard || std || TRUE e FALSE || sintetizável
 
|-
 
| BIT || standard || std ||  valores '0', '1' || sintetizável
 
|-
 
| INTEGER || standard || std || números inteiros de 32 bits [de -2^31-1 até + (2^31 - 1)] || sintetizável
 
|-
 
| NATURAL || standard || std || números inteiros não negativos [de 0 até + (2^31 - 1)] || sintetizável
 
|-
 
| POSITIVE || standard || std || números inteiros positivos [de 1 até + (2^31 - 1)] || sintetizável
 
|-
 
| BOOLEAN_VECTOR || standard (2008) || std || vetor de BOOLEAN || sintetizável
 
|-
 
| BIT_VECTOR || standard || std ||  vetor de BIT || sintetizável
 
|-
 
| INTEGER_VECTOR || standard (2008) || std || vetor de INTEGER || sintetizável
 
|-
 
| REAL || standard || std || números reais [de -1.0E-38 até + 1.0E38] || simulação
 
|-
 
| CHARACTER || standard || std || caracteres ASCII ||
 
|-
 
| STRING || standard || std || vetor de CHARACTER ||
 
|}
 
  
{| class="wikitable sortable"  border="1" cellpadding="3" cellspacing="0" style="text-align:left; font-size:100%" bgcolor="#efefef"
+
<syntaxhighlight lang=vhdl>
! scope="col" width=15% align="left"| Tipo de Dado
+
package standard is
! scope="col" width=10% align="left"| Package
+
type boolean is (false,true);
! scope="col" width=7%  align="left"| Library
+
type bit is ('0', '1');
! scope="col" width=50% align="left"| Valores
+
type severity_level is (note, warning, error, failure);
! scope="col" width=15% align="left"| Observações
+
type integer is range -2147483647 to 2147483647;
|-
+
type real is range -1.0E308 to 1.0E308;
| STD_LOGIC || std_logic_1164 || ieee || valores 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' || sintetizável
+
type time is range -2147483648 to 2147483647
|-
+
units
| STD_LOGIC_VECTOR || std_logic_1164 || ieee || vetor de STD_LOGIC || sintetizável
+
fs;
|-
+
ps = 1000 fs;
| SIGNED || numeric_std || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas com sinal|| sintetizável
+
ns = 1000 ps;
|-
+
us = 1000 ns;
| UNSIGNED || numeric_std || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas sem sinal  || sintetizável
+
ms = 1000 us;
|-
+
sec = 1000 ms;
| SIGNED || numeric_bit || ieee || BIT_VECTOR que aceitam operações aritméticas com sinal || sintetizável
+
min = 60 sec;
|-
+
hr = 60 min;
| UNSIGNED || numeric_bit || ieee || BIT_VECTOR que aceitam operações aritméticas sem sinal  || sintetizável
+
end units;
|- 
+
subtype natural is integer range 0 to integer'high;
| SIGNED || std_logic_arith || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas com sinal || sintetizável (não é padrão, não utilizar)
+
subtype positive is integer range 1 to integer'high;
|- 
+
type string is array (positive range <>) of character;
| UNSIGNED || std_logic_arith || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas sem sinal || sintetizável (não é padrão, não utilizar)
+
type bit_vector is array (natural range <>) of bit;
|-
+
</syntaxhighlight>
| UFIXED || fixed_pkg + (2008) || ieee || números de ponto fixo sem sinal|| sintetizável
 
|-
 
| SFIXED || fixed_pkg + (2008) || ieee || números de ponto fixo com sinal|| sintetizável
 
|-
 
| FLOAT || float_pkg + (2008) || ieee || Números de ponto flutuante  || sintetizável
 
|}
 
  
* Exemplo: Buffer Tri-state
+
A biblioteca [[Std logic 1164.vhd]] define os tipos STD_(U)LOGIG, STD_(U)LOGIG_VECTOR.
:*Ver como funciona em [https://tinyurl.com/ym77x4af]
 
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
library ieee;
+
PACKAGE std_logic_1164 IS
use ieee.std_logic_1164.all;
+
TYPE std_ulogic IS ( 'U',  -- Uninitialized
 
+
                        'X',  -- Forcing  Unknown
entity tri_state is
+
                        '0',  -- Forcing  0
  generic (N: NATURAL := 1);
+
                        '1',  -- Forcing  1
   port
+
                        'Z',  -- High Impedance    
  (
+
                        'W',  -- Weak    Unknown
     input      : in std_logic_vector(N-1 downto 0);
+
                        'L',  -- Weak     0      
     ena        : in std_logic;
+
                        'H',  -- Weak     1     
    output    : out std_logic_vector(N-1 downto 0);
+
                        '-'  -- Don't care
  );
+
                      );
end entity;
+
TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic;
 
+
SUBTYPE std_logic IS resolved std_ulogic;
architecture tri_state of tri_state is
+
TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic;
begin
 
  output <= input when ena = '1' else "Z";
 
end architecture;
 
 
</syntaxhighlight>
 
</syntaxhighlight>
  
:: '''Importante''': O terceiro estado 'Z' só pode ser usado em saídas, e a sua realização nos FPGAs só ocorre nos nós de I/O. 
+
A biblioteca  [[Std logic 1164.vhd]] ainda define algumas funções importantes como a '''rising_edge''' que determina se um sinal está na borda de subida (usado em sinais de clock).
;Curiosidade:  Existem circuitos comerciais que implementam essa função three-state [https://www.ti.com/lit/ds/symlink/sn74lvc16244a-q1.pdf?ts=1681232207751&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252FSN74LVC16244A-Q1 16 buffers], [https://www.ti.com/lit/ds/symlink/sn74lv244a-ep.pdf?ts=1681237777688&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252FSN74LV244A-EP 8 buffers], [https://www.ti.com/lit/ds/symlink/sn74auc1g126.pdf?ts=1681222704977&ref_url=https%253A%252F%252Fwww.google.com%252F 1 buffer].  Porque não utilizar um CPLD ou FPGA em seu lugar?
 
  
;Exemplo de aplicação:
+
<syntaxhighlight lang=vhdl>
*Demultiplexador com saída em 3-state. [https://tinyurl.com/2x4b5r5c]
+
    -------------------------------------------------------------------
:*Baseado no Demultiplexador com enable, implemente ele com 3-state.  Se o circuito não estiver habilitado, as saídas devem ficar em 3-state.
+
    -- conversion functions
:*Para implementar em VHDL será necessário utilizar o tipo de dado '''std_logic''' ou '''std_logic_vector'''
+
    -------------------------------------------------------------------
{{collapse bottom}}
+
    FUNCTION To_bit            ( s : std_ulogic;        xmap : BIT := '0') RETURN BIT;
 +
    FUNCTION To_bitvector      ( s : std_logic_vector ; xmap : BIT := '0') RETURN BIT_VECTOR;
 +
    FUNCTION To_StdULogic      ( b : BIT              ) RETURN std_ulogic;
 +
    FUNCTION To_StdLogicVector  ( b : BIT_VECTOR        ) RETURN std_logic_vector;
  
===Unidade 6 - Circuitos aritméticos (com VHDL) ===
+
    -------------------------------------------------------------------   
* 5 ENCONTROS
+
    -- edge detection
{{collapse top | Unidade 6 - Circuitos aritméticos (com VHDL)}}
+
    -------------------------------------------------------------------   
 +
    FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
 +
    FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
  
;Encontro 34 (28 nov.)
+
  -------------------------------------------------------------------   
*Circuitos aritméticos: somadores, incrementador, decrementador, complemento de dois, multiplicador, comparadores
+
    -- edge detection
:* Somador completo [https://tinyurl.com/yqkt49kl]
+
    -------------------------------------------------------------------   
:* Somador de 4 bits [https://tinyurl.com/yucqnkwz]
+
    FUNCTION rising_edge  (SIGNAL s : std_ulogic) RETURN BOOLEAN IS
:* Prova que [https://www.wolframalpha.com/input?i=a+and+b+or+a+and+c+or+b+and+c (a and b) or (a and c) or (b and c)] = [https://www.wolframalpha.com/input?i=a+and+b+or+%28a+xor+b%29+and+c (a and b) or ((a xor b) and c)]
+
      -- altera built_in builtin_rising_edge
 +
    BEGIN
 +
        RETURN (s'EVENT AND (To_X01(s) = '1') AND
 +
                            (To_X01(s'LAST_VALUE) = '0'));
 +
    END;
  
;Encontro 35 (30 nov.)
+
</syntaxhighlight>
*Ver slides [https://moodle.ifsc.edu.br/pluginfile.php/291703/mod_resource/content/1/Pedroni_Cap_12_Circuitos_combinacionais_Aritmeticos.pdf]
+
A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED.
*Ver pag. XXX a XXX de <ref name="PEDRONI2010a"> PEDRONI, Volnei A. Eletrônica digital moderna e VHDL; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. . ISBN 9788535234657 </ref>
 
  
;Encontro 36 (05 dez.)
+
<syntaxhighlight lang=vhdl>
*Usando o tipo '''integer'''
+
package NUMERIC_STD is
Para implementar circuitos aritméticos, ao invés de se descrever o circuito com portas lógicas conforme mostrado para somadores, subtratores, comparadores e multiplicadores, deve-se utilizar os operadores aritméticos, e o compilador realizará a escolha do melhor circuito para cada caso.  Inicialmente apresentamos alguns exemplos utilizando dados do tipo '''integer'''.
+
  type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
 +
  type SIGNED is array (NATURAL range <>) of STD_LOGIC;
 +
</syntaxhighlight>
  
Para o uso do tipo integer, se não houver limitação da faixa de valores, o compilador entenderá que os sinais devem ter 32 bits, o que gera circuitos muito maiores que normalmente necessário. Assim, ao usar as entradas e saidas como integer sem range, o diagrama RTL mostrará que o circuito foi construido com 32 bits [31..0]. Nos dispositivos da familia Cyclone IV E serão utilizados 32 elementos lógicos para tal circuito.
+
A biblioteca  [[Numeric std.vhd]] ainda define os operadores (abs, "+", "-", "*", "/", rem, mod, sll, slr, ror, rol), comparações ("=", '/=', ">", ">=", "<", "<=") e operadores lógicos (not, and, nand, or, nor, xor, xnor)  para os tipos SIGNED e UNSIGNED. Além disso também define algumas funções muito utilizadas como:
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
entity somador is
+
  --============================================================================
port (  
+
  --  RESIZE Functions
a, b : in integer;  
+
  --============================================================================
s : out integer;
+
  function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;
end entity;
+
  function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED;
  
architecture ifsc of somador is
+
  --============================================================================
begin
+
  -- Conversion Functions
s <= a + b;
+
  --============================================================================
end architecture;
+
  function TO_INTEGER (ARG: UNSIGNED) return NATURAL;
 +
  function TO_INTEGER (ARG: SIGNED) return INTEGER;
 +
  function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED;
 +
  function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED;
 +
 
</syntaxhighlight>
 
</syntaxhighlight>
{{fig|4.1|Código RTL do somador com tipo integer sem range| RTL_somadorv1.png| 300 px |}}
 
{{fig|4.2|Technology Map do somador com tipo integer sem range| TM_somadorv1.png| 1000 px |}}
 
Por isso, o uso correto do tipo integer, exige que se limite a faixa de valores ('''range 0 to 15'''), o que fará com que o compilador atribua para os sinais a quantidade correta de bits, gerando circuitos de tamanho adequado.
 
  
Assim, ao usar as entradas e saidas como integer com range 0 to 15, o diagrama RTL mostrará que o circuito foi construido com 4 bits [3..0]. Nos dispositivos da familia Cyclone IV E serão utilizados 4 elementos lógicos para tal circuito.
+
:: Ver pag. 73 a 78 de <ref name="PEDRONI2010b"/>
  
<syntaxhighlight lang=vhdl>
+
:* Resumo dos Tipos predefinidos.
entity somador is
+
{| class="wikitable sortable"  border="1" cellpadding="3" cellspacing="0" style="text-align:left; font-size:100%" bgcolor="#efefef"
port (
+
! scope="col" width=15% align="left"| Tipo de Dado
a, b : in integer range 0 to 15;
+
! scope="col" width=10% align="left"| Package
s : out integer range 0 to 15);
+
! scope="col" width=7% align="left"| Library
end entity;
+
! scope="col" width=50% align="left"| Valores
 
+
! scope="col" width=15% align="left"| Observações
architecture ifsc of somador is
+
|-
begin
+
| BOOLEAN || standard || std || TRUE e FALSE || sintetizável
s <= a + b;
+
|-
end architecture;
+
| BIT || standard || std ||  valores '0', '1' || sintetizável
</syntaxhighlight>
+
|-
{{fig|4.3|Código RTL do somador com tipo integer com range| RTL_somadorv2.png| 300 px |}}
+
| INTEGER || standard || std || números inteiros de 32 bits [de -2^31-1 até + (2^31 - 1)] || sintetizável
{{fig|4.4|Technology Map do somador com tipo integer com range| TM_somadorv2.png| 600 px |}}
+
|-
 
+
| NATURAL || standard || std || números inteiros não negativos [de 0 até + (2^31 - 1)] || sintetizável
Para fazer uma subtração, basta trocar o operador "+" pelo "-", e o compilador irá implementar um subtrator realizando o complemento 2 da entrada b.
+
|-
 +
| POSITIVE || standard || std || números inteiros positivos [de 1 até + (2^31 - 1)] || sintetizável
 +
|-
 +
| BOOLEAN_VECTOR || standard (2008) || std || vetor de BOOLEAN || sintetizável
 +
|-
 +
| BIT_VECTOR || standard || std || vetor de BIT || sintetizável
 +
|-
 +
| INTEGER_VECTOR || standard (2008) || std || vetor de INTEGER || sintetizável
 +
|-
 +
| REAL || standard || std || números reais [de -1.0E-38 até + 1.0E38] || simulação
 +
|-
 +
| CHARACTER || standard || std || caracteres ASCII ||  
 +
|-
 +
| STRING || standard || std || vetor de CHARACTER ||
 +
|}
  
<syntaxhighlight lang=vhdl>
+
{| class="wikitable sortable"  border="1" cellpadding="3" cellspacing="0" style="text-align:left; font-size:100%" bgcolor="#efefef"
entity subtrator is
+
! scope="col" width=15% align="left"| Tipo de Dado
port (
+
! scope="col" width=10% align="left"| Package
a, b : in integer range to 15;
+
! scope="col" width=7%  align="left"| Library
s : out integer range 0 to 15);
+
! scope="col" width=50% align="left"| Valores
end entity;
+
! scope="col" width=15% align="left"| Observações
 
+
|-
architecture ifsc of subtrator is
+
| STD_LOGIC || std_logic_1164 || ieee || valores 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' || sintetizável
begin
+
|-
s <=  a - b;
+
| STD_LOGIC_VECTOR || std_logic_1164 || ieee || vetor de STD_LOGIC || sintetizável
end architecture;
+
|-
</syntaxhighlight>
+
| SIGNED || numeric_std || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas com sinal|| sintetizável
 +
|-
 +
| UNSIGNED || numeric_std || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas sem sinal || sintetizável
 +
|-
 +
| SIGNED || numeric_bit || ieee || BIT_VECTOR que aceitam operações aritméticas com sinal || sintetizável
 +
|-
 +
| UNSIGNED || numeric_bit || ieee || BIT_VECTOR que aceitam operações aritméticas sem sinal  || sintetizável
 +
|- 
 +
| SIGNED || std_logic_arith || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas com sinal || sintetizável (não é padrão, não utilizar)
 +
|-  
 +
| UNSIGNED || std_logic_arith || ieee || STD_LOGIC_VECTOR que aceitam operações aritméticas sem sinal || sintetizável (não é padrão, não utilizar)  
 +
|-
 +
| UFIXED || fixed_pkg + (2008) || ieee || números de ponto fixo sem sinal|| sintetizável
 +
|-
 +
| SFIXED || fixed_pkg + (2008) || ieee || números de ponto fixo com sinal|| sintetizável
 +
|-
 +
| FLOAT || float_pkg + (2008) || ieee || Números de ponto flutuante  || sintetizável
 +
|}
  
{{fig|4.5|Código RTL do subtrator com tipo integer com range| RTL_subtratorv1.png| 300 px |}}
+
* Exemplo: Buffer Tri-state
Note nesta figura que as entradas b[3..0] são conectadas ao B[4..1] do somador, e que o B[0] é conectado ao Vcc ("1").  O mesmo ocorre com a entrada A.  Ao mesmo tempo a entrada b é invertida, gerando assim o complemento de dois dessa entrada. Assim para realizar uma subtração pode ser utilizado o mesmo circuito do somador.
+
:*Ver como funciona em [https://tinyurl.com/ym77x4af]
 
 
Para fazer uma multiplicação, basta usar o operador "*"e o compilador irá implementar um multiplicador. Neste caso para evitar o overflow é importante definir o range da saída com um tamanho suficiente para comportar o maior produto
 
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
entity multiplicador is
+
library ieee;
port (  
+
use ieee.std_logic_1164.all;
a, b : in integer range 0 to 15;  
+
 
s : out integer range 0 to 15*15);
+
entity tri_state is
 +
  generic (N: NATURAL := 1);
 +
  port  
 +
  (
 +
    input      : in std_logic_vector(N-1 downto 0);
 +
    ena        : in std_logic;
 +
    output    : out std_logic_vector(N-1 downto 0);
 +
  );
 
end entity;
 
end entity;
  
architecture ifsc of multiplicador is
+
architecture tri_state of tri_state is
 
begin
 
begin
s <= a * b;
+
  output <= input when ena = '1' else "Z";
 
end architecture;
 
end architecture;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
{{fig|4.6|Código RTL do multiplicador com tipo integer com range| RTL_multiplicadorv1.png| 300 px |}}
+
:: '''Importante''': O terceiro estado 'Z' só pode ser usado em saídas, e a sua realização nos FPGAs só ocorre nos nós de I/O.
Note que esse circuito no Cyclone IV E necessita de 31 elementos lógicos, e no caso em que multiplicador tem  entradas com 4 bits [3..0], a saída terá 8 bits [7..0]
+
;Curiosidade: Existem circuitos comerciais que implementam essa função three-state [https://www.ti.com/lit/ds/symlink/sn74lvc16244a-q1.pdf?ts=1681232207751&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252FSN74LVC16244A-Q1 16 buffers], [https://www.ti.com/lit/ds/symlink/sn74lv244a-ep.pdf?ts=1681237777688&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252FSN74LV244A-EP 8 buffers], [https://www.ti.com/lit/ds/symlink/sn74auc1g126.pdf?ts=1681222704977&ref_url=https%253A%252F%252Fwww.google.com%252F 1 buffer].  Porque não utilizar um CPLD ou FPGA em seu lugar?
Caso a saída não tenha a quantidade suficiente de bits, haverá ''overflow'' e a resultado poderá estar incorreto.
 
  
Caso se esqueça de limitar o range dos sinais de entrada, o compilador novamente assumirá que devem ser usada a faixa inteira dos inteiros (32 bis).
+
;Exemplo de aplicação:
{{fig|4.7|Código RTL do multiplicador com tipo integer sem range| RTL_multiplicadorv2.png| 300 px |}}
+
*Demultiplexador com saída em 3-state. [https://tinyurl.com/2x4b5r5c]
Note que esse circuito no Cyclone IV E aparentemente utiliza apenas 28 elementos lógicos, mas é importante observar que ele utiliza 6 dispositivo DSP (multiplicador de  bits), os quais estão  disponíveis dentro do FPGA.  Se desativar o uso dos multiplicadores internos, forçando o uso dos elementos lógicos o total de elementos lógicos passará para 592, mostrando o desperdício de hardware que pode ocorrer.  
+
:*Baseado no Demultiplexador com enable, implemente ele com 3-state.  Se o circuito não estiver habilitado, as saídas devem ficar em 3-state.
Para  forçar o uso de elementos lógicos no lugar dos DSP realize a seguinte sequencia: '''Assignments > Settings > Compiler Settings > [Advanced Settings (Synthesis)] > Filter = DSP > DSP Block Balancing = Logic Elements > [OK]'''
+
:*Para implementar em VHDL será necessário utilizar o tipo de dado '''std_logic''' ou '''std_logic_vector'''
 +
-->
 +
{{collapse bottom}}
 +
 
 +
===Unidade 6 - Circuitos aritméticos (com VHDL) ===
 +
* 5 ENCONTROS
 +
{{collapse top | expand=true | Unidade 6 - Circuitos aritméticos  (com VHDL)}}
 +
<!--
 +
;Encontro 34 (28 nov.)
 +
*Circuitos aritméticos: somadores, incrementador, decrementador, complemento de dois, multiplicador, comparadores
 +
:* Somador completo [https://tinyurl.com/yqkt49kl]
 +
:* Somador de 4 bits [https://tinyurl.com/yucqnkwz]
 +
:* Prova que [https://www.wolframalpha.com/input?i=a+and+b+or+a+and+c+or+b+and+c (a and b) or (a and c) or (b and c)] = [https://www.wolframalpha.com/input?i=a+and+b+or+%28a+xor+b%29+and+c (a and b) or ((a xor b) and c)]
 +
 
 +
;Encontro 35 (30 nov.)
 +
*Ver slides [https://moodle.ifsc.edu.br/pluginfile.php/291703/mod_resource/content/1/Pedroni_Cap_12_Circuitos_combinacionais_Aritmeticos.pdf]
 +
*Ver pag. XXX a XXX de <ref name="PEDRONI2010a"> PEDRONI, Volnei A. Eletrônica digital moderna e VHDL; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. . ISBN 9788535234657 </ref>
  
{{collapse top | Detalhando a sequencia}}
+
;Encontro 36 (05 dez.)
*No menu, vá para "'''Assignments'''" e depois escolha "'''Settings'''".
+
*Usando o tipo '''integer'''
*Na janela "Settings", clique em "'''Compiler Settings'''". Em seguida, clique em "'''Advanced Settings (Synthesis)'''".
+
Para implementar circuitos aritméticos, ao invés de se descrever o circuito com portas lógicas conforme mostrado para somadores, subtratores, comparadores e multiplicadores, deve-se utilizar os operadores aritméticos, e o compilador realizará a escolha do melhor circuito para cada caso. Inicialmente apresentamos alguns exemplos utilizando dados do tipo '''integer'''.
*Digite em '''Filter = DSP''' e na opção "'''DSP Block Balancing'''" configure com "'''Logic Elements'''" para forçar o uso dos elementos lógicos no lugar dos DSPs.
 
*Depois clique em "'''OK'''" para aplicar as alterações.
 
{{collapse bottom}}
 
  
Para fazer uma divisão, basta usar o operador "/" e o compilador irá implementar um divisor inteiro. O tamanho do quociente deve ser igual ao dividendo.
+
Para o uso do tipo integer, se não houver limitação da faixa de valores, o compilador entenderá que os sinais devem ter 32 bits, o que gera circuitos muito maiores que normalmente necessário. Assim, ao usar as entradas e saidas como integer sem range, o diagrama RTL mostrará que o circuito foi construido com 32 bits [31..0]. Nos dispositivos da familia Cyclone IV E serão utilizados 32 elementos lógicos para tal circuito.
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
entity divisor is
+
entity somador is
 
port (  
 
port (  
dividendo : in integer range 0  to 15;  
+
a, b : in integer;  
divisor : in integer range 0  to 3;
+
s : out integer;
quociente : out integer range 0  to 15;
 
resto : out integer range 0  to 3
 
);
 
 
 
 
end entity;
 
end entity;
  
architecture ifsc of divisor is
+
architecture ifsc of somador is
 
begin
 
begin
quociente <=  dividendo / divisor;
+
s <=  a + b;
resto <=  dividendo rem divisor;
 
 
end architecture;
 
end architecture;
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
{{fig|4.1|Código RTL do somador com tipo integer sem range| RTL_somadorv1.png| 300 px |}}
 +
{{fig|4.2|Technology Map do somador com tipo integer sem range| TM_somadorv1.png| 1000 px |}}
 +
Por isso, o uso correto do tipo integer, exige que se limite a faixa de valores ('''range 0 to 15'''), o que fará com que o compilador atribua para os sinais a quantidade correta de bits, gerando circuitos de tamanho adequado.
  
{{fig|4.8|Código RTL do divisor com tipo integer com range| RTL_divisorv1.png| 300 px |}}
+
Assim, ao usar as entradas e saidas como integer com range 0 to 15, o diagrama RTL mostrará que o circuito foi construido com 4 bits [3..0]. Nos dispositivos da familia Cyclone IV E serão utilizados 4 elementos lógicos para tal circuito.
  
Multiplicações e divisões por potências de 2 (2, 4, 8, 16, ... $2^N$) não necessitam de nenhum elemento lógico pois podem ser implementados pelo simples deslocamento dos signais.
+
<syntaxhighlight lang=vhdl>
 +
entity somador is
 +
port (  
 +
a, b : in integer range 0  to 15;
 +
s : out integer range 0  to 15);
 +
end entity;
  
{{fig|4.8|Código RTL do multiplicador por 4| RTL_multiplicador4.png| 300 px |}}
+
architecture ifsc of somador is
 +
begin
 +
s <=  a + b;
 +
end architecture;
 +
</syntaxhighlight>
 +
{{fig|4.3|Código RTL do somador com tipo integer com range| RTL_somadorv2.png| 300 px |}}
 +
{{fig|4.4|Technology Map do somador com tipo integer com range| TM_somadorv2.png| 600 px |}}
  
{{fig|4.9|Código RTL do divisor por 2| RTL_divisor2.png| 300 px |}}
+
Para fazer uma subtração, basta trocar o operador "+" pelo "-", e o compilador irá implementar um subtrator realizando o complemento 2 da entrada b.
  
Multiplicações por constantes não precisam utilizar os multiplicadores, e são implementadas através de simples deslocamentos de sinais e somas. Assim multiplicar por 10 corresponde a multiplicar por 2 somar com a multiplicação por 8.
+
<syntaxhighlight lang=vhdl>
 +
entity subtrator is
 +
port (
 +
a, b : in integer range 0  to 15;
 +
s : out integer range 0  to 15);
 +
end entity;
 +
 
 +
architecture ifsc of subtrator is
 +
begin
 +
s <=  a - b;
 +
end architecture;
 +
</syntaxhighlight>
  
{{fig|4.10|Código RTL do multiplicador por 10| RTL_multiplicador10.png| 300 px |}}
+
{{fig|4.5|Código RTL do subtrator com tipo integer com range| RTL_subtratorv1.png| 300 px |}}
 +
Note nesta figura que as entradas b[3..0] são conectadas ao B[4..1] do somador, e que o B[0] é conectado ao Vcc ("1").  O mesmo ocorre com a entrada A.  Ao mesmo tempo a entrada b é invertida, gerando assim o complemento de dois dessa entrada. Assim para realizar uma subtração pode ser utilizado o mesmo circuito do somador.
  
;Encontro 37 (07 dez.)
+
Para fazer uma multiplicação, basta usar o operador "*"e o compilador irá implementar um multiplicador. Neste caso para evitar o overflow é importante definir o range da saída com um tamanho suficiente para comportar o maior produto
*A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED.
 
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
package NUMERIC_STD is
+
entity multiplicador is
  type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
+
port (  
  type SIGNED is array (NATURAL range <>) of STD_LOGIC;
+
a, b : in integer range 0  to 15;
 +
s : out integer range 0  to 15*15);
 +
end entity;
 +
 
 +
architecture ifsc of multiplicador is
 +
begin
 +
s <=  a * b;
 +
end architecture;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
A biblioteca [[Numeric std.vhd]] ainda define os operadores (abs, "+", "-", "*", "/", rem, mod, sll, slr, ror, rol), comparações ("=", '/=', ">", ">=", "<", "<=") e operadores lógicos (not, and, nand, or, nor, xor, xnor)  para os tipos SIGNED e UNSIGNED. Além disso também define algumas funções muito utilizadas como:
+
{{fig|4.6|Código RTL do multiplicador com tipo integer com range| RTL_multiplicadorv1.png| 300 px |}}
 +
Note que esse circuito no Cyclone IV E necessita de 31 elementos lógicos, e  no caso em que multiplicador tem entradas com 4 bits [3..0], a saída terá 8 bits [7..0]
 +
Caso a saída não tenha a quantidade suficiente de bits, haverá ''overflow'' e a resultado poderá estar incorreto.
  
<syntaxhighlight lang=vhdl>
+
Caso se esqueça de limitar o range dos sinais de entrada, o compilador novamente assumirá que devem ser usada a faixa inteira dos inteiros (32 bis).
  --============================================================================
+
{{fig|4.7|Código RTL do multiplicador com tipo integer sem range| RTL_multiplicadorv2.png| 300 px |}}
  --  RESIZE Functions
+
Note que esse circuito no Cyclone IV E aparentemente utiliza apenas 28 elementos lógicos, mas é importante observar que ele utiliza 6 dispositivo DSP (multiplicador de  bits), os quais estão  disponíveis dentro do FPGA.  Se desativar o uso dos multiplicadores internos, forçando o uso dos elementos lógicos o total de elementos lógicos passará para 592, mostrando o desperdício de hardware que pode ocorrer.
  --============================================================================
+
Para  forçar o uso de elementos lógicos no lugar dos DSP realize a seguinte sequencia: '''Assignments > Settings > Compiler Settings > [Advanced Settings (Synthesis)] > Filter = DSP > DSP Block Balancing = Logic Elements > [OK]'''
  function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;
 
  function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED;
 
  
  --============================================================================
+
{{collapse top | Detalhando a sequencia}}
  -- Conversion Functions
+
*No menu, vá para "'''Assignments'''" e depois escolha "'''Settings'''".
  --============================================================================
+
*Na janela "Settings", clique em "'''Compiler Settings'''". Em seguida, clique em "'''Advanced Settings (Synthesis)'''".
  function TO_INTEGER (ARG: UNSIGNED) return NATURAL;
+
*Digite em '''Filter = DSP''' e na opção "'''DSP Block Balancing'''" configure com "'''Logic Elements'''" para forçar o uso dos elementos lógicos no lugar dos DSPs.
  function TO_INTEGER (ARG: SIGNED) return INTEGER;
+
*Depois clique em "'''OK'''" para aplicar as alterações.
  function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED;
+
{{collapse bottom}}
  function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED;
 
 
</syntaxhighlight>
 
:: Ver pag. 73 a 78 de <ref name="PEDRONI2010b"/>
 
  
[[Arquivo:SumaryOfNumeric_std.gif]]
+
Para fazer uma divisão, basta usar o operador "/" e o compilador irá implementar um divisor inteiro. O tamanho do quociente deve ser igual ao dividendo.
  
[[Arquivo:Numeric_stdConvertions.gif]]
+
<syntaxhighlight lang=vhdl>
 +
entity divisor is
 +
port (
 +
dividendo : in integer range 0  to 15;
 +
divisor : in integer range 0  to 3;
 +
quociente : out integer range 0  to 15;
 +
resto : out integer range 0  to 3
 +
);
  
FONTE: http://www.doulos.com/knowhow/vhdl_designers_guide/numeric_std/
+
end entity;
  
<center>
+
architecture ifsc of divisor is
{{Mensagem
+
begin
|indent =
+
quociente <= dividendo / divisor;
|title=
+
resto <= dividendo rem divisor;
|equation = <big> Ler e guardar a página sobre [[Aritmética com vetores em VDHL]] </big>
+
end architecture;
|cellpadding= 6
+
</syntaxhighlight>
|border
 
|border colour = #0073CF
 
|background colour=#F5FFFA}}
 
</center>
 
  
;Exemplo 1:
+
{{fig|4.8|Código RTL do divisor com tipo integer com range| RTL_divisorv1.png| 300 px |}}
  
Fazer um circuito que detecte se existe alguma vaga vazia em um lote de 4 vagas. A entrada '''x(n)''' está baixo '0' se a vaga está vazia, e alto '1' se tem carro. A saída '''y''' estará alta '1' sempre que houver uma ou mais vagas vazias, e em baixo '0' se não houver nenhuma vaga.
+
Multiplicações e divisões por potências de 2 (2, 4, 8, 16, ... $2^N$) não necessitam de nenhum elemento lógico pois podem ser implementados pelo simples deslocamento dos signais.  
  
Para fazer este circuito, podemos testar cada posição da entrada x e verificar se alguma delas está com '0', e neste caso mudar a saída para '1', caso contrário a saída será '0'.
+
{{fig|4.8|Código RTL do multiplicador por 4| RTL_multiplicador4.png| 300 px |}}
Conforme veremos a seguir, é possível realizar diversas descrições em VHDL para esse circuito.
 
  
;Solução 1:
+
{{fig|4.9|Código RTL do divisor por 2| RTL_divisor2.png| 300 px |}}
Testar cada uma das entradas  x e verificar se há alguma delas com '0', então indicar que a saída é '1', senão a saída será '0'.  
+
 
 +
Multiplicações por constantes não precisam utilizar os multiplicadores, e são implementadas através de simples deslocamentos de sinais e somas. Assim multiplicar por 10 corresponde a multiplicar por 2 somar com a multiplicação por 8.  
  
<syntaxhighlight lang=vhdl>
+
{{fig|4.10|Código RTL do multiplicador por 10| RTL_multiplicador10.png| 300 px |}}
library ieee;
 
use ieee.std_logic_1164.all;
 
entity vagas is
 
    generic (N : natural := 4    );
 
  
    port    (
+
;Encontro 37 (07 dez.)
        x : in std_logic_vector  (N-1 downto 0);
+
*A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED.
        y : out std_logic
 
    );
 
end entity;
 
  
architecture ifsc_v1 of vagas is
+
<syntaxhighlight lang=vhdl>
begin
+
package NUMERIC_STD is
-- usando when-else
+
  type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
y <= '1' when x(0) = '0' else
+
  type SIGNED is array (NATURAL range <>) of STD_LOGIC;
        '1' when x(1) = '0' else
 
        '1' when x(2) = '0' else
 
        '1' when x(3) = '0' else
 
'0';
 
end architecture;
 
 
</syntaxhighlight>
 
</syntaxhighlight>
  
{{fig|4.12| RTL do indicador de vagas com when-else| RTLvagas4.png | 800 px |}}
+
A biblioteca  [[Numeric std.vhd]] ainda define os operadores (abs, "+", "-", "*", "/", rem, mod, sll, slr, ror, rol), comparações ("=", '/=', ">", ">=", "<", "<=") e operadores lógicos (not, and, nand, or, nor, xor, xnor)  para os tipos SIGNED e UNSIGNED. Além disso também define algumas funções muito utilizadas como:
  
{{fig|4.13| Technology Map do indicador de vagas | TMvagas4.png | 800 px |}}
+
<syntaxhighlight lang=vhdl>
 +
  --============================================================================
 +
  --  RESIZE Functions
 +
  --============================================================================
 +
  function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;
 +
  function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED;
  
Note neste ''Technology Map'' que para implementar esse circuito, o compilador deduziu que basta inverter as entradas X e realizar a operação OR sobre elas para determinar se tem ou não vagas.
+
  --============================================================================
 +
  -- Conversion Functions
 +
  --============================================================================
 +
  function TO_INTEGER (ARG: UNSIGNED) return NATURAL;
 +
  function TO_INTEGER (ARG: SIGNED) return INTEGER;
 +
  function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED;
 +
  function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED;
 +
 +
</syntaxhighlight>
 +
:: Ver pag. 73 a 78 de <ref name="PEDRONI2010b"/>
  
Fazendo a simulação do circuito podemos perceber que ele está funcionando, pois a saída y está em '1' sempre quando existe alguma vaga x(i) = '0'. A única situação em que a saída y está em '0' é quando todas as entradas estão em '1' (todas vagas ocupadas).
+
[[Arquivo:SumaryOfNumeric_std.gif]]
{{fig|4.14| Simulação do indicador de vagas | vagas9.png | 800 px |}}
 
  
;Solução 2:
+
[[Arquivo:Numeric_stdConvertions.gif]]
Realizar uma operação ou sobre todas as entradas  x invertidas.  
 
<syntaxhighlight lang=vhdl>
 
architecture ifsc_v2 of vagas is
 
begin
 
-- usando or e not
 
y <=  (not x(0)) or (not x(1)) or (not x(2)) or (not x(3));
 
end architecture;
 
</syntaxhighlight>
 
  
{{fig|4.15| RTL do indicador de vagas com portas NOT e OR| RTLvagas_or.png | 800 px |}}
+
FONTE: http://www.doulos.com/knowhow/vhdl_designers_guide/numeric_std/
 +
 
 +
<center>
 +
{{Mensagem
 +
|indent =
 +
|title=
 +
|equation = <big> Ler e guardar a página sobre [[Aritmética com vetores em VDHL]] </big>
 +
|cellpadding= 6
 +
|border
 +
|border colour = #0073CF
 +
|background colour=#F5FFFA}}
 +
</center>
 +
 
 +
;Exemplo 1:
  
Note que o ''Technology Map'' e a simulação produzem o mesmo resultado, apesar da descrição do hardware ser complemente diferente.
+
Fazer um circuito que detecte se existe alguma vaga vazia em um lote de 4 vagas. A entrada '''x(n)''' está baixo '0' se a vaga está vazia, e alto '1' se tem carro. A saída '''y''' estará alta '1' sempre que houver uma ou mais vagas vazias, e em baixo '0' se não houver nenhuma vaga.
  
Tanto na solução 1 como na 2, se tivermos mais vagas para verificar, será necessário alterar a descriçãoEntão para realizar uma descrição que seja genérica é necessário transformar essas soluções ou encontrar outras.
+
Para fazer este circuito, podemos testar cada posição da entrada x e verificar se alguma delas está com '0', e neste caso mudar a saída para '1', caso contrário a saída será '0'.   
 +
Conforme veremos a seguir, é possível realizar diversas descrições em VHDL para esse circuito.
  
;Solução 3:
+
;Solução 1:
Realizar uma operação ou sobre todas as entradas x invertidas.  Para tornar genérico o código use o '''for generate''' para fazer a operação de NOT e  OR sobre as entradas.  A seguir é apresentado o esboço da ideia, e fica por conta do estudante implementar essa solução.
+
Testar cada uma das entradas x e verificar se há alguma delas com '0', então indicar que a saída é '1', senão a saída será '0'.  
  
 
<syntaxhighlight lang=vhdl>
 
<syntaxhighlight lang=vhdl>
architecture ifsc_v3 of vagas is
+
library ieee;
signal tmp : std_logic_vector(N downto 0);
+
use ieee.std_logic_1164.all;
begin
+
entity vagas is
tmp(0) <= '0';  -- inicializar tmp(0) com 0, pois nao afeta o resultado do OR.
+
    generic (N : natural := 4    );
-- use o  for-generate para implementar de forma generica as seguintes linhas:
 
-- tmp(1) <= tmp(0) or (not x(0));   -- retorna 0 OR (not x0) => (not x0)
 
-- tmp(2) <= tmp(1) or (not x(1));  -- retorna (not x0) OR (not x1)
 
-- tmp(3) <= tmp(2) or (not x(2));  -- retorna (not x0) OR (not x1) OR (not x2)
 
--
 
-- tmp(i+1) <= tmp(i) or (not x(i));
 
-- ...
 
-- tmp(N) <= tmp(N-1) or (not x(N-1)); -- retorna (not x0) OR (not x1) ... OR (not xN)
 
  
 +
    port    (
 +
        x : in std_logic_vector  (N-1 downto 0);
 +
        y : out std_logic
 +
    );
 +
end entity;
  
y <= tmp(N);    -- tmp(N) tem o resultado, precisa ser enviado para a saida y.
+
architecture ifsc_v1 of vagas is
 +
begin
 +
-- usando when-else
 +
y <= '1' when x(0) = '0' else
 +
        '1' when x(1) = '0' else
 +
        '1' when x(2) = '0' else
 +
        '1' when x(3) = '0' else
 +
'0';
 
end architecture;
 
end architecture;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
 +
{{fig|4.12| RTL do indicador de vagas com when-else| RTLvagas4.png | 800 px |}}
  
<!--
+
{{fig|4.13| Technology Map do indicador de vagas | TMvagas4.png | 800 px |}}
:* Tipos de dados: SIGNED e UNSIGNED
 
  
:* Exemplo 3.3 Multiplicador de 4x4 bits (UN)SIGNED e INTEGER
+
Note neste ''Technology Map'' que para implementar esse circuito, o compilador deduziu que basta inverter as entradas X e realizar a operação OR sobre elas para determinar se tem ou não vagas.
  
{{collapse top | expand=true| Código Multiplicador}}
+
Fazendo a simulação do circuito podemos perceber que ele está funcionando, pois a saída y está em '1' sempre quando existe alguma vaga x(i) = '0'. A única situação em que a saída y está em '0' é quando todas as entradas estão em '1' (todas vagas ocupadas).
<syntaxhighlight lang=vhdl>
+
{{fig|4.14| Simulação do indicador de vagas | vagas9.png | 800 px |}}
--LIBRARY ieee;
 
--USE ieee.numeric_std.all;
 
--USE ieee.std_logic_1164.all;
 
  
ENTITY multiplicador4x4 IS
+
;Solução 2:
 +
Realizar uma operação ou sobre todas as entradas  x invertidas.
 +
<syntaxhighlight lang=vhdl>
 +
architecture ifsc_v2 of vagas is
 +
begin
 +
-- usando or e not
 +
y <=  (not x(0)) or (not x(1)) or (not x(2)) or (not x(3));
 +
end architecture;
 +
</syntaxhighlight>
  
-- multiplicador usando INTEGER (positivos)
+
{{fig|4.15| RTL do indicador de vagas com portas NOT e OR| RTLvagas_or.png | 800 px |}}
-- PORT (a, b: IN INTEGER RANGE 0 TO 15;  -- min(a) = 0; max(a) = 15      -> 4 bits
 
-- y: OUT INTEGER RANGE 0 TO 225);        -- min(a*b) = 0, max(a*b) = 225  -> 8 bits
 
  
-- multiplicador usando INTEGER (positivos e negativos)
+
Note que o ''Technology Map'' e a simulação produzem o mesmo resultado, apesar da descrição do hardware ser complemente diferente.
-- PORT (a, b: IN INTEGER RANGE -8 TO 7;  -- min(a) = -8; max(a) = 7      -> 4 bits
 
-- y: OUT INTEGER RANGE -56 TO 64);        -- min(a*b) = -56, max(a*b) = 64 -> 8 bits
 
  
-- multiplicador usando UNSIGNED
+
Tanto na solução 1 como na 2, se tivermos mais vagas para verificar, será necessário alterar a descrição.  Então para realizar uma descrição que seja genérica é necessário transformar essas soluções ou encontrar outras.  
-- PORT (a, b: IN UNSIGNED(3 DOWNTO 0);    -- min(a) = 0; max(a) = 15      <- 4 bits
 
-- y: OUT UNSIGNED(7 DOWNTO 0));          -- min(a*b) = 0, max(a*b) = 225 -> 8 bits
 
  
-- multiplicador usando SIGNED
+
;Solução 3:
-- PORT (a, b: IN SIGNED(3 DOWNTO 0);      -- min(a) = -8; max(a) = 7      <- 4 bits
+
Realizar uma operação ou sobre todas as entradas x invertidas.  Para tornar genérico o código use o '''for generate''' para fazer a operação de NOT e  OR sobre as entradas.  A seguir é apresentado o esboço da ideia, e fica por conta do estudante implementar essa solução.
-- y: OUT SIGNED(7 DOWNTO 0));            -- min(a*b) = -56, max(a*b) = 64 -> 8 bits
 
  
 +
<syntaxhighlight lang=vhdl>
 +
architecture ifsc_v3 of vagas is
 +
signal tmp : std_logic_vector(N downto 0);
 +
begin
 +
tmp(0) <= '0';  -- inicializar tmp(0) com 0, pois nao afeta o resultado do OR.
 +
-- use o  for-generate para implementar de forma generica as seguintes linhas:
 +
-- tmp(1) <= tmp(0) or (not x(0));  -- retorna 0 OR (not x0) => (not x0)
 +
-- tmp(2) <= tmp(1) or (not x(1));  -- retorna (not x0) OR (not x1)
 +
-- tmp(3) <= tmp(2) or (not x(2));  -- retorna (not x0) OR (not x1) OR (not x2)
 +
--
 +
-- tmp(i+1) <= tmp(i) or (not x(i));
 +
-- ...
 +
-- tmp(N) <= tmp(N-1) or (not x(N-1));  -- retorna (not x0) OR (not x1) ... OR (not xN)
 +
 +
 +
y <= tmp(N);    -- tmp(N) tem o resultado, precisa ser enviado para a saida y.
 +
end architecture;
 +
</syntaxhighlight>
  
-- multiplicador usando STD_LOGIC_VECTOR
+
:* Tipos de dados: SIGNED e UNSIGNED
-- PORT (a, b: IN STD_LOGIC_VECTOR(3 DOWNTO 0);    -- min(a) = 0; max(a) = 15      <- 4 bits
 
-- y: OUT STD_LOGIC_VECTOR(7 DOWNTO 0));          -- min(a*b) = 0, max(a*b) = 225  -> 8 bits
 
 
 
-- multiplicador usando STD_LOGIC_VECTOR
 
-- PORT (a, b: STD_LOGIC_VECTOR(3 DOWNTO 0);      -- min(a) = -8; max(a) = 7      <- 4 bits
 
-- y: OUT STD_LOGIC_VECTOR(7 DOWNTO 0));          -- min(a*b) = -56, max(a*b) = 64 -> 8 bits
 
  
 +
:* Exemplo 3.3 Multiplicador de 4x4 bits (UN)SIGNED e INTEGER
  
END ENTITY;
+
{{collapse top | expand=true| Código Multiplicador}}
 +
<syntaxhighlight lang=vhdl>
 +
--LIBRARY ieee;
 +
--USE ieee.numeric_std.all;
 +
--USE ieee.std_logic_1164.all;
  
ARCHITECTURE v1 OF multiplicador4x4 IS
+
ENTITY multiplicador4x4 IS
BEGIN
+
 
  y <= a * b;
+
-- multiplicador usando INTEGER (positivos)
END ARCHITECTURE;
+
-- PORT (a, b: IN INTEGER RANGE 0 TO 15;  -- min(a) = 0; max(a) = 15      -> 4 bits
</syntaxhighlight>
+
-- y: OUT INTEGER RANGE 0 TO 225);        -- min(a*b) = 0, max(a*b) = 225  -> 8 bits
 +
 
 +
-- multiplicador usando INTEGER (positivos e negativos)
 +
-- PORT (a, b: IN INTEGER RANGE -8 TO 7;  -- min(a) = -8; max(a) = 7      -> 4 bits
 +
-- y: OUT INTEGER RANGE -56 TO 64);        -- min(a*b) = -56, max(a*b) = 64 -> 8 bits
 +
 
 +
-- multiplicador usando UNSIGNED
 +
-- PORT (a, b: IN UNSIGNED(3 DOWNTO 0);    -- min(a) = 0; max(a) = 15      <- 4 bits
 +
-- y: OUT UNSIGNED(7 DOWNTO 0));          -- min(a*b) = 0, max(a*b) = 225  -> 8 bits
 +
 
 +
-- multiplicador usando SIGNED
 +
-- PORT (a, b: IN SIGNED(3 DOWNTO 0);      -- min(a) = -8; max(a) = 7      <- 4 bits
 +
-- y: OUT SIGNED(7 DOWNTO 0));            -- min(a*b) = -56, max(a*b) = 64 -> 8 bits
 +
 
 +
 
 +
-- multiplicador usando STD_LOGIC_VECTOR
 +
-- PORT (a, b: IN STD_LOGIC_VECTOR(3 DOWNTO 0);    -- min(a) = 0; max(a) = 15      <- 4 bits
 +
-- y: OUT STD_LOGIC_VECTOR(7 DOWNTO 0));          -- min(a*b) = 0, max(a*b) = 225  -> 8 bits
 +
 
 +
-- multiplicador usando STD_LOGIC_VECTOR
 +
-- PORT (a, b: STD_LOGIC_VECTOR(3 DOWNTO 0);      -- min(a) = -8; max(a) = 7      <- 4 bits
 +
-- y: OUT STD_LOGIC_VECTOR(7 DOWNTO 0));          -- min(a*b) = -56, max(a*b) = 64 -> 8 bits
 +
 
 +
 
 +
END ENTITY;
 +
 
 +
ARCHITECTURE v1 OF multiplicador4x4 IS
 +
BEGIN
 +
  y <= a * b;
 +
END ARCHITECTURE;
 +
</syntaxhighlight>
 +
 
 +
*Observar o número de elementos lógicos, bits usados para representar as entradas e saídas.
 +
*Observar o código RTL obtido.
 +
*Realizar a simulação com entradas UNSIGNED e INTEGER na faixa de valores de 0 até 15, e analisar se o valor da saída está correto.
 +
*Realizar a simulação com entradas SIGNED e INTEGER na faixa de valores de -8 até 7, e analisar se o valor da saída está correto.
 +
*Realizar a simulação com entradas STD_LOGIC_VECTOR na faixa de valores de 0 até 15, e analisar se o valor da saída está correto.  Neste caso será necessário realizar uma conversão de STD_LOGIC_VECTOR para UNSIGNED antes de efetuar a operação de "*", e após a operação é necessário fazer a operação inversa UNSIGNED para STD_LOGIC_VECTOR
 +
*Realizar a simulação com entradas STD_LOGIC_VECTOR na faixa de valores de -8 até 7, e analisar se o valor da saída está correto.  Neste caso será necessário realizar uma conversão de STD_LOGIC_VECTOR para SIGNED antes de efetuar a operação de "*", e após a operação é necessário fazer a operação inversa SIGNED para STD_LOGIC_VECTOR
 +
 
 +
:: Ver pag. 39 a 54 de <ref name="PEDRONI2010b"/>
 +
 
 +
;Encontro 38 (12 dez.)
 +
* Exercícios da Unidades 4 e 5
 +
-->
 +
{{collapse bottom}}
 +
<!--
 +
;Encontro 39 (14 dez.)
 +
*Avaliação A2 (Unidades 4 e 5).
 +
 
 +
;Encontro 40 (19 dez.)
 +
*Avaliação REC1 e REC2 (Unidades 1 a 5).
 +
-->
 +
 
 +
==Avaliações==
 +
Durante o semestre serão realizadas 4 avaliações.  As avaliações devem  ser enviadas pela plataforma Moodle com os arquivos solicitados.
 +
;Data das avaliações:
 +
*A1 - : 05/03 - 1ª parte A1a (3 pontos) (Sistema de Numeração e códigos);
 +
*A2 - :
 +
*R - Recuperação de A1 a A2 :
 +
 
 +
== Atividade relâmpago (AR) ==
 +
As atividades relâmpago devem ser entregues no Moodle da disciplina. A não entrega dessas atividades não gera nenhum desconto, apenas geram pontos de BÔNUS que são adicionados aos conceitos das avaliações A1 a AN. 
 +
 
 +
== Atividade extra-classe (AE) ==
 +
A média ponderada das atividades extra-classe será considerada no cálculo do conceito final da UC.  A entrega das mesmas será feita pelo Moodle, e cada dia de atraso irá descontar 0,2 na nota da atividade.  Muitas dessas atividades também geram pontos de BÔNUS que são adicionados aos conceitos das avaliações A1 a AN.  Para os BÔNUS só serão considerados projetos entregues no prazo.
 +
 
 +
 
 +
Objetivos
 +
Projetar um circuito digital que realize a conversão de uma entrada BCD para um saída de um mostrador de 7 segmentos.
 +
Descrever através de uma tabela verdade o funcionamento de um circuito.
 +
Usar a técnica do mapa de Karnaugh para minimizar a função lógica de cada saída.
 +
 
 +
===AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos===
 +
{{collapse top | bg=lightyellow | AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos}}
 +
;Objetivos:
 +
* Conhecer o mostrador (diplay) de 7 segmento
 +
* Projetar um circuito digital que realize a conversão de uma entrada binária de 4 bits para uma saída de um mostrador de 7 segmentos.
 +
* Descrever o funcionamento de um circuito através de uma tabela verdade.
 +
* Usar a técnica do mapa de Karnaugh para minimizar a função lógica de cada uma das saídas.
 +
 
 +
;Atividades:
 +
*Veja como funciona o [[Display de 7 segmentos]].
 +
*Nesta atividade os estudantes devem projetar um conversor de binário para mostrador de 7 segmentos. Considere que na entrada são possíveis apenas os valores 0, 1, 2,  ... 8, 9. 
 +
*Apesar de uma entrada binária de 4 bits poder receber os valores 1010 (dez), 1011 (onze), ... 1111 (quinze), pode considerar que elas não acontecem por restrição dos dados de entrada. Por isso, cada estudante tem a liberdade de definir como o mostrador se comportará nesta situação. 
 +
 
 +
;Entregas:
 +
*O projeto todo deverá se realizado manuscrito, devendo as folhas ter a identificação do nome completo do estudante e estar grampeadas. *Deverão ser apresentados no mínimo:
 +
:1) A tabela verdade completa indicando para as entradas de 0 a 9 quais são os valores das saídas (segmentos) a, b, c, d, e, f, g.
 +
:2) Para cada saída mostre o mapa de Karnough e a indicação dos agrupamentos de bits obtidos, e o respectiva produto (implicante). 
 +
:3) Para cada saída deve ser apresentada a expressão lógica minimizada e também o circuito lógico obtido.
 +
*A entrega será feita pessoalmente para o professor no prazo indicado no Moodle.
 +
{{collapse bottom}}
 +
 
 +
===AE2 -  Conhecendo os dispositivos lógicos programáveis===
 +
{{collapse top | expand=true| bg=lightyellow | AE2 -  Conhecendo os dispositivos lógicos programáveis}}
 +
;Objetivos:
 +
*Conhecer o Quartus Prime e as características dos dispositivos lógicos programáveis
 +
*Analisar os tempos de propagação em um circuito combinacional
 +
*Alterar configurações do compilador
 +
*Fazer a simulação funcional de um circuito combinacional.
 +
 
 +
;Atividades:
 +
*'''PASSO 1:''' Realize a atividade descrita em [[Conhecendo os dispositivos lógicos programáveis - QUARTUS PRIME]]
 +
:*Ao escolher a família de FPGAS, escolha inicialmente um dispositivo da família '''Max II'''. Anote o código desse dispositivo.
 +
:*Capture as telas solicitadas e depois utilize-as no relatório da atividade.
 +
:*Anote o tempo utilizado para cada uma das etapas do processo de compilação.
 +
:*Anote o número de elementos lógicos utilizados e o número de pinos utilizados, bem com o percentual em relação ao número total do dispositivo.
 +
:*Anote algum erro ('''Error''') ou alertas ('''Warnings''') que o Quartus II indicar no painel de mensagens '''[Messages]'''
 +
:*Ao final salve o projeto em um arquivo QAR (sugestão PJ1.QAR)
 +
 
 +
*'''PASSO 2''': Repita a atividade descrita em [[Conhecendo os dispositivos lógicos programáveis - QUARTUS PRIME]], trocando a família e dispositivo a ser usado na implementação.  Escolha nesta vez um dispositivos da família '''Cyclone IV E'''  ou  '''Stratix II GX'''. Anote o código desse dispositivo.
 +
:*Observe as mudanças que ocorrem tanto no tipo de Elemento Lógico disponível, no Chip Planner, no Pin Planner, e no circuito dos pinos de I/O.  Note que estes FPGAs também apresenta novos componentes, tais como: Memória, Multiplicadores, DSP, PLL, DLL, etc. Verifique se consegue encontra-los no leiaute mostrado no Chip Planner,  e documente aqueles que encontrar.
 +
:*Compare os resultados obtidos nos procedimentos do PASSO 1 e PASSO 2.
 +
 
 +
*'''PASSO 3''': Realize o procedimento descrito em [[Medição de tempos de propagação em circuitos combinacionais - Quartus Prime]]
 +
:*Ao escolher a família de FPGAS, escolha um dispositivo FPGA da família '''Cyclone IV E'''. Anote o código desse dispositivo.
 +
:*Se você está com o código da '''AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos''' escrito, use este código no lugar do código do '''cálculo da distância de Hamming'''
 +
:*Capture as telas mostradas no roteiro e depois utilize-as no relatório da atividade.
 +
:*Anote o máximo tempo de propagação entre entrada e saída.
 +
:*Anote o número de elementos lógicos utilizados e o número de pinos utilizados, bem com o percentual em relação ao número total do dispositivo.
 +
:*Experimente modificar as configurações do compilador, conforme mostrado em '''Configurando o compilador'''.  Se desejar mude a semente inicial trocando o valor de '''[Seed: 1]'''
 +
:*Experimente inserir diferentes restrições de atraso máximo para o compilador, e analise o resultado obtido.
 +
:*Anote algum erro ('''Error''') ou alertas ('''Warnings''') que o Quartus II indicar no painel de mensagens '''[Messages]'''
 +
:*Ao final salve o projeto em um arquivo QAR (sugestão PJ2.QAR)
 +
 
 +
*'''PASSO 4''': Realize a simulação funcional de um dos projetos '''CI74161''' ou do '''cálculo da distância de Hamming''' ou '''conversor de binário para mostrador de 7 segmentos'''
 +
:*Capture as telas que mostram o circuito funcionando e depois utilize-as no relatório da atividade.
 +
 
 +
;Entregas:
 +
#Envie um arquivo QAR contendo todos os arquivos necessário para compilar cada um dos projetos.
 +
#Envie um relatório em PDF, incluindo as imagens capturadas (inclua um título para cada figura) e escreva para cada imagem um texto comentando o que representa.  O relatório também deve ter a identificação (autor, título, data) uma breve introdução e uma conclusão.  A descrição dos procedimentos feita na página wiki não precisa incluída no relatório.
 +
#Use preferencialmente o [[Uso_do_Overleaf | Overleaf]] para gerar o relatório. Mas o uso de MS-Word, Libreoffice e Google Docs também é permitida.
 +
#A entrega será feita através do Moodle da disciplina.  Observe o prazo de entrega.
 +
{{collapse bottom}}
 +
 
 +
===AE3 - Programação do kit Mercurio IV===
 +
{{collapse top | expand=true | bg=lightyellow | AE3 - Programação do kit Mercurio IV}}
 +
;Objetivos:
 +
* Apreender como programar um FPGA usando um kit de desenvolvimento
 +
* Baseado na '''AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos''', implementar o projeto em VHDL.
 +
* Descrever um circuito que você projetou em VHDL, implentá-lo e testá-lo.
 +
* Fazer as adaptações necessárias para que o circuito projetado funcione no kit escolhido
 +
* Testar o circuito, e anotar os resultados.
 +
 
 +
;Procedimento de laboratório:
 +
;Passo 1 - Descrevendo o hardware e fazendo a Análise e Síntese:
 +
*Abra o projeto do '''conversor de binário para mostrador de 7 segmentos''' (já simulado em aula anterior)
 +
*Fazer a análise e síntese e corrigir eventuais erros.
 +
 
 +
<syntaxhighlight lang=vhdl>
 +
-- A bibliteca std e o pacote standard são autodeclarados, então as linhas abaixo podem ser comentadas com "--"
 +
--library std;
 +
--use std.standard.all;
 +
 
 +
entity BCD2SSD is
 +
port (
 +
-- Entradas ABCD do circuito
 +
eA, eB, eC, eD: in bit;
 +
-- Saidas para os leds do mostrador de 7 segmentos. Note que o nome a, b, .. g foi mudado para ssd_a, ssd_b, ... ssd_g pois o VHDL é insensível a caixa                           
 +
ssd_a, ssd_b, ssd_c, ssd_d, ssd_e, ssd_f, ssd_g : out bit
 +
);
 +
end entity;
 +
 
 +
architecture ifsc_v1 of BCD2SSD is
 +
begin
 +
-- descreva a expressão lógica obtida para cada uma das saídas;
 +
-- Por exemplo: se for a = A + C + (B'.D') + (B.D)
 +
ssd_a <= eA or eC or (not eB and not eD) or (eB and eD);
 +
 
 +
ssd_g <=    ;             
 +
end architecture;
 +
</syntaxhighlight>
 +
 
 +
;Passo 2 - Configurando o dispositivo e os pinos a serem utilizados:
 +
Veja os detalhes em [[Preparando para gravar o circuito lógico no FPGA]]. Após escolher o kit a ser usado no projeto, é necessário informar ao Quartus II a família e o dispositivo (device) que será utilizado
 +
*para DE2-115 '''{Assignments > Device... > Device family (Family: [Cyclone IV E],  Name filter: [EP4CE115F29C7] ) > [OK]}'''
 +
*para MERCÚRIO IV '''{Assignments > Device... > Device family (Family: [Cyclone IV E],  Name filter: [EP4CE30F23C7] ) > [OK]}'''
 +
 
 +
Para evitar que saídas de circuitos da placa sejam ligadas ao terra através do FPGA, defina como alta impedância o estado dos pinos não utilizados no projeto.
 +
*'''{Assignments > Device... > Device and Pin Options... > Category: Unused Pins > Reserve all unused pins: [As input tri-stated] > [OK] > [OK]}'''
 +
 
 +
Atribua os pinos conforme a necessidade do projeto.
 +
* Uso do Pin Planner '''{Assignments > Pin Planner}''' no modo tabela.  Digite o número do pino na coluna {Location}.  Apenas posições válidas são aceitas.
 +
 
 +
*Abra a página com o resumo da pinagem do kit [[Pinagem dos dispositivos de entrada e saída do kit MERCURIO IV]]. Observe a tabela com a pinagem das chaves disponíveis neste kit.
 +
{| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222;"
 +
|- style="font-weight:bold;"
 +
! Signal
 +
! Name FPGA
 +
! Pin No. Description
 +
! I/O Standard
 +
|-
 +
| SW[0] || PIN_Y22 || Chave tipo Slide Switch 0 || 3.3V
 +
|-
 +
| SW[1] || PIN_W21 || Chave tipo Slide Switch 1 || 3.3V
 +
|-
 +
| SW[2] || PIN_W22 || Chave tipo Slide Switch 2 || 3.3V
 +
|-
 +
| SW[3] || PIN_V21 || Chave tipo Slide Switch 3 || 3.3V
 +
|}
 +
* Configurar como entrada os seguintes pinos:
 +
eA V21
 +
eB W22
 +
eC W21
 +
eD Y22
 +
*Observe a tabela com a pinagem dos display (mostrador de sete segmentos) disponíveis neste kit.
 +
{| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222;"
 +
|- style="font-weight:bold;"
 +
! Signal
 +
! Name FPGA
 +
! Pin No. Description
 +
! I/O Standard
 +
|-
 +
| DISP0_D[0] || PIN_V2 || Segmento A - Display 0 || 3.3V
 +
|-
 +
| DISP0_D[1] || PIN_V1 || Segmento B - Display 0 || 3.3V
 +
|-
 +
| DISP0_D[2] || PIN_U2 || Segmento C - Display 0 || 3.3V
 +
|-
 +
| DISP0_D[3] || PIN_U1 || Segmento D - Display 0 || 3.3V
 +
|-
 +
| DISP0_D[4] || PIN_Y2 || Segmento E - Display 0 || 3.3V
 +
|-
 +
| DISP0_D[5] || PIN_Y1 || Segmento F - Display 0 || 3.3V
 +
|-
 +
| DISP0_D[6] || PIN_W2 || Segmento G - Display 0 || 3.3V
 +
|}
 +
 
 +
* Configure como saída do FPGA os seguintes pinos:
 +
ssd_a V2
 +
ssd_b V1
 +
ssd_c U2
 +
ssd_d U1
 +
ssd_e Y2
 +
ssd_f Y1
 +
ssd_g W2
 +
*A final do processo, o Pin Planner '''{Assignments > Pin Planner}''' deverá mostrar a correta pinagem conforme exemplificado na figura abaixo:
 +
<center>[[Arquivo:PinagemSSDM4.png| 400px]]</center>
 +
 
 +
Uma vez completada a configuração e pinagem, execute o '''Fitter (Place & Route)'''. Após a compilação a mensagem de warning '''"Critical Warning (XXXXX): No exact pin location assignment(s) for XX pins of XX total pins"''' não deverá mais ser mostrada.  Caso seja mostrada verifique qual o pino que não foi configurado corretamente e corrija.
 +
 
 +
;Passo 3 - Programando o FPGA:
 +
Veja o procedimento de como deve ser feita a programação do FPGA em [[Programando o FPGA através da USB-Blaster]]
 +
 
 +
;Passo 4 - Testes de validação:
 +
*Realizar os seguintes testes, acionando as chaves A, B, C e D e observando o resultado no mstrador de sete segmentos:
 +
:# Carregar nas chaves os valores binários de 0 ("0000") a 9 ("1001") e observar se o valor mostrado é o desejado.
 +
:# Carregar nas chaves os valores binários de 10 ("1010") a 15 ("1111") e observar se o que é mostrado. 
 +
:# Anote todos os resultados
 +
[[Arquivo:Display7Seg.png|thumb| 300px|right]]
 +
{| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222;"
 +
|+
 +
|-
 +
! Digito
 +
! ABCD
 +
! ssd_a
 +
! ssd_b
 +
! ssd_c
 +
! ssd_d
 +
! ssd_e
 +
! ssd_f
 +
! ssd_g
 +
! Mostrador
 +
|-
 +
| 0 || 0000 || ON || ON || ON || ON || ON || ON || OFF || [[Arquivo:ssd0.png|15px]]
 +
|-
 +
| 1 || 0001 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| 2 || 0010 ||  ||  ||  ||  ||  ||  ||  || 
 +
|-
 +
| 3 || 0011 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| 4 || 0100 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| 5 || 0101 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| 6 || 0110 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| 7 || 0111 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| 8 || 1000 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| 9 || 1001 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| A || 1010 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| B || 1011 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| C || 1100 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| D || 1101 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| E || 1110 ||  ||  ||  ||  ||  ||  ||  ||
 +
|-
 +
| F || 1111 ||  ||  ||  ||  ||  ||  ||  ||
 +
|}
  
*Observar o número de elementos lógicos, bits usados para representar as entradas e saídas.
 
*Observar o código RTL obtido.
 
*Realizar a simulação com entradas UNSIGNED e INTEGER na faixa de valores de 0 até 15, e analisar se o valor da saída está correto.
 
*Realizar a simulação com entradas SIGNED e INTEGER na faixa de valores de -8 até 7, e analisar se o valor da saída está correto.
 
*Realizar a simulação com entradas STD_LOGIC_VECTOR na faixa de valores de 0 até 15, e analisar se o valor da saída está correto.  Neste caso será necessário realizar uma conversão de STD_LOGIC_VECTOR para UNSIGNED antes de efetuar a operação de "*", e após a operação é necessário fazer a operação inversa UNSIGNED para STD_LOGIC_VECTOR
 
*Realizar a simulação com entradas STD_LOGIC_VECTOR na faixa de valores de -8 até 7, e analisar se o valor da saída está correto.  Neste caso será necessário realizar uma conversão de STD_LOGIC_VECTOR para SIGNED antes de efetuar a operação de "*", e após a operação é necessário fazer a operação inversa SIGNED para STD_LOGIC_VECTOR
 
-->
 
:: Ver pag. 39 a 54 de <ref name="PEDRONI2010b"/>
 
  
;Encontro 38 (12 dez.)
+
;Relatório Técnico:
* Exercícios da Unidades 4 e 5
+
* Documentar o experimento em um relatório técnico que contenha no mínimo:
 +
:* Identificação (título, disciplina, data, autores);
 +
:* Introdução;
 +
:* Descrição do procedimento realizado;
 +
:* Resultados obtidos (com imagens dos itens importantes) e análise dos resultados;
 +
:* Conclusão.
 +
:* Apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito no Passo 4
 +
* O relatório deve também responder as questões levantadas e mostrar que os objetivos apresentados na introdução foram atendidos.
 
{{collapse bottom}}
 
{{collapse bottom}}
 
;Encontro 39 (14 dez.)
 
*Avaliação A2 (Unidades 4 e 5).
 
 
;Encontro 40 (19 dez.)
 
*Avaliação REC1 e REC2 (Unidades 1 a 5).
 
 
==Avaliações==
 
Durante o semestre serão realizadas 4 avaliações.  As avaliações devem  ser enviadas pela plataforma Moodle com os arquivos solicitados.
 
;Data das avaliações:
 
*A1 - : dividida em 3 avaliações A1a (Sistemas Numéricos e códigos), A1b (Funções e portas lógicas), A1c (Álgebra booleana e simplificação de funções lógicas, mapa de Karnaugh)
 
*A2 - :
 
*R - Recuperação de A1 a A2 : dia 19/12
 
 
== Atividade relâmpago (AR) ==
 
As atividades relâmpago devem ser entregues no Moodle da disciplina. A não entrega dessas atividades não gera nenhum desconto, apenas geram pontos de BÔNUS que são adicionados aos conceitos das avaliações A1 a AN. 
 
 
== Atividade extra-classe (AE) ==
 
A média ponderada das atividades extra-classe será considerada no cálculo do conceito final da UC.  A entrega das mesmas será feita pelo Moodle, e cada dia de atraso irá descontar 0,2 na nota da atividade.  Muitas dessas atividades também geram pontos de BÔNUS que são adicionados aos conceitos das avaliações A1 a AN.  Para os BÔNUS só serão considerados projetos entregues no prazo.
 
  
 
==Referências Bibliográficas:==
 
==Referências Bibliográficas:==
 
<references/>
 
<references/>
 
{{ENGTELECO}}
 
{{ENGTELECO}}

Edição atual tal como às 18h02min de 6 de maio de 2024

Registro on-line das aulas

Unidade 1 - Aula inicial, Introdução a disciplina

  • 1 ENCONTRO
Unidade 1 - Aula inicial, Introdução a disciplina
Encontro 1 (15 fev)
  • A página da UC contém os materiais que não alteram entre semestre.
  • Relação com as outras UCs do Eixo Sistemas Computacionais (Marrom). Ver grafo do curriculo
  • ELD129002 - ELETRÔNICA DIGITAL I (ELD1): Sistema de numeração e códigos. Lógica booleana. Circuitos combinacionais. Circuitos aritméticos. Linguagem de descrição de hardware. Implementação e teste de circuitos digitais. Projeto de circuitos lógicos.
  • ELD129003 - ELETRÔNICA DIGITAL II (ELD2): Dispositivos lógicos programáveis. Circuitos sequenciais. Metodologia síncrona. Projeto hierárquico e parametrizado. Máquinas de estados finita. Register Transfer Methodology. Teste de circuitos digitais. Implementação em FPGA. Introdução a Linguagem de Descrição de Hardware.
  • AOC129004 - ARQUITETURA E ORGANIZAÇÃO DE COMPUTADORES (AOC): Introdução à Arquitetura Computadores. Linguagem Assembly. Linguagem de Máquina. Programação Assembly. Modos de Endereçamento. Processo de compilação e carga de um programa. Introdução à Organização de Computadores. Organização Monociclo e Multiciclo. Pipeline. Memória e Sistema de E/S.
  • MIC129007 - MICROCONTROLADORES (MIC): Introdução a Microcontroladores e Aplicações. Arquitetura de um microcontrolador. Pilha e Subrotinas. Interrupção. Contadores e Temporizadores. Interface com Periféricos. Programação em alto nível (ex.: C, C++ e RUST) para Microcontroladores: Mapeamento de tipos e estruturas de alto nível para sistemas com recursos limitados. Projeto de hardware e firmware com microcontroladores.
  • STE129008 - STE - SISTEMAS EMBARCADOS (STE): Conceitos em Sistemas Embarcados. Metodologia de Desenvolvimento de Sistemas Embarcados. Sistemas Operacionais para Sistemas Embarcados. Ferramentas de desenvolvimento e depuração. Barramentos e dispositivos de acesso a redes. Desenvolvimento de Projeto.
  • Nesta página está o Registro diário dos encontros e avaliações.
  • A entrega de atividades e avaliações será através da plataforma Moodle. A inscrição dos alunos é automática a partir do SIGAA.
  • Para a comunicação entre professor-aluno, além dos avisos no SIGAA, utilizaremos o chat institucional. A princípio todos os alunos já estão previamente cadastrados pelo seu email institucional. Confiram enviando uma mensagem de apresentação.
  • Utilizaremos durante as aulas algumas ferramentas computacionas como o site do Falstad para entender circuitos digitais e fazer simulações básicas.
  • Também utilizaremos os softwares Quartus Light e ModelSim instalados nas maquinas do laboratório para praticar a parte de programação de hardware (descrição de hardware). Esses softwares também podem ser usados através da Nuvem do IFSC..
LER PARA O PRÓXIMO ENCONTRO

Unidade 2 - Sistema de numeração e códigos

  • 4 ENCONTROS
Unidade 2 - Sistema de numeração e códigos
Encontro 2 (20 fev) - Sistemas numéricos

O ser humano precisa contar para determinar quantidades de coisas, com as quantidades ele pode fazer operações matemáticas e comparações.

  • Os números permitem representar quantidades de forma simbólica.
  • Os símbolos utilizados são chamados de dígitos.
  • Em alguns sistemas a posição do símbolo faz diferença (sistemas posicionais), enquanto que em outros o símbolo já representa a quantidade.
  • Dependendo do sistema podem existir diferentes tipos e quantidades de símbolos.
  • Sistema decimal:
  • É o sistema utilizado no dia a dia das tarefas diárias
  • Utiliza 10 símbolos (dígitos). 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9
  • É um sistema posicional, onde a posição do dígito tem um peso dado pela base (10) elevado ao expoente da posição.
  • Exemplo: o número representado 135, corresponde a 1 centena (10² = 100), 3 dezenas (10¹ = 10) e 5 unidades (10⁰ = 1), pois
1*10² + 3*10¹ + 5*10⁰ = 1*100 + 3*10 + 5*1 = 100 + 30 + 5 = 135
  • Com o sistema podemos contar quantidades, representar quantidades inteiras e fracionárias, comparar valores (quantidades), fazer operações de soma, subtração, multiplicação, divisão, entre outras;
  • Exemplos:
Contar: …, 34, 35, 36, 37, …
Somar: 21 + 46 + 100 = 100 + 20 + 40 + 1 + 6 = 100 + 60 + 7 = 167;
Multiplicar: 3 x 6 = 6 + 6 + 6 = 18;
Dividir: 35/7 = (5+ 5 + 5 + 5 + 5 + 5 +5)/7 = (5*7)/7 = 5;
Representar frações: 12/10 = 1,2; 3/4 = 0,75
Comparar valores: 145 > 14,5; 230 = 2,3x102
  • Outros sistemas:
  • Nos computadores e circuitos digitais, para fazer a representação de números são utilizadas normalmente duas tensões, sendo uma para representar o dígito “0” (0 volt), e outra para representar o dígito “1” ( X volts).
  • Este sistema é chamado de sistema binário, pois utiliza apenas dois dígitos (0 e 1).
  • O sistema também é posicional, e permite representar quantidades e fazer operações matemáticas e comparações
  • OBS: Muitas vezes os números binários são representados através do sistema hexadecimal ou do sistema octal (já em desuso).
  • Sistema binário:
  • Utiliza apenas 2 símbolos (dígitos). 0 e 1
  • É um sistema posicional, onde a posição do dígito tem um peso dado pela base (2) elevado ao expoente da posição.
  • Exemplo: o número representado 111, corresponde a 1 quadra (2² = 4), 1 dupla (2¹ = 2) e 1 unidade (2⁰ = 1).
1*2² + 1*2¹ + 1*2⁰ = 1*4 + 1*2 + 1*1 = 4 + 2 + 1 = 7
  • O que são bits, nibbles, bytes e word (palavra) de bits
↓msb lsb↓
0 1 1 0 0 1 1 0 1 1 1 0 0 0 1 1
nibble nibble nibble nibble
byte (MSB) byte (LSB)
word (palavra)
  • Note no quadro acima:
  • o nibble corresponde ao grupo de 4 bits (meio byte)
  • o byte corresponde ao grupo de 8 bits. Este grupo de 8 bits também é denominado de forma mais exata de octeto.
  • a word corresponde ao grupo de 16 bits (as vezes 32 bits)
  • a double word corresponte ao grupo de 32 bits (as vezes 64 bits)
  • o bit menos significativo (lsb - less significative bit)
  • o bit mais significativo (msb - most significative bit)
  • o byte menos significativo (LSB - Less Significative Byte)
  • o byte mais significativo (MSB - Most Significative Byte)
  • Prefixos e multiplos utilizados para quantidades de informação
Nome Símbolo Número de bytes Aproximação decimal
Byte B / Byte 1 1
kilobyte kB / kByte (mil)
Megabyte MB / MByte (milhão)
Gigabyte GB / GByte (bilhão)
Terabyte TB / TByte (trilhão)
Petabyte PB / PByte (quadrilhão)
PARA O PRÓXIMO ENCONTRO
Encontro 3 (22 fev)
Conversão de bases entre sistemas numéricos
  • Conversão entre os sistemas de numeração decimal - binário - hexadecimal.
  • Regra geral de conversão de valor para qualquer sistema de numeração
  • Dividir o valor (número) pela base e obter o quociente e o resto.
  • Dividir sucessivas vezes o quociente anterior até obter um quociente nulo.
  • Os restos obtidos são os digitos que representam o valor (número) no novo sistema de numeração.
  • O primeiro resto obtido é o dígito menos significativo.
  • O último resto obtido é o dígito mais significativo.
  • Regra geral de conversão de um sistema de numeração qualquer de base N para decimal
  • Verifique a posição do ponto decimal.
  • Os dígitos a esquerda do ponto decimal correspondem as posições 0, 1, 2, … .
  • Se houver dígitos a direita do ponto decimal, eles correspondem as posições -1, -2, -3, … .
  • A cada dígito é dado um peso correspondente ao valor da base elevada ao expoente Nposição.
  • Multiplique os pesos pelos dígitos correspondentes.
  • O valor final (em decimal) é a soma dos valores obtidos.
posição k 2 1 0 , -1 -2 -l
dígito dk d2 d1 d0 d-1 d-2 d-l
peso Nk N2 N1 N0 N-1 N-2 N-l
somar dk × Nk d2 × N2 d1 × N1 d0 × N0 d-1 × N-1 d-2 × N-2 d-l × N-l
valor dk × Nk + d2 × N2 + d1 × N1 + d0 × N0 + d-1 × N-1 + d-2 × N-2 + d-l × N-l
Códigos numéricos binários
  • Número sem sinal (UNSIGNED)
Neste caso apenas números inteiros naturais podem ser representados.
Usando bits é possível representar números inteiros no intervalo de .
Por exemplo usando 8 bits =>
bit 7 6 5 4 3 2 1 0
valor 1 0 1 0 0 1 1 1
peso 27 26 25 24 23 22 21 20
peso +128 +64 +32 +16 +8 +4 +2 +1
somar +128 +32 +4 +2 +1
resultado 128 + 32 + 4 + 2 + 1 = 167
  • Número com sinal (Sinal-Magnitude ou Magnitude e Sinal)
Neste caso os números inteiros negativos são representados com 1 no msb, e o positivos com 0 no msb.
Usando bits é possível representar números inteiros no intervalo de . Nesta representação existem dois zeros, o +0 e o -0.
Por exemplo usando 8 bits =>
bit 7 6 5 4 3 2 1 0
peso 26 25 24 23 22 21 20
peso +64 +32 +16 +8 +4 +2 +1
valor 1 0 1 0 0 1 1 1
somar - +32 +4 +2 +1
resultado - ( 32 + 4 + 2 + 1) = - 39
valor 0 0 1 0 0 1 1 1
somar + +32 +4 +2 +1
resultado + ( 32 + 4 + 2 + 1) = +39
  • Número com sinal (Complemento de 2 ou SIGNED)
Neste caso o msb corresponde ao peso negativo, de modo que ao colocar 1 no msb o número inteiro passa a ser negativo, e se o msb for 0, o número será positivo.
Usando bits é possível representar números inteiros no intervalo de . Nesta representação existem apenas um zero.
Por exemplo usando 8 bits =>
Neste caso note que quando todos os bits são 1, o número representado será o -1,
bit 7 6 5 4 3 2 1 0
peso 27
26 25 24 23 22 21 20
peso -128 +64 +32 +16 +8 +4 +2 +1
valor 1 0 1 0 0 1 1 1
somar -128 +32 +4 +2 +1
resultado - 128 + 32 + 4 + 2 + 1 = -128 + 39 = -89
valor 0 0 1 0 0 1 1 1
somar +32 +4 +2 +1
resultado 32 + 4 + 2 + 1 = +39
valor 1 1 1 1 1 1 1 1
somar -128 +64 +32 +16 +8 +4 +2 +1
resultado -128 + 64 + 32 +16 + 8 + 4 + 2 + 1 = -128 + 127 = -1


Comparação das representações

O quadro abaixo mostra as representações em binário dos valores de +15 a -8 no sistema sem sinal (UNSIGNED), com signal-magnitude , com sinal em complemento de um , com sinal em complemento de dois (SIGNED). No quadro é importante notar que sempre os números negativos tem o msb = 1. Adicionalmente alguns sistemas possuem dois zeros (+0 e -0). No tipo SIGNED note que o valor máximo positivo será menor que o valor absoluto do mínimo negativo, por uma unidade.

Representação binária
Decimal Sem sinal Sinal-magnitude Complemento de um Complemento de dois
+15 1111
+14 1110
+13 1101
+12 1100
+11 1011
+10 1010
+9 1001
+8 1000
+7 0111 0111 0111 0111
+6 0110 0110 0110 0110
+5 0101 0101 0101 0101
+4 0100 0100 0100 0100
+3 0011 0011 0011 0011
+2 0010 0010 0010 0010
+1 0001 0001 0001 0001
+0 0000 0000
0 0000 0000
−0 1000 1111
−1 1001 1110 1111
−2 1010 1101 1110
−3 1011 1100 1101
−4 1100 1011 1100
−5 1101 1010 1011
−6 1110 1001 1010
−7 1111 1000 1001
−8 1000
  • Para obter o número negativo em complemento de um deve-se complementar (inverter) todos os bits do número binário positivo.
  • Para obter o número negativo em complemento de dois deve-se: a) obter o complemento de um (complementar (inverter) todos os bits do número binário positivo ); b) somar 1 ao resultado.
  • Para obter o número negativo em sinal-magnitude é necessário apenas adicionar um bit 1 a esquerda do msb.
  • Note que em todos os casos a representação de números com sinal, sempre implica na necessidade de um bit a mais.
 13 (decimal) =  1101 (binário sem sinal)
+13 (decimal) = 01101 (binário em sinal-magnitude)
-13 (decimal) = 11101 (binário em sinal-magnitude)
+13 (decimal) = 01101 (binário em complemento de um)
-13 (decimal) = 10010 (binário em complemento de um)
+13 (decimal) = 01101 (binário em complemento de dois)
-13 (decimal) = 10011 =  10010 + 1  (binário em complemento de dois)
PARA O PRÓXIMO ENCONTRO


Encontro 4 (27 fev)
Código ASCII

O código ASCII (American Standard Code for Information Interchange), é um padrão de codificação de caracteres para comunicação digital. Ele tem apenas 128 pontos de código, sendo 95 são caracteres imprimíveis e os demais são não imprimíveis (em azul no quadro abaixo), sendo usados para diversos controles de equipamentos eletrônicos. Atualmente esse código está sendo substituido pelos códigos UNICODE, que tem milhões de pontos de código, mas nos UNICODE os primeiros 128 são iguais ao conjunto ASCII.

Código ...0000 ...0001 ...0010 ...0011 ...0100 ...0101 ...0110 ...0111 ...1000 ...1001 ...1010 ...1011 ...1100 ...1101 ...1110 ...1111
…0 …1 …2 …3 …4 …5 …6 …7 …8 …9 …A …B …C …D …E …F
000... 0… NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
001... 1… DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
010... 2… SP ! " # $ % & ' ( ) * + , - . /
011... 3… 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
100... 4… @ A B C D E F G H I J K L M N O
101... 5… P Q R S T U V W X Y Z [ \ ] ^ _
110... 6… ` a b c d e f g h i j k l m n o
111... 7… p q r s t u v w x y z { } ~ DEL

Exemplo de leitura do quadro acima:

  • A letra "A" é representado pelo número hexadecimal 41, o que corresponde a 01000001 em binário
  • A letra "a" é representado pelo número hexadecimal 61, o que corresponde a 01100001 em binário
  • O espaço "SP" é representado pelo número hexadecimal 20, o que corresponde a 00100000 em binário

Descubra o que está escrito neste código binário onde cada 8 bits correspondem a um simbolo ASCII:

01000010 01101111 01101101 00100000 01100100 01101001 01100001 00100000 01110000 01100101 01110011 01110011 01101111 01000001 01001100 01001100
Código UNICODE

O Unicode é capaz de representar uma ampla variedade de caracteres, incluindo caracteres alfabéticos, numéricos, símbolos, caracteres especiais e até mesmo caracteres em idiomas e sistemas de escrita complexos, como chinês, árabe, hindi, hebraico, japonês, emojis entre outros. O Unicode possui um espaço de codificação grande o suficiente para suportar milhares de caracteres diferentes. O Unicode é implementado nos esquemas de codificação UTF-8, UTF-16 e UTF-32. O mais utilizado na web é o UTF-8, por ser eficiente em uso de número de bits e ser compatível com o ASCII. Hoje em dia o UTF-8 é usado em 98% de todos os websites conhecidos [1]. Para cobrir uma vasta gama de caracteres, o Unicode os organiza em blocos. Exemplos de blocos: "Latin basic","Greek and Coptic", "Chess Symbols", "Emoticons", "Mayan Numerals", etc.

  • Outros códigos binários:
  • Gray - É um código em que dois valores consecutivos diferem em apenas um bit. Isso é útil para minimizar erros de leitura em sistemas eletrônicos, já que a transição entre estados ocorre com uma única mudança de bit, facilitando a detecção de erros.
Note por exemplo:
  • Em código binário convencional o número adjacente a 0111 (7) é o 1000 (8), mudança em 4 bits.
  • Em código Gray o número adjacente a 0100 (7) é o 1100 (8), mudança de apenas 1 bit.
  • One-hot - Neste código cada valor é representado por uma única posição ativa (ALTO) dentro do conjunto de bits, enquanto todas as outras posições estão inativas (BAIXO). Esse código é frequentemente usado em sistemas digitais para representar estados discretos, como em máquinas de estados finitos, e também na geração de sinais de seleção de múltiplos circuitos tais como memórias. A vantagem principal reside na simplicidade da detecção de um único estado ativo, evitando ambiguidades e permitindo uma implementação eficiente em hardware.
  • Johnson - Neste código é gerado deslocando-se sucessivamente todos os bits para a esquerda e colocando o bit complementar do msb como lsb. A codificação normalmente começa com todos bits "0". Devido a sua simplicidade, ele é utilizado para contadores utilizados em controle de sistemas digitais simples de alta velocidade. Por sempre ter apenas 1 bit de diferença entre números adjacentes, ele fornece boa proteção contra erros, mas necessita de mais bits para representar a mesma faixa de valores que um binário sequencial.
  • BCD (Binary-coded decimal) - Esse código basicamente consiste em representar cada digito decimal de 0 a 9 por um grupo de 4 bits (0 -> 0000, 1 -> 0001, ... 8 -> 1000 e 9 -> 1001). Ele é utilizado em mostradores de sete segmentos, onde cada um deles indica um dígito.
Decimal Hexadecimal Octal Binário
convencional
Binário
Gray
Binário
One Hot
Binário
Johnson
BCD
00 0 00 0000 0000 0000.0000.0000.0001 00000000 0000.0000
01 1 01 0001 0001 0000.0000.0000.0010 10000000 0000.0001
02 2 02 0010 0011 0000.0000.0000.0100 11000000 0000.0010
03 3 03 0011 0010 0000.0000.0000.1000 11100000 0000.0011
04 4 04 0100 0110 0000.0000.0001.0000 11110000 0000.0100
05 5 05 0101 0111 0000.0000.0010.0000 11111000 0000.0101
06 6 06 0110 0101 0000.0000.0100.0000 11111100 0000.0110
07 7 07 0111 0100 0000.0000.1000.0000 11111110 0000.0111
08 8 10 1000 1100 0000.0001.0000.0000 11111111 0000.1000
09 9 11 1001 1101 0000.0010.0000.0000 01111111 0000.1001
10 A 12 1010 1111 0000.0100.0000.0000 00111111 0001.0000
11 B 13 1011 1110 0000.1000.0000.0000 00011111 0001.0001
12 C 14 1100 1010 0001.0000.0000.0000 00001111 0001.0010
13 D 15 1101 1011 0010.0000.0000.0000 00000111 0001.0011
14 E 16 1110 1001 0100.0000.0000.0000 00000011 0001.0100
15 F 17 1111 1000 1000.0000.0000.0000 00000001 0001.0101
Extensão de bits de um número inteiro sem sinal
  • Para estender um número de M bits para N bits, basta adicionar (N-M) zeros à esquerda, de modo a ter N bits no total.
Exemplo: Estender o número binário sem sinal de 5 bits "01101" para 8 bits:
Número original: 01101      = (13 em decimal), pois 8 + 4 + 1 = 13
Número estendido: 00001101  = (13 em decimal), pois 8 + 4 + 1 = 13
Extensão de bits de um número inteiro com sinal em complemento de 2
  • Para estender um número de M bits para N bits em complemento de 2, o msb (o bit mais significativo) deve ser estendido (copiado) (N-M) vezes para os novos bits à esquerda, de modo a ter N bits no total.
Exemplo: Estender o número binário com sinal em complemento de 2 de 5 bits "10011" para 8 bits:
Número original: 10011      = (-13 em decimal), pois -16 + 2 + 1 = -13
Número estendido: 11110011  = (-13 em decimal), pois -128 + 64 + 32 + 16 + 2 + 1 = -13
Note que para números positivos o resultado é similar a estender o número inteiro sem sinal.
Extensão de bits de um número inteiro com sinal em sinal-magnitude
  • Para estender um número de M bits para N bits do tipo sinal-magnitude, o msb (o bit mais significativo) deve ser movido para o novo msb, e os demais novos bits devem ser zerados.
Exemplo: Estender o número binário com sinal em sinal-magnitude de 5 bits "10011" para 8 bits:
Número original: 11101      = (-13 em decimal), pois -(+8 + 4 + 1) = -13
Número estendido: 10001101  = (-13 em decimal), pois -(+8 + 4 + 1) = -13

Números binário fracionários em Ponto Fixo
  • A representaçaõ de Ponto Fixo é um número binário que permite representares números fracionários. Os valores são todos escalonados por um fator constante para transformar em um número inteiro. Assim, o número 5,25 pode ser escalonado por 2² => 5,25 x 4 = 21, e portanto 5,25 = 21 / 2². Assim, usando dois bits fracionarios, o número 5,25 pode ser escrito em binário como 10101, onde o separador fracionário esta em 101,01.
  • Usando bits para representar um número de ponto fixo Q(M,F) com F bits fracionários, é possível representar números fracionários no intervalo de . Neste caso a resolução (menor quantidade que se pode representar) é de
Por exemplo usando Q(8,3) => , e a resolução é de .
bit 4 3 2 1 0 -1 -2 -3
valor 1 0 1 0 0 1 1 1
peso 24 23 22 21 20 2-1 2-2 2-3
peso +16 +8 +4 +2 +1 +0,5 +0,25 +0,125
somar +16 +4 +0,5 +0,25 +0,125
resultado 16 + 4 + 0,5 + 0,25 + 0,125 = 20,875
  • Note que que é possível obter rapidamente o valor de um número de ponto fixo, obtendo o valor do seu número inteiro correspondente, dividindo-o por 2-F. No exemplo acima, 10100111, corresponde ao inteiro 167, ou seja se o número é do tipo Q(8,3), o valor é de 167/2-F = 20,875.
  • Assim como nos números inteiros, é possível representar também números em ponto fixo negativos usando complemento de 2 ou sinal-magnitude.
PARA O PRÓXIMO ENCONTRO
Encontro 5 (29 fev)
Ponto Flutuante (floating point)
Os números de ponto flutuante são agrupados da esquerda para a direita:1) bit de sinal, 2) expoente e 3) mantissa. Para os formatos binários IEEE 754 (básico e estendido) que possuem implementações de hardware existentes, eles são distribuídos da seguinte forma:
Tipo Sinal Exponente Mantissa Total
bits
  Viés do
exponente
Precisão
em bits
Half-precision 1 5 10 16   15 11
Single-precision 1 8 23 32   127 24
Double-precision 1 11 52 64   1023 53

Embora o expoente possa ser positivo ou negativo, em formatos binários ele é armazenado como um número sem sinal que possui um "viés" fixo adicionado a ele. A faixa de expoente para números normais é [−126, 127] para precisão simples, [−1022, 1023] para dupla. Existem três tipos principais de números: normalizados, denormalizados (ou desnormalizados) e especiais (como infinito e NaN - "Not a Number").

Nos formatos IEEE, o bit 1 inicial de um significando normalizado não é realmente armazenado. É chamado de bit "oculto" ou "implícito". Por causa disso, o formato de precisão simples na verdade tem um significando com 24 bits de precisão, o formato de precisão dupla tem 53.

O layout para o ponto flutuante de 32 bits e de 64 bits são mostrados abaixo:

PontoFlutuante32.png
PontoFlutuante64.png
Como converter de decimal para floating point?
  1. Identifique quantos bits serão usados e obtenha o viés (veja na tabela acima)
  2. Converta o número decimal para binário ponto fixo:
  3. Normalize a mantissa, movendo o ponto decimal para que haja apenas um um dígito à esquerda do ponto decimal.
  4. Determine o sinal, o expoente e a mantissa: 1) O número é positivo, então o bit de sinal é 0. 2) O expoente é o deslocamento necessário para normalizar a mantissa. 3) A mantissa é a parte fracionária normalizada.
  5. Converta o expoente para binário com bias: Adicionamos o viés ao expoente para obter o valor final.
  6. Junte os bits na ordem: sinal, expoente e mantissa, e obtenha o número em IEEE 754 Floating Point
Exemplo: Dado o número 85,125 converta para a representação floating point de 32 bits 
P1: 32 bits, portanto o viés é 127.
P2: 85 em binário é 1010101. 0.125 em binário é 0.001. Portanto, 85,125 em binário é 1010101.001
P3: 1010101.001 => 1.010101001 × 2^6
P4: O número é positivo, então o bit de sinal é 0. O expoente é o deslocamento necessário para normalizar a mantissa. No caso, 6. A mantissa é a parte fracionária normalizada, que é 010101001.(note que o 1 a esquerda do ponto decimal não será representado.
P5: Expoente = 6 + 127 = 133 em binário é 10000101.
P6: Sinal: 0, Expoente: 10000101, Mantissa: 01010100100000000000000 (completar com zeros até 23 bits), portanto 0 10000101 01010100100000000000000
FONTE: How to Convert a Number from Decimal to IEEE 754 Floating Point Representation
Como converter de floating point para decimal?
  1. Identifique o número de bits e obtenha o número de bits do expoente e o viés (veja na tabela acima),
  2. Obtenha o sinal do número a partir do msb (S = 0 => +; S = 1 => -)
  3. Obtenha o número correspondente ao Expoente (E).
  4. Considerando o viés, calcule o expoente (e = E - viés)
  5. Obtenha o valor da mantissa (M) e
  6. Obtenha o valor decimal correspondente, acrescentando o 1 inteiro (se o numero estiver normalizado) antes da conversão
  7. O resultado em decimal é
Exemplo: Dado o número representado em floating point de 32 bits = 11000000111000000000000000000000 
P1: Expoente tem 8 bits => viés = 127 (28-1-1)
P2: Sinal (msb): 1 => é um número negativo (-)
P3: Expoente (8 bits): 10000001 = 129
P4: expoente (e = E - vies) 129 - 127 = 2
P5: Mantissa: (23 bits): 11000000000000000000000
P6: Valor (24 bits):1.11000000000000000000000 = 1,75
P7: Resultado: (-) 1,75 x 22 = -7
Números sub_normais

Os números sub_normais são indicados pelo Expoente = 00000000. Esse Expoente será interpretado como 2-126. Eles, ao contrário dos números normalizados, não usam um "1" implícito no início da mantissa. Isso significa que a mantissa desses números começa com um "0" explícito antes da parte fracionária, permitindo representar valores muito pequenos que não podem ser normalizados devido à limitação dos bits do expoente.

Exemplos:
0 00000000 00000000000000000000000  corresponde ao número +0
1 00000000 00000000000000000000000  corresponde ao número -0
0 00000000 10000000000000000000000  corresponde ao número 0,5 x 2-126 = 5.877472E-39
1 00000000 00000000000000000000001  corresponde ao número -2-23 x 2-126  = -0.00000011920928955078125 x 2-126 = -1.40129846432481707092373E-45 (2-149
Números especiais
  • Infinito Positivo (Inf): Bit de sinal: 0 (positivo) Expoente: Todos os bits definidos como 1 (8 bits)
Mantissa: Todos os bits definidos como 0 (23 bits)
Representação em 32 bits: 0 11111111 00000000000000000000000
  • Infinito Negativo (-Inf): Bit de sinal: 1 (negativo) Expoente: Todos os bits definidos como 1 (8 bits)
Mantissa: Todos os bits definidos como 0 (23 bits)
Representação em 32 bits: 1 11111111 00000000000000000000000
  • NaN (Not a Number): Bit de sinal: Pode ser 0 ou 1 (geralmente usado para sinalizar erros ou operações indefinidas) Expoente: Todos os bits definidos como 1 (8 bits)
Mantissa: Pelo menos um bit não nulo (23 bits)
Representação: x 11111111 yyyyyyyyyyyyyyyyyyyyyyy (onde "x" é o bit de sinal e "y" são bits da mantissa)
Exemplos de conversores online

Unidade 3 - Funções, portas lógicas e álgebra booleana

  • 10 ENCONTROS
Unidade 3 - Funções, portas lógicas e álgebra booleana
Encontro 6 (5 mar.)
Funções e portas lógicas
PARA O PRÓXIMO ENCONTRO
Encontro 7 (7 mar.)
Funções e portas lógicas
PARA O PRÓXIMO ENCONTRO


Encontro 8 (12 mar.)
PARA O PRÓXIMO ENCONTRO
Encontro 9 (14 mar.)
Teoremas de De Morgan
  • O complemento do produto é igual a soma dos complementos:
  • O complemento da soma é igual ao produto dos complementos:

Para provar os teoremas, podemos obter a tabela verdade de ambos lados de cada equação booleana.

Entradas Saídas
X Y
0 0 1 1
0 1 1 1
1 0 1 1
1 1 0 0
Entradas Saídas
X Y
0 0 1 1
0 1 0 0
1 0 0 0
1 1 0 0

Ou utilizar os postulados e teoremas da algebra de boole. Considerando que seja verdade, então

PASSO 1: pelo postulado do complemento , podemos afirmar que
PASSO 2: pelo teorema da distribuição , podemos afirmar que
PASSO 3: pelo teorema da comutação , podemos afirmar que
PASSO 4: pelo postulado do complemento , podemos afirmar que
PASSO 5: pelo postulado do elemento absorvente , podemos afirmar que
PASSO 6: pelo postulado da multiplicação (AND) , podemos afirmar que
Portanto a consideração inicial é verdadeira .
Nota: O teorema também pode ser provado usando o postulado do complemento , pois neste caso, podemos afirmar que
.
Tente desenvolver o restante da prova usando apenas os postulados e teoremas.

Os teoremas de De Morgam são validos para qualquer número (N) de entradas, podem ser escritos como:

Exercícios

Simplifique as expressões lógicas (caso seja possível). Indique os Postulados ou Teoremas utilizado em cada passo. Para simplificar as notações os códigos A1 a A5 e T1 a T12 ou T1' a T12' indicado na Folha de consulta - álgebra booleana.

a) ABC + A + BC
b) A.B + A.B’ + A’.B
c) X.Y + X.Y’ + X’.Y + X.Y
d) X.Y + X.Z + Z.Y
e) D.B’+D.(D.B+C.D’)

Ver também exemplos em 4-4 ANÁLISE BOOLEANA DE CIRCUITOS LÓGICOS [FLOYD, Thomas. Sistemas digitais. Grupo A, 2011. E-book. ISBN 9788577801077

PARA O PRÓXIMO ENCONTRO
Encontro 10 (21 mar.)
Encontro 11 (26 mar.)
Encontro 12 (28 mar.)
Encontro 13 (2 abr.)
Encontro 14 (4 abr.)


Encontro 15 (9 abr.) - Projeto de circuitos combinacionais
Encontro 16 (11 abr.)
  • Exercícios 2.1, 2.2, 2.5-7, 2.13-18, 2.22-25, 2.28-29, 2.31-32, 2.34, 2.35, 2.36-37, 2.39-40 ver [4]
  • Pergunta 2.2, 2.3, 2.4 ver [5]
Encontro 18 (23 abr.) - Avaliação A1c (6 pontos)
  • Simplificação de expressões lógicas e mapa de Karnaugh
  • Representação de circuitos lógicos - Diagrama de portas lógicos = Tabela Verdade = Expressão lógica

Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim

  • 6 ENCONTROS
Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim


Encontro 17 (18 abr.) - Linguagem VHDL
Encontro 19 (25 abr.) - Linguagem VHDL
  • Estrutura do código VHDL
  • Declaração das bibliotecas e pacotes LIBRARY / PACKAGE
 library library_name;
 use library_name.package_name.all;
  • ENTITY
 entity entity_name is
   [generic (
     cons_name1: const_type const_value;
     cons_name2: const_type const_value;
     ...
     cons_nameN: const_type const_value);]
   [port (
     signal_name1: mode signal_type;
     signal_name2: mode signal_type;
     ...
     signal_nameN: mode signal_type);]
   [declarative_part]
 [begin
   statement_part]
 end [entity] [entity_name];
  • ARCHITECTURE
 architecture arch_name of entity_name is
   [declarative_part]
 begin
   statement_part
 end [architecture] [arch_name];
  • Exemplo - Declaração de uma porta NAND em VHDL
library std;
use std.standard.all;

entity nand_gate is
	port (a, b: in bit; x: out bit);
end entity;

architecture nome_arch of nand_gate is
begin
	x <= a nand b;
end architecture;
  • Uso do ambiente EDA - QUARTUS Prime para programação em VHDL.
PASSO 0

Acesse a nuvem do IFSC usando um terminal via ssh:

USER=LOGIN_SIGAA
ssh $USER@quartus.sj.ifsc.edu.br -XC  

Insira a senha do SIGAA

LOGIN_SIGAA@quartus.sj.ifsc.edu.br's password:
PASSO 1

Abra o Quartus Prime digitando no terminal

quartus20.1.sh

Em seguida abra um arquivo para inserir o código VHDL. No menu superior selecione [File > New > Design Files: VHDL File] e [OK]

PASSO 2
  • Copie o código VHDL acima para o espaço de edição e salve o arquivo com o nome da entity: nand_gate.vhd, em um pasta exclusiva para este projeto.
  • Ao ser perguntado se deseja criar um novo projeto, responda [Yes]. Os próximos passos podem ser realizados da seguinte forma:
  • Na tela Introduction [Next >]
  • Na tela Directory, Name, Top-Level Entity
  • Note onde o projeto será salvo.
 /home/USER/PASTA_DO_PROJETO/
  • Note o nome do projeto. Se quiser pode mudá-lo
nand_gate
  • Note o nome da top-level design entity
nand_gate
  • Em seguida [Next >]
  • Na tela Project Type [Next >]
  • Na tela Add Files [Next >], pois seu arquivo já está na lista dos arquivos.
  • Na tela Family, Device & Board Settings, escolha a Family = [Cyclone IV E] e o Device = [EP4CE6E22A7] e [Next >]
  • Na tela EDA Tool Setting [Next >]
  • Note na tela Summary os dados do projeto e clique [Finish]
PASSO 3

Realize a Analysis & Synthesis [Processing > Start > Start Analysis & Synthesis], ou use um dos botões que o professor mostrou em aula.

  • Note o Compilation Report
PASSO 4
  • Use o RTL Viewer para ver a descrição RTL do circuito. Selecione [Tools > Netlist Vieweres > RTL Viewer].
  • Use o Technology Map Viewer para ver a como o circuito foi mapeado para os elementos lógicos disponíveis no dispositivo FPGA selecionado. Selecione [Tools > Netlist Vieweres > Technology Map Viewer].
PASSO 5
  • Modifique a descrição do circuito para implementar o circuito da função Y = (A.B)' + C.D'B', salve o projeto Ckt2.vhd e de o mesmo nome para a entity.
PARA O PRÓXIMO ENCONTRO
  • Use como modelo:
-- A bibliteca std e o pacote standard são autodeclarados, então as linhas abaixo podem ser comentadas com "--"
--library std;
--use std.standard.all;

entity BCD2SSD is
	port (
	-- Entradas ABCD do circuito
	A, B, C, D: in bit; 
	-- Saidas para os leds do mostrador de 7 segmentos. Note que o nome a, b, .. g foi mudado para ssd_a, ssd_b, ... ssd_g pois o VHDL é insensível a caixa                            
	ssd_a, ssd_b, ssd_c, ssd_d, ssd_e, ssd_f, ssd_g : out bit
	);
end entity;

architecture ifsc_v1 of BCD2SSD is
begin
	-- descreva a expressão lógica obtida para cada uma das saídas;
	-- Por exemplo: se for a = A + C + (B'.D') + (B.D)
	ssd_a <= A or C or (not B and not D) or (B and D);

	ssd_g <=    ;              
end architecture;
Encontro 20 (30 abr.) AE2 - Conhecendo os dispositivos lógicos programáveis

ATUAL

Encontro 21 (2 mai.) AE2 - Conhecendo os dispositivos lógicos programáveis
  • (Continuação)
Encontro 22 (7 mai.) AE3

Preparando para gravar o circuito lógico no FPGA

Unidade 5 - Circuitos lógicos combinacionais (com VHDL)

  • 12 ENCONTROS
Unidade 5 - Circuitos lógicos combinacionais (com VHDL)

Unidade 6 - Circuitos aritméticos (com VHDL)

  • 5 ENCONTROS
Unidade 6 - Circuitos aritméticos (com VHDL)

Avaliações

Durante o semestre serão realizadas 4 avaliações. As avaliações devem ser enviadas pela plataforma Moodle com os arquivos solicitados.

Data das avaliações
  • A1 - : 05/03 - 1ª parte A1a (3 pontos) (Sistema de Numeração e códigos);
  • A2 - :
  • R - Recuperação de A1 a A2 :

Atividade relâmpago (AR)

As atividades relâmpago devem ser entregues no Moodle da disciplina. A não entrega dessas atividades não gera nenhum desconto, apenas geram pontos de BÔNUS que são adicionados aos conceitos das avaliações A1 a AN.

Atividade extra-classe (AE)

A média ponderada das atividades extra-classe será considerada no cálculo do conceito final da UC. A entrega das mesmas será feita pelo Moodle, e cada dia de atraso irá descontar 0,2 na nota da atividade. Muitas dessas atividades também geram pontos de BÔNUS que são adicionados aos conceitos das avaliações A1 a AN. Para os BÔNUS só serão considerados projetos entregues no prazo.


Objetivos Projetar um circuito digital que realize a conversão de uma entrada BCD para um saída de um mostrador de 7 segmentos. Descrever através de uma tabela verdade o funcionamento de um circuito. Usar a técnica do mapa de Karnaugh para minimizar a função lógica de cada saída.

AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos

AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos
Objetivos
  • Conhecer o mostrador (diplay) de 7 segmento
  • Projetar um circuito digital que realize a conversão de uma entrada binária de 4 bits para uma saída de um mostrador de 7 segmentos.
  • Descrever o funcionamento de um circuito através de uma tabela verdade.
  • Usar a técnica do mapa de Karnaugh para minimizar a função lógica de cada uma das saídas.
Atividades
  • Veja como funciona o Display de 7 segmentos.
  • Nesta atividade os estudantes devem projetar um conversor de binário para mostrador de 7 segmentos. Considere que na entrada são possíveis apenas os valores 0, 1, 2, ... 8, 9.
  • Apesar de uma entrada binária de 4 bits poder receber os valores 1010 (dez), 1011 (onze), ... 1111 (quinze), pode considerar que elas não acontecem por restrição dos dados de entrada. Por isso, cada estudante tem a liberdade de definir como o mostrador se comportará nesta situação.
Entregas
  • O projeto todo deverá se realizado manuscrito, devendo as folhas ter a identificação do nome completo do estudante e estar grampeadas. *Deverão ser apresentados no mínimo:
1) A tabela verdade completa indicando para as entradas de 0 a 9 quais são os valores das saídas (segmentos) a, b, c, d, e, f, g.
2) Para cada saída mostre o mapa de Karnough e a indicação dos agrupamentos de bits obtidos, e o respectiva produto (implicante).
3) Para cada saída deve ser apresentada a expressão lógica minimizada e também o circuito lógico obtido.
  • A entrega será feita pessoalmente para o professor no prazo indicado no Moodle.

AE2 - Conhecendo os dispositivos lógicos programáveis

AE2 - Conhecendo os dispositivos lógicos programáveis
Objetivos
  • Conhecer o Quartus Prime e as características dos dispositivos lógicos programáveis
  • Analisar os tempos de propagação em um circuito combinacional
  • Alterar configurações do compilador
  • Fazer a simulação funcional de um circuito combinacional.
Atividades
  • Ao escolher a família de FPGAS, escolha inicialmente um dispositivo da família Max II. Anote o código desse dispositivo.
  • Capture as telas solicitadas e depois utilize-as no relatório da atividade.
  • Anote o tempo utilizado para cada uma das etapas do processo de compilação.
  • Anote o número de elementos lógicos utilizados e o número de pinos utilizados, bem com o percentual em relação ao número total do dispositivo.
  • Anote algum erro (Error) ou alertas (Warnings) que o Quartus II indicar no painel de mensagens [Messages]
  • Ao final salve o projeto em um arquivo QAR (sugestão PJ1.QAR)
  • Observe as mudanças que ocorrem tanto no tipo de Elemento Lógico disponível, no Chip Planner, no Pin Planner, e no circuito dos pinos de I/O. Note que estes FPGAs também apresenta novos componentes, tais como: Memória, Multiplicadores, DSP, PLL, DLL, etc. Verifique se consegue encontra-los no leiaute mostrado no Chip Planner, e documente aqueles que encontrar.
  • Compare os resultados obtidos nos procedimentos do PASSO 1 e PASSO 2.
  • Ao escolher a família de FPGAS, escolha um dispositivo FPGA da família Cyclone IV E. Anote o código desse dispositivo.
  • Se você está com o código da AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos escrito, use este código no lugar do código do cálculo da distância de Hamming
  • Capture as telas mostradas no roteiro e depois utilize-as no relatório da atividade.
  • Anote o máximo tempo de propagação entre entrada e saída.
  • Anote o número de elementos lógicos utilizados e o número de pinos utilizados, bem com o percentual em relação ao número total do dispositivo.
  • Experimente modificar as configurações do compilador, conforme mostrado em Configurando o compilador. Se desejar mude a semente inicial trocando o valor de [Seed: 1]
  • Experimente inserir diferentes restrições de atraso máximo para o compilador, e analise o resultado obtido.
  • Anote algum erro (Error) ou alertas (Warnings) que o Quartus II indicar no painel de mensagens [Messages]
  • Ao final salve o projeto em um arquivo QAR (sugestão PJ2.QAR)
  • PASSO 4: Realize a simulação funcional de um dos projetos CI74161 ou do cálculo da distância de Hamming ou conversor de binário para mostrador de 7 segmentos
  • Capture as telas que mostram o circuito funcionando e depois utilize-as no relatório da atividade.
Entregas
  1. Envie um arquivo QAR contendo todos os arquivos necessário para compilar cada um dos projetos.
  2. Envie um relatório em PDF, incluindo as imagens capturadas (inclua um título para cada figura) e escreva para cada imagem um texto comentando o que representa. O relatório também deve ter a identificação (autor, título, data) uma breve introdução e uma conclusão. A descrição dos procedimentos feita na página wiki não precisa incluída no relatório.
  3. Use preferencialmente o Overleaf para gerar o relatório. Mas o uso de MS-Word, Libreoffice e Google Docs também é permitida.
  4. A entrega será feita através do Moodle da disciplina. Observe o prazo de entrega.

AE3 - Programação do kit Mercurio IV

AE3 - Programação do kit Mercurio IV
Objetivos
  • Apreender como programar um FPGA usando um kit de desenvolvimento
  • Baseado na AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos, implementar o projeto em VHDL.
  • Descrever um circuito que você projetou em VHDL, implentá-lo e testá-lo.
  • Fazer as adaptações necessárias para que o circuito projetado funcione no kit escolhido
  • Testar o circuito, e anotar os resultados.
Procedimento de laboratório
Passo 1 - Descrevendo o hardware e fazendo a Análise e Síntese
  • Abra o projeto do conversor de binário para mostrador de 7 segmentos (já simulado em aula anterior)
  • Fazer a análise e síntese e corrigir eventuais erros.
-- A bibliteca std e o pacote standard são autodeclarados, então as linhas abaixo podem ser comentadas com "--"
--library std;
--use std.standard.all;

entity BCD2SSD is
	port (
	-- Entradas ABCD do circuito
	eA, eB, eC, eD: in bit; 
	-- Saidas para os leds do mostrador de 7 segmentos. Note que o nome a, b, .. g foi mudado para ssd_a, ssd_b, ... ssd_g pois o VHDL é insensível a caixa                            
	ssd_a, ssd_b, ssd_c, ssd_d, ssd_e, ssd_f, ssd_g : out bit
	);
end entity;

architecture ifsc_v1 of BCD2SSD is
begin
	-- descreva a expressão lógica obtida para cada uma das saídas;
	-- Por exemplo: se for a = A + C + (B'.D') + (B.D)
	ssd_a <= eA or eC or (not eB and not eD) or (eB and eD);

	ssd_g <=    ;              
end architecture;
Passo 2 - Configurando o dispositivo e os pinos a serem utilizados

Veja os detalhes em Preparando para gravar o circuito lógico no FPGA. Após escolher o kit a ser usado no projeto, é necessário informar ao Quartus II a família e o dispositivo (device) que será utilizado

  • para DE2-115 {Assignments > Device... > Device family (Family: [Cyclone IV E], Name filter: [EP4CE115F29C7] ) > [OK]}
  • para MERCÚRIO IV {Assignments > Device... > Device family (Family: [Cyclone IV E], Name filter: [EP4CE30F23C7] ) > [OK]}

Para evitar que saídas de circuitos da placa sejam ligadas ao terra através do FPGA, defina como alta impedância o estado dos pinos não utilizados no projeto.

  • {Assignments > Device... > Device and Pin Options... > Category: Unused Pins > Reserve all unused pins: [As input tri-stated] > [OK] > [OK]}

Atribua os pinos conforme a necessidade do projeto.

  • Uso do Pin Planner {Assignments > Pin Planner} no modo tabela. Digite o número do pino na coluna {Location}. Apenas posições válidas são aceitas.
Signal Name FPGA Pin No. Description I/O Standard
SW[0] PIN_Y22 Chave tipo Slide Switch 0 3.3V
SW[1] PIN_W21 Chave tipo Slide Switch 1 3.3V
SW[2] PIN_W22 Chave tipo Slide Switch 2 3.3V
SW[3] PIN_V21 Chave tipo Slide Switch 3 3.3V
  • Configurar como entrada os seguintes pinos:
eA	V21
eB	W22
eC	W21
eD	Y22
  • Observe a tabela com a pinagem dos display (mostrador de sete segmentos) disponíveis neste kit.
Signal Name FPGA Pin No. Description I/O Standard
DISP0_D[0] PIN_V2 Segmento A - Display 0 3.3V
DISP0_D[1] PIN_V1 Segmento B - Display 0 3.3V
DISP0_D[2] PIN_U2 Segmento C - Display 0 3.3V
DISP0_D[3] PIN_U1 Segmento D - Display 0 3.3V
DISP0_D[4] PIN_Y2 Segmento E - Display 0 3.3V
DISP0_D[5] PIN_Y1 Segmento F - Display 0 3.3V
DISP0_D[6] PIN_W2 Segmento G - Display 0 3.3V
  • Configure como saída do FPGA os seguintes pinos:
ssd_a	V2
ssd_b	V1
ssd_c	U2
ssd_d	U1
ssd_e	Y2
ssd_f	Y1
ssd_g	W2
  • A final do processo, o Pin Planner {Assignments > Pin Planner} deverá mostrar a correta pinagem conforme exemplificado na figura abaixo:
PinagemSSDM4.png

Uma vez completada a configuração e pinagem, execute o Fitter (Place & Route). Após a compilação a mensagem de warning "Critical Warning (XXXXX): No exact pin location assignment(s) for XX pins of XX total pins" não deverá mais ser mostrada. Caso seja mostrada verifique qual o pino que não foi configurado corretamente e corrija.

Passo 3 - Programando o FPGA

Veja o procedimento de como deve ser feita a programação do FPGA em Programando o FPGA através da USB-Blaster

Passo 4 - Testes de validação
  • Realizar os seguintes testes, acionando as chaves A, B, C e D e observando o resultado no mstrador de sete segmentos:
  1. Carregar nas chaves os valores binários de 0 ("0000") a 9 ("1001") e observar se o valor mostrado é o desejado.
  2. Carregar nas chaves os valores binários de 10 ("1010") a 15 ("1111") e observar se o que é mostrado.
  3. Anote todos os resultados
Display7Seg.png
Digito ABCD ssd_a ssd_b ssd_c ssd_d ssd_e ssd_f ssd_g Mostrador
0 0000 ON ON ON ON ON ON OFF Ssd0.png
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
A 1010
B 1011
C 1100
D 1101
E 1110
F 1111


Relatório Técnico
  • Documentar o experimento em um relatório técnico que contenha no mínimo:
  • Identificação (título, disciplina, data, autores);
  • Introdução;
  • Descrição do procedimento realizado;
  • Resultados obtidos (com imagens dos itens importantes) e análise dos resultados;
  • Conclusão.
  • Apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito no Passo 4
  • O relatório deve também responder as questões levantadas e mostrar que os objetivos apresentados na introdução foram atendidos.

Referências Bibliográficas:


Curso de Engenharia de Telecomunicações