ELD129002-Engtelecom (Diário) - Prof. Marcos Moecke: mudanças entre as edições
Ir para navegação
Ir para pesquisar
| (264 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. | * 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:// | * Relação com as outras UCs do '''Eixo Sistemas Computacionais (Marrom)'''. Ver [https://telegrafo.sj.ifsc.edu.br/ grafo do curriculo] | ||
:*'''ELD129002 - ELETRÔNICA DIGITAL I (ELD1)''': Sistema de numeração e códigos. Lógica booleana. Circuitos combinacionais. Circuitos aritméticos. Linguagem de descrição de hardware. Implementação e teste de circuitos digitais. Projeto de circuitos lógicos. | :*'''ELD129002 - ELETRÔNICA DIGITAL I (ELD1)''': Sistema de numeração e códigos. Lógica booleana. Circuitos combinacionais. Circuitos aritméticos. Linguagem de descrição de hardware. Implementação e teste de circuitos digitais. Projeto de circuitos lógicos. | ||
:*'''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 20: | Linha 19: | ||
;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 (20 | <!-- | ||
;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 33: | 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 47: | 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 53: | 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. | ||
*Sistema binário: | {{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 144: | Linha 170: | ||
| <math> 10^{15} </math> (quadrilhão) | | <math> 10^{15} </math> (quadrilhão) | ||
|} | |} | ||
;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: | ;PARA O PRÓXIMO ENCONTRO: | ||
* Ler capítulo 1. Do Zero ao Um, seção 1.4 do livro [https:// | * 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 | * 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 ( | ;Encontro 3 (25 mar.): | ||
*Regra geral de conversão de valor para qualquer sistema de numeração | *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 o valor (número) pela base e obter o '''quociente''' e o '''resto'''. | ||
| Linha 161: | Linha 189: | ||
:* O primeiro resto obtido é o '''dígito menos significativo'''. | :* O primeiro resto obtido é o '''dígito menos significativo'''. | ||
:* O último resto obtido é o '''dígito mais 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: | |||
5 - 4 = 1 | |||
O bit correspondente a (2<sup>2</sup>) é 1. | |||
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. | |||
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: | |||
1 - 1 = 0 | |||
Resultados da Conversão. Agora, temos os bits correspondentes às potências de 2, da maior para a menor: | |||
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 | *Regra geral de conversão de um sistema de numeração qualquer de base N para decimal | ||
| Linha 169: | Linha 244: | ||
:* Multiplique os pesos pelos dígitos correspondentes. | :* Multiplique os pesos pelos dígitos correspondentes. | ||
:* O valor final (em decimal) é a soma dos valores obtidos. | :* O valor final (em decimal) é a soma dos valores obtidos. | ||
{| class="wikitable" style="text-align:center;" | {| class="wikitable" style="text-align:center;" | ||
|- style="font-weight:bold;" | |- style="font-weight:bold;" | ||
| Linha 223: | Linha 300: | ||
|} | |} | ||
;Códigos numéricos binários: | |||
;PARA O PRÓXIMO ENCONTRO: | |||
* 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) | |||
;Encontro 4 (27 mar.): | |||
;Códigos numéricos binários: | |||
*Número sem sinal ('''UNSIGNED''') | *Número sem sinal ('''UNSIGNED''') | ||
:Neste caso apenas números inteiros naturais podem ser representados. | :Neste caso apenas números inteiros naturais podem ser representados. | ||
| Linha 286: | Linha 369: | ||
*Número com sinal (Sinal-Magnitude ou Magnitude e Sinal) | *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. | :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 | :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> | :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;" | {| class="wikitable" style="text-align:center;" | ||
| Linha 386: | 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 474: | Linha 557: | ||
| colspan="8" | -128 + 64 + 32 +16 + 8 + 4 + 2 + 1 = -128 + 127 = -1 | | colspan="8" | -128 + 64 + 32 +16 + 8 + 4 + 2 + 1 = -128 + 127 = -1 | ||
|} | |} | ||
;Comparação das representações: | ;Comparação das representações: | ||
| Linha 659: | Linha 741: | ||
-13 (decimal) = '''10011''' = 10010 + 1 (binário em complemento de dois) | -13 (decimal) = '''10011''' = 10010 + 1 (binário em complemento de dois) | ||
;Código ASCII: | ;Código ASCII: | ||
O código '''ASCII''' (''American Standard Code for Information Interchange''), é um padrão de codificação de caracteres para comunicação digital. Ele tem apenas 128 pontos de código, sendo 95 são caracteres imprimíveis e os demais são não imprimíveis (em azul no quadro abaixo), sendo usados para diversos controles de equipamentos eletrônicos. Atualmente esse código está sendo substituido pelos códigos '''UNICODE''', que tem milhões de pontos de código, mas nos UNICODE os primeiros 128 são iguais ao conjunto ASCII. | O código '''ASCII''' (''American Standard Code for Information Interchange''), é um padrão de codificação de caracteres para comunicação digital. Ele tem apenas 128 pontos de código, sendo 95 são caracteres imprimíveis e os demais são não imprimíveis (em azul no quadro abaixo), sendo usados para diversos controles de equipamentos eletrônicos. Atualmente esse código está sendo substituido pelos códigos '''UNICODE''', que tem milhões de pontos de código, mas nos UNICODE os primeiros 128 são iguais ao conjunto ASCII. | ||
| Linha 866: | Linha 943: | ||
;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 873: | 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 | |||
console.log(String.fromCodePoint(0x00E1)); | |||
O resultado será | |||
á | |||
{{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: | *Outros códigos binários: | ||
:* '''Gray''' - É um código em que dois valores consecutivos diferem em apenas um bit. Isso é útil para minimizar erros de leitura em sistemas eletrônicos, já que a transição entre estados ocorre com uma única mudança de bit, facilitando a detecção de erros. | :* '''Gray''' - É um código em que dois valores consecutivos diferem em apenas um bit. Isso é útil para minimizar erros de leitura em sistemas eletrônicos, já que a transição entre estados ocorre com uma única mudança de bit, facilitando a detecção de erros. | ||
| Linha 1 125: | Linha 1 267: | ||
;PARA O PRÓXIMO ENCONTRO: | ;PARA O PRÓXIMO ENCONTRO: | ||
*Resolução dos [https:// | *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] | *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] | *Ver exercícios 2.2 a 2.13, 2.16 a 2.18, 2.21 a 2.26, 2.29 a 2.32, 2.39 a 2.41 de [http://biblioteca.ifsc.edu.br/index.asp?codigo_sophia=30631] | ||
;Encontro | * [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: | ;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: | ||
| Linha 1 210: | Linha 1 355: | ||
'''P4:''' expoente (e = E - vies) 129 - 127 = 2 | '''P4:''' expoente (e = E - vies) 129 - 127 = 2 | ||
'''P5:''' Mantissa: (23 bits): <span style="color:blue;">11000000000000000000000</span> | '''P5:''' Mantissa: (23 bits): <span style="color:blue;">11000000000000000000000</span> | ||
'''P6:''' Valor (24 bits):1.<span style="color:blue;">11000000000000000000000</span> = 1,75 | '''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 | '''P7:''' Resultado: (-) 1,75 x 2<sup>2</sup> = -7 | ||
| Linha 1 238: | Linha 1 383: | ||
* Ver [https://en.wikipedia.org/wiki/IEEE_754 IEEE 754] - wikipedia | * Ver [https://en.wikipedia.org/wiki/IEEE_754 IEEE 754] - wikipedia | ||
* Ler sobre os hardware de microprocessadores [https://en.wikipedia.org/wiki/History_of_computing_hardware_(1960s%E2%80%93present)#Microprocessors]. Para ver o número de bits de cada arquitetura, clique no link correspondente na tabela. | * 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. | ||
;PARA O PRÓXIMO ENCONTRO: | |||
* 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.) | |||
;Funções e portas lógicas: | ;Funções e portas lógicas: | ||
*[https:// | *[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link Funções e portas lógicas] | ||
;PARA O PRÓXIMO ENCONTRO: | ;PARA O PRÓXIMO ENCONTRO: | ||
*Rever [https:// | *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:// | *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 | ;Encontro 8 (10 abr.) | ||
;Funções e portas lógicas: | ;Funções e portas lógicas: | ||
*[https:// | *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: | ;PARA O PRÓXIMO ENCONTRO: | ||
*[[Como as portas lógicas são implementadas com transistores CMOS]] | *[[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.) | ||
*[https:// | *Avaliação A1a - Sistemas numéricos (55 minutos) | ||
; | *[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] - slides | ||
*Rever slides 1 a 15 de [https:// | ;Para o próximo encontro: | ||
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https:// | *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]] | *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:// | *[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] | ||
;Teoremas de De Morgan: | ;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 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> | *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 | Para provar os teoremas, podemos: | ||
;obter a tabela verdade de ambos lados de cada equação booleana: | |||
{| class="wikitable" style="text-align:center;" | {| class="wikitable" style="text-align:center;" | ||
| Linha 1 279: | Linha 1 446: | ||
| style="vertical-align:middle; width: 25%;" | X | | style="vertical-align:middle; width: 25%;" | X | ||
| style="vertical-align:middle; width: 25%;" | Y | | style="vertical-align:middle; width: 25%;" | Y | ||
| style="font-weight:normal; width: 25%;" | <math> \overline{X | | style="font-weight:normal; width: 25%;" | <math> \overline{X + Y} </math> | ||
| style="font-weight:normal; width: 25%;" | <math> \overline{X} | | style="font-weight:normal; width: 25%;" | <math> \overline{X} \cdot \overline{Y} </math> | ||
|- style="vertical-align:middle; | |- style="vertical-align:middle; | ||
| 0 | | 0 || 0 || 1 || 1 | ||
| 0 | |||
| 1 | |||
| 1 | |||
|- | |- | ||
| 0 | | 0 || 1 || 1 || 1 | ||
| 1 | |||
| 1 | |||
| 1 | |||
|- | |- | ||
| 1 | | 1 || 0 || 1 || 1 | ||
| 0 | |||
| 1 | |||
| 1 | |||
|- | |- | ||
| 1 | | 1 || 1 || 0 || 0 | ||
| 1 | |||
| 0 | |||
| 0 | |||
|} | |} | ||
| Linha 1 313: | Linha 1 468: | ||
| style="font-weight:normal; width: 25%;" | <math> \overline{X} \cdot \overline{Y} </math> | | style="font-weight:normal; width: 25%;" | <math> \overline{X} \cdot \overline{Y} </math> | ||
|- style="vertical-align:middle; | |- style="vertical-align:middle; | ||
| 0 | | 0 || 0 || 1 || 1 | ||
| 0 | |||
| 1 | |||
| 1 | |||
|- | |- | ||
| 0 | | 0 || 1 || 0 || 0 | ||
| 1 | |||
| 0 | |||
| 0 | |||
|- | |- | ||
| 1 | | 1 || 0 || 0 || 0 | ||
| 0 | |||
| 0 | |||
| 0 | |||
|- | |- | ||
| 1 | | 1 || 1 || 0 || 0 | ||
| 1 | |||
| 0 | |||
| 0 | |||
|} | |} | ||
Ou utilizar os postulados e teoremas da algebra de boole | ;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 | |||
:'''PASSO | ::<math>X+Y + \overline{X+Y} = 1 </math> | ||
::<math>(X+Y) + (\overline{X}\cdot\overline{Y}) = 1 </math> | |||
:'''PASSO | :'''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> | ::<math> (X + Y) + (\overline{X}\cdot\overline{Y})=(X + Y + \overline{X})\cdot(X + Y + \overline{Y}) </math> | ||
:'''PASSO | |||
:'''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> | ::<math>(X + Y + \overline{X})\cdot(X + Y + \overline{Y}) = (Y + X + \overline{X})\cdot(X + Y + \overline{Y}) </math> | ||
:'''PASSO | |||
:'''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> | ::<math>(Y + X + \overline{X})\cdot(X + Y + \overline{Y}) = (Y + 1) \cdot (X + 1) </math> | ||
:'''PASSO | |||
:'''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> | ::<math> (Y + 1) \cdot (X + 1) = 1 \cdot 1 </math> | ||
:'''PASSO | :'''PASSO 7:''' pelo axioma da multiplicação ('''A5''') <math> 1 \cdot 1 = 1 </math>, podemos afirmar que | ||
::<math> 1 \cdot 1 = 1 </math> | ::<math> 1 \cdot 1 = 1 </math> | ||
: Portanto a consideração inicial é verdadeira <math> \overline{X+Y} = \overline{X} \cdot \overline{Y} </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 | :'''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>. | ::<math>(X+Y) . (\overline{X}\cdot\overline{Y}) = 0 </math>. | ||
:Tente desenvolver o restante da prova usando apenas os postulados e teoremas. | :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 \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> | : <math> \overline{X_1 + X_2 + ... + X_N} = \overline{X_1} \cdot \overline{X_2} \cdot ... \cdot \overline{X_N}</math> | ||
;Exercícios: | ;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 [ | 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 | :a) ABC + A + BC | ||
:b) A.B + A.B’ + A’.B | :b) A.B + A.B’ + A’.B | ||
| Linha 1 365: | Linha 1 518: | ||
:d) X.Y + X.Z + Z.Y | :d) X.Y + X.Z + Z.Y | ||
:e) D.B’+D.(D.B+C.D’) | :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: | ;PARA O PRÓXIMO ENCONTRO: | ||
*Rever slides 16 até fim de [https:// | *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]] | ||
*Ler a seção '''2.3.ÁLGEBRA BOOLEANA''' nas pag 107 a 116 de [https:// | *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]] | *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 | ;Encontro 12 (24 abr.) | ||
* | * Exercícios de algebra booleana | ||
* Mapa de Karnaugh | |||
* | |||
;Encontro | ;Encontro 13 (29 abr.) | ||
* | *Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch: | ||
*Ver resumo em [https:// | *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. | *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 | ;Encontro 14 (6 mai.) | ||
*Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch: | *Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch: | ||
*Ver resumo em [https:// | *Uso do ''don't care'' na simplificação | ||
*Ler a seção '''2.7.MAPAS DE KARNAUGH''' nas pag 99 a 108 de [https:// | |||
*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 13 (2 | ;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 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] | *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] | *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://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] | *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 | ;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 19 (22 mai.) | |||
;Encontro | Projeto de circuitos combinacionais: | ||
*Ver resumo em [https:// | *Ver resumo em [https://drive.google.com/file/d/1O86iYyEQ2ZJ77x1hERSAwaKqQfRanrBx/view?usp=drive_link Projeto de circuitos combinacionais] | ||
*Multiplexadores e Decodificadores: | *Multiplexadores e Decodificadores: | ||
*Ler a seção '''2.8.BLOCOS COMBINATÓRIOS''' nas pag 109 a 114 [https:// | *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): | ;Encontro 18 (23 abr.) - Avaliação A1c (6 pontos): | ||
*Consumo de energia de circuitos digitais. | *Consumo de energia de circuitos digitais. | ||
| Linha 1 427: | Linha 1 609: | ||
::<math> P_{Total} = P_{Estatica} + P_{Dinamica} </math> | ::<math> P_{Total} = P_{Estatica} + P_{Dinamica} </math> | ||
*Ler pag 69 a 70 de [https:// | *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) | ||
--> | --> | ||
| Linha 1 443: | Linha 1 615: | ||
===Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim=== | ===Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim=== | ||
* | * 7 ENCONTROS | ||
{{collapse top | Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim }} | {{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 | ;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 | * Estrutura do código VHDL | ||
| Linha 1 504: | Linha 1 678: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
*Uso do ambiente EDA - QUARTUS Prime para programação em VHDL | *[[Uso do ambiente EDA - QUARTUS Prime para programação em VHDL]] | ||
;PARA O PRÓXIMO ENCONTRO | ;PARA O PRÓXIMO ENCONTRO | ||
| Linha 1 576: | Linha 1 710: | ||
*Guardar [[Folha de consulta de VHDL]] | *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]] | |||
*[https://wiki. | *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}} | {{collapse bottom}} | ||
===Unidade 5 - Circuitos lógicos combinacionais (com VHDL)=== | ===Unidade 5 - Circuitos lógicos combinacionais (com VHDL)=== | ||
* | * 7 ENCONTROS | ||
{{collapse top | expand=true |Unidade 5 - Circuitos lógicos combinacionais (com VHDL)}} | {{collapse top |expand=true |Unidade 5 - Circuitos lógicos combinacionais (com VHDL)}} | ||
<!-- | |||
;Encontro | ;Encontro 29 e 30 (24 e 26 jun.) | ||
* Conhecer o [[Código Gray]] | * Conhecer o [[Código Gray]] | ||
* Implementação de conversor Binário para Gray (bin2gray) | * Implementação de conversor Binário para Gray (bin2gray) | ||
| Linha 1 686: | Linha 1 816: | ||
* Descubra quantas portas ou exclusivo seriam necessárias para o caso de N bits. | * 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. | 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. | ||
| Linha 1 712: | Linha 1 841: | ||
end architecture | end architecture | ||
</syntaxhighlight> | </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> | |||
------------------------- | |||
-- File: inc_gray.vhd -- | |||
------------------------- | |||
entity inc_gray is | |||
port | |||
( | |||
g_in : in std_logic_vector(3 downto 0); | |||
g_out : out std_logic_vector(3 downto 0) | |||
); | |||
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; | |||
</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> | |||
-- 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> | |||
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; | |||
</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. | * 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). | 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''' | *'''MUX2:1''' | ||
A tabela verdade que descreve um MUX2:1 é mostrada abaixo: | A tabela verdade que descreve um MUX2:1 é mostrada abaixo: | ||
| Linha 1 789: | Linha 1 999: | ||
|} | |} | ||
</center> | </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: | A função booleana que descreve a operação de um MUX 2:1 pode ser representada da seguinte forma: | ||
| Linha 1 861: | Linha 2 071: | ||
port | 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; | end entity; | ||
| Linha 1 871: | Linha 2 087: | ||
-- Implementação com lógica pura | -- Implementação com lógica pura | ||
architecture v_logica_pura of mux4x1 is | architecture v_logica_pura of mux4x1 is | ||
begin | begin | ||
Y <= (X(0) and (not Sel(1)) and (not Sel(0))) or | 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; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
| Linha 1 891: | Linha 2 107: | ||
Warning (13012): Latch ... has unsafe behavior | Warning (13012): Latch ... has unsafe behavior | ||
* No | * 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 | -- Implementação com WHEN ELSE | ||
architecture v_WHEN_ELSE of mux4x1 is | architecture v_WHEN_ELSE of mux4x1 is | ||
begin | begin | ||
Y <= X(0) when Sel = "00" else | Y <= X(0) when Sel = "00" else | ||
| Linha 1 910: | Linha 2 125: | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
<optional_label>: with <expression> select | <optional_label>: with <expression> select | ||
<target> <= | <target> <= <value> when <choices>, | ||
<value> when <choices>, | |||
<value> when <choices>, | |||
... | |||
<value> when others; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
| Linha 1 922: | Linha 2 136: | ||
Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression | Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression | ||
* No | * 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 | -- Implementação com WITH SELECT | ||
architecture v_WITH_SELECT of mux4x1 is | architecture v_WITH_SELECT of mux4x1 is | ||
begin | begin | ||
with Sel select | with Sel select | ||
| Linha 1 960: | Linha 2 174: | ||
* Note a que ao verificar o Technology Map Viewer, nos 3 primeiros casos serão usados os mesmos elementos lógicos. | * 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 |}} | {{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. | * 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. | ||
| Linha 1 976: | Linha 2 182: | ||
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. | 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. | {{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). | |||
;Encontro | |||
* | |||
:*Considere o decodificador que havia sido implementado na | |||
:*Em uma solução melhorada devem ser utilizados vetores para representar a entrada ( | |||
* Usando a instrução '''when else''' | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
library ieee; | library ieee; | ||
| Linha 2 013: | Linha 2 202: | ||
port( | port( | ||
bin : in std_logic_vector (3 downto 0); | bin : in std_logic_vector (3 downto 0); | ||
ssd : out std_logic_vector (6 downto 0) | ssd : out std_logic_vector (6 downto 0) -- indices decrescentes | ||
-- ssd : out std_logic_vector (0 to 6) -- indices crescentes | |||
); | ); | ||
end entity; | end entity; | ||
| Linha 2 020: | Linha 2 210: | ||
begin | begin | ||
-- indices decrescentes | |||
ssd <= "0111111" when bin = "0000" else | ssd <= "0111111" when bin = "0000" else | ||
... | ... | ||
-- indices crescentes | |||
-- ssd <= "1111110" when bin = "0000" else | |||
end architecture; | end architecture; | ||
</syntaxhighlight > | </syntaxhighlight > | ||
* Usando a instrução '''with select''' | |||
<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> | <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> | |||
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> | |||
library ieee; | |||
use ieee.std_logic_1164.all; | |||
</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> | ||
:'''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> | |||
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> | |||
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> | </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> | <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> | </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> | <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> | ||
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> | |||
< | :: 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> | ||
package standard is | |||
type boolean is (false,true); | |||
type bit is ('0', '1'); | |||
type severity_level is (note, warning, error, failure); | |||
type integer is range -2147483647 to 2147483647; | |||
type real is range -1.0E308 to 1.0E308; | |||
type time is range -2147483648 to 2147483647 | |||
units | |||
fs; | |||
ps = 1000 fs; | |||
ns = 1000 ps; | |||
us = 1000 ns; | |||
ms = 1000 us; | |||
sec = 1000 ms; | |||
min = 60 sec; | |||
hr = 60 min; | |||
end units; | |||
subtype natural is integer range 0 to integer'high; | |||
subtype positive is integer range 1 to integer'high; | |||
type string is array (positive range <>) of character; | |||
type bit_vector is array (natural range <>) of bit; | |||
</syntaxhighlight> | |||
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 | ;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> | <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> | </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> | <syntaxhighlight lang=vhdl> | ||
--============================================================================ | |||
-- RESIZE Functions | |||
--============================================================================ | |||
function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED; | |||
function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED; | |||
--============================================================================ | |||
-- Conversion Functions | |||
--============================================================================ | |||
function TO_INTEGER (ARG: UNSIGNED) return NATURAL; | |||
function TO_INTEGER (ARG: SIGNED) return INTEGER; | |||
function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED; | |||
function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
:: Ver pag. 73 a 78 de <ref name="PEDRONI2010b"/> | |||
; | :* 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> | |||
library ieee; | |||
use ieee.std_logic_1164.all; | |||
<syntaxhighlight lang=vhdl> | |||
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> | <syntaxhighlight lang=vhdl> | ||
entity somador is | |||
port ( | |||
a, b : in integer; | |||
s : out integer; | |||
end entity; | |||
architecture ifsc of somador is | |||
begin | |||
s <= a + b; | |||
end architecture; | |||
</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; | end entity; | ||
architecture | architecture ifsc of somador is | ||
begin | begin | ||
s <= a + b; | |||
end architecture; | end architecture; | ||
</syntaxhighlight> | </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> | </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> | <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> | </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 |}} | |||
Para fazer uma multiplicação, basta usar o operador "*"e o compilador irá implementar um multiplicador. Neste caso para evitar o overflow é importante definir o range da saída com um tamanho suficiente para comportar o maior produto | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
entity multiplicador is | |||
port ( | |||
entity | a, b : in integer range 0 to 15; | ||
s : out integer range 0 to 15*15); | |||
end entity; | end entity; | ||
architecture | architecture ifsc of multiplicador is | ||
begin | begin | ||
s <= a * b; | |||
end architecture; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
{{fig|4. | {{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> | <syntaxhighlight lang=vhdl> | ||
architecture | entity divisor is | ||
begin | 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; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
{{fig|4. | {{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> | <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> | </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> | <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> | </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 | ;Encontro 40 (6 mar.) | ||
* Avaliação de recuperação R1 e R2. | |||
--> | |||
{{collapse | <!-- | ||
;Encontro 37 (07 dez.) | |||
; | |||
* | |||
;Exemplo 1: | |||
;Encontro 38 ( | |||
* | 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. | ||
==Avaliações== | 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'. | ||
Durante o semestre serão realizadas 4 avaliações. As avaliações devem ser enviadas pela plataforma Moodle com os arquivos solicitados. | Conforme veremos a seguir, é possível realizar diversas descrições em VHDL para esse circuito. | ||
;Data das avaliações: | |||
* | ;Solução 1: | ||
*A2 - : | 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> | |||
== Atividade relâmpago (AR) == | library ieee; | ||
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. | use ieee.std_logic_1164.all; | ||
entity vagas is | |||
== Atividade extra-classe (AE) == | generic (N : natural := 4 ); | ||
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. | |||
port ( | |||
x : in std_logic_vector (N-1 downto 0); | |||
y : out std_logic | |||
); | |||
end entity; | |||
architecture ifsc_v1 of vagas is | |||
===AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos=== | begin | ||
{{collapse top | bg=lightyellow | AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos}} | -- usando when-else | ||
;Objetivos: | y <= '1' when x(0) = '0' else | ||
* Conhecer o mostrador (diplay) de 7 segmento | '1' when x(1) = '0' else | ||
* 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. | '1' when x(2) = '0' else | ||
* Descrever o funcionamento de um circuito através de uma tabela verdade. | '1' when x(3) = '0' else | ||
* Usar a técnica do mapa de Karnaugh para minimizar a função lógica de cada uma das saídas. | '0'; | ||
end architecture; | |||
;Atividades: | </syntaxhighlight> | ||
*Veja como funciona o [[Display de 7 segmentos]]. | |||
*Nesta atividade os estudantes devem projetar um conversor de binário para mostrador de 7 segmentos. | {{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 |}} | |||
;Entregas: | |||
*O projeto todo deverá se realizado manuscrito, devendo as folhas ter a identificação do nome completo do estudante e estar grampeadas. *Deverão ser apresentados no mínimo: | 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. | ||
:1) A tabela verdade completa indicando para as entradas de 0 a | |||
:2) Para cada saída mostre o mapa de | 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). | ||
:3) Para cada saída deve ser apresentada a expressão lógica minimizada e também o circuito lógico obtido. | {{fig|4.14| Simulação do indicador de vagas | vagas9.png | 800 px |}} | ||
*A entrega será feita pessoalmente para o professor no prazo indicado no Moodle. | |||
{{collapse bottom}} | ;Solução 2: | ||
Realizar uma operação ou sobre todas as entradas x invertidas. | |||
===AE2 - Conhecendo os dispositivos lógicos programáveis=== | <syntaxhighlight lang=vhdl> | ||
{{collapse top | | architecture ifsc_v2 of vagas is | ||
;Objetivos: | begin | ||
*Conhecer o Quartus Prime e as características dos dispositivos lógicos programáveis | -- usando or e not | ||
*Analisar os tempos de propagação em um circuito combinacional | 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 | |||
END ENTITY; | |||
ARCHITECTURE v1 OF multiplicador4x4 IS | |||
BEGIN | |||
y <= a * b; | |||
END ARCHITECTURE; | |||
</syntaxhighlight> | |||
*Observar o número de elementos lógicos, bits usados para representar as entradas e saídas. | |||
*Observar o código RTL obtido. | |||
*Realizar a simulação com entradas UNSIGNED e INTEGER na faixa de valores de 0 até 15, e analisar se o valor da saída está correto. | |||
*Realizar a simulação com entradas SIGNED e INTEGER na faixa de valores de -8 até 7, e analisar se o valor da saída está correto. | |||
*Realizar a simulação com entradas STD_LOGIC_VECTOR na faixa de valores de 0 até 15, e analisar se o valor da saída está correto. Neste caso será necessário realizar uma conversão de STD_LOGIC_VECTOR para UNSIGNED antes de efetuar a operação de "*", e após a operação é necessário fazer a operação inversa UNSIGNED para STD_LOGIC_VECTOR | |||
*Realizar a simulação com entradas STD_LOGIC_VECTOR na faixa de valores de -8 até 7, e analisar se o valor da saída está correto. Neste caso será necessário realizar uma conversão de STD_LOGIC_VECTOR para SIGNED antes de efetuar a operação de "*", e após a operação é necessário fazer a operação inversa SIGNED para STD_LOGIC_VECTOR | |||
:: Ver pag. 39 a 54 de <ref name="PEDRONI2010b"/> | |||
;Encontro 38 (12 dez.) | |||
* Exercícios da Unidades 4 e 5 | |||
--> | |||
{{collapse bottom}} | |||
==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 | *Alterar configurações do compilador | ||
*Fazer a simulação funcional de um circuito combinacional. | *Fazer a simulação funcional de um circuito combinacional. | ||
;Atividades: | ;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]] | *'''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. | :*Ao escolher a família de FPGAS, escolha inicialmente um dispositivo da família '''Max II'''. Anote o código desse dispositivo. | ||
| Linha 2 793: | Linha 3 306: | ||
:*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''' | :*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. | :*Capture as telas mostradas no roteiro e depois utilize-as no relatório da atividade. | ||
:*Anote o máximo | :*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. | :*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 modificar as configurações do compilador, conforme mostrado em '''Configurando o compilador'''. Se desejar mude a semente inicial trocando o valor de '''[Seed: 1]''' | ||
| Linha 2 800: | Linha 3 313: | ||
:*Ao final salve o projeto em um arquivo QAR (sugestão PJ2.QAR) | :*Ao final salve o projeto em um arquivo QAR (sugestão PJ2.QAR) | ||
*'''PASSO 4''': Realize a simulação funcional de | *'''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. | :*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: | ;Entregas: | ||
| Linha 2 852: | Linha 3 368: | ||
*para DE2-115 '''{Assignments > Device... > Device family (Family: [Cyclone IV E], Name filter: [EP4CE115F29C7] ) > [OK]}''' | *para DE2-115 '''{Assignments > Device... > Device family (Family: [Cyclone IV E], Name filter: [EP4CE115F29C7] ) > [OK]}''' | ||
*para MERCÚRIO IV '''{Assignments > Device... > Device family (Family: [Cyclone IV E], Name filter: [EP4CE30F23C7] ) > [OK]}''' | *para 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. | 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. | ||
| Linha 2 860: | Linha 3 377: | ||
*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. | *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;" | {| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222;" | ||
|- style="font-weight:bold;" | |- style="font-weight:bold;" | ||
| Linha 2 867: | Linha 3 385: | ||
! I/O Standard | ! I/O Standard | ||
|- | |- | ||
| SW[0] || | | SW[0] || PIN_V21 || Chave tipo Slide Switch 3 || 3.3V | ||
|- | |- | ||
| SW[1] || | | SW[1] || PIN_W22 || Chave tipo Slide Switch 2 || 3.3V | ||
|- | |- | ||
| SW[2] || | | SW[2] || PIN_W21 || Chave tipo Slide Switch 1 || 3.3V | ||
|- | |- | ||
| SW[3] || | | SW[3] || PIN_Y22 || Chave tipo Slide Switch 0 || 3.3V | ||
|} | |} | ||
* Configurar como entrada os seguintes pinos: | * Configurar como entrada os seguintes pinos: | ||
eA | eA Y22 | ||
eB | eB W21 | ||
eC | eC W22 | ||
eD | eD V21 | ||
*Observe a tabela com a pinagem dos display (mostrador de sete segmentos) disponíveis neste kit. | *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;" | {| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222;" | ||
| Linha 2 924: | Linha 3 442: | ||
:# Carregar nas chaves os valores binários de 10 ("1010") a 15 ("1111") e observar se o que é mostrado. | :# Carregar nas chaves os valores binários de 10 ("1010") a 15 ("1111") e observar se o que é mostrado. | ||
:# Anote todos os resultados | :# Anote todos os resultados | ||
{| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222; text-align:center;" | |||
{| class="wikitable" style="vertical-align:middle; background-color:#FFF; color:#222;" | |||
|+ | |+ | ||
|- | |- | ||
| Linha 2 939: | Linha 3 456: | ||
! Mostrador | ! Mostrador | ||
|- | |- | ||
| 0 || 0000 || | | 0 || 0000 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 1 || 0001 || || || || || || || || | | 1 || 0001 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 2 || 0010 || || || || || || || || | | 2 || 0010 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 3 || 0011 || || || || || || || || | | 3 || 0011 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 4 || 0100 || || || || || || || || | | 4 || 0100 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 5 || 0101 || || || || || || || || | | 5 || 0101 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 6 || 0110 || || || || || || || || | | 6 || 0110 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 7 || 0111 || || || || || || || || | | 7 || 0111 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 8 || 1000 || || || || || || || || | | 8 || 1000 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| 9 || 1001 || || || || || || || || | | 9 || 1001 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| A || 1010 || || || || || || || || | | A || 1010 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| B || 1011 || || || || || || || || | | B || 1011 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| C || 1100 || || || || || || || || | | C || 1100 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| D || 1101 || || || || || || || || | | D || 1101 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| E || 1110 || || || || || || || || | | E || 1110 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|- | |- | ||
| F || 1111 || || || || || || || || | | F || 1111 || || || || || || || || [[Arquivo:ssd_off.png|15px]] | ||
|} | |} | ||
;Relatório Técnico: | ;Relatório Técnico: | ||
| Linha 2 983: | Linha 3 499: | ||
* O relatório deve também responder as questões levantadas e mostrar que os objetivos apresentados na introdução foram atendidos. | * O relatório deve também responder as questões levantadas e mostrar que os objetivos apresentados na introdução foram atendidos. | ||
{{collapse bottom}} | {{collapse bottom}} | ||
--> | |||
==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: