ELD129002-Engtelecom (Diário) - Prof. Marcos Moecke: mudanças entre as edições

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
← Edição anterior
Moecke (discussão | contribs)
Alunos, Bolsistas, CST, Engenharia, G10, G2, G5, G6, G7, G9, Gt2, Professores, TAEs, Burocratas, Administradores
22 924 edições
Moecke (discussão | contribs)
Alunos, Bolsistas, CST, Engenharia, G10, G2, G5, G6, G7, G9, Gt2, Professores, TAEs, Burocratas, Administradores
22 924 edições
 
(161 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://docente.ifsc.edu.br/moecke/ppc-engtelecom/PPC2023/ grafo do curriculo]
* 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 24: Linha 23:


===Unidade 2 - Sistema de numeração e códigos===
===Unidade 2 - Sistema de numeração e códigos===
* 4 ENCONTROS
* 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 - Sistemas numéricos:
<!--
;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:
;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,3x102 </big>
: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 (já em desuso).
:*'''OBS:''' Muitas vezes os números binários são representados através do sistema hexadecimal ou do sistema octal.
 
{{collapse top | Uso do Sistema Hexadecimal e Octal}}
;Sistema Hexadecimal (Base 16):
*'''Computação e Programação''': Muito usado para representar cores em HTML/CSS (ex: #FF5733), endereços de memória, e depuração de código em linguagens de baixo nível como Assembly e C.
*'''Endereços MAC''': Dispositivos de rede usam endereços MAC, que são representados em hexadecimal (ex: 00:1A:2B:3C:4D:5E).
Codificação e Criptografia: Muitos algoritmos de criptografia usam representações hexadecimais para armazenar e exibir dados de forma compacta.
*'''Representação Binária Compacta''': Como cada dígito hexadecimal representa 4 bits, ele é frequentemente usado para simplificar a leitura de valores binários grandes.
 
;Sistema Octal (Base 8):
*'''Permissões de Arquivos no Linux/Unix''': O sistema octal é utilizado para definir permissões de arquivos no formato '''chmod'''.  No Linux/Unix, cada arquivo tem três tipos principais de permissões:
:*Leitura (r): Permite visualizar o conteúdo do arquivo.
:*Escrita (w): Permite modificar o conteúdo do arquivo.
:*Execução (x): Permite executar o arquivo, se for um programa ou script.
:Essas permissões são atribuídas a três categorias de usuários:
:*Dono (owner): O usuário que possui o arquivo.
:*Grupo (group): O grupo de usuários associado ao arquivo.
:*Outros (others): Todos os outros usuários.
:Assim o comando chmod 755, indica que as permissões seriam:
:*Dono: leitura, escrita, execução (rwx = 7)
:*Grupo: leitura, execução (r-x = 5)
:*Outros: leitura, execução (r-x = 5)
{{collapse bottom}}


*Sistema binário:
;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 representado 111, corresponde a 1 quadra (2² = 4), 1 dupla (2¹ = 2) e 1 unidade (2⁰ = 1).
:*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://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)
* 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)
* Ver [https://drive.google.com/file/d/1aaQ3x7HqHN6Y652GpxwEoQHd3vO-LpJq/view?usp=drive_link Slides - Sistemas Numéricos] (#page=1)
* 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:
 
;Conversão de bases entre sistemas numéricos:
;Encontro 3 (25 mar.):
*Conversão entre os sistemas de numeração '''decimal - binário - hexadecimal'''.
:*ver os [https://drive.google.com/file/d/1aaQ3x7HqHN6Y652GpxwEoQHd3vO-LpJq/view?usp=drive_link  slides - Sistemas Numéricos (conversão entre sistemas)] (#page=15)
*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 222: Linha 299:
| colspan="10" style="font-weight:bold;" |  d<sub>k</sub> × N<sup>k</sup> + d<sub>2</sub> × N<sup>2</sup> + d<sub>1</sub> × N<sup>1</sup> + d<sub>0</sub> × N<sup>0</sup> + d<sub>-1</sub> × N<sup>-1</sup> + d<sub>-2</sub> × N<sup>-2</sup> + d<sub>-l</sub> × N<sup>-l</sup>
| colspan="10" style="font-weight:bold;" |  d<sub>k</sub> × N<sup>k</sup> + d<sub>2</sub> × N<sup>2</sup> + d<sub>1</sub> × N<sup>1</sup> + d<sub>0</sub> × N<sup>0</sup> + d<sub>-1</sub> × N<sup>-1</sup> + d<sub>-2</sub> × N<sup>-2</sup> + d<sub>-l</sub> × N<sup>-l</sup>
|}
|}
;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:
;Códigos numéricos binários:
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(] </math>. Nesta representação existem dois zeros, o +0 e o -0.  
: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)


;PARA O PRÓXIMO ENCONTRO:
* Iniciar a 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)
;Encontro 4:
;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 129: Linha 1 271:
*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 5:
* [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===
* 10 ENCONTROS
* 13 ENCONTROS
{{collapse top | expand=true | Unidade 3 - Funções, portas lógicas e álgebra booleana }}
{{collapse top | expand=true|   Unidade 3 - Funções, portas lógicas e álgebra booleana }}
;Encontro 6
<!--
;Encontro 7  (8 abr.)
;Funções e portas lógicas:
;Funções e portas lógicas:
*[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link  Funções e portas lógicas]
*[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link  Funções e portas lógicas]
Linha 1 249: Linha 1 400:
*Rever[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link  Funções e portas lógicas]
*Rever[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link  Funções e portas lógicas]
*Ler pag 49 a 69 de [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link  Projeto Digital e Arquitetura de Computadores] (#page=49)
*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 7
;Encontro 8  (10 abr.)
;Funções e portas lógicas:
;Funções e portas lógicas:
*[https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link  Funções e portas lógicas]
*continuação [https://drive.google.com/file/d/19NxKecPdEgnVGBCYxY5OndR-SurEwhdW/view?usp=drive_link  Funções e portas lógicas]
 
;PARA O PRÓXIMO ENCONTRO:
;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 8
;Encontro 10  (17 abr.)
*Avaliação A1a - Sistemas numéricos (55 minutos)
*[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] - slides
*[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole] - slides
;PARA O PRÓXIMO ENCONTRO:
;Para o próximo encontro:
*Rever slides 1 a 15 de [https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole]  
*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 '''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]]
;Encontro 9 (15 out.)
*Estudar a [[Media:Algebra_booleana.pdf | Folha de consulta sobre álgebra booleana]] para as próximas duas avaliações
*Avaliação A1a - 1ª parte A1a (3 pontos) - Sistema de numeração, Códigos, Álgebra booleana;


 
;Encontro 11 (22 abr.)
;Encontro 10 (17 out.)
*[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole]
*[https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole]
;Teoremas de De Morgan:
;Teoremas de De Morgan:
Linha 1 273: Linha 1 436:
*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 282: 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 \cdot Y}  </math>
| style="font-weight:normal; width: 25%;" | <math> \overline{X + Y}  </math>
| style="font-weight:normal; width: 25%;" |  <math> \overline{X} + \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 || 1 || 1
| 1
| 1
| 1
|-
|-
| 1
| 1 || 0 || 1 || 1
| 0
| 1
| 1
|-
|-
| 1
| 1 || 1 || 0 || 0
| 1
| 0
| 0
|}
|}


Linha 1 316: 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:
Considerando que <math> \overline{X+Y} = \overline{X} \cdot \overline{Y} </math> seja verdade, então
:'''PASSO 1:''' pelo teorema da complementação ('''T5'''') <math> A + \overline{A}  = 1 </math>, podemos afirmar que  
:'''PASSO 1:''' pelo postulado do complemento <math> A + \overline{A}  = 1 </math>, podemos afirmar que  
::<math>X+Y + \overline{X+Y} = 1 </math>
::<math>(X + Y) + (\overline{X + Y}) = 1 </math>
 
:'''PASSO 2:''' considerando  <math> \overline{X+Y} = \overline{X} \cdot \overline{Y} </math> substituindo na equação acima temos:
:'''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>
::<math>(X + Y) + (\overline{X} \cdot \overline{Y}) = 1 </math>
:'''PASSO 3:''' pelo teorema da distribuição <math> A + (B \cdot C) = (A + B) \cdot (A + C) </math>, podemos afirmar que   
 
:'''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 4:''' pelo teorema da comutação <math> A + B = B + A </math>, podemos afirmar que   
 
:'''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 5:''' pelo postulado do complemento <math> A + \overline{A}  = 1 </math>, podemos afirmar que   
 
:'''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 6:''' pelo postulado do elemento absorvente <math> A + 1  = 1 </math>, podemos afirmar que   
 
:'''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 7:''' pelo postulado da multiplicação (AND) <math> 1 \cdot 1  = 1 </math>, podemos afirmar que   
:'''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 postulado do complemento <math> \overline{A} \cdot A = 0 </math>, pois neste caso, podemos afirmar que  
:'''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.


Usando um circuito lógico é possível verificar que o teorema é verdadeiro.  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>].
;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:
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:
Linha 1 366: Linha 1 512:


;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 [https://moodle.ifsc.edu.br/pluginfile.php/372852/mod_resource/content/1/Folha%20de%20consulta%20-%20%C3%A1lgebra%20booleana.pdf Folha de consulta - álgebra booleana].
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 372: 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)
Ver também exemplos em 4-4 ANÁLISE BOOLEANA DE CIRCUITOS LÓGICOS [[https://app.minhabiblioteca.com.br/reader/books/9788577801077/pageid/206 FLOYD, Thomas. Sistemas digitais. Grupo A, 2011. E-book. ISBN 9788577801077]


;PARA O PRÓXIMO ENCONTRO:
;PARA O PRÓXIMO ENCONTRO:
*Ver exemplos em 4-4 ANÁLISE BOOLEANA DE CIRCUITOS LÓGICOS [[https://app.minhabiblioteca.com.br/reader/books/9788577801077/pageid/206 FLOYD, Thomas. Sistemas digitais. Grupo A, 2011. E-book. ISBN 9788577801077] na [[Minha Biblioteca]]
*Rever slides 16 até fim de [https://drive.google.com/file/d/1sEbeggOkjlb0VlRBWsnoqxSoFV-_igpr/view?usp=drive_link Álgebra de Boole]
*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 '''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)
Linha 1 385: Linha 1 531:
:* [https://tinyurl.com/25owykbn Teorema de Demorgan <math> \overline{X \cdot Y} = \overline{X} + \overline{Y} </math>]
:* [https://tinyurl.com/25owykbn Teorema de Demorgan <math> \overline{X \cdot Y} = \overline{X} + \overline{Y} </math>]


;Encontro 11-12:
;Encontro 12 (24 abr.)
*Expressão booleana - Tabela verdade - Circuito com portas lógicas:
* Exercícios de algebra booleana
*Ver resumo em [https://drive.google.com/file/d/1lNvJtT1oXv9JlBUDm-veVWExX2IehtzQ/view?usp=drive_link Expressão booleana - Tabela verdade - Circuito com portas lógicas]
* Mapa de Karnaugh
;Para a próxima aula:
 
*Rever resumo em [https://drive.google.com/file/d/1lNvJtT1oXv9JlBUDm-veVWExX2IehtzQ/view?usp=drive_link Expressão booleana - Tabela verdade - Circuito com portas lógicas]
;Encontro 13 (29 abr.)
*Resolver [https://drive.google.com/file/d/16pN70NdO9a-qEKthQwn5OFidA_Y92CTm/view?usp=drive_link Exercícios de álgebra de Boole]
;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 13 e 14  (29 e 31 out.)
*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://drive.google.com/file/d/1BuOGIYApQmoL77jVTrXtXTE4BZkWaPfU/view?usp=drive_link Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch]
*Ver resumo em [https://drive.google.com/file/d/1BuOGIYApQmoL77jVTrXtXTE4BZkWaPfU/view?usp=drive_link Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch]
Linha 1 405: Linha 1 546:
{{fig|3.1|Conjuntos para mostrador de 7 segmentos| 7segment_sets.png| 800 px | }}
{{fig|3.1|Conjuntos para mostrador de 7 segmentos| 7segment_sets.png| 800 px | }}


;Encontro 15  (5 nov.)
;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:
*Uso do ''don't care'' na simplificação
*Uso do ''don't care'' na simplificação
*Ver resumo em [https://drive.google.com/file/d/1BuOGIYApQmoL77jVTrXtXTE4BZkWaPfU/view?usp=drive_link Simplificação de expressões lógicas - Mapas de Karnaugh-Veitch]
*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:
;Para a próxima aula:
Linha 1 414: Linha 1 557:
*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]
*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 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 e 17  (7 e 12 nov.)
;Encontro 16 (13 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]
*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.)
;Encontro 13 (2 abr.)
*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]
*K-Map online [https://www.docjava.com/cpe210/kmapExplorer.html docjava.com], [https://ictlab.kz/extra/Kmap/ ICT laboratory], [https://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/karnaughmap/ uni-marburg.de]
;Artigos originais dos métodos:
;Encontro 15 (9  abr.) - Projeto de circuitos combinacionais:  
*[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]
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311789/mod_resource/content/1/Projeto%20de%20circuitos%20combinacionais.pdf Projeto de circuitos combinacionais]
*[https://ieeexplore-ieee-org.ez130.periodicos.capes.gov.br/stamp/stamp.jsp?tp=&arnumber=6769983 E. J. McCluskey, "Minimization of Boolean functions," in The Bell System Technical Journal, vol. 35, no. 6, pp. 1417-1444, Nov. 1956, doi: 10.1002/j.1538-7305.1956.tb03835.x]
 
;Encontro 18 (20 mai.)
*Como transformar uma Expressão booleana em Tabela verdade e em Circuito com portas lógicas, e vice-versa:
*[https://drive.google.com/file/d/1lNvJtT1oXv9JlBUDm-veVWExX2IehtzQ/view?usp=drive_link Expressão booleana - Tabela verdade - Circuito com portas lógicas]
*[https://drive.google.com/file/d/1O86iYyEQ2ZJ77x1hERSAwaKqQfRanrBx/view?usp=drive_link Projeto de circuitos combinacionais]
 
;Encontro 19 (22 mai.)
Projeto de circuitos combinacionais:  
*Ver resumo em [https://drive.google.com/file/d/1O86iYyEQ2ZJ77x1hERSAwaKqQfRanrBx/view?usp=drive_link Projeto de circuitos combinacionais]
*Multiplexadores e Decodificadores:
*Multiplexadores e Decodificadores:
*Ler a seção '''2.8.BLOCOS COMBINATÓRIOS''' nas pag 109 a 114 [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=135)
*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 16 (11 abr.)
<!--
*Exercícios 2.1, 2.2, 2.5-7, 2.13-18, 2.22-25, 2.28-29, 2.31-32, 2.34, 2.35, 2.36-37, 2.39-40 ver [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link Projeto Digital e Arquitetura de Computadores] (#page=151)
*Pergunta 2.2, 2.3, 2.4 ver [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link  Projeto Digital e Arquitetura de Computadores] (#page=163)


;Encontro 18 (23  abr.) - Avaliação A1c (6 pontos):  
;Encontro 18 (23  abr.) - Avaliação A1c (6 pontos):  
*Simplificação de expressões lógicas e mapa de Karnaugh
 
*Representação de circuitos lógicos - '''Diagrama de portas lógicos = Tabela Verdade = Expressão lógica'''
-->
<!--


*Consumo de energia de circuitos digitais.
*Consumo de energia de circuitos digitais.
Linha 1 446: Linha 1 610:


*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)
*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)
;Encontro 11 (31  ago) - Exercícios de álgebra de Boole:
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/252198/mod_resource/content/1/Exercicios%20de%20algebra%20de%20boole.pdf Exercícios de álgebra de Boole]
*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)
;Encontro 12 (5  set) - Expressão booleana - Tabela verdade - Circuito com portas lógicas:
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/254019/mod_resource/content/1/Portas%20-%20Tabela%20verdade%20-%20Express%C3%B5es.pdf Expressão booleana - Tabela verdade - Circuito com portas lógicas]
*Ler a seção '''2.4. DA LÓGICA ÀS PORTAS e 2.5.LÓGICA COMBINATÓRIO MULTI-NÍVEL''' nas pag 90 a 95 de  [https://drive.google.com/file/d/1g8mbdH8DOc5_D8CfzUNcUb8P6qy0S4eV/view?usp=drive_link  Projeto Digital e Arquitetura de Computadores] (#page=116)
*Avaliação A1b (55 minutos)


-->
-->
Linha 1 461: Linha 1 615:


===Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim===
===Unidade 4 - Introdução a linguagem VHDL e Quartus/ModelSim===
* 6 ENCONTROS
* 7 ENCONTROS
{{collapse top | expand = true | 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 18 (14 nov.) - Linguagem VHDL:
;Encontro 21 a 23  (27 mai. a 3.jun.)
*Ver resumo em [https://moodle.ifsc.edu.br/pluginfile.php/311793/mod_resource/content/2/Introdu%C3%A7%C3%A3o%20a%20linguagem%20de%20descri%C3%A7%C3%A3o%20de%20hardware.pdf Introdução a linguagem de descrição de hardware (DHL)]
*[https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE2_-_Conhecendo_os_dispositivos_l.C3.B3gicos_program.C3.A1veis AE2 - Conhecendo os dispositivos lógicos programáveis] '''PASSOS 1 a 4'''
 
;Encontro 24 (5 jun.) - Linguagem VHDL:
* [https://wiki.sj.ifsc.edu.br/images/7/75/Introdu%C3%A7%C3%A3o_a_linguagem_de_descri%C3%A7%C3%A3o_de_hardware.pdf Introdução a linguagem de descrição de hardware (DHL)]


* Estrutura do código VHDL
* Estrutura do código VHDL
Linha 1 518: 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]]
;PASSO 0:
[[Acesso ao IFSC-CLOUD (NUVEM) | Acesse a nuvem do IFSC]] usando um terminal via ssh:
ssh LOGIN_SIGAA@quartus.sj.ifsc.edu.br -XC 
Insira a senha do SIGAA
LOGIN_SIGAA@quartus.sj.ifsc.edu.br's password:
 
;PASSO 1:
Abra o Quartus Prime digitando no terminal
quartus20.1.sh
Em seguida abra um arquivo para inserir o código VHDL.  No menu superior selecione '''[File > New > Design Files: VHDL File]''' e '''[OK]'''
 
;PASSO 2:
*Copie o código VHDL acima para o espaço de edição e salve o arquivo com o nome da '''entity''': ''nand_gate.vhd'', em um pasta exclusiva para este projeto.
*Ao ser perguntado se deseja criar um novo projeto, responda [Yes].  Os próximos passos podem ser realizados da seguinte forma:
:*Na tela '''Introduction''' [Next >]
:*Na tela '''Directory, Name, Top-Level Entity'''
::*Note onde o projeto será salvo. 
  /home/USER/PASTA_DO_PROJETO/
::*Note o nome do projeto. Se quiser pode mudá-lo
nand_gate
::*Note  o nome da '''top-level design entity'''
nand_gate
::*Em seguida [Next >]
:*Na tela '''Project Type''' [Next >]
:*Na tela '''Add Files''' [Next >], pois seu arquivo já está na lista dos arquivos.
:*Na tela '''Family, Device & Board Settings''', escolha a Family = ['''Cyclone IV E'''] e o Device = ['''EP4CE6E22A7'''] e [Next >]
:*Na tela '''EDA Tool Setting''' [Next >]
:*Note na tela Summary os dados do projeto e clique [Finish]
 
;PASSO 3:
Realize a '''Analysis & Synthesis''' ['''Processing > Start > Start Analysis & Synthesis'''], ou use um dos botões que o professor mostrou em aula.
:*Note o '''Compilation Report'''
 
;PASSO 4:
*Use o [[RTL Viewer]] para ver a descrição RTL do circuito. Selecione '''[Tools > Netlist Vieweres > RTL Viewer]'''.
*Use o [[Technology Map Viewer]] para ver a como o circuito foi mapeado para os elementos lógicos disponíveis no dispositivo FPGA selecionado.  Selecione '''[Tools > Netlist Vieweres > Technology Map Viewer]'''.
 
;PASSO 5:
*Modifique a descrição do circuito para implementar o circuito da função  Y = (A.B)' + C.D'B', salve o projeto Ckt2.vhd e de o mesmo nome para a entity.
 


;Encontro 19 (19  nov.)
*[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]
*ver também [[Preparando para gravar o circuito lógico no FPGA]]
<!--
;PARA O PRÓXIMO ENCONTRO
;PARA O PRÓXIMO ENCONTRO
*Escreva em VHDL o circuito do [https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE1_-_Projeto_de_um_conversor_de_bin.C3.A1rio_para_mostrador_de_7_segmentos AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos]  
*Escreva em VHDL o circuito do [https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE1_-_Projeto_de_um_conversor_de_bin.C3.A1rio_para_mostrador_de_7_segmentos AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos]  
Linha 1 595: Linha 1 711:




-->
;Encontro 25 e 26  (10 e 12  jun.)
*[https://wiki.sj.ifsc.edu.br/index.php/ELD129002-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE3_-_Programa.C3.A7.C3.A3o_do_kit_Mercurio_IV AE3 - Programação do kit Mercurio IV]
;PARA O PRÓXIMO ENCONTRO:
*ver [[Preparando para gravar o circuito lógico no FPGA]].
*ver [[Como arquivar um projeto]].
*ver [[Simulação Funcional usando o ModelSim]].
*ver [[Como utilizar a matriz de leds do kit Mercurio IV da Macnica]] - caso alguém deseje acender os leds conforme as chaves de entrada são selecionados.
*ver [[Acesso_ao_IFSC-CLOUD_(NUVEM)#Como_transferir_arquivos_entre_o_computador_local_e_a_NUVEM-IFSC | Como_transferir_arquivos_entre_o_computador_local_e_a_NUVEM-IFSC]].
*ver [[Acesso_ao_IFSC-CLOUD_(NUVEM)#Configuração_do_X2GO | Como configurar o X2Go para acessar a nuvem de seu computador pessoal]].
*ver [[Preparando_para_gravar_o_circuito_lógico_no_FPGA#Programando_o_kit_FPGA_usando_comando_de_linha | Programando o kit FPGA usando comando de linha]].
 
*Consultar e guardar a [[Folha de consulta de VHDL]]
*Ler a seção [https://pt.wikipedia.org/wiki/VHDL#História História] da página VHDL da wikipedia em português e as seções [https://en.wikipedia.org/wiki/VHDL#History History], [https://en.wikipedia.org/wiki/VHDL#Standardization Standardization}, [https://en.wikipedia.org/wiki/VHDL#Design Design] e [https://en.wikipedia.org/wiki/VHDL#Advantages Advantages] da página VHDL na Wikipedia em ingles.
-->
{{collapse bottom}}
{{collapse bottom}}


===Unidade 5 - Circuitos lógicos combinacionais (com VHDL)===
===Unidade 5 - Circuitos lógicos combinacionais (com VHDL)===
* 12 ENCONTROS
* 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 20 e 21 (21 e 26 nov.)  
<!--
;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):
;DESAFIO - 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>
;Encontro 22  (28 nov.)
*Avaliação A1b
;Encontro 23 e 24  (03 e 05 dez.) 
* Conhecer o [[Código Gray]]
* Implementação de incrementador Gray  (inc_gray)
* Implementação de incrementador Gray  (inc_gray)


Linha 1 743: Linha 1 866:
port
port
(
(
g_in  : in bit_vector(3 downto 0);
g_in  : in std_logic_vector(3 downto 0);
g_out  : out bit_vector(3 downto 0)
g_out  : out std_logic_vector(3 downto 0)
);
);
end entity;
end entity;


architecture ifsc_v1 of inc_gray is
architecture ifsc_v1 of inc_gray is
signal b_in   : bit_vector(3 downto 0);
signal bin   : std_logic_vector(3 downto 0);
signal b_in   : bit_vector(3 downto 0);
signal bin_inc   : std_logic_vector(3 downto 0);
begin
begin
-- Converter a entrada de g_in para b_in
-- Converter a entrada de g_in para b_in
Linha 1 766: Linha 1 889:
O problema nesta solução é como fazer o incremento de um número em binário.  Será necessário aprender:
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.
* 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,
* 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''').  
* 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?   
'''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.  
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 25 (10 dez.)
;Encontro 31 (1 jul.)  
*Realização da etapa 3 da avaliação A1 (60 minutos):
 
;Encontro 26 (12 dez.)  
* 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).
Linha 2 035: Linha 2 184:
{{fig|2.6|Technology Map do mux4x1 para a família Aria 10 | TM_mux4x1_S3.png| 400 px |}}
{{fig|2.6|Technology Map do mux4x1 para a família Aria 10 | TM_mux4x1_S3.png| 400 px |}}


;Encontro 27 (17 dez.)
;Encontro 32 (3 jul.)  
*Realize a simulação das 3 arquiteturas do MUX4:1 no Modelsim
*Avaliação A1c.
*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
;Encontro 33  (8 jul.)
vlib rtl_work
*Nova modelagem do decodificador (conversor) de binário para sete segmentos '''bin2ssd''':
vmap work rtl_work
:*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).
#vcom -93 -work work {/home/moecke/ELD1/ANO2024.2/Aula26/mux4x1.vhd}
:*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].
# substitua o caminho absoluto pelo relativo ../../
:*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.
vcom -93 -work work {../../mux4x1.vhd}
::A correspondencia dos bits do vetor ssd seria: a => ssd(0), b => ssd(1), ... g => ssd(6).
vsim work.mux4x1(v_logica_pura)
::A correspondencia dos bits do vetor bin seria: A => bin(3), B => bin(2), C => bin(1), D => bin(0). 


#adicionando os sinais a aba wave
* Usando a instrução '''when else'''
add wave -position end  sim:/mux4x1/X
<syntaxhighlight lang=vhdl>
add wave -position end  sim:/mux4x1/Sel
library ieee;
add wave -position end sim:/mux4x1/Y
use ieee.std_logic_1164.all;
entity bin2ssd is
    port(
        bin : in std_logic_vector (3 downto 0);
        ssd : out std_logic_vector (6 downto 0) -- indices decrescentes
    -- ssd : out std_logic_vector (0 to 6)    -- indices crescentes
    );
end entity;


#definindo o valor de um estimulo  (valor instante_de_tempo)
architecture when_else of bin2ssd is
force -freeze sim:/mux4x1/X 0101 0
 
#definindo varios valores de um estimulo  pares (valor instante_de_tempo) separados por virgula
begin
force -freeze sim:/mux4x1/Sel 00 0, 01 100, 10 200, 11 300
    -- indices decrescentes
# Execução da simulação. run ou run tempo
    ssd <= "0111111" when bin = "0000" else
# Se não tiver unidade é ps (pico segundos)
          ...
# fs            => femto segundos
 
# ps = 1000 fs;  => pico segundos
    -- indices crescentes
# ns = 1000 ps;  => nano segundos
--  ssd <= "1111110" when bin = "0000" else
# us = 1000 ns; => micro segundos
 
# ms = 1000 us;  => mili segundos
end architecture;
# sec = 1000 ms; => segundos
</syntaxhighlight >
# min = 60 sec;  => minutos
 
# hr = 60 min;  => horas
* Usando a instrução '''with select'''
run 400
<syntaxhighlight lang=vhdl>
force -freeze sim:/mux4x1/X 1100 0
architecture with_select of bin2ssd is
force -freeze sim:/mux4x1/Sel 00 0, 01 100, 10 200, 11 300
 
run 400
begin
force -freeze sim:/mux4x1/X 0011 0
 
force -freeze sim:/mux4x1/Sel 00 0, 01 100, 10 200, 11 300
end architecture;
run 400
</syntaxhighlight >
</syntaxhighlight>
;DESAFIO:
{{fig|2.7|Resultado da simulação do mux4x1 | SIM_mux4x1.png| 600 px |}}
*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.


*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>
*Inclua todos os arquivos .do no projeto do Quartus e salve o arquivo QAR


;Encontro 28 (19 dez.)  
;Encontro 34 (10 jul.)  
*Demultiplexador de 1 para 4 [https://tinyurl.com/yrvmxgq7]
Demultiplexador de 1 para 4 [https://tinyurl.com/yrvmxgq7]
:*Implementar em VHDL
:*Implementar em VHDL
<syntaxhighlight lang=vhdl>
<syntaxhighlight lang=vhdl>
Linha 2 107: Linha 2 254:
end architecture;
end architecture;
</syntaxhighlight>
</syntaxhighlight>
;Encontro 29  (28 jan.)
*Revisão dos circuitos do multiplexador mux4x1 e demux4x1. 
*Revisão do uso do simulador ModelSim e do script de simulação.
;Encontro 30 (30 jan.)


;Entender a importância do tipo de dado STD_LOGIC:
;Entender a importância do tipo de dado STD_LOGIC:
Linha 2 231: Linha 2 371:
:(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]].
:(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]].


*Nova modelagem do decodificador de binário para sete segmentos '''bin2ssd''':
<!--
::Considere o decodificador que havia sido implementado na AE2 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).
*Realize a simulação das 3 arquiteturas do MUX4:1 no Modelsim
::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 o decodificador.
*Crie um arquivo tb_mux4x1_v1.do que repita a simulação da arquitetura v1
<syntaxhighlight lang=tcl>
#file_name: tb_mux4x1_v1.do


<syntaxhighlight lang=vhdl>
#preparando o simulador
library ieee;
vlib rtl_work
use ieee.std_logic_1164.all;
vmap work rtl_work
entity bin2ssd is
#vcom -93 -work work {/home/moecke/ELD1/ANO2024.2/Aula26/mux4x1.vhd}
    port(
# substitua o caminho absoluto pelo relativo ../../
        bin : in std_logic_vector (3 downto 0);
vcom -93 -work work {../../mux4x1.vhd}
        ssd : out std_logic_vector (6 downto 0)
vsim work.mux4x1(v_logica_pura)
    );
end entity;


architecture when_else of bin2ssd is
#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


begin
#definindo o valor de um estimulo  (valor instante_de_tempo)
    ssd <= "0111111" when bin = "0000" else
force -freeze sim:/mux4x1/X 0101 0
          ...
#definindo varios valores de um estimulo  pares (valor instante_de_tempo) separados por virgula
end architecture;
force -freeze sim:/mux4x1/Sel 00 0, 01 100, 10 200, 11 300
</syntaxhighlight >
# Execução da simulação. run ou run tempo
 
# Se não tiver unidade é ps (pico segundos)
<!--
# fs            => femto segundos
;Encontro 29  (25 jul.)  
# ps = 1000 fs;  => pico segundos
*Implementação de um MUX4:1 usando chips comerciais de portas lógicas.
# ns = 1000 ps;  => nano segundos
;Encontro 27 e 28  (ANP e 7 nov.)  
# us = 1000 ns;  => micro segundos
*[[Laboratório - Implementação de um MUX4:1 em protoboard | AE2 - Atividade de Laboratório 2 ]] Passos 1 e 2
# 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>
*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.)  
;Encontro 29  (9 nov.)  
*[[Laboratório - Implementação de um MUX4:1 em protoboard | AE2 - Atividade de Laboratório 2 ]] Passos 3 e 4
*[[Laboratório - Implementação de um MUX4:1 em protoboard | AE2 - Atividade de Laboratório 2 ]] Passos 3 e 4
Linha 2 264: Linha 2 433:


;Encontro 31 e 32  (16 e 21 nov.)
;Encontro 31 e 32  (16 e 21 nov.)
-->




Linha 2 594: Linha 2 761:
:*Implementar em VHDL usando with-select e portas lógicas
:*Implementar em VHDL usando with-select e portas lógicas
:*Implementar a implementar em VHDL de um decodificador de 32 endereços
:*Implementar a implementar em VHDL de um decodificador de 32 endereços
 
-->
{{collapse bottom}}
{{collapse bottom}}


===Unidade 6 - Circuitos aritméticos (com VHDL) ===
===Unidade 6 - Circuitos aritméticos (com VHDL) ===
* 5 ENCONTROS
* 5 ENCONTROS
{{collapse top | expand=true | Unidade 6 - Circuitos aritméticos  (com VHDL)}}
{{collapse top | expand=true| Unidade 6 - Circuitos aritméticos  (com VHDL)}}
;Encontro 33 (11 fev.)
<!--
;Encontro 35 (15 jul.)
*Circuitos aritméticos: somadores, incrementador, decrementador, complemento de dois, multiplicador, comparadores  
*Circuitos aritméticos: somadores, incrementador, decrementador, complemento de dois, multiplicador, comparadores  
:* [https://drive.google.com/file/d/1kql0io2sh9Mp4FfnqpEPrdUFkVhHBx6_/view?usp=drive_link slides]
:* [https://drive.google.com/file/d/1kql0io2sh9Mp4FfnqpEPrdUFkVhHBx6_/view?usp=drive_link slides]
Linha 2 610: Linha 2 778:
*Ver <ref name="PEDRONI2010a"> PEDRONI, Volnei A. Eletrônica digital moderna e VHDL; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. . ISBN 9788535234657 </ref>
*Ver <ref name="PEDRONI2010a"> PEDRONI, Volnei A. Eletrônica digital moderna e VHDL; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. . ISBN 9788535234657 </ref>


;Encontro 34  (13 fev.)
* Avaliação A2a - Circuitos combinacionais em VHDL
;Encontro 35  (18 fev.)
*Usando o tipo '''integer'''
*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 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'''.
Linha 2 631: Linha 2 795:
end architecture;
end architecture;
</syntaxhighlight>
</syntaxhighlight>
{{fig|4.1|Código RTL do somador com tipo integer sem range| RTL_somadorv1.png| 300 px |}}
{{fig|6.1|Código RTL do somador com tipo integer sem range| RTL_somadorv1.png| 300 px |}}
{{fig|4.2|Technology Map do somador com tipo integer sem range| TM_somadorv1.png| 1000 px |}}
{{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.  
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.  


Linha 2 649: Linha 2 813:
end architecture;
end architecture;
</syntaxhighlight>
</syntaxhighlight>
{{fig|4.3|Código RTL do somador com tipo integer com range| RTL_somadorv2.png| 300 px |}}
{{fig|6.3|Código RTL do somador com tipo integer com range| RTL_somadorv2.png| 300 px |}}
{{fig|4.4|Technology Map do somador com tipo integer com range| TM_somadorv2.png| 600 px |}}
{{fig|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.
Para fazer uma subtração, basta trocar o operador "+" pelo "-", e o compilador irá implementar um subtrator realizando o complemento 2 da entrada b.
Linha 2 667: Linha 2 831:
</syntaxhighlight>
</syntaxhighlight>


{{fig|4.5|Código RTL do subtrator com tipo integer com range| RTL_subtratorv1.png| 300 px |}}
{{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.
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.


Linha 2 685: Linha 2 849:
</syntaxhighlight>
</syntaxhighlight>


{{fig|4.6|Código RTL do incrementador com tipo integer com range| RTL_incrementadorv1.png| 300 px |}}
{{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.
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.


Linha 2 704: Linha 2 868:
</syntaxhighlight>
</syntaxhighlight>


{{fig|4.7|Código RTL do decrementador com tipo integer com range| RTL_decrementadorv1.png| 300 px |}}
{{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).
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 |}}


;Encontro 36  (20 fev.)
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
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


Linha 2 773: Linha 2 941:
{{fig|4.10|Código RTL do multiplicador por 10| RTL_multiplicador10.png| 300 px |}}
{{fig|4.10|Código RTL do multiplicador por 10| RTL_multiplicador10.png| 300 px |}}


;Encontro 37 e 38 (22 e 25 fev.)
;Encontro 37  (22 jul.)
*A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED.
*A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED.


Linha 2 790: Linha 2 958:
   function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;
   function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;
   function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED;
   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.


   --============================================================================
   --============================================================================
Linha 2 818: Linha 2 991:
|background colour=#F5FFFA}}
|background colour=#F5FFFA}}
</center>
</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).  
*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.
:*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.
Linha 3 001: Linha 3 181:
Durante o semestre serão realizadas 4 avaliações.  As avaliações devem  ser enviadas pela plataforma Moodle com os arquivos solicitados.
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:
;Data das avaliações:
*A1a - (3 pontos) Sistema de Numeração e códigos :  
*A1a - (3 pontos) Sistema de Numeração e códigos : XX/2025 
*A1b - (5 pontos) () :
*A1b - (4 pontos) Expressões lógicas e mapa de Karnaugh : XX/2025
*A1c - (3 pontos) () :  
*A1c - (4 pontos) Circuitos lógicos, Introdução ao VHDL e revisão de A1a e A1b : XX/2025
*A2a - (5 pontos) Circuitos combinacionais : 13/02/2025  
*A2 - (10 pontos) Circuitos combinacionais e ariméticos : XX/2025
*A2b - (5 pontos) Circuitos aritméticos : 27/02/2025
*R1 - Recuperação de A1: XX/2025
*R12 - Recuperação de A1 a A2 : 06/03/2025
*R2 - Recuperação de A2: XX/2025
Folhas de consulta:
Folhas de consulta:
*A1b, A1c [[Media:Algebra_booleana.pdf | Álgebra booleana]]
*A1b, A1c [[Media:Algebra_booleana.pdf | Álgebra booleana]]
Linha 3 012: Linha 3 192:
*A2b  [[Media:Numeric_std_conversions.png | Conversões do pacote numeric_std]] ou [[Media:Numeric_stdConvertions.gif | Conversões do pacote numeric_std (DOULOS)]]
*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) ==
== 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.
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) ==
== 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.
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===
===AE1 - Projeto de um conversor de binário para mostrador de 7 segmentos===
{{collapse top | expand=true | bg=lightyellow | 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:
;Objetivos:
* Conhecer o mostrador (diplay) de 7 segmento
* Conhecer o mostrador (diplay) de 7 segmento
Linha 3 033: Linha 3 215:


*Nesta atividade os estudantes devem projetar um conversor de binário para mostrador de 7 segmentos.  
*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.   
* 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.
* Em um novo projeto considere que os valores 1010 (dez), 1011 (onze), ... 1111 (quinze) mostram os segmentos acessos conforme figura acima.


Linha 3 049: Linha 3 277:


===AE2 -  Conhecendo os dispositivos lógicos programáveis===
===AE2 -  Conhecendo os dispositivos lógicos programáveis===
{{collapse top | expand=true| bg=lightyellow | AE2 -  Conhecendo os dispositivos lógicos programáveis}}
{{collapse top | bg=lightyellow | AE2 -  Conhecendo os dispositivos lógicos programáveis}}
;Objetivos:
;Objetivos:
*Conhecer o Quartus Prime e as características dos dispositivos lógicos programáveis
*Conhecer o Quartus Prime e as características dos dispositivos lógicos programáveis
Linha 3 057: Linha 3 285:


;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 3 073: 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 tempo de propagação entre entrada e saída.
:*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 3 080: 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 um dos projetos '''CI74161''' ou do '''cálculo da distância de Hamming''' ou '''conversor de binário para mostrador de 7 segmentos'''
*'''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 3 132: 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 3 140: 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 3 147: Linha 3 385:
! I/O Standard
! I/O Standard
|-
|-
| SW[0] || PIN_Y22 || Chave tipo Slide Switch 0 || 3.3V
| SW[0] || PIN_V21 || Chave tipo Slide Switch 3 || 3.3V
|-
|-
| SW[1] || PIN_W21 || Chave tipo Slide Switch 1 || 3.3V
| SW[1] || PIN_W22 || Chave tipo Slide Switch 2 || 3.3V
|-
|-
| SW[2] || PIN_W22 || Chave tipo Slide Switch 2 || 3.3V
| SW[2] || PIN_W21 || Chave tipo Slide Switch 1 || 3.3V
|-
|-
| SW[3] || PIN_V21 || Chave tipo Slide Switch 3 || 3.3V
| SW[3] || PIN_Y22 || Chave tipo Slide Switch 0 || 3.3V
|}
|}
* Configurar como entrada os seguintes pinos:
* Configurar como entrada os seguintes pinos:
  eA V21
  eA Y22
  eB W22
  eB W21
  eC W21
  eC W22
  eD Y22
  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 3 204: 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
[[Arquivo:Display7Seg.png|thumb| 300px|right]]
{| 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 3 219: Linha 3 456:
! Mostrador
! Mostrador
|-
|-
| 0 || 0000 || ON || ON || ON || ON || ON || ON || OFF || [[Arquivo:ssd0.png|15px]]
| 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 3 262: Linha 3 498:
:* Apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito no Passo 4
:* Apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito no Passo 4
* O relatório deve também responder as questões levantadas e mostrar que os objetivos apresentados na introdução foram atendidos.
* 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
Encontro 1 (12 ago.)
  • A página da UC contém os materiais que não alteram entre semestre.
  • Relação com as outras UCs do Eixo Sistemas Computacionais (Marrom). Ver grafo do curriculo
  • ELD129002 - ELETRÔNICA DIGITAL I (ELD1): Sistema de numeração e códigos. Lógica booleana. Circuitos combinacionais. Circuitos aritméticos. Linguagem de descrição de hardware. Implementação e teste de circuitos digitais. Projeto de circuitos lógicos.
  • ELD129003 - ELETRÔNICA DIGITAL II (ELD2): Dispositivos lógicos programáveis. Circuitos sequenciais. Metodologia síncrona. Projeto hierárquico e parametrizado. Máquinas de estados finita. Register Transfer Methodology. Teste de circuitos digitais. Implementação em FPGA. Introdução a Linguagem de Descrição de Hardware.
  • AOC129004 - ARQUITETURA E ORGANIZAÇÃO DE COMPUTADORES (AOC): Introdução à Arquitetura Computadores. Linguagem Assembly. Linguagem de Máquina. Programação Assembly. Modos de Endereçamento. Processo de compilação e carga de um programa. Introdução à Organização de Computadores. Organização Monociclo e Multiciclo. Pipeline. Memória e Sistema de E/S.
  • MIC129007 - MICROCONTROLADORES (MIC): Introdução a Microcontroladores e Aplicações. Arquitetura de um microcontrolador. Pilha e Subrotinas. Interrupção. Contadores e Temporizadores. Interface com Periféricos. Programação em alto nível (ex.: C, C++ e RUST) para Microcontroladores: Mapeamento de tipos e estruturas de alto nível para sistemas com recursos limitados. Projeto de hardware e firmware com microcontroladores.
  • STE129008 - STE - SISTEMAS EMBARCADOS (STE): Conceitos em Sistemas Embarcados. Metodologia de Desenvolvimento de Sistemas Embarcados. Sistemas Operacionais para Sistemas Embarcados. Ferramentas de desenvolvimento e depuração. Barramentos e dispositivos de acesso a redes. Desenvolvimento de Projeto.
  • Nesta página está o Registro diário dos encontros e avaliações.
  • A entrega de atividades e avaliações será através da plataforma Moodle. A inscrição dos alunos é automática a partir do SIGAA.
  • Para a comunicação entre professor-aluno, além dos avisos no SIGAA, utilizaremos o chat institucional. A princípio todos os alunos já estão previamente cadastrados pelo seu email institucional. Confiram enviando uma mensagem de apresentação.
  • Utilizaremos durante as aulas algumas ferramentas computacionas como o site do Falstad para entender circuitos digitais e fazer simulações básicas.
  • Também utilizaremos os softwares Quartus Light e ModelSim instalados nas maquinas do laboratório para praticar a parte de programação de hardware (descrição de hardware). Esses softwares também podem ser usados através da Nuvem do IFSC..
LER PARA O PRÓXIMO ENCONTRO

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:


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:


Curso de Engenharia de Telecomunicações

Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=ELD129002-Engtelecom_(Diário)_-_Prof._Marcos_Moecke&oldid=201604”