ELD129002-Engtelecom (Diário) - Prof. Marcos Moecke: mudanças entre as edições
Ir para navegação
Ir para pesquisar
| (411 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 (12 ago.): | |||
;Encontro 1 ( | * A '''[[ELD1-EngTelecom (Página) | 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 [https://telegrafo.sj.ifsc.edu.br/ grafo do curriculo] | |||
* A [[ELD1- | |||
* Relação com as outras UCs do '''Eixo Sistemas Computacionais (Marrom)'''. Ver [https:// | |||
:*'''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. | ||
:*'''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. | :*'''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. | ||
| Linha 14: | Linha 12: | ||
:*'''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 | | * 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 | * 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 | * 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)| | *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:// | *Capítulo 1. Do Zero ao Um, seções 1.1 a 1.3 do livro [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link David Money Harris, B., & Harris Morgan Kaufman, S. L. (2013). Projeto Digital e Arquitetura de Computadores], diponibilizado gratuitamente pela www.imgtec.com. (#page=27) | ||
{{collapse bottom}} | {{collapse bottom}} | ||
===Unidade 2 - Sistema de numeração e códigos=== | ===Unidade 2 - Sistema de numeração e códigos=== | ||
* | * 5 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 ( | <!-- | ||
;Encontro 2 (20 mar.): | |||
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 34: | Linha 33: | ||
*Dependendo do sistema podem existir diferentes tipos e quantidades de símbolos. | *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 | :*É 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 | :*Utiliza 10 símbolos (dígitos). 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9 | ||
| Linha 48: | Linha 47: | ||
:Dividir: <big> 35/7 = (5+ 5 + 5 + 5 + 5 + 5 +5)/7 = (5*7)/7 = 5; </big> | :Dividir: <big> 35/7 = (5+ 5 + 5 + 5 + 5 + 5 +5)/7 = (5*7)/7 = 5; </big> | ||
:Representar frações: <big> 12/10 = 1,2; 3/4 = 0,75 </big> | :Representar frações: <big> 12/10 = 1,2; 3/4 = 0,75 </big> | ||
:Comparar valores: <big> 145 > 14,5; 230 = 2, | :Comparar valores: <big> 145 > 14,5; 230 = 2,3x10² </big> | ||
*Outros sistemas: | *Outros sistemas: | ||
| Linha 54: | Linha 53: | ||
:*Este sistema é chamado de sistema binário, pois utiliza apenas dois dígitos (0 e 1). | :*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 | :*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 ( | :*'''OBS:''' Muitas vezes os números binários são representados através do sistema hexadecimal ou do sistema octal. | ||
{{collapse top | Uso do Sistema Hexadecimal e Octal}} | |||
;Sistema Hexadecimal (Base 16): | |||
*'''Computação e Programação''': Muito usado para representar cores em HTML/CSS (ex: #FF5733), endereços de memória, e depuração de código em linguagens de baixo nível como Assembly e C. | |||
*'''Endereços MAC''': Dispositivos de rede usam endereços MAC, que são representados em hexadecimal (ex: 00:1A:2B:3C:4D:5E). | |||
Codificação e Criptografia: Muitos algoritmos de criptografia usam representações hexadecimais para armazenar e exibir dados de forma compacta. | |||
*'''Representação Binária Compacta''': Como cada dígito hexadecimal representa 4 bits, ele é frequentemente usado para simplificar a leitura de valores binários grandes. | |||
;Sistema Octal (Base 8): | |||
*'''Permissões de Arquivos no Linux/Unix''': O sistema octal é utilizado para definir permissões de arquivos no formato '''chmod'''. No Linux/Unix, cada arquivo tem três tipos principais de permissões: | |||
:*Leitura (r): Permite visualizar o conteúdo do arquivo. | |||
:*Escrita (w): Permite modificar o conteúdo do arquivo. | |||
:*Execução (x): Permite executar o arquivo, se for um programa ou script. | |||
:Essas permissões são atribuídas a três categorias de usuários: | |||
:*Dono (owner): O usuário que possui o arquivo. | |||
:*Grupo (group): O grupo de usuários associado ao arquivo. | |||
:*Outros (others): Todos os outros usuários. | |||
:Assim o comando chmod 755, indica que as permissões seriam: | |||
:*Dono: leitura, escrita, execução (rwx = 7) | |||
:*Grupo: leitura, execução (r-x = 5) | |||
:*Outros: leitura, execução (r-x = 5) | |||
{{collapse bottom}} | |||
;Sistema binário: | |||
:* Utiliza apenas 2 símbolos (dígitos). 0 e 1 | :* 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. | :* É 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 | :*Exemplo 1: o número binário 111<sub>2</sub>, 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<sub>10</sub> </big> | ||
:*Exemplo 2: o número binário 010010101<sub>2</sub>, corresponde a: | |||
:: <big> 1*2<sup>7</sup> + 1*2<sup>4</sup> + 1*2<sup>2</sup> + 1*2<sup>0</sup> = 1*128 + 1*16 + 1*4 + 1*1 = 149<sub>10</sub> </big> | |||
* | :*Exemplo 3: o número decimal 111<sub>10</sub>, corresponde ao número binário 01101111<sub>2</sub>, pois: | ||
* | :: <big> 1*2<sup>6</sup> + 1*2<sup>5</sup> + 1*2<sup>3</sup> + 1*2<sup>2</sup> + 1*2<sup>1</sup> + 1*2<sup>0</sup> = 64 + 32 + 8 + 4 + 2 + 1 = 111<sub>10</sub> </big> | ||
* | |||
*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 122: | ||
*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 171: | ||
|} | |} | ||
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 | ;Conversão de bases entre sistemas numéricos: | ||
*Conversão entre os sistemas de numeração '''decimal - binário - hexadecimal'''. | |||
:*ver os [https://drive.google.com/file/d/1wKvppdsiPophyPfcfUHiIMy8EiaMkgKC/view?usp=drive_link slides - Sistemas de Numeração: Conversão entre bases] | |||
;PARA O PRÓXIMO ENCONTRO: | |||
* Ler capítulo 1. Do Zero ao Um, seção 1.4 do livro [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores], diponibilizado gratuitamente pela www.imgtec.com. (#page=34) | |||
* Rever [https://drive.google.com/file/d/1wKvppdsiPophyPfcfUHiIMy8EiaMkgKC/view?usp=drive_link slides - Sistemas de Numeração: Conversão entre bases] | |||
* 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 | |||
* Curiosidade [[Codificação binária 2 entre 5]]. | |||
;Encontro 3 (25 mar.): | |||
*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'''. | |||
{{collapse top | Passos para a Conversão de Decimal para Binário - divisões sucessivas pela base}} | |||
A conversão de um número decimal (base 10) para binário (base 2) pode ser feita utilizando o método da divisão sucessiva pela base. Esse método é baseado em dividir o número decimal por 2 (a base do sistema binário) e registrar os restos das divisões até o quociente ser igual a zero. O número binário será obtido a partir dos restos dessas divisões, onde o primeiro resto obtido é o bit lsb. Vejamos um exemplo, convertendo o número decimal 13<sub>10</sub> para binário. | |||
Divida o número 13 por 2: | |||
13 ÷ 2 = 6, resto = '''1''' (indica que o número não é divisível por 2, portanto é um número IMPAR) | |||
Divida o quociente 6 por 2: | |||
6 ÷ 2 = 3, resto = '''0''' | |||
Divida o quociente 3 por 2: | |||
3 ÷ 2 = 1, resto = '''1''' | |||
Divida o quociente 1 por 2: | |||
1 ÷ 2 = 0, resto = '''1''' | |||
O quociente agora é 0, então paramos aqui. | |||
Os valores dos restos obtidos, considerando o primeiro resto como lsb (fica a direita), podem ser escrito como: '''1 1 0 1'''. | |||
Portanto, o número 13<sub>10</sub> em decimal é 1101<sub>2</sub> em binário. | |||
{{collapse bottom}} | |||
{{collapse top | Passos para a Conversão de Decimal para Binário - subtrações sucessivas pelos pesos dos bits}} | |||
A conversão de um número decimal (base 10) para binário (base 2) pode ser feita utilizando o método da subtrações sucessivas. Esse método é baseado em subtrair sucessivamente do número decimal os pesos das potências de 2 e registrar como 1 os pesos que foram subtraidos e como zero quando o número obtido é menor que o peso. Como o método, o primeiro bit obtido é o msb. Vejamos um exemplo, convertendo o número decimal 13<sub>10</sub> para binário. | |||
Começando com 13. O maior número que é menor ou igual a 13 e que é uma potência de 2 é 8 (2<sup>3</sup>). Então, subtraímos 8 de 13: | |||
13 - 8 = 5 | |||
: | O bit correspondente a (2<sup>3</sup>) é 1. | ||
: | Agora, com 5. O próximo número que uma potência de 2 é 4 (2<sup>2</sup>). Como 5 ≥ 4 subtraímos 4 de 5: | ||
{| class="wikitable" style="text-align:center;" | 5 - 4 = 1 | ||
|- style="font-weight:bold;" | O bit correspondente a (2<sup>2</sup>) é 1. | ||
!style="width: | |||
!style="width: | Agora, com 1. O próximo número que uma potência de 2 é 2 (2<sup>1</sup>). Como 1 < 2 a subtração não pode ser feita e portanto, o bit correspondente a (2<sup>1</sup>) é 0. | ||
!style="width: | |||
!style="width: | Agora, com 1 novamente. O próximo número que uma potência de 2 é 1 (2<sup>0</sup>). Como 1 ≥ 1 subtraímos 1 de 1: | ||
!style="width: | 1 - 1 = 0 | ||
!style="width: | |||
!style="width: | Resultados da Conversão. Agora, temos os bits correspondentes às potências de 2, da maior para a menor: | ||
!style="width: | |||
!style="width: | Portanto, o número decimal 13<sub>10</sub> é igual ao número binário 1101<sub>2</sub>. | ||
;Resumo do Processo de Subtração Sucessiva: | |||
* Começamos com 13 e subtraímos as maiores potências de 2 possíveis (8, 4, 2, 1). | |||
* A cada subtração, associamos um 1 ou 0 ao bit correspondente à potência de 2. | |||
* O resultado final é o número binário 1101, que é a representação binária de 13. | |||
{{collapse bottom}} | |||
*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;" | | | style="font-weight:bold;" | dígito | ||
| | | d<sub>k</sub> | ||
| | | | ||
| 1 | | d<sub>2</sub> | ||
| 0 | | d<sub>1</sub> | ||
| | | d<sub>0</sub> | ||
| 1 | | | ||
| | | d<sub>-1</sub> | ||
| | | d<sub>-2</sub> | ||
| | |||
| d<sub>-l</sub> | |||
|- | |- | ||
| style="font-weight:bold;" | peso | | 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 | | 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;" | | | style="font-weight:bold;" | valor | ||
| colspan=" | | 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> | ||
|} | |} | ||
*Número | |||
:Neste caso | ;PARA O PRÓXIMO ENCONTRO: | ||
:Usando <math> N </math> bits é possível representar números inteiros no intervalo de <math> [ | * Resolver exercícios (1.4 a 1.8; 1.13 a 1.20; 1.25 a 1.30; 1.37 a 1.40; 1.43 a 1.49), do livro [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores], diponibilizado gratuitamente pela www.imgtec.com. (#page=47 no pdf page=73) | ||
:Por exemplo usando 8 bits => <math> | |||
;Encontro 4 (27 mar.): | |||
;Códigos numéricos binários: | |||
*Número sem sinal ('''UNSIGNED''') | |||
: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>. | |||
:Por exemplo usando 8 bits => <math> [0, 2^{8}-1] = [ 0, 255] = [00000000_2, 11111111_2] </math> | |||
{| class="wikitable" style="text-align:center;" | {| class="wikitable" style="text-align:center;" | ||
|- style="font-weight:bold;" | |- style="font-weight:bold;" | ||
| Linha 231: | Linha 322: | ||
!style="width: 11%;" | 1 | !style="width: 11%;" | 1 | ||
!style="width: 11%;" | 0 | !style="width: 11%;" | 0 | ||
|- | |||
| style="font-weight:bold;" | valor | |||
| 1 | |||
| 0 | |||
| 1 | |||
| 0 | |||
| 0 | |||
| 1 | |||
| 1 | |||
| 1 | |||
|- | |- | ||
| style="font-weight:bold;" | peso | | style="font-weight:bold;" | peso | ||
| | | 2<sup>7</sup> | ||
| 2<sup>6</sup> | | 2<sup>6</sup> | ||
| 2<sup>5</sup> | | 2<sup>5</sup> | ||
| Linha 243: | Linha 344: | ||
|- | |- | ||
| style="font-weight:bold;" | peso | | style="font-weight:bold;" | peso | ||
| | | +128 | ||
| +64 | | +64 | ||
| +32 | | +32 | ||
| Linha 252: | Linha 353: | ||
| +1 | | +1 | ||
|- | |- | ||
| style="font-weight:bold;" | somar | |||
| +128 | |||
| | |||
| +32 | |||
| | |||
| style="font-weight:bold;" | somar | |||
| | |||
| | |||
| +32 | |||
| | |||
| | | | ||
| +4 | | +4 | ||
| Linha 273: | Linha 364: | ||
|- | |- | ||
| style="font-weight:bold;" | resultado | | style="font-weight:bold;" | resultado | ||
| colspan="8" style="font-weight:bold;" | | | colspan="8" style="font-weight:bold;" | 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 <math> N </math> bits é possível representar números inteiros no intervalo de <math> [-(2^{N-1}-1), (2^{N-1}-1)] </math>. Nesta representação existem dois zeros, o +0 e o -0. | |||
:Por exemplo usando 8 bits => <math> [-(2^{8-1}-1), (2^{8-1}-1)] = [-(2^{7}-1), (2^{7}-1)] = [ -127,-0, +0,+127] = [11111111_2, 10000000_2, 00000000_2, 01111111_2] </math> | |||
{| class="wikitable" style="text-align:center;" | |||
|- style="font-weight:bold;" | |||
!style="width: 12%;" | bit | |||
!style="width: 11%;" | 7 | |||
!style="width: 11%;" | 6 | |||
!style="width: 11%;" | 5 | |||
!style="width: 11%;" | 4 | |||
!style="width: 11%;" | 3 | |||
!style="width: 11%;" | 2 | |||
!style="width: 11%;" | 1 | |||
!style="width: 11%;" | 0 | |||
|- | |- | ||
| style="font-weight:bold;" | valor | | style="font-weight:bold;" | peso | ||
| | | | ||
| 2<sup>6</sup> | |||
| 2<sup>5</sup> | |||
| 2<sup>4</sup> | |||
| 2<sup>3</sup> | |||
| 2<sup>2</sup> | |||
| 2<sup>1</sup> | |||
| 2<sup>0</sup> | |||
|- | |||
| style="font-weight:bold;" | peso | |||
| | |||
| +64 | |||
| +32 | |||
| +16 | |||
| +8 | |||
| +4 | |||
| +2 | |||
| +1 | |||
|- | |||
| style="font-weight:bold;" | valor | |||
| 1 | |||
| 0 | | 0 | ||
| 1 | | 1 | ||
| Linha 286: | Linha 414: | ||
|- | |- | ||
| style="font-weight:bold;" | somar | | style="font-weight:bold;" | somar | ||
| | | - | ||
| | | | ||
| +32 | | +32 | ||
| Linha 294: | Linha 422: | ||
| +2 | | +2 | ||
| +1 | | +1 | ||
|- style="font-weight:bold;" | |- | ||
| resultado | | style="font-weight:bold;" | resultado | ||
| colspan="8" | + ( 32 + 4 + 2 + 1) = +39 | | colspan="8" style="font-weight:bold;" | - ( 32 + 4 + 2 + 1) = - 39 | ||
|} | |- | ||
| style="font-weight:bold;" | valor | |||
| 0 | |||
| 0 | |||
| 1 | |||
| 0 | |||
| 0 | |||
| 1 | |||
| 1 | |||
| 1 | |||
|- | |||
| style="font-weight:bold;" | somar | |||
| + | |||
| | |||
| +32 | |||
| | |||
| | |||
| +4 | |||
| +2 | |||
| +1 | |||
|- style="font-weight:bold;" | |||
| resultado | |||
| colspan="8" | + ( 32 + 4 + 2 + 1) = +39 | |||
|} | |||
*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 318: | Linha 469: | ||
|- | |- | ||
| style="font-weight:bold;" | peso | | style="font-weight:bold;" | peso | ||
| 2<sup>7</sup><br /> | | -2<sup>7</sup><br /> | ||
| 2<sup>6</sup> | | 2<sup>6</sup> | ||
| 2<sup>5</sup> | | 2<sup>5</sup> | ||
| Linha 407: | Linha 558: | ||
|} | |} | ||
;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 730: | ||
*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 | *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) = | 13 (decimal) = 1101 (binário sem sinal) | ||
-13 (decimal) = | +13 (decimal) = '''0'''1101 (binário em sinal-magnitude) | ||
-13 (decimal) = 10010 + | -13 (decimal) = '''1'''1101 (binário em sinal-magnitude) | ||
-13 (decimal) = | +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) | |||
;Código ASCII: | ;Código ASCII: | ||
| Linha 783: | Linha 938: | ||
*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 | |||
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: | ||
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 [https://en.wikipedia.org/wiki/UTF-8 '''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 [https://w3techs.com/technologies/cross/character_encoding/ranking]. Para cobrir uma vasta gama de caracteres, o Unicode os organiza em blocos. Exemplos de blocos: [https://www.unicode.org/charts/PDF/U0000.pdf "Latin basic"],[https://www.unicode.org/charts/PDF/U0370.pdf "Greek and Coptic"], [https://www.unicode.org/charts/PDF/U1FA00.pdf "Chess Symbols"], [https://www.unicode.org/charts/PDF/U1F600.pdf "Emoticons"], [https://www.unicode.org/charts/PDF/U1D2E0.pdf "Mayan Numerals"], etc. | 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 [https://en.wikipedia.org/wiki/UTF-8 '''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 [https://w3techs.com/technologies/cross/character_encoding/ranking]. Para cobrir uma vasta gama de caracteres, o Unicode os organiza em blocos. Exemplos de blocos: [https://www.unicode.org/charts/PDF/U0000.pdf "Latin basic"],[https://www.unicode.org/charts/PDF/U0080.pdf Latin-1 Supplement], [https://www.unicode.org/charts/PDF/U0370.pdf "Greek and Coptic"], [https://www.unicode.org/charts/PDF/U1FA00.pdf "Chess Symbols"], [https://www.unicode.org/charts/PDF/U1F600.pdf "Emoticons"], [https://www.unicode.org/charts/PDF/U1D2E0.pdf "Mayan Numerals"], etc. | ||
*Ver outros em [https://www.lookuptables.com/text/unicode-characters Unicode Characters and Blocks - Lookup Tables] | *Ver outros em [https://www.lookuptables.com/text/unicode-characters Unicode Characters and Blocks - Lookup Tables] | ||
*Para testar a conversão de texto para o código UTF-8 use [https://onlineutf8tools.com/convert-utf8-to-hexadecimal utf8 to hexadecimal converter] | *Para testar a conversão de texto para o código UTF-8 use [https://onlineutf8tools.com/convert-utf8-to-hexadecimal utf8 to hexadecimal converter] | ||
| Linha 796: | Linha 950: | ||
*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] | ||
;PARA O PRÓXIMO ENCONTRO: | |||
{{collapse top | Passos para visualizar os bytes UTF-8 no navegador}} | |||
;Abra o '''Console do Desenvolvedor''' no navegador: | |||
*No Chrome ou Edge: Pressione F12 ou Ctrl + Shift + I, depois vá para a aba '''Console'''. | |||
*No Firefox: Pressione F12 ou Ctrl + Shift + K para abrir o console diretamente. | |||
Digite o seguinte comando no console: | |||
new TextEncoder().encode("Ol'''a''' mundo!") | |||
Isso retorna um Uint8Array contendo os bytes em UTF-8. | |||
Uint8Array(10) [79, 108, '''97''', 32, 109, 117, 110, 100, 111, 33, buffer: ArrayBuffer(10), byteLength: 10, byteOffset: 0, length: 10, Symbol(Symbol.toStringTag): 'Uint8Array'] | |||
Substitua o a por um "á" (que não está na tabela ASCII) | |||
new TextEncoder().encode("Ol'''á''' mundo!") | |||
Isso retorna um Uint8Array contendo os bytes em UTF-8. | |||
Uint8Array(11) [79, 108, '''195, 161''', 32, 109, 117, 110, 100, 111, 33, buffer: ArrayBuffer(11), byteLength: 11, byteOffset: 0, length: 11, Symbol(Symbol.toStringTag): 'Uint8Array'] | |||
Note que o "á" (com acento) é representado por dois bytes: 195 161 (ou C3 A1 em hexadecimal), pois está fora da tabela ASCII. | |||
Outras opções de visualização seriam: | |||
Array.from(new TextEncoder().encode("Olá mundo!")).map(b => b.toString(10).padStart(2, '0')).join(' ') | |||
79 108 '''195 161''' 32 109 117 110 100 111 33 | |||
Array.from(new TextEncoder().encode("Olá mundo!")).map(b => b.toString(2).padStart(2, '0')).join(' ') | |||
1001111 1101100 '''11000011 10100001''' 100000 1101101 1110101 1101110 1100100 1101111 100001 | |||
Array.from(new TextEncoder().encode("Olá mundo!")).map(b => b.toString(16).padStart(2, '0')).join(' ') | |||
4f 6c '''c3 a1''' 20 6d 75 6e 64 6f 21 | |||
; | Para fazer o contrário, descobrir como o navegador irá apresentar um código UTF-8 | ||
*Outros códigos binários: | console.log(String.fromCodePoint(0x00E1)); | ||
:* '''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. | O resultado será | ||
::Note por exemplo: | á | ||
::*Em código binário convencional o número adjacente a 0111 (7) é o 1000 (8), mudança em 4 bits. | {{collapse bottom}} | ||
{{collapse top | Como o UTF-8 codificado? }} | |||
O UTF-8 usa um esquema variável de codificação: | |||
{| class="wikitable" | |||
|+ Estrutura do UTF-8 | |||
|- | |||
! Código Unicode !! Intervalo (Hex) !! Bytes usados !! Formato em binário | |||
|- | |||
| ASCII || U+0000 – U+007F || 1 byte || 0xxxxxxx | |||
|- | |||
| Latin-1 e outros || U+0080 – U+07FF || 2 bytes || 110xxxxx 10xxxxxx | |||
|- | |||
| Acima de U+0800 || U+0800 – U+FFFF || 3 bytes || 1110xxxx 10xxxxxx 10xxxxxx | |||
|- | |||
| Caracteres especiais e emojis || U+10000 – U+10FFFF || 4 bytes || 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx | |||
|} | |||
Portanto para os caracteres da tabela ASCII de 0 a 127 (ou códigos UTF-8 U+0000 a U+007F) apenas é colocado um 0 no ''msb''. Para os códigos UTF-8 U+0080 até U+07FF são usados dois bytes: | |||
'''110'''xxxxx '''10'''xxxxxx | |||
Onde o primeiro byte começa com 110 (indica que usará 2 bytes) e o segundo byte sempre começa com 10 (indicando a continuação dos bits). | |||
No caso da letra "á", o código UTF-8 é U+00E1 [[Arquivo:UTF00E1.png|UTF00E1| 40 px]]. Convertendo 00E1 para binário: | |||
00E1 (hex) = 0000 0000 1110 0001 (binário) | |||
Desses bits, apenas os 11 bits a direita serão codificados 00011100001 e colocados no lugar dos xxxx, definindo a sequência binária de 16 bits: | |||
'''110''' 00011 '''10''' 100001 | |||
Essa sequência em hexadecimal corresponde a C3A1, ou em decimal C3 => 195, A1 => 161, que é o valor mostrado pelo navegador: | |||
Uint8Array(11) [79, 108, '''195, 161''', 32, | |||
{{collapse bottom}} | |||
* Ler capítulo 1. Do Zero ao Um, seção 1.4.6. '''Números Binários com Sinal''' em [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (no pdf page=43) | |||
* Resolver exercícios (1.9 a 1.12; 1.21 a 1.24; 1.31 a 1.36; 1.41 a 1.42; 1.50 a 1.51), do livro [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=47 no pdf page=73) | |||
;Encontro 5 (1 abr.) | |||
*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. | ::*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 184: | ||
|} | |} | ||
</center> | </center> | ||
;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 204: | ||
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: | ||
* | *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 265: | ||
*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://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Exercícios 1.7 ao 1.49 Capítulo 1 - Projeto Digital e Arquitetura de Computadores] (#page=74) | |||
*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] | |||
* [https://g2384.github.io/collection/Hex_Calc_IEEE754_conversion.html Conversores numéricos] | |||
:* Experimente os conversores: Bin, Hex, Dec Converter; Fix-Point <-> Dec Converter; Dec -> IEEE-754 Float/Double | |||
;Encontro 6 (3 abr.) | |||
;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 284: | ||
! 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 324: | ||
<center>[[Arquivo:PontoFlutuante64.png]]</center> | <center>[[Arquivo:PontoFlutuante64.png]]</center> | ||
;Como converter de decimal para floating point?: | |||
: | # Identifique quantos bits serão usados e obtenha o viés (veja na tabela acima) | ||
# Converta o número decimal para binário ponto fixo: | |||
#Identifique | # 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 | # 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 | # 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 | |||
#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 = | '''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 => <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):<span style="color:red;">1</span>.<span style="color:blue;">11000000000000000000000</span> = 1,75 | |||
'''P7:''' Resultado: (-) 1,75 x 2<sup>2</sup> = -7 | |||
;Números sub_normais: | |||
Os números | 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: | |||
* 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) | 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) | |||
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) | |||
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: | |||
* [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-bitsVer [[Media: PontoFixoFlutuante.pdf| Ponto Fixo e Flutuante]] - prof. Odilson | |||
* Ver [https://en.wikipedia.org/wiki/Floating-point_arithmetic Floating-point arithmetic] - wikipedia | |||
* 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. | ||
*Ver [https://en.wikipedia.org/wiki/IEEE_754 IEEE 754] - wikipedia | ;PARA O PRÓXIMO ENCONTRO: | ||
*Ler sobre os hardware de microprocessadores [https://en.wikipedia.org/wiki/History_of_computing_hardware_(1960s%E2%80%93present)#Microprocessors]. | * Ler 5.3.SISTEMAS NUMÉRICOS (5.3.1. Sistema Numérico de Vírgula Fixa e 5.3.2. Sistemas Numéricos de Virgula Flutuante do livro [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=387) | ||
* Resolver exercicios do livro (1.64 a 1.67, 1.69) [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=86) | |||
* Resolver exercicios do livro (5.24, 5.27 a 5.30, 5.31 a 5.32, 5.38) [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=430) | |||
--> | |||
{{collapse bottom}} | {{collapse bottom}} | ||
===Unidade 3 - Funções, portas lógicas e álgebra booleana=== | ===Unidade 3 - Funções, portas lógicas e álgebra booleana=== | ||
* | * 13 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 | <!-- | ||
* | ;Encontro 7 (8 abr.) | ||
*Ler pag 49 a 69 de [https:// | ;Funções e portas lógicas: | ||
* | *[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link Funções e portas lógicas] | ||
:: | ;PARA O PRÓXIMO ENCONTRO: | ||
:: | *Rever[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link Funções e portas lógicas] | ||
:: | *Ler pag 49 a 69 de [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=49) | ||
* No laboratório remoto do Falstad [[Laboratórios de Eletrônica Digital]], faça os tópicos: | |||
:*Aula de laboratório sobre porta lógicas | |||
:*Aula de laboratório sobre porta lógicas com mais de 2 entradas | |||
;Encontro 8 (10 abr.) | |||
;Funções e portas lógicas: | |||
*continuação [https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link Funções e portas lógicas] | |||
;PARA O PRÓXIMO ENCONTRO: | |||
*[[Como as portas lógicas são implementadas com transistores CMOS]] [[https://www.youtube.com/watch?v=IcrBqCFLHIY&]] | |||
*[https://www.youtube.com/watch?v=gfOD-Qpl6eg Technology Size Comparison 🤯🤯 3D Animation] Quão pequeno é um transistor de 3nm. | |||
*[https://www.youtube.com/watch?v=fuufPRwBv7A Sabe como é feito o MicroChip usado nos equipamentos eletrônicos?] (apenas os 8 minutos iniciais) | |||
*[https://www.youtube.com/watch?v=dX9CGRZwD-w How are Microchips Made? 🖥️🛠️ CPU Manufacturing Process Steps] (mais detalhado 28 minutos) | |||
*[https://klabs.org/history/ech/agc_schematics APOLLO GUIDANCE COMPUTER (AGC) Schematics] - Computador de bordo do módulo lunar da Apollo 11, construido usando apenas portas NOR] | |||
*[https://www.righto.com/2019/09/a-computer-built-from-nor-gates-inside.html A computer built from NOR gates: inside the Apollo Guidance Computer] | |||
*[https://github.com/chrislgarry/Apollo-11/blob/master/Luminary099/README.md Códigos de programação do módulo lunar] [https://www.ibiblio.org/apollo/assembly_language_manual.html AGC Assembly Language] | |||
* | ;Encontro 9 (15 abr.) | ||
*Apresentação da chapa do Zizimo para a Reitoria (40 minutos) | |||
*Revisão de exercícios sobre sistemas numéricos | |||
;Encontro | ;Encontro 10 (17 abr.) | ||
* | *Avaliação A1a - Sistemas numéricos (55 minutos) | ||
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https:// | *[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] - slides | ||
;Para o próximo encontro: | |||
*Rever slides 1 a 15 de [https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] | |||
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=107) | |||
*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]] | |||
*Estudar a [[Media:Algebra_booleana.pdf | Folha de consulta sobre álgebra booleana]] para as próximas duas avaliações | |||
;Encontro | ;Encontro 11 (22 abr.) | ||
* | *[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] | ||
* | ;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> | |||
Para provar os teoremas, podemos: | |||
;obter a tabela verdade de ambos lados de cada equação booleana: | |||
; | {| class="wikitable" style="text-align:center;" | ||
|- style="text-align:left;" | |||
! colspan="2" | Entradas | |||
! colspan="2" | Saídas | |||
|- style="font-weight:bold; background-color:#EAECF0; color:#202122;" | |||
| style="vertical-align:middle; width: 25%;" | X | |||
| style="vertical-align:middle; width: 25%;" | Y | |||
| style="font-weight:normal; width: 25%;" | <math> \overline{X + Y} </math> | |||
| style="font-weight:normal; width: 25%;" | <math> \overline{X} \cdot \overline{Y} </math> | |||
|- style="vertical-align:middle; | |||
| 0 || 0 || 1 || 1 | |||
|- | |||
| 0 || 1 || 1 || 1 | |||
|- | |||
| 1 || 0 || 1 || 1 | |||
|- | |||
| 1 || 1 || 0 || 0 | |||
|} | |||
; | {| class="wikitable" style="text-align:center;" | ||
|- style="text-align:left;" | |||
! colspan="2" | Entradas | |||
! colspan="2" | Saídas | |||
|- style="font-weight:bold; background-color:#EAECF0; color:#202122;" | |||
| style="vertical-align:middle; width: 25%;" | X | |||
| style="vertical-align:middle; width: 25%;" | Y | |||
| style="font-weight:normal; width: 25%;" | <math> \overline{X + Y} </math> | |||
| style="font-weight:normal; width: 25%;" | <math> \overline{X} \cdot \overline{Y} </math> | |||
|- style="vertical-align:middle; | |||
| 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: | ||
:'''PASSO 1:''' pelo teorema da complementação ('''T5'''') <math> A + \overline{A} = 1 </math>, podemos afirmar que | |||
{ | ::<math>X+Y + \overline{X+Y} = 1 </math> | ||
:'''PASSO 2:''' Considerando que <math> \overline{X+Y} = \overline{X} \cdot \overline{Y} </math> seja verdade | |||
::<math>(X + Y) + (\overline{X} \cdot \overline{Y}) = 1 </math> | |||
:'''PASSO 3:''' pelo teorema da distribuição ('''T8'''') <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 4:''' pelo teorema da comutatividade ('''T6'''') <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 5:''' pelo teorema da complementação ('''T5'''') <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 6:''' pelo teorema da nulidade ('''T2'''') <math> A + 1 = 1 </math>, podemos afirmar que | ||
< | ::<math> (Y + 1) \cdot (X + 1) = 1 \cdot 1 </math> | ||
:'''PASSO 7:''' pelo axioma da multiplicação ('''A5''') <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 teorema da complementação ('''T5''') <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. | |||
< | ;Usar um circuito lógico para verificar que o teorema é verdadeiro: | ||
* Neste caso, basta analisar as saídas para todas as possíveis entradas. Se a saída sempre for igual o teorema é verificado. [https://tinyurl.com/2cmt8qlu Teorema de Demorgan <math> \overline{X + Y} = \overline{X} \cdot \overline{Y} </math>]. | |||
Apesar de termos demostrado um dos teoremas de De Morgam para duas entradas, eles são válidos 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 [[Media:Algebra_booleana.pdf | folha de consulta sobre á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’) | |||
*Fazer exercícios 2.13, 2.14, 2.17, 2.18, 2.22, 2.23, pag 127ss [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=153) | |||
;PARA O PRÓXIMO ENCONTRO: | |||
*Ver 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] na [[Minha Biblioteca]] | |||
*Rever slides 16 até fim de [https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] | |||
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=107) | |||
*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]] | |||
* Verificar no Falstad algumas das propriedades e teoremas da Algebra de Boole | |||
:* [https://tinyurl.com/24rf2ao2 Redundância <math> X + (X \cdot Y) = X </math>] | |||
:* [https://tinyurl.com/29qgtewm Combinação <math> {X \cdot Y} + {\overline{X} \cdot Y} = Y </math>] | |||
:* [https://tinyurl.com/2cexorw7 Consenso <math> {X \cdot Y} + {\overline{X} \cdot Z} + {Y \cdot Z} = {X \cdot Y} + {\overline{X} \cdot Z} </math>] | |||
:* [https://tinyurl.com/25owykbn Teorema de Demorgan <math> \overline{X \cdot Y} = \overline{X} + \overline{Y} </math>] | |||
;Encontro 12 (24 abr.) | |||
; | * Exercícios de algebra booleana | ||
* Mapa de Karnaugh | |||
; | ;Encontro 13 (29 abr.) | ||
*Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch: | |||
*Ver resumo em [https://drive.google.com/file/d/1BuOGIYApQmoL77jVTrXtXTE4BZkWaPfU/view?usp=drive_link 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://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=125) | |||
; | ;Para a próxima aula: | ||
* | * '''Completar os Mapas de Karnaugh''': Realizar o preenchimento dos mapas de Karnaugh para o decodificador de 7 segmentos, considerando os números de 0 a 9. | ||
* '''Formar equipes''': Organizar equipes de 2 a 3 alunos para desenvolver o projeto de um decodificador de 7 segmentos. Abaixo estão listados 8 conjuntos de informações a serem exibidas no mostrador, correspondentes a cada entrada binária de 0 ("0000") a 15 ("1111"). Cada equipe deverá escolher um conjunto, sendo que nenhum conjunto poderá ser implementado por mais de uma equipe. | |||
: | |||
{{fig|3.1|Conjuntos para mostrador de 7 segmentos| 7segment_sets.png| 800 px | }} | |||
; | ;Encontro 14 (6 mai.) | ||
* | *Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch: | ||
*Uso do ''don't care'' na simplificação | |||
*Ver resumo em [https://drive.google.com/file/d/1BuOGIYApQmoL77jVTrXtXTE4BZkWaPfU/view?usp=drive_link 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://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=125) | ||
; | ;Para a próxima aula: | ||
* | * '''Completar os Mapas de Karnaugh''': Realizar o preenchimento dos mapas de Karnaugh para o decodificador de 7 segmentos, incluindo os valores conforme conjunto escolhido e também usando ''don't care'' para os números de 10 a 15. | ||
*Preparação da [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] | |||
;Encontro | ;Encontro 15 (8 mai.) | ||
* | *Resolver [https://drive.google.com/file/d/16pN70NdO9a-qEKthQwn5OFidA_Y92CTm/view?usp=drive_link Exercícios de álgebra de Boole] | ||
*Resolver exercicios do livro (2.1, 2.2, 2.5 a 2.10, 2.13 a 2.18, 2.21 a 2.25) [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=151) | |||
;Complementos | |||
*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://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=113) | |||
*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://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=116) | |||
;Encontro 16 (13 mai.) | |||
*Avaliação A1b - Funções e portas lógicas, tabela verdade, algebra de Boole, simplificação de equações e mapa de Karnaugh | |||
;Encontro | ;Encontro 17 (15 mai.) | ||
* | *Ver os K-Map online: | ||
:*[https://www.docjava.com/cpe210/kmapExplorer.html docjava.com], | |||
:*[https://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/karnaughmap/ Departamento de Matemática e Informática da Philipps-Universität Marburg - Alemanha], | |||
:*[https://ictlab.kz/extra/Kmap ICT Laboratory - Cazaquistão] | |||
*Ver soluções de expressões booleanas online: | |||
:*[https://www.boolean-algebra.com link 1] | |||
:*[https://www.emathhelp.net/calculators/discrete-mathematics/boolean-algebra-calculator/?f=%7EA%7EB+%2B+%7EA%E2%80%89B%7EC+%2B+%7E%28A+%2B+%7EC%29 link2] | |||
:*[https://www.emathhelp.net/calculators/discrete-mathematics/boolean-algebra-calculator/?f=%28not+a+and+not+b%29+or+%28not+a+and+b+and+not+c%29+or+not+%28a+or+not+c%29 link3] | |||
*Como transformar uma Expressão booleana em Tabela verdade e em Circuito com portas lógicas, e vice-versa: | |||
*[https://drive.google.com/file/d/1lNvJtT1oXv9JlBUDm-veVWExX2IehtzQ/view?usp=drive_link Expressão booleana - Tabela verdade - Circuito com portas lógicas] | |||
*[https://drive.google.com/file/d/1O86iYyEQ2ZJ77x1hERSAwaKqQfRanrBx/view?usp=drive_link Projeto de circuitos combinacionais] | |||
;Para o próximo encontro: | |||
*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] | |||
*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] | |||
;Artigos originais dos métodos: | |||
*[https://ieeexplore-ieee-org.ez130.periodicos.capes.gov.br/stamp/stamp.jsp?tp=&arnumber=6371932 M. Karnaugh, "The map method for synthesis of combinational logic circuits," in Transactions of the American Institute of Electrical Engineers, Part I: Communication and Electronics, vol. 72, no. 5, pp. 593-599, Nov. 1953, doi: 10.1109/TCE.1953.6371932] | |||
*[https://ieeexplore-ieee-org.ez130.periodicos.capes.gov.br/stamp/stamp.jsp?tp=&arnumber=6769983 E. J. McCluskey, "Minimization of Boolean functions," in The Bell System Technical Journal, vol. 35, no. 6, pp. 1417-1444, Nov. 1956, doi: 10.1002/j.1538-7305.1956.tb03835.x] | |||
;Encontro 18 (20 mai.) | |||
* | *Como transformar uma Expressão booleana em Tabela verdade e em Circuito com portas lógicas, e vice-versa: | ||
*[https://drive.google.com/file/d/1lNvJtT1oXv9JlBUDm-veVWExX2IehtzQ/view?usp=drive_link Expressão booleana - Tabela verdade - Circuito com portas lógicas] | |||
*[https://drive.google.com/file/d/1O86iYyEQ2ZJ77x1hERSAwaKqQfRanrBx/view?usp=drive_link Projeto de circuitos combinacionais] | |||
;Encontro 22 | ;Encontro 19 (22 mai.) | ||
*[ | Projeto de circuitos combinacionais: | ||
* | *Ver resumo em [https://drive.google.com/file/d/1O86iYyEQ2ZJ77x1hERSAwaKqQfRanrBx/view?usp=drive_link Projeto de circuitos combinacionais] | ||
*[ | *Multiplexadores e Decodificadores: | ||
*Ler a seção '''2.8.BLOCOS COMBINATÓRIOS''' nas pag 109 a 114 [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=135) | |||
<!-- | |||
< | |||
-- | |||
;Encontro 18 (23 abr.) - Avaliação A1c (6 pontos): | |||
< | *Consumo de energia de circuitos digitais. | ||
::<math> P_{Estatica} = I_{DD} \times V_{DD} </math> | |||
::<math> P_{Dinamica} = 1/2 \times C \times V_{DD}^2 \times f </math> | |||
::<math> P_{Total} = P_{Estatica} + P_{Dinamica} </math> | |||
*Ler pag 69 a 70 de [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=95) | |||
--> | |||
{{collapse bottom}} | |||
-- | |||
===Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim=== | |||
* 7 ENCONTROS | |||
{{collapse top |expand=true| Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim }} | |||
<!-- | |||
;Encontro 20 (24 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] '''PASSOS 0 ''' - - Aprendendo a usar a nuvem do IFSC remotamente | |||
;Encontro 21 a 23 (27 mai. a 3.jun.) | |||
*[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] '''PASSOS 1 a 4''' | |||
;Encontro 24 (5 jun.) - Linguagem VHDL: | |||
* [https://wiki.sj.ifsc.edu.br/images/7/75/Introdu%C3%A7%C3%A3o_a_linguagem_de_descri%C3%A7%C3%A3o_de_hardware.pdf Introdução a linguagem de descrição de hardware (DHL)] | |||
* Estrutura do código VHDL | |||
:* Declaração das bibliotecas e pacotes '''LIBRARY''' / '''PACKAGE''' | |||
<syntaxhighlight lang=vhdl> | |||
library library_name; | |||
use library_name.package_name.all; | |||
</syntaxhighlight> | |||
:* '''ENTITY''' | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
entity entity_name is | |||
[generic ( | |||
cons_name1: const_type const_value; | |||
entity | cons_name2: const_type const_value; | ||
... | |||
cons_nameN: const_type const_value);] | |||
[port ( | |||
signal_name1: mode signal_type; | |||
signal_name2: mode signal_type; | |||
... | |||
end entity; | signal_nameN: mode signal_type);] | ||
[declarative_part] | |||
[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> | ||
* Exemplo - Declaração de uma porta NAND em VHDL | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
library std; | |||
use std.standard.all; | |||
entity | entity nand_gate is | ||
port (a, b: in bit; x: out bit); | |||
port | end entity; | ||
end entity | |||
architecture | architecture nome_arch of nand_gate is | ||
begin | begin | ||
x <= a nand b; | |||
end architecture; | |||
</syntaxhighlight> | |||
*[[Uso do ambiente EDA - QUARTUS Prime para programação em VHDL]] | |||
;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> | |||
-- 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 | 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); | |||
end architecture | ssd_g <= ; | ||
end architecture; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
;Encontro 25 e 26 ( | *Ler [https://pt.wikipedia.org/wiki/VHDL VHDL] na Wikipedia. | ||
* | *Guardar [[Folha de consulta de VHDL]] | ||
* | |||
;Encontro 25 e 26 (10 e 12 jun.) | |||
*[https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE3_-_Programa.C3.A7.C3.A3o_do_kit_Mercurio_IV AE3 - Programação do kit Mercurio IV] | |||
{ | ;PARA O PRÓXIMO ENCONTRO: | ||
| | *ver [[Preparando para gravar o circuito lógico no FPGA]]. | ||
! | *ver [[Como arquivar um projeto]]. | ||
*ver [[Simulação Funcional usando o ModelSim]]. | |||
*ver [[Como utilizar a matriz de leds do kit Mercurio IV da Macnica]] - caso alguém deseje acender os leds conforme as chaves de entrada são selecionados. | |||
*ver [[Acesso_ao_IFSC-CLOUD_(NUVEM)#Como_transferir_arquivos_entre_o_computador_local_e_a_NUVEM-IFSC | Como_transferir_arquivos_entre_o_computador_local_e_a_NUVEM-IFSC]]. | |||
*ver [[Acesso_ao_IFSC-CLOUD_(NUVEM)#Configuração_do_X2GO | Como configurar o X2Go para acessar a nuvem de seu computador pessoal]]. | |||
*ver [[Preparando_para_gravar_o_circuito_lógico_no_FPGA#Programando_o_kit_FPGA_usando_comando_de_linha | Programando o kit FPGA usando comando de linha]]. | |||
*Consultar e guardar a [[Folha de consulta de VHDL]] | |||
*Ler a seção [https://pt.wikipedia.org/wiki/VHDL#História História] da página VHDL da wikipedia em português e as seções [https://en.wikipedia.org/wiki/VHDL#History History], [https://en.wikipedia.org/wiki/VHDL#Standardization Standardization}, [https://en.wikipedia.org/wiki/VHDL#Design Design] e [https://en.wikipedia.org/wiki/VHDL#Advantages Advantages] da página VHDL na Wikipedia em ingles. | |||
--> | |||
{{collapse bottom}} | |||
===Unidade 5 - Circuitos lógicos combinacionais (com VHDL)=== | |||
* 7 ENCONTROS | |||
{{collapse top |expand=true |Unidade 5 - Circuitos lógicos combinacionais (com VHDL)}} | |||
<!-- | |||
;Encontro 29 e 30 (24 e 26 jun.) | |||
* Conhecer o [[Código Gray]] | |||
* Implementação de conversor Binário para Gray (bin2gray) | |||
<syntaxhighlight lang=vhdl> | |||
------------------------- | |||
-- File: bin2gray_v1.vhd -- | |||
------------------------- | |||
entity bin2gray_v1 is | |||
port | |||
( | |||
b0, b1, b2, b3 : in bit; | |||
g0, g1, g2, g3 : in bit | |||
); | |||
end entity; | |||
--Exemplo implementando o circuito diretamente com as portas lógicas | |||
architecture ifsc_v1 of ____ is | |||
begin | |||
end architecture; | |||
</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. | |||
<syntaxhighlight lang=vhdl> | |||
------------------------- | |||
-- File: bin2gray_v2.vhd -- | |||
------------------------- | |||
entity bin2gray_v2 is | |||
port | |||
( | |||
b : in bit_vector(3 downto 0); | |||
g : out bit_vector(3 downto 0) | |||
); | |||
end entity; | |||
--Exemplo implementando o circuito diretamente com as portas lógicas | |||
architecture ifsc_v2 of ____ is | |||
begin | |||
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. | |||
<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> | |||
<syntaxhighlight lang=vhdl> | |||
------------------------- | |||
-- File: bin2gray_v3.vhd -- | |||
------------------------- | |||
entity bin2gray_v3 is | |||
generic (N : natural := 4 ); | |||
port | |||
( | |||
b : in bit_vector(N-1 downto 0); | |||
g : out bit_vector(N-1 downto 0) | |||
); | |||
end entity; | |||
architecture ifsc_v3 of ____ is | |||
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. | |||
* 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. | |||
*Implemente um conversor Gray para Binário (gray2bin): | |||
Considerando o que aprendeu com as versões do conversor '''bin2gray''', descreva o circuito do conversor '''gray2bin'''. Inicie descrevendo o código VHDL para 4 bits, em seguida busque tornar o código genérico para qualquer número de bits. | |||
<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 | |||
begin | |||
< | end architecture | ||
architecture ifsc_v2 of ____ is | |||
begin | |||
end architecture | |||
</syntaxhighlight> | |||
* Implementação de incrementador Gray (inc_gray) | |||
O circuito deve usar uma entrada Gray de N bits, e retornar na saída o valor em Gray incrementado. | |||
Por exemplo: | |||
g_in = 100110 (59) | |||
g_out = 100010 (60) | |||
A solução sugerida foi: | |||
#Converter a entrada de Gray para binário | |||
#Incrementar em binário | |||
#Converter de binário para Gray | |||
Por exemplo: | |||
g_in = 100110 (59) | |||
b_in = 111011 (59) | |||
b_in + 1 = 111100 (60) | |||
b_out = 111100 (60) | |||
g_out = 100010 (60) | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
entity | ------------------------- | ||
-- File: inc_gray.vhd -- | |||
------------------------- | |||
entity inc_gray is | |||
port | port | ||
( | ( | ||
g_in : in std_logic_vector(3 downto 0); | |||
g_out : out std_logic_vector(3 downto 0) | |||
); | ); | ||
end entity; | end entity; | ||
-- | architecture ifsc_v1 of inc_gray is | ||
signal bin : std_logic_vector(3 downto 0); | |||
signal bin_inc : std_logic_vector(3 downto 0); | |||
begin | |||
-- Converter a entrada de g_in para b_in | |||
-- código visto e aula anterior | |||
-- Incrementar e binário b_out = b_in + 1 | |||
-- aqui falta conhecimento de linguagem para fazer. | |||
-- Converter a entrada de b_out para g_out | |||
-- código visto e aula anterior | |||
end architecture; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
O problema nesta solução é como fazer o incremento de um número em binário. Será necessário aprender: | |||
* somar em binário, pois incrementar é somar 1. | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
-- necessário usar os pacotes std_logic_1164 e numeric_std da biblioteca ieee | |||
library ieee; | |||
use ieee.std_logic_1164.all; | |||
use ieee.numeric_std.all; | |||
-- Declare um signal do tipo unsigned para usar operador aritmético sobre ele | |||
signal bin_uns : unsigned(3 downto 0); | |||
-- converta o valor binário para unsigned | |||
bin_uns <= (unsigned(bin)); | |||
bin_inc <= std_logic_vector(bin_uns + 1); | |||
</syntaxhighlight> | </syntaxhighlight> | ||
architecture ifsc_v1 of inc_gray is | |||
signal b_in : std_logic_vector(3 downto 0); | |||
signal b_inc : std_logic_vector(3 downto 0); | |||
begin | |||
-- Converter a entrada de g_in para b_in | |||
-- código visto e aula anterior | |||
-- Incrementar e binário b_out = b_in + 1 | |||
-- aqui falta conhecimento de linguagem para fazer. | |||
-- Converter a entrada de b_out para g_out | |||
-- código visto e aula anterior | |||
end architecture; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
* os tipos de dados que permitem fazer operações aritméticas em binário, | |||
* como fazer a conversão entre tipos de dados em VHDL ('''integer''', '''bit_vector''', '''std_logic_vector''', '''unsigned'''). | |||
'''Fica a pergunta.''' Seria possível fazer o incremento direto em gray sem passar primeiro para o binário? | |||
Tente encontrar alguma solução observando a regra de mudança dos bits no código Gray. Não esqueça que apenas o valor atual da entrada é conhecido. | |||
;Encontro 31 (1 jul.) | |||
* 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> | |||
O MUX2:1 também pode ser representado de forma resumida por: | |||
<center> | |||
{| class="wikitable" style="text-align:center;" | |||
|- style="font-weight:bold;" | |||
! X1 | |||
! X0 | |||
! Sel | |||
! style="background-color:#c0c0c0;" | Y | |||
|- | |||
| - | |||
| X0 | |||
| 0 | |||
| style="background-color:#c0c0c0;" | X0 | |||
|- | |||
| 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: | |||
{ | <math> Y = \overline{Sel} . X0 + Sel . X1 </math> | ||
; | 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> | |||
; | {| class="wikitable" style="text-align:center;" | ||
|- style="font-weight:bold;" | |||
: | ! colspan="4" | Entradas | ||
: | ! colspan="2" | Seleção | ||
! Saída | |||
|- style="font-weight:bold;" | |||
| X3 | |||
| X2 | |||
| X1 | |||
| X0 | |||
| Sel1 | |||
| Sel0 | |||
| style="background-color:#c0c0c0;" | Y | |||
|- | |||
| - | |||
| - | |||
| - | |||
| X0 | |||
| 0 | |||
| 0 | |||
| style="background-color:#c0c0c0;" | X0 | |||
|- | |||
| - | |||
| - | |||
| X1 | |||
| - | |||
| 0 | |||
| 1 | |||
| style="background-color:#c0c0c0;" | X1 | |||
|- | |||
| - | |||
| 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: | |||
<math> Y = X0 . \overline{Sel1} . \overline{Sel0} + X1 . \overline{Sel1} . Sel0 + X2 . Sel1 . \overline{Sel0} + X3 . Sel1 . Sel0 </math> | |||
</ | |||
: | Dada a função booleana do MUX4:1 é simples para descreve-lo em VHDL utilizando apenas operadores lógicos. | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
entity mux4x1 is | |||
port | |||
( | |||
X: in bit_vector (3 downto 0); | |||
-- Quando X é declarado como bit_vector (3 downto 0) | |||
-- ordem dos bits | X(3) | X(2) | X(1) | X(0) | | |||
-- X(0) é o bit mais a direita do vetor X, X(3) é o bit mais a esquerda do vetor X. | |||
-- X: in bit_vector (0 to 3); | |||
-- Se X é declarado como bit_vector (0 to 3) | |||
-- ordem dos bits | X(0) | X(1) | X(2) | X(3) | | |||
-- X(3) é o bit mais a direita do vetor X, X(0) é o bit mais a esquerda do vetor X. | |||
Sel : in bit_vector (1 downto 0); | |||
Y : out bit | |||
); | |||
end entity; | |||
-- | -- Implementação com lógica pura | ||
architecture v_logica_pura of mux4x1 is | |||
begin | |||
Y <= (X(0) and (not Sel(1)) and (not Sel(0))) or | |||
(X(1) and (not Sel(1)) and Sel(0)) or | |||
... -- continue para X(2) e X(3) | |||
end architecture; | |||
</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> | </syntaxhighlight> | ||
O | *Importante: O último ELSE deve cobrir todos os demais valores para evitar a criação de LATCHES. | ||
Warning (13012): Latch ... has unsafe behavior | |||
* No Quartus Prime SE existe um template pronto para ser utilizado em: '''[Edit > Insert Template > Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Conditional Signal Assignment]''' | |||
;Exemplo do mux4x1 implementado com WHEN ELSE: | |||
<syntaxhighlight lang=vhdl> | <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''' | |||
<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. | |||
Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression | |||
* No Quartus Prime SE existe um template pronto para ser utilizado em: '''[Edit > Insert Template > Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Selected Signal Assignment]''' | |||
;Exemplo do mux4x1 implementado com WITH SELECT: | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
-- | -- Implementação com WITH SELECT | ||
- | architecture v_WITH_SELECT of mux4x1 is | ||
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> | |||
* 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> | ||
-- Design Unit que associa a architecture com a entity | |||
configuration cfg_ifsc of mux4x1 is | |||
for v_logica_pura end for; | |||
-- for v_WHEN_ELSE end for; | |||
-- for v_WITH_SELECT end for; | |||
end configuration; | |||
</syntaxhighlight> | |||
-- | * 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 |}} | |||
* 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. | |||
{{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). | |||
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.6|Technology Map do mux4x1 para a família Aria 10 | TM_mux4x1_S3.png| 400 px |}} | |||
;Encontro 32 (3 jul.) | |||
*Avaliação A1c. | |||
;Encontro 33 (8 jul.) | |||
*Nova modelagem do decodificador (conversor) de binário para sete segmentos '''bin2ssd''': | |||
:*Considere o decodificador que havia sido implementado na AE3 através de lógica pura. Neste caso foram usados bits individuais para cada entrada (A, B, C e D) e também para as saídas (a, b, c, d, e, f, g). | |||
:*Ver a tabela verdade na página do [https://wiki.sj.ifsc.edu.br/index.php/Display_de_7_segmentos#Codificador_de_bin%C3%A1rio_para_mostrador_de_7_segmentos display de sete segmentos]. | |||
:*Em uma solução melhorada devem ser utilizados vetores para representar a entrada ('''bin''') e a saída ('''ssd'''). Com isso será possível explorar as instruções WHEN ELSE e WITH SELECT para implementar esse decodificador, descrevendo-o diretamente através da sua tabela verdade. | |||
::A correspondencia dos bits do vetor ssd seria: a => ssd(0), b => ssd(1), ... g => ssd(6). | |||
::A correspondencia dos bits do vetor bin seria: A => bin(3), B => bin(2), C => bin(1), D => bin(0). | |||
< | * Usando a instrução '''when else''' | ||
<syntaxhighlight lang=vhdl> | |||
library ieee; | |||
use ieee.std_logic_1164.all; | |||
entity bin2ssd is | |||
port( | |||
bin : in std_logic_vector (3 downto 0); | |||
ssd : out std_logic_vector (6 downto 0) -- indices decrescentes | |||
-- ssd : out std_logic_vector (0 to 6) -- indices crescentes | |||
); | |||
end entity; | |||
architecture when_else of bin2ssd is | |||
begin | |||
-- indices decrescentes | |||
ssd <= "0111111" when bin = "0000" else | |||
... | |||
-- indices crescentes | |||
-- ssd <= "1111110" when bin = "0000" else | |||
end architecture; | |||
</syntaxhighlight > | |||
* Usando a instrução '''with select''' | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
architecture with_select of bin2ssd is | |||
begin | |||
end architecture; | |||
</syntaxhighlight > | |||
;DESAFIO: | |||
*Faça a implementação de um conversor de binário para ssd que forneça na saída as seguintes letras: | |||
{{fig|5.20|Alfabeto usando mostrador de 7 segmentos| alfabeto_ssd.png| 400 px | }} | |||
*Use o kit Mercúrio IV para implementar o hardware. As chaves SW0 a SW3 devem ser usadas como as entradas binárias bin(0) a bin(3), e o display de sete segmentos DISP0 como saída ssd(0) a ssd(6). | |||
:*Veja a [[ELD129002-Engtelecom (Diário) - Prof. Marcos Moecke#AE3_-_Programação_do_kit_Mercurio_IV | AE3 - Programação do kit Mercurio IV ]]para fazer a configuração dos pinos. | |||
;Encontro 34 (10 jul.) | |||
Demultiplexador de 1 para 4 [https://tinyurl.com/yrvmxgq7] | |||
:*Implementar em VHDL | |||
<syntaxhighlight lang=vhdl> | |||
entity demux1x4 is | |||
port( | |||
X : in _____; | |||
A : ___ bit_vector__________; | |||
y : ___ bit_vector__________ | |||
); | |||
end entity; | |||
architecture ______ of _____ is | |||
begin | |||
y(0) <= X and (not A(1)) and (not A(0)); | |||
y(1) <= | |||
end architecture; | |||
</syntaxhighlight> | |||
;Entender a importância do tipo de dado STD_LOGIC: | |||
O tipo de dado STD_LOGIC é amplamente utilizado em projetos digitais, especialmente em VHDL, devido à sua flexibilidade e capacidade de representar múltiplos estados lógico, ou seja o STD_LOGIC pode representar não apenas os valores binários 0 e 1, mas também estados adicionais como: | |||
<syntaxhighlight lang=vhdl> | |||
'U', -- Uninitialized (não inicializado) | |||
'X', -- Forcing Unknown (valor desconhecido) | |||
'0', -- Forcing 0 (valor 0) | |||
'1', -- Forcing 1 (valor 1) | |||
'Z', -- High Impedance (alta impedância, terceiro estado) | |||
'W', -- Weak Unknown (fraco com valor desconhecido) | |||
'L', -- Weak 0 (fraco com valor 0) | |||
'H', -- Weak 1 (fraco com valor 1) | |||
'-' -- Don't care (irrelevante) | |||
</syntaxhighlight> | </syntaxhighlight> | ||
Esses estados são essenciais para uma melhor modelagem e simulação de circuitos digitais, especialmente quando há necessidade de considerar condições indefinidas ou barramentos tri-state. Para permitir o uso desse tipo de dado é necessário usar o pacote '''[[Std logic 1164.vhd|std_logic_1164]]''' da biblioteca '''ieee'''. | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
library ieee; | |||
use ieee.std_logic_1164.all; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
O STD_LOGIC facilita a Integração com Bibliotecas e Ferramentas de Síntese, sendo por isso considerado o padrão industrial. As ferramentas de síntese e simulação, como ModelSim e Quartus, são otimizadas para trabalhar com esse tipo de dado. | |||
O estado Z é crucial para barramentos de comunicação, onde múltiplos dispositivos podem compartilhar a mesma linha de dados. | |||
O suporte a valores desconhecidos (X) melhora a detecção de falhas durante a simulação. | |||
Para exemplificar o uso da alta impedância, vamos retornar ao circuito demultiplexador. Agora queremos que apenas a saída selecionada apresente o valor da entrada. As demais saídas devem ficar em alta-impendância. Para isso será necessário utilizar o tipo de dado STD_LOGIC[_VECTOR]. | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
library ieee; | |||
use ieee.std_logic_1164.all; | |||
entity demux1x4 is | |||
port ( | |||
X : in std_logic; | |||
enable : in std_logic; | |||
A : in std_logic_vector(1 downto 0); | |||
Y : out std_logic_vector(3 downto 0) | |||
); | |||
end entity; | |||
</syntaxhighlight> | |||
*Demultiplexador de 1 para 4 [https://tinyurl.com/yrvmxgq7] | |||
:*Implementar em VHDL enviando a entrada X apenas para a saída selecionada e fixando em '0' as demais saídas. | |||
<syntaxhighlight lang=vhdl> | |||
architecture ifsc_v1 of demux1x4 is | |||
begin | |||
Y <= | |||
"000" & X when A = "00" else | |||
"00" & X & "0" when A = "01" else | |||
"0" & X & "00" when A = "10" else | |||
X & "000"; | |||
end architecture; | |||
</syntaxhighlight> | |||
::'''Nota''': o operador de concatenação ('''&''') pode ser utilizado para agrupar vetores para formar um vetor maior. No exemplo '''Y <= "000" & X;''' a saída Y que tem 4 posições [Y3 Y2 Y1 Y0], recebe '0' nas posições Y3 Y2 Y1, e a posição Y0 recebe o X. | |||
{{fig|2.8|Código RTL do demux1x4 v1| RTL_demux1x4v1.png| 500 px |}} | |||
:*Implementar em VHDL enviando a entrada X apenas para a saída selecionada e deixando em alta impedância 'Z' as saídas. | |||
<syntaxhighlight lang=vhdl> | |||
architecture ifsc_v2 of demux1x4 is | |||
begin | |||
Y <= | |||
"ZZZ" & X when A = "00" else | |||
"ZZ" & X & "Z" when A = "01" else | |||
"Z" & X & "ZZ" when A = "10" else | |||
X & "ZZZ"; | |||
end architecture; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
A | :'''Nota''': A alta impendância é representada por '''"Z"''' '''maiúsculo''' e não pelo "z" minúsculo. | ||
*Demultiplexador com enable. [https://tinyurl.com/yqnaz3sl] | |||
:*Implementar em VHDL utilizando a proposta do exemplo anterior, mas acrescentando uma decisão de mudar a saída para "ZZZZ" se o demux não estiver habilitado ('''enable = '0'''') | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
architecture ifsc_v3 of demux1x4 is | |||
signal Y_aux : std_logic_vector(3 downto 0); | |||
begin | |||
Y_aux <= | |||
"ZZZ" & X when A = "00" else | |||
"ZZ" & X & "Z" when A = "01" else | |||
"Z" & X & "ZZ" when A = "10" else | |||
X & "ZZZ"; | |||
Y <= Y_aux when enable = '1' else "ZZZZ"; | |||
end architecture; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
Note que neste caso é necessário criar um "sinal" auxiliar que recebe o resultado do demux anterior. Em seguida, observando a entrada enable se decide o que fazer com as saídas. Para criar sinais em VHDL eles precisam ser declarados entre a linha '''architecture .. is''' e o '''begin'''. | |||
{{fig|2.9|Código RTL do demux1x4 v3| RTL_demux1x4v3.png| 500 px |}} | |||
:*Também é possível implementar em VHDL comparando diretamente todas as entradas '''enable''' e '''A'''. | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
architecture ifsc_v4 of demux1x4 is | |||
begin | |||
Y <= | |||
"ZZZZ" when enable = '0' else | |||
"ZZZ" & X when (A = "00" and enable = '1') else | |||
"ZZ" & X & "Z" when (A = "01" and enable = '1') else | |||
"Z" & X & "ZZ" when (A = "10" and enable = '1') else | |||
X & "ZZZ"; | |||
end architecture; | |||
</syntaxhighlight> | |||
{{fig|2.10|Código RTL do demux1x4 v4| RTL_demux1x4v4.png| 500 px |}} | |||
;PARA O PRÓXIMO ENCONTRO: | |||
*Simulação dos circuitos do demux1x4 | |||
::Faça a simulação dos circuitos acima, e verifique se eles estão funcionando corretamente, enviando o sinal da entrada para a saída de acordo com o endereço indicado. | |||
{{fig|2.11|Simulação do demux1x4 v4| SIM_demux1x4v4.png| 1000 px |}} | |||
Explicação da simulação: | |||
:(1) - Nos primeiros 100 ps, o sinal de enable está em '0', e por isso as saídas estão em alta impendância "ZZZZ". | |||
:(2) - Nos próximos 100 ps, o sinal de enable passou para em '1', mas como não foi definido um valor para a entrada X, ela fica como indefinida "U". por isso a saída Y(0) mostra 'U' (em vermelho) enquanto que as demais estão com 'Z' (em azul). | |||
:(3) - foi definido um valor para a entrada X = '0', por isso a saída Y(0) mostra '0' enquanto que as demais estão com 'Z'. | |||
:(4) - foi definido um valor para a entrada X = '1', por isso a saída Y(0) mostra '1' enquanto que as demais estão com 'Z'. | |||
:(3 a 10) - é alternado o valor de X e a cada 200 ps a entrada A também é modificada (00 -> 01 -> 10 -> 11) | |||
:(11) e (12) - o sinal A foi adicionado duas vezes ao wave. Na primeira está com radix '''binary''', e na segunda com radix '''unsigned'''. | |||
:(13) e (14) - o sinal Y está sendo mostrado como um grupo de bits e separado por bit. Para tal é necessário clicar sobre o [+] antes sinal Y [[Arquivo:Expand.png]]. | |||
<!-- | |||
*Realize a simulação das 3 arquiteturas do MUX4:1 no Modelsim | |||
*Crie um arquivo tb_mux4x1_v1.do que repita a simulação da arquitetura v1 | |||
<syntaxhighlight lang=tcl> | |||
#file_name: tb_mux4x1_v1.do | |||
#preparando o simulador | |||
vlib rtl_work | |||
vmap work rtl_work | |||
#vcom -93 -work work {/home/moecke/ELD1/ANO2024.2/Aula26/mux4x1.vhd} | |||
# substitua o caminho absoluto pelo relativo ../../ | |||
vcom -93 -work work {../../mux4x1.vhd} | |||
vsim work.mux4x1(v_logica_pura) | |||
#adicionando os sinais a aba wave | |||
add wave -position end sim:/mux4x1/X | |||
add wave -position end sim:/mux4x1/Sel | |||
add wave -position end sim:/mux4x1/Y | |||
#definindo o valor de um estimulo (valor instante_de_tempo) | |||
force -freeze sim:/mux4x1/X 0101 0 | |||
#definindo varios valores de um estimulo pares (valor instante_de_tempo) separados por virgula | |||
force -freeze sim:/mux4x1/Sel 00 0, 01 100, 10 200, 11 300 | |||
# Execução da simulação. run ou run tempo | |||
# Se não tiver unidade é ps (pico segundos) | |||
# fs => femto segundos | |||
# ps = 1000 fs; => pico segundos | |||
# ns = 1000 ps; => nano segundos | |||
# us = 1000 ns; => micro segundos | |||
# ms = 1000 us; => mili segundos | |||
# sec = 1000 ms; => segundos | |||
# min = 60 sec; => minutos | |||
# hr = 60 min; => horas | |||
run 400 | |||
force -freeze sim:/mux4x1/X 1100 0 | |||
force -freeze sim:/mux4x1/Sel 00 0, 01 100, 10 200, 11 300 | |||
run 400 | |||
force -freeze sim:/mux4x1/X 0011 0 | |||
force -freeze sim:/mux4x1/Sel 00 0, 01 100, 10 200, 11 300 | |||
run 400 | |||
</syntaxhighlight> | |||
{{fig|2.7|Resultado da simulação do mux4x1 | SIM_mux4x1.png| 600 px |}} | |||
*Crie um arquivo tb_mux4x1_v2.do que repita a simulação da arquitetura v2 | |||
*Crie um arquivo tb_mux4x1_v3.do que repita a simulação da arquitetura v3 | |||
*opcionalmente é possível apenas mudar a arquitetura a ser simulado na linha, deixando 2 comentadas e uma ativa | |||
<syntaxhighlight lang=tcl> | |||
#vsim work.mux4x1(v_logica_pura) | |||
#vsim work.mux4x1(v_WHEN_ELSE) | |||
vsim work.mux4x1(v_WITH_SELECT) | |||
</syntaxhighlight> | </syntaxhighlight> | ||
*Inclua todos os arquivos .do no projeto do Quartus e salve o arquivo QAR | |||
;Encontro 29 (25 jul.) | |||
*Implementação de um MUX4:1 usando chips comerciais de portas lógicas. | |||
;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.) | |||
;Encontro 31 e 32 (16 e 21 nov.) | |||
;Encontro 31 (4 fev.) | |||
*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. | |||
<syntaxhighlight lang=vhdl> | |||
type string is array (positive range <>) of character; | |||
</syntaxhighlight> | |||
string: "IFSC" "teste" "teste123" | |||
:*Números em geral | |||
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) | |||
:*Números binários: | |||
0 -> '0' | |||
7 (em base 2) -> "0111" ou b"0111" ou B"0111" | |||
1023 (em base 2) -> "001111111111" ou b"1111111111" ou B"1111111111" | |||
:*Números octais: | |||
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: | |||
1023 (em base 16) -> 3*16^2 + 15*16^1 + 15*16^0 = X"3FF" ou x"3FF" 16#3FF# | |||
* | :*Números decimais: | ||
: | 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> | |||
< | |||
:: | constant <constant_name> : <type> := <constant_value>; | ||
; | |||
-- Declarações comuns de constantes | |||
== | constant GND : std_logic := '0'; | ||
constant VCC : std_logic := '1'; | |||
constant SSD_0 : std_logic_vector(0 to 6) := "1111110"; | |||
constant MAX : natural := 44; | |||
</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. | |||
<syntaxhighlight lang=vhdl> | |||
-- Signal sem valor default | |||
-- Para atribuir um valor a um signal use "<=" como operador. | |||
; | signal <name> : <type>; | ||
-- Signal com valor default | |||
signal <name> : <type> := <default_value>; | |||
-- Declarações comuns de signals | |||
signal <name> : std_logic; | |||
signal <name> : std_logic_vector(<msb_index> downto <lsb_index>); | |||
signal <name> : integer; | |||
signal <name> : integer range <low> to <high>; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
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. | |||
-- Para atribuir um valor a um variable use ":=" como operador. | |||
-- Variable sem valor default. | |||
variable <name> : <type>; | |||
-- Variable com valor default. | |||
variable <name> : <type> := <default_value>; | |||
-- 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> | ||
:*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> | ||
CONSTANT a: BIT_VECTOR(5 DOWNTO 0) := (OTHERS => '0'); -- "000000" | |||
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" | |||
CONSTANT d: BIT_VECTOR(7 DOWNTO 0) := "01111111"; | |||
SIGNAL e: STD_LOGIC_VECTOR(7 DOWNTO 0); -- Not initialized | |||
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" | |||
</syntaxhighlight> | </syntaxhighlight> | ||
:: 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''''') | |||
* Classificação dos tipos de dados. | |||
A biblioteca [[standard.vhd]] define os tipos BIT, BIT_VECTOR, BOOLEAN, INTEGER, NATURAL, POSITIVE, CHARACTER, STRING. | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
package standard is | |||
type boolean is (false,true); | |||
type bit is ('0', '1'); | |||
type severity_level is (note, warning, error, failure); | |||
end | 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. | |||
<syntaxhighlight lang=vhdl> | |||
PACKAGE std_logic_1164 IS | |||
TYPE std_ulogic IS ( 'U', -- Uninitialized | |||
'X', -- Forcing Unknown | |||
'0', -- Forcing 0 | |||
'1', -- Forcing 1 | |||
'Z', -- High Impedance | |||
'W', -- Weak Unknown | |||
'L', -- Weak 0 | |||
'H', -- Weak 1 | |||
'-' -- Don't care | |||
); | |||
TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic; | |||
SUBTYPE std_logic IS resolved std_ulogic; | |||
TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic; | |||
</syntaxhighlight> | |||
;PARA O PRÓXIMO ENCONTRO: | |||
Para quem ainda não fez, no próximo encontro peço de completem estes dois exercícios | |||
* | *Simulação dos circuitos do demux1x4 | ||
* | *Nova modelagem do decodificador de binário para sete segmentos '''bin2ssd''': | ||
;Encontro 32 (6 fev.) | |||
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). | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
------------------------------------------------------------------- | |||
-- conversion functions | |||
------------------------------------------------------------------- | |||
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; | ||
------------------------------------------------------------------- | |||
-- edge detection | |||
------------------------------------------------------------------- | |||
FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN; | |||
FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN; | |||
------------------------------------------------------------------- | |||
-- edge detection | |||
------------------------------------------------------------------- | |||
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; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED. | |||
<syntaxhighlight lang=vhdl> | |||
package NUMERIC_STD is | |||
<syntaxhighlight lang=vhdl> | |||
package NUMERIC_STD is | |||
type UNSIGNED is array (NATURAL range <>) of STD_LOGIC; | type UNSIGNED is array (NATURAL range <>) of STD_LOGIC; | ||
type SIGNED is array (NATURAL range <>) of STD_LOGIC; | type SIGNED is array (NATURAL range <>) of STD_LOGIC; | ||
| Linha 2 184: | Linha 2 662: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
:: Ver pag. 73 a 78 de <ref name="PEDRONI2010b"/> | :: Ver pag. 73 a 78 de <ref name="PEDRONI2010b"/> | ||
:* Resumo dos Tipos predefinidos. | |||
{| 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 | ||
! 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" | ||
! scope="col" width=15% align="left"| Tipo de Dado | |||
! 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 | |||
|- | |||
| STD_LOGIC || std_logic_1164 || ieee || valores 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' || sintetizável | |||
|- | |||
| STD_LOGIC_VECTOR || std_logic_1164 || ieee || vetor de STD_LOGIC || sintetizável | |||
|- | |||
| 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 | |||
|} | |||
* Exemplo: Buffer Tri-state | |||
:*Ver como funciona em [https://tinyurl.com/ym77x4af] | |||
<syntaxhighlight lang=vhdl> | |||
<syntaxhighlight lang=vhdl> | |||
library ieee; | library ieee; | ||
use ieee.std_logic_1164.all; | use ieee.std_logic_1164.all; | ||
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 | architecture tri_state of tri_state is | ||
begin | begin | ||
output <= input when ena = '1' else "Z"; | |||
end architecture; | 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. | |||
;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: | |||
*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. | |||
:*Para implementar em VHDL será necessário utilizar o tipo de dado '''std_logic''' ou '''std_logic_vector''' | |||
*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 | |||
--> | |||
{{collapse bottom}} | |||
; | ===Unidade 6 - Circuitos aritméticos (com VHDL) === | ||
* 5 ENCONTROS | |||
{{collapse top | expand=true| Unidade 6 - Circuitos aritméticos (com VHDL)}} | |||
<!-- | |||
;Encontro 35 (15 jul.) | |||
*Circuitos aritméticos: somadores, incrementador, decrementador, complemento de dois, multiplicador, comparadores | |||
:* [https://drive.google.com/file/d/1kql0io2sh9Mp4FfnqpEPrdUFkVhHBx6_/view?usp=drive_link slides] | |||
:* Incrementador de 4 bits [https://tinyurl.com/2b2feccq] [https://tinyurl.com/2xzje3w6] | |||
</ | :* Decrementador de 4 bits [https://tinyurl.com/2aks3mgp] [https://tinyurl.com/22c8v57r] | ||
:* Somador completo [https://tinyurl.com/yqkt49kl] | |||
:* Somador de 4 bits [https://tinyurl.com/yucqnkwz] | |||
:* Complemento de dois de 4 bits [https://tinyurl.com/23532lga] | |||
*Ver <ref name="PEDRONI2010a"> PEDRONI, Volnei A. Eletrônica digital moderna e VHDL; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. . ISBN 9788535234657 </ref> | |||
*Usando o tipo '''integer''' | |||
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'''. | |||
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> | |||
entity somador is | |||
port ( | |||
a, b : in integer; | |||
s : out integer; | |||
end entity; | |||
architecture ifsc of somador is | |||
architecture | |||
begin | begin | ||
s <= a + b; | |||
end architecture; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
{{fig|6.1|Código RTL do somador com tipo integer sem range| RTL_somadorv1.png| 300 px |}} | |||
{{fig|6.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. | |||
< | <syntaxhighlight lang=vhdl> | ||
: | entity somador is | ||
port ( | |||
a, b : in integer range 0 to 15; | |||
s : out integer range 0 to 15); | |||
end entity; | |||
architecture ifsc of somador is | |||
begin | |||
s <= a + b; | |||
end architecture; | |||
</syntaxhighlight> | |||
{{fig|6.3|Código RTL do somador com tipo integer com range| RTL_somadorv2.png| 300 px |}} | |||
{{fig|6.4|Technology Map do somador com tipo integer com range| TM_somadorv2.png| 600 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. | |||
<syntaxhighlight lang=vhdl> | <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|6.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. | |||
Para fazer um incrementador, um dos fatores do somador é substituído por '1' e o compilador irá implementar um circuito incrementador. | |||
<syntaxhighlight lang=vhdl> | |||
entity incrementador is | |||
port ( | |||
a : in integer range 0 to 15; | |||
inc : out integer range 0 to 15); | |||
end entity; | |||
architecture ifsc of incrementador is | |||
begin | |||
inc <= a + 1; | |||
end architecture; | |||
</syntaxhighlight> | |||
{{fig|6.6|Código RTL do incrementador com tipo integer com range| RTL_incrementadorv1.png| 300 px |}} | |||
Note que no incrementador apenas a segunda entrada do módulo RTL somador passa a ter um valor fixo '1'. Isso faz com que o hardware necessário para efetuar a soma (+1) é reduzido. | |||
Para fazer o decrementador, um dos fatores do somador é substituído por '-1' e o compilador irá implementar um circuito decrementador. | |||
<syntaxhighlight lang=vhdl> | |||
entity decrementador is | |||
port ( | |||
a : in integer range 0 to 15; | |||
dec : out integer range 0 to 15); | |||
end entity; | |||
architecture ifsc of decrementador is | |||
begin | |||
dec <= a - 1; | |||
end architecture; | |||
</syntaxhighlight> | |||
{{fig|6.7|Código RTL do decrementador com tipo integer com range| RTL_decrementadorv1.png| 300 px |}} | |||
Note que no decrementador apenas a segunda entrada do módulo RTL somador passa a ter um valor fixo, mas também nas duas entradas o sinal A(0) e B(0) recebem o valor fixo '1', para produzir um ''carry_in'' para a soma do bit A(1) com B(1). | |||
;Encontro 36 (17 jul.) | |||
*Multiplicação digital | |||
{{fig|6.8|Algoritmo de multiplicação sem sinal| Multiplier_Alg.png| 500 px |}} | |||
{{fig|6.9|Circuito de multiplicação sem sinal| Multiplier_Hw.png| 500 px |}} | |||
-- multiplicador usando STD_LOGIC_VECTOR | 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 | ||
-- PORT (a, b: STD_LOGIC_VECTOR(3 DOWNTO 0); -- min(a) = -8; max(a) = 7 <- 4 bits | |||
<syntaxhighlight lang=vhdl> | |||
entity multiplicador is | |||
port ( | |||
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> | |||
{{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. | |||
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 |}} | |||
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]''' | |||
{{collapse top | Detalhando a sequencia}} | |||
*No menu, vá para "'''Assignments'''" e depois escolha "'''Settings'''". | |||
*Na janela "Settings", clique em "'''Compiler Settings'''". Em seguida, clique em "'''Advanced Settings (Synthesis)'''". | |||
*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. | |||
<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 | |||
); | |||
end entity; | |||
architecture ifsc of divisor is | |||
begin | |||
quociente <= dividendo / divisor; | |||
resto <= dividendo rem divisor; | |||
end architecture; | |||
</syntaxhighlight> | |||
{{fig|4.8|Código RTL do divisor com tipo integer com range| RTL_divisorv1.png| 300 px |}} | |||
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. | |||
{{fig|4.8|Código RTL do multiplicador por 4| RTL_multiplicador4.png| 300 px |}} | |||
{{fig|4.9|Código RTL do divisor por 2| RTL_divisor2.png| 300 px |}} | |||
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. | |||
{{fig|4.10|Código RTL do multiplicador por 10| RTL_multiplicador10.png| 300 px |}} | |||
;Encontro 37 (22 jul.) | |||
*A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED. | |||
<syntaxhighlight lang=vhdl> | |||
package NUMERIC_STD is | |||
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> | |||
--============================================================================ | |||
-- RESIZE Functions | |||
--============================================================================ | |||
function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED; | |||
function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED; | |||
* Utilizar a função RESIZE para aumentar o número de bits na entrada de um operador. Isso visa aumentar o número de bits a ser usado pelo operador. | |||
* Utilizar a função RESIZE para aumentar o número de bits na saída de uma pperação. Isso visa apenas adequar o número de bits ao número especificado na porta da entidade. | |||
* Em números usando o tipo UNSIGNED, o RESIZE apenas acrescenta ZEROS a esquerda até atingir o número de bits. | |||
* Em números usando o tipo SIGNED, o RESIZE apenas repete o MSB a esquerda até atingir o número de bits. | |||
--============================================================================ | |||
-- 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"/> | |||
[[Arquivo:SumaryOfNumeric_std.gif]] | |||
[[Arquivo:Numeric_stdConvertions.gif]] | |||
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> | |||
* A recomendação da IEEE é utilizar nas portas das entidades sempre tipos std_logic e std_logic_vector. | |||
* Para realizar operações aritméticas utilize preferencialmente os tipos UNSIGNED e SIGNED | |||
* Implementar as diferentes unidades aritméticas (incrementador, decrementador, somador, subtrator, multiplicador, divisor) usando o tipo UNSIGNED e também SIGNED. | |||
<!-- | |||
;Encontro 37 e 38 (22 e 25 fev.) | |||
*Unidade de Aritmética UA). | |||
:*Escreva o código VHDL que implemente a ALU mostrada no diagrama abaixo. Use operações do tipo SIGNED. As entradas '''a''' e '''b''' e saída '''y''' ter o número de bits definido através de GENERIC, e ser do tipo STD_LOGIC_VECTOR. Faça simulação funcional para os diferentes OPCODE. | |||
<syntaxhighlight lang=vhdl> | |||
---------------------- | |||
-- File: alu.vhd -- | |||
---------------------- | |||
entity ua is | |||
generic (N : natural := 4); | |||
port | |||
( | |||
a, b : in std_logic(? downto 0); | |||
cin : in std_logic; | |||
opcode : in std_logic(? downto 0); | |||
y : out std_logic(? downto 0) | |||
); | |||
end entity; | |||
architecture alu of alu is | |||
begin | |||
end architecture; | |||
</syntaxhighlight> | |||
{{fig|3.9| Unidade de Lógica e Aritmética | Alu_pedroni.png | 600 px | pag. 127 <ref name="PEDRONI2010b"/>}} | |||
*Ver pag. 127 a 134 de <ref name="PEDRONI2010b"/> | |||
;Encontro 39 (27 fev.) | |||
* Avaliação A2 | |||
;Encontro 40 (6 mar.) | |||
* Avaliação de recuperação R1 e R2. | |||
<!-- | |||
;Encontro 37 (07 dez.) | |||
;Exemplo 1: | |||
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. | |||
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 1: | |||
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> | |||
library ieee; | |||
use ieee.std_logic_1164.all; | |||
entity vagas is | |||
generic (N : natural := 4 ); | |||
port ( | |||
x : in std_logic_vector (N-1 downto 0); | |||
y : out std_logic | |||
); | |||
end entity; | |||
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; | |||
</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 |}} | |||
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. | |||
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). | |||
{{fig|4.14| Simulação do indicador de vagas | vagas9.png | 800 px |}} | |||
;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> | |||
{{fig|4.15| RTL do indicador de vagas com portas NOT e OR| RTLvagas_or.png | 800 px |}} | |||
Note que o ''Technology Map'' e a simulação produzem o mesmo resultado, apesar da descrição do hardware ser complemente diferente. | |||
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. | |||
;Solução 3: | |||
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. | |||
<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> | |||
:* Tipos de dados: SIGNED e UNSIGNED | |||
:* Exemplo 3.3 Multiplicador de 4x4 bits (UN)SIGNED e INTEGER | |||
{{collapse top | expand=true| Código Multiplicador}} | |||
<syntaxhighlight lang=vhdl> | |||
--LIBRARY ieee; | |||
--USE ieee.numeric_std.all; | |||
--USE ieee.std_logic_1164.all; | |||
ENTITY multiplicador4x4 IS | |||
-- multiplicador usando INTEGER (positivos) | |||
-- 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) | |||
-- 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 | -- y: OUT STD_LOGIC_VECTOR(7 DOWNTO 0)); -- min(a*b) = -56, max(a*b) = 64 -> 8 bits | ||
END ENTITY; | END ENTITY; | ||
ARCHITECTURE v1 OF multiplicador4x4 IS | ARCHITECTURE v1 OF multiplicador4x4 IS | ||
BEGIN | BEGIN | ||
y <= a * b; | y <= a * b; | ||
END ARCHITECTURE; | END ARCHITECTURE; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
*Observar o número de elementos lógicos, bits usados para representar as entradas e saídas. | *Observar o número de elementos lógicos, bits usados para representar as entradas e saídas. | ||
*Observar o código RTL obtido. | *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 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 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 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 | *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}} | |||
==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: | |||
*A1a - (3 pontos) Sistema de Numeração e códigos : XX/2025 | |||
*A1b - (4 pontos) Expressões lógicas e mapa de Karnaugh : XX/2025 | |||
*A1c - (4 pontos) Circuitos lógicos, Introdução ao VHDL e revisão de A1a e A1b : XX/2025 | |||
*A2 - (10 pontos) Circuitos combinacionais e ariméticos : XX/2025 | |||
*R1 - Recuperação de A1: XX/2025 | |||
*R2 - Recuperação de A2: XX/2025 | |||
Folhas de consulta: | |||
*A1b, A1c [[Media:Algebra_booleana.pdf | Álgebra booleana]] | |||
*A2a, A2b [[Media:Tabelas_Pedroni.pdf | Tabelas das figuras 3.6, 3.10 e 4.1]] do livro do Pedroni. | |||
*A2b [[Media:Numeric_std_conversions.png | Conversões do pacote numeric_std]] ou [[Media:Numeric_stdConvertions.gif | Conversões do pacote numeric_std (DOULOS)]] | |||
<!-- | |||
== 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. | |||
<!-- | |||
===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, para o conjunto escolhido. | |||
* 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]]. | |||
*Veja os conjuntos disponíveis: | |||
{{fig|AE1.1|Conjuntos para mostrador de 7 segmentos| 7segment_sets.png| 800 px | }} | |||
*Nesta atividade os estudantes devem projetar um conversor de binário para mostrador de 7 segmentos. | |||
* Inicialmente 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. | |||
{| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222; text-align:center;" | |||
|+ | |||
|- | |||
! Digito | |||
! ABCD | |||
! ssd_a | |||
! ssd_b | |||
! ssd_c | |||
! ssd_d | |||
! ssd_e | |||
! ssd_f | |||
! ssd_g | |||
! Mostrador | |||
|- | |||
| 0 || 0000 || || || || || || || || [[Arquivo:ssd0.png|15px]] | |||
|- | |||
| 1 || 0001 || || || || || || || || [[Arquivo:ssd1.png|15px]] | |||
|- | |||
| 2 || 0010 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 3 || 0011 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 4 || 0100 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 5 || 0101 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 6 || 0110 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 7 || 0111 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 8 || 1000 || || || || || || || || [[Arquivo:ssd8.png|15px]] | |||
|- | |||
| 9 || 1001 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| A || 1010 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| B || 1011 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| C || 1100 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| D || 1101 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| E || 1110 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| F || 1111 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|} | |||
* Em um novo projeto considere que os valores 1010 (dez), 1011 (onze), ... 1111 (quinze) mostram os segmentos acessos conforme figura acima. | |||
;Entregas: | |||
* O projeto todo deverá se realizado manuscrito, devendo as folhas ter a identificação do nome completo do estudante e estar grampeadas. | |||
* Devem ser feitos dois projetos, sendo que um deve usaro o ''don't care'' e outro usando todas as entradas conforme o conjunto escolhido. | |||
* Compare o resultado final dos dois projetos. Deverão ser apresentados no mínimo: | |||
:1) A tabela verdade completa indicando para as entradas de 0 a 15 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 Karnaugh 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. | |||
* Os projetos serão depois implementados em hardware, quando você saberá se houve algum erro no seu projeto. | |||
* 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 | 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 0:''' Abrindo o Quartus Prime na Nuvem do IFSC | |||
:*Abra um terminal na maquina local LINUX [CRTL]+[ALT]+T | |||
:*[https://wiki.sj.ifsc.edu.br/index.php/Acesso_ao_IFSC-CLOUD_(NUVEM)#Acesso_via_ssh Acesso no IFSC via ssh] | |||
:*[https://wiki.sj.ifsc.edu.br/index.php/Acesso_ao_IFSC-CLOUD_(NUVEM)#Quartus_Prime_20.1.1: Abra o Quartus Prime] | |||
*'''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 tempo máximo de propagação entre as entradas e saídas. | |||
:*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: '''Cálculo da distância de Hamming (hamming_distance.vhd)''' ou '''Circuito conversor de binário para BCD (bin2bcd.vhd) ''' | |||
:*Siga as passos indicados em [[Simulação Funcional usando o ModelSim]]. | |||
:*Capture as telas que mostram o circuito funcionando e depois utilize-as no relatório da atividade. | |||
:*Anote algum erro ('''Error''') ou alertas ('''Warnings''') que o Modelsim indicar no painel de mensagens '''[Messages]''' | |||
:*Ao final salve o projeto em um arquivo QAR (sugestão PJ3.QAR) | |||
;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]}''' | |||
Após selecionar o dispositivo faça uma nova '''[Analysis and Synthesis]'''. | |||
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_V21 || Chave tipo Slide Switch 3 || 3.3V | |||
|- | |||
| SW[1] || PIN_W22 || Chave tipo Slide Switch 2 || 3.3V | |||
|- | |||
| SW[2] || PIN_W21 || Chave tipo Slide Switch 1 || 3.3V | |||
|- | |||
| SW[3] || PIN_Y22 || Chave tipo Slide Switch 0 || 3.3V | |||
|} | |||
* Configurar como entrada os seguintes pinos: | |||
eA Y22 | |||
eB W21 | |||
eC W22 | |||
eD V21 | |||
*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 | |||
{| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222; text-align:center;" | |||
|+ | |||
|- | |||
! Digito | |||
! ABCD | |||
! ssd_a | |||
! ssd_b | |||
! ssd_c | |||
! ssd_d | |||
! ssd_e | |||
! ssd_f | |||
! ssd_g | |||
! Mostrador | |||
|- | |||
| 0 || 0000 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 1 || 0001 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 2 || 0010 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 3 || 0011 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 4 || 0100 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 5 || 0101 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 6 || 0110 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 7 || 0111 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 8 || 1000 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| 9 || 1001 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| A || 1010 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| B || 1011 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| C || 1100 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| D || 1101 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| E || 1110 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|- | |||
| F || 1111 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | |||
|} | |||
;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. | |||
{{collapse bottom}} | |||
--> | --> | ||
==Referências Bibliográficas:== | ==Referências Bibliográficas:== | ||
<references/> | <references/> | ||
{{ENGTELECO}} | {{ENGTELECO}} | ||
Edição atual tal como às 07h59min de 12 de agosto de 2025
1 Registro on-line das aulas
1.1 Unidade 1 - Aula inicial, Introdução a disciplina
- 1 ENCONTRO
| Unidade 1 - Aula inicial, Introdução a disciplina |
|---|
|
1.2 Unidade 2 - Sistema de numeração e códigos
- 5 ENCONTROS
| Unidade 2 - Sistema de numeração e códigos |
|---|
1.3 Unidade 3 - Funções, portas lógicas e álgebra booleana
- 13 ENCONTROS
| Unidade 3 - Funções, portas lógicas e álgebra booleana |
|---|
1.4 Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim
- 7 ENCONTROS
| Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim |
|---|
1.5 Unidade 5 - Circuitos lógicos combinacionais (com VHDL)
- 7 ENCONTROS
| Unidade 5 - Circuitos lógicos combinacionais (com VHDL) |
|---|
1.6 Unidade 6 - Circuitos aritméticos (com VHDL)
- 5 ENCONTROS
| Unidade 6 - Circuitos aritméticos (com VHDL) |
|---|
2 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
- A1a - (3 pontos) Sistema de Numeração e códigos : XX/2025
- A1b - (4 pontos) Expressões lógicas e mapa de Karnaugh : XX/2025
- A1c - (4 pontos) Circuitos lógicos, Introdução ao VHDL e revisão de A1a e A1b : XX/2025
- A2 - (10 pontos) Circuitos combinacionais e ariméticos : XX/2025
- R1 - Recuperação de A1: XX/2025
- R2 - Recuperação de A2: XX/2025
Folhas de consulta:
- A1b, A1c Álgebra booleana
- A2a, A2b Tabelas das figuras 3.6, 3.10 e 4.1 do livro do Pedroni.
- A2b Conversões do pacote numeric_std ou Conversões do pacote numeric_std (DOULOS)
3 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.
4 Referências Bibliográficas: