Mudanças entre as edições de "DLP29006-Engtelecom (Diário) - Prof. Marcos Moecke"
(237 revisões intermediárias pelo mesmo usuário não estão sendo mostradas) | |||
Linha 1: | Linha 1: | ||
==Registro on-line das aulas== | ==Registro on-line das aulas== | ||
===Unidade 1 - Introdução a disciplina=== | ===Unidade 1 - Introdução a disciplina=== | ||
− | * | + | * 6 ENCONTROS |
{{collapse top | expand=true | Unidade 1 - Introdução a disciplina}} | {{collapse top | expand=true | Unidade 1 - Introdução a disciplina}} | ||
− | + | ;Encontro 1 (26 jul): | |
− | ;Encontro 1 ( | ||
* [[DLP1-EngTel (Plano de Ensino) | APRESENTAÇÃO DA DISCIPLINA]] | * [[DLP1-EngTel (Plano de Ensino) | APRESENTAÇÃO DA DISCIPLINA]] | ||
− | |||
* A [[DLP1-EngTel (página) | PÁGINA DA DISCIPLINA]] contem os materiais que não alteram entre semestre. | * A [[DLP1-EngTel (página) | PÁGINA DA DISCIPLINA]] contem os materiais que não alteram entre semestre. | ||
* Nesta página está o [[DLP29006-Engtelecom (Diário) - Prof. Marcos Moecke | REGISTRO DIÁRIO E AVALIAÇÕES]]. | * Nesta página está o [[DLP29006-Engtelecom (Diário) - Prof. Marcos Moecke | REGISTRO DIÁRIO E AVALIAÇÕES]]. | ||
− | * | + | * A entrega de atividades e avaliações será através da [https://moodle.ifsc.edu.br/course/view.php?id=699 plataforma Moodle]. A inscrição dos alunos é automática a partir do SIGAA. |
− | * Para a comunicação entre professor-aluno, além dos avisos no SIGAA, utilizaremos o [https://mail.google.com/chat/u/0/#chat/space/ | + | * Para a comunicação entre professor-aluno, além dos avisos no SIGAA, utilizaremos o [https://mail.google.com/chat/u/0/#chat/space/AAAAu052zos chat institucional]. A princípio todos os alunos já estão previamente cadastrados pelo seu email institucional. Confiram enviando uma mensagem de apresentação. |
− | * | + | *Durante as aulas é recomendado que o aluno utilize os softwares '''Quartus''' e '''Modelsim''' instalados nas maquinas do laboratório, mas estes também podem ser usados através da '''Nuvem do IFSC'''. |
+ | * Nas aulas é recomendado que o aluno utilize os softwares '''Quartus Light''' e '''ModelSim''' instalado nas máquinas do laboratório ou então acesse estes softwares através da [[Acesso ao IFSC-CLOUD (NUVEM)|NUVEM do IFSC]]. | ||
+ | ;LER PARA O PRÓXIMO ENCONTRO: | ||
+ | *Seção 4.1 a 4.5 de [http://www.vhdl.us/book/Pedroni_VHDL_3E_Chapter4.pdf Review of Field Programmable Gate Arrays (FPGAs)], Volnei A. Pedroni. (ou para quem preferir em português, leia as seções 18.1 a 18.3 do livro: PEDRONI, Volnei A '''Eletrônica Digital Moderna e VHDL: Princípios Digitais, Eletrônica Digital, Projeto Digital, Microeletrônica e VHDL'''; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. ISBN 9788535234657. Têm 16 exemplares disponíveis na [https://biblioteca.ifsc.edu.br/ Biblioteca do campus]. Número de chamada: 621.392 P372e) | ||
+ | *Seção 2.1 Dispositivos lógicos programáveis do TCC [[Integração de ramais analógicos com FPGA utilizando processador softcore]], Renan Rodolfo da Silva. | ||
+ | ;Encontro 2 (28 jul): | ||
*Introdução aos dispositivos lógicos programáveis: | *Introdução aos dispositivos lógicos programáveis: | ||
:* Conceito, tipos de PLDs | :* Conceito, tipos de PLDs | ||
− | + | :* SPLD: | |
− | + | ::*PAL (e.g. [[Media: PAL16.pdf| PAL16 da Texas Instruments (1984)]]) | |
+ | ::*PLA (e.g. [[Media: PLS100.pdf| PLS100 da Philips Semiconductors (1993)]]) | ||
+ | ::*GAL (e.g. [[Media: GAL16V8.pdf| GAL16V8 da Lattice (2004)]]) | ||
+ | :* CPLDs (e.g. [[Media: ATF2500C.pdf| ATF2500C da Atmel (2008)]], [https://br.mouser.com/c/ds/semiconductors/programmable-logic-ics/cpld-complex-programmable-logic-devices/ Complex Programmable Logic Devices Datasheets - Mouser]) | ||
− | {{collapse top | Exemplos de PLDs}} | + | {{collapse top | expand=true| Exemplos de PLDs}} |
− | {{fig|1.1| | + | {{fig|1.1|Exemplo de PAL| PedroniFig4_4a.png| 400 px | http://www.vhdl.us/book/Pedroni_VHDL_3E_Chapter4.pdf}} |
− | {{fig|1.2| | + | {{fig|1.2|Exemplo de PLA| PedroniFig4_4b.png| 400 px | http://www.vhdl.us/book/Pedroni_VHDL_3E_Chapter4.pdf}} |
− | {{fig|1. | + | {{fig|1.3|Macrobloco do PLD EP300 da ALTERA| ep310_macrocell.jpg| 400 px | https://www.altera.com/solutions/technology/system-design/articles/_2013/in-the-beginning.html}} |
− | {{fig|1. | + | {{fig|1.4|Macrocélula dos PLDs Clássicos EP600, EP900, EP1800 da ALTERA (1999)| Macrocell_EP900.png| 400 px | https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ds/archives/classic.pdf}} |
− | {{fig|1.5| | + | {{fig|1.5|Architetura do PLD EP1800 da ALTERA| ep1800_block_diagram.jpg| 400 px | https://www.altera.com/solutions/technology/system-design/articles/_2013/in-the-beginning.html}} |
− | {{fig|1.6|Architetura do CPLD MAX 5000 da ALTERA| max_5000_architecture.jpg| 400 px | https://www.altera.com/solutions/technology/system-design/articles/_2013/in-the-beginning.html}} | + | {{fig|1.6|Architetura do PLD EP1800 da ALTERA| ep1800_block_diagram2.jpg| 400 px | https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ds/archives/classic.pdf}} |
+ | |||
+ | {{fig|1.7|Pinagem e tipos de encapsulamento do PLD EP1800 da ALTERA| PackagePinOut_EP1810.png| 400 px | https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ds/archives/classic.pdf }} | ||
+ | |||
+ | {{fig|1.8|Architetura do CPLD MAX 5000 da ALTERA| max_5000_architecture.jpg| 400 px | https://www.altera.com/solutions/technology/system-design/articles/_2013/in-the-beginning.html}} | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | + | :* Ver preços em | |
− | :* | + | ::*[https://www.arrow.com/ ARROW] |
− | ::* [https://www. | + | ::*[https://www.digikey.com/ Digikey] |
+ | ::*[https://mouser.com Mouser Electronics] | ||
+ | ::*[https://www.newark.com/ Newark] | ||
:* Fabricantes de DLPs/FPGAs e familias de DLPs atuais. | :* Fabricantes de DLPs/FPGAs e familias de DLPs atuais. | ||
::*[https://www.altera.com/products/fpga/overview.html ALTERA/INTEL] - Stratix, Arria, Cyclone, Max | ::*[https://www.altera.com/products/fpga/overview.html ALTERA/INTEL] - Stratix, Arria, Cyclone, Max | ||
− | ::*[https://www.xilinx.com/products/silicon-devices/fpga.html Xilinx] - Virtex, Kintex, Artix, Zynq (SoC) | + | ::*[https://www.xilinx.com/products/silicon-devices/fpga.html Xilinx/AMD] - Virtex, Kintex, Artix, Zynq (SoC) |
− | ::*[ | + | ::*[https://www.microchip.com/en-us/products/fpgas-and-plds/fpgas Microchip] - Igloo, PolarFire |
::*[http://www.latticesemi.com/Products.aspx#_D5A173024E414501B36997F26E842A31 Lattice] - ECP, iCE, Mach | ::*[http://www.latticesemi.com/Products.aspx#_D5A173024E414501B36997F26E842A31 Lattice] - ECP, iCE, Mach | ||
− | + | ;PARA O PRÓXIMO ENCONTRO: | |
− | + | *[https://www.intel.com/content/www/us/en/products/details/fpga/platforms.html See why Microsoft chose Intel FPGAs to accelerate their next generation cloud infrastructure] | |
− | + | *[https://www.youtube.com/watch?v=ecyyZ6zTLic Microsoft's Bing* Intelligent Search with Intel® FPGAs] | |
− | + | ||
− | + | ;Encontro 3 (1 ago): | |
− | : | + | * [https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE2_-_Conhecendo_os_dispositivos_l.C3.B3gicos_program.C3.A1veis Laboratório AE2 - Conhecendo os dispositivos lógicos programáveis] - Passo 1 e 2 |
− | |||
− | |||
− | * | + | ;PARA O PRÓXIMO ENCONTRO: |
+ | * Leia a assista a alguns dos vídeos sobre a historia e processo de produção dos chips. | ||
:*[https://www.semiwiki.com/forum/content/1535-brief-history-fabless-semiconductor-industry.html A Brief History of the Fabless Semiconductor Industry] | :*[https://www.semiwiki.com/forum/content/1535-brief-history-fabless-semiconductor-industry.html A Brief History of the Fabless Semiconductor Industry] | ||
:*[http://www.semiwiki.com/forum/content/1539-brief-history-tsmc.html Taiwan Semiconductor Manufacturing Corporation (TSMC)], [http://www.globalfoundries.com/ GLOBALFOUNDRIES] | :*[http://www.semiwiki.com/forum/content/1539-brief-history-tsmc.html Taiwan Semiconductor Manufacturing Corporation (TSMC)], [http://www.globalfoundries.com/ GLOBALFOUNDRIES] | ||
:*[https://www.linkedin.com/pulse/free-copy-fabless-transformation-semiconductor-industry-daniel-nenni-1 Fabless: The Transformation of the Semiconductor Industry, 2014] - Download free | :*[https://www.linkedin.com/pulse/free-copy-fabless-transformation-semiconductor-industry-daniel-nenni-1 Fabless: The Transformation of the Semiconductor Industry, 2014] - Download free | ||
− | |||
:*[https://www.youtube.com/watch?v=W3rfVpkNquA Produção do FinFET], [https://www.youtube.com/watch?v=d9SWNLZvA8g] | :*[https://www.youtube.com/watch?v=W3rfVpkNquA Produção do FinFET], [https://www.youtube.com/watch?v=d9SWNLZvA8g] | ||
− | :*[https://en.wikipedia.org/wiki/ | + | :*[https://en.wikipedia.org/wiki/3_nm_process 3 nm process], [https://en.wikipedia.org/wiki/Multigate_device multi-gate MOSFET] |
:*[https://www.youtube.com/watch?v=UvluuAIiA50 GLOBALFOUNDRIES Sand to Silicon], [https://www.youtube.com/watch?v=F2KcZGwntgg How Microchips are made] - Processo de fabricação de um chip | :*[https://www.youtube.com/watch?v=UvluuAIiA50 GLOBALFOUNDRIES Sand to Silicon], [https://www.youtube.com/watch?v=F2KcZGwntgg How Microchips are made] - Processo de fabricação de um chip | ||
:*[https://en.wikipedia.org/wiki/Foundry_model Foundries], [https://en.wikipedia.org/wiki/List_of_semiconductor_fabrication_plants List of semiconductor fabrication plants] | :*[https://en.wikipedia.org/wiki/Foundry_model Foundries], [https://en.wikipedia.org/wiki/List_of_semiconductor_fabrication_plants List of semiconductor fabrication plants] | ||
+ | :*[https://www.youtube.com/watch?v=GU87SH5e0eI A dependência do mundo com a TMSC] | ||
− | + | ;Encontro 4 (4 ago): | |
− | + | * Arquitetura de FPGAs (Xilinx e Altera): CLB, LAB, LUT, Flip_flop D, RAM, DSP, Clock, PLL, DLL, I/O | |
− | * | + | {{collapse top | expand=true |Exemplos de FPGA}} |
− | |||
− | |||
− | |||
− | |||
− | + | {{fig|1.7|Arquitetura de um FPGA | Architecture_FPGAs.png| 600 px | https://www.intel.com/content/www/us/en/docs/programmable/683176/18-1/fpga-overview-opencl-standard.html}} | |
− | + | {{fig|1.8|Diagrama simplificado da CLB de um FPGA ARM/Xilinx | CLB_FPGAs.jpg| 600 px | https://www.sciencedirect.com/science/article/pii/B9780750678667500032#f14}} | |
− | {{ | ||
− | {{fig|1. | + | {{fig|1.9|Diagrama simplificado da ALM de um FPGA Intel/Altera | ALM_LUT_FPGAs.png| 600 px | https://www.intel.com/content/www/us/en/content-details/771003/fpga-architecture-8-input-lut-legacy-white-paper.html}} |
− | {{fig|1. | + | {{fig|1.10|Arquitetura do Cyclone® V Intel/Altera | CycloneV_FPGAs.jpg| 600 px | https://www.intel.com.br/content/www/br/pt/products/details/fpga/cyclone/v/article.html}} |
− | |||
− | |||
− | |||
− | |||
{{fig|1.11|Leiaute de um FPGA Xilinx genérico | Leiaute2_FPGAs.jpg| 600 px | https://www.sciencedirect.com/science/article/pii/B9780750678667500032 }} | {{fig|1.11|Leiaute de um FPGA Xilinx genérico | Leiaute2_FPGAs.jpg| 600 px | https://www.sciencedirect.com/science/article/pii/B9780750678667500032 }} | ||
Linha 90: | Linha 92: | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | |||
− | * | + | ;PARA O PRÓXIMO ENCONTRO: |
+ | * Leia a assista a alguns dos vídeos sobre FPGAs. | ||
+ | :*[https://youtu.be/v2ZloNgU-EE Tecnologia FPGA Intel - Macnica DHW] | ||
+ | :*[https://www.sciencedirect.com/science/article/pii/B9780750678667500032 Chapter 2 - FPGA Fundamentals], R.C. Cofer, Benjamin F. Harding, Science Direct | ||
+ | :*[https://edisciplinas.usp.br/pluginfile.php/530826/mod_resource/content/1/DISPOSITIVOS%20L%C3%93GICOS%20PROGRAM%C3%81VEIS_2014.pdf Dispositivos Lógicos Programáveis], L.M.R. Codá, USP | ||
− | : | + | ;CURIOSIDADES: |
− | |||
− | + | * Quais são os tipos de [[Níveis lógicos]] utilizados. | |
− | + | * [[Como as portas lógicas são implementadas com transistores CMOS]] | |
− | + | *[https://www.computerhistory.org/siliconengine/timeline/ The Silicon Engine Timeline], Computer History Museum (CHM) | |
− | : | + | *[https://www10.edacafe.com/book/ASIC/CH04/CH04.1.php The Antifuse], [https://www.youtube.com/watch?v=7qa1dsCpMMo EEPROM], [https://www.youtube.com/watch?v=ELl3abwYQ90&list=PL9B4edd-p2agcmJl2EscTdLudLv58uXHt&index=1 What Is Flash Memory] |
− | + | *[https://numato.com/blog/differences-between-fpga-and-asics/ FPGA Vs ASIC: Differences Between Them And Which One To Use?] | |
− | |||
− | * [https:// | ||
+ | ;Encontro 5 (8 ago): | ||
+ | * [https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE2_-_Conhecendo_os_dispositivos_l.C3.B3gicos_program.C3.A1veis Laboratório AE2 - Conhecendo os dispositivos lógicos programáveis] - Passo 3 e 4 | ||
+ | *Exemplo de um Circuito para cálculo da '''distância de Hamming'''. | ||
+ | :*[[Medição de tempos de propagação em circuitos combinacionais]] | ||
+ | :* Os alunos devem utilizar a nuvem para realizar a atividade. | ||
+ | :*[https://wiki.sj.ifsc.edu.br/index.php/Medi%C3%A7%C3%A3o_de_tempos_de_propaga%C3%A7%C3%A3o_em_circuitos_combinacionais#Inserindo_restri.C3.A7.C3.B5es_de_atraso_m.C3.A1ximo_para_o_compilador Inserindo restrições de atraso máximo para o compilador] | ||
+ | :* Objetivos: Copiar e colar o código no Quartus; diferença entre analise e síntese e compilação; observar o RTL (usar UNGROUP); simulação funcional e simulação temporal; observar os atrasos de propagação na simulação temporal. | ||
+ | ;PARA CONHECER MAIS: | ||
+ | * Ler pag. 413 a 431 de <ref name="PEDRONI2010a"> PEDRONI, Volnei A. Eletrônica digital moderna e VHDL; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. . ISBN 9788535234657 </ref> ou pag. 495 a 501 de de <ref name="PEDRONI2010b"> PEDRONI, Volnei A. '''Circuit Design and Simulation with VHDL'''; 2ª ed. Massachusetts-EUA:MIT, 2010. 608 p. ISBN 9780262014335 </ref>. | ||
+ | * [https://en.wikipedia.org/wiki/Field-programmable_gate_array#History FPGA History] | ||
+ | * [https://en.wikipedia.org/wiki/Field-programmable_gate_array#Design_and_programming FPGA Design and programming] | ||
+ | * [https://en.wikipedia.org/wiki/Field-programmable_gate_array#Basic_process_technology_types FPGA Basic process technology types] | ||
+ | * [https://en.wikipedia.org/wiki/Field-programmable_gate_array#Major_manufacturers FPGA Major manufacturers] | ||
+ | * Assistir [https://www.coursera.org/lecture/intro-fpga-design-embedded-systems/1-many-types-of-fpgas-EWo0n Many types of FPGAs] Coursera | ||
+ | * O que é um Schmitt trigger? | ||
+ | :*[https://youtu.be/d-7Oyd8o8hE?t=93 Um pouco de lab] - lab até o minuto 5:20, depois um exemplo com AMPOP | ||
+ | :*[https://howtomechatronics.com/how-it-works/electrical-engineering/schmitt-trigger/ como funciona] | ||
+ | * O que é a JTAG? | ||
+ | :*[https://www.corelis.com/educationdownload/JTAG-Tutorial.pdf Como funciona para testes e programação] - In-System-Programming pag.7 | ||
;Notícias recentes do mundo dos DLPs: | ;Notícias recentes do mundo dos DLPs: | ||
− | |||
*[https://newsroom.intel.com/press-kits/intel-acquisition-of-altera/#:~:text=Intel%20and%20Altera%20announced%20on,transaction%20closed%20December%2028%2C%202015. Intel Acquisiton of Altera] | *[https://newsroom.intel.com/press-kits/intel-acquisition-of-altera/#:~:text=Intel%20and%20Altera%20announced%20on,transaction%20closed%20December%2028%2C%202015. Intel Acquisiton of Altera] | ||
<i> | <i> | ||
Linha 123: | Linha 143: | ||
</i> | </i> | ||
− | <!-- | + | <!-- |
− | * [https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE2_-_Conhecendo_os_dispositivos_l.C3.B3gicos_program.C3.A1veis Laboratório AE2 - Conhecendo os dispositivos lógicos programáveis] - Passo | + | |
+ | ;Encontro 6 (28 fev.): | ||
+ | * [https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE2_-_Conhecendo_os_dispositivos_l.C3.B3gicos_program.C3.A1veis Laboratório AE2 - Conhecendo os dispositivos lógicos programáveis] - Passo 3 | ||
*Exemplo de um Circuito para cálculo da '''distância de Hamming'''. | *Exemplo de um Circuito para cálculo da '''distância de Hamming'''. | ||
:*[[Medição de tempos de propagação em circuitos combinacionais]] | :*[[Medição de tempos de propagação em circuitos combinacionais]] | ||
− | |||
− | |||
:* Os alunos devem utilizar a nuvem para realizar a atividade. | :* Os alunos devem utilizar a nuvem para realizar a atividade. | ||
:* O professor estará disponível através do chat da UC e pelo link de meet disponibilizado no chat.[https://wiki.sj.ifsc.edu.br/index.php/Medi%C3%A7%C3%A3o_de_tempos_de_propaga%C3%A7%C3%A3o_em_circuitos_combinacionais#Inserindo_restri.C3.A7.C3.B5es_de_atraso_m.C3.A1ximo_para_o_compilador Inserindo restrições de atraso máximo para o compilador] | :* O professor estará disponível através do chat da UC e pelo link de meet disponibilizado no chat.[https://wiki.sj.ifsc.edu.br/index.php/Medi%C3%A7%C3%A3o_de_tempos_de_propaga%C3%A7%C3%A3o_em_circuitos_combinacionais#Inserindo_restri.C3.A7.C3.B5es_de_atraso_m.C3.A1ximo_para_o_compilador Inserindo restrições de atraso máximo para o compilador] | ||
Linha 135: | Linha 155: | ||
--> | --> | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | + | ||
===Unidade 2 - Introdução ao VHDL e ambienta EDA - QUARTUS=== | ===Unidade 2 - Introdução ao VHDL e ambienta EDA - QUARTUS=== | ||
− | * | + | * 10 ENCONTROS |
{{collapse top| expand = true | Unidade 2 - Introdução ao VHDL e ambienta EDA - QUARTUS}} | {{collapse top| expand = true | Unidade 2 - Introdução ao VHDL e ambienta EDA - QUARTUS}} | ||
− | ;Encontro | + | ;Encontro 6 (11 ago.) |
* Introdução ao VHDL e ambiente EDA - QUARTUS | * Introdução ao VHDL e ambiente EDA - QUARTUS | ||
* Estrutura do código VHDL | * Estrutura do código VHDL | ||
Linha 193: | Linha 213: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | ;Encontro | + | ;Encontro 8 (7 mar.) |
− | Exemplo | + | * Exemplo - Descrição de um multiplexador de 4 entradas |
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
entity mux_novo is | entity mux_novo is | ||
Linha 263: | Linha 283: | ||
{{fig|2.3|Código RTL do mux 4x1 v_WITH_SELECT| RTL_mux4x1v3.png| 200 px |}} | {{fig|2.3|Código RTL do mux 4x1 v_WITH_SELECT| RTL_mux4x1v3.png| 200 px |}} | ||
:'''OBS''': [https://en.wikipedia.org/wiki/Register-transfer_level Register Transfer-Level] (RTL) é uma abstração na qual o circuito é descrito em termos de fluxo de sinais entre os registradores presentes no hardware e as operações combinacionais realizadas com esses dados. | :'''OBS''': [https://en.wikipedia.org/wiki/Register-transfer_level Register Transfer-Level] (RTL) é uma abstração na qual o circuito é descrito em termos de fluxo de sinais entre os registradores presentes no hardware e as operações combinacionais realizadas com esses dados. | ||
− | |||
* Note a que ao verificar o Technology Map Viewer, nos 3 primeiros casos serão usados os mesmos elementos lógicos. | * Note a que ao verificar o Technology Map Viewer, nos 3 primeiros casos serão usados os mesmos elementos lógicos. | ||
{{fig|2.4|Technology Map do mux 4x1 para a família Cyclone | TM_mux4x1.png| 400 px |}} | {{fig|2.4|Technology Map do mux 4x1 para a família Cyclone | TM_mux4x1.png| 400 px |}} | ||
− | |||
* Note que o elemento lógico acima possui uma LUT (LookUp Table) que basicamente implementa o circuito combinacional através de uma tabela de consulta (Tabela Verdade), a qual pode ser visualizada clicando com o botão Direito do Mouse e selecionando Properties, juntamente com Mapa de Karnaugh e seu Circuito Lógico representado por portas. Todas as representações são equivalentes. | * Note que o elemento lógico acima possui uma LUT (LookUp Table) que basicamente implementa o circuito combinacional através de uma tabela de consulta (Tabela Verdade), a qual pode ser visualizada clicando com o botão Direito do Mouse e selecionando Properties, juntamente com Mapa de Karnaugh e seu Circuito Lógico representado por portas. Todas as representações são equivalentes. | ||
Linha 278: | Linha 296: | ||
{{fig|2.5|Technology Map do mux 4x1 para a família Stratix III | TM_mux4x1_S3.png| 400 px |}} | {{fig|2.5|Technology Map do mux 4x1 para a família Stratix III | TM_mux4x1_S3.png| 400 px |}} | ||
− | |||
− | |||
+ | ;Encontro 7 (15 ago.) | ||
− | |||
* Exemplo 2.2 (VHDL) - programação de um flip-flop | * Exemplo 2.2 (VHDL) - programação de um flip-flop | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
Linha 326: | Linha 342: | ||
:*[[Palavras reservadas do VHDL]] | :*[[Palavras reservadas do VHDL]] | ||
:*[http://g2384.github.io/work/VHDLformatter.html VHDL Beautifier, Formatter] - para formatar automaticamente um código VHDL. | :*[http://g2384.github.io/work/VHDLformatter.html VHDL Beautifier, Formatter] - para formatar automaticamente um código VHDL. | ||
− | |||
− | ;Encontro | + | ;Encontro 8 (18 ago.) |
− | |||
− | |||
− | |||
− | * | + | *[[Simulação Funcional usando o ModelSim]] |
− | + | *Funcionamento do ModelSim: GUI, caracteristicas, testbench | |
+ | *Prática do Modelsim com bin2bcd | ||
+ | *Faça a simulação inserindo os valores 64, 99, 09, 00, 01, 109, 190. | ||
+ | *Perceba que com 7 bits na entrada, o número 190 não é representado corretamente, pois necessita de 8 bits. | ||
+ | *Perceba que a conversão para BCD do número 109 não é correta, pois o algoritmo implementado só preve a separação de dezena e unidade, e portanto não trata a centena. | ||
− | + | ;Encontro 9 (22 ago.) | |
− | + | * [[Simulação Funcional usando o ModelSim]] - completar passos 11 e 12. | |
− | + | * Uso das bibliotecas no VHDL. | |
− | + | :*Library '''std''' | |
− | + | ::O Package '''standard''': é parte do VHDL desde a primeira versão (1987). Ela contem definição de tipos de dados (BIT, INTEGER, BOOLEAN, CHARACTER, etc.) e seus operadores logicos, aritméticos, de comparação e shift. | |
− | + | ::O Package textio fornece os recurso para o tratamento de textos e arquivos, que podem ser utilizados na simulação. | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | * Uso das bibliotecas no VHDL. | ||
− | :*Library '''std''' | ||
− | ::O Package '''standard''': é parte do VHDL desde a primeira versão (1987). Ela contem definição de tipos de dados (BIT, INTEGER, BOOLEAN, CHARACTER, etc.) e seus operadores logicos, aritméticos, de comparação e shift. | ||
− | ::O Package textio fornece os recurso para o tratamento de textos e arquivos, que podem ser utilizados na simulação. | ||
*Como declarar e usar os pacotes da biblioteca '''std'''. | *Como declarar e usar os pacotes da biblioteca '''std'''. | ||
:: Note que esses pacotes são implicitamente carregados não precisando ser declarados. Ambos pacotes foram expandidos no VHDL 2008. | :: Note que esses pacotes são implicitamente carregados não precisando ser declarados. Ambos pacotes foram expandidos no VHDL 2008. | ||
Linha 367: | Linha 366: | ||
use std.textio.all; | use std.textio.all; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | *Onde estão os arquivos dessa biblioteca na versão Quartus | + | *Onde estão os arquivos dessa biblioteca na versão Quartus instalada nos computadores do IFSC e na IFSC_CLOUD? |
− | ls /opt/ | + | ls /opt/intelFPGA/20.1/quartus/libraries/vhdl/std |
:*Library '''ieee''' | :*Library '''ieee''' | ||
Linha 397: | Linha 396: | ||
*Onde estão os arquivos dessa biblioteca na versão Quartus II versão 13.0sp1 instalada nos computadores do IFSC e na IFSC_CLOUD? | *Onde estão os arquivos dessa biblioteca na versão Quartus II versão 13.0sp1 instalada nos computadores do IFSC e na IFSC_CLOUD? | ||
::Os pacotes padrão: | ::Os pacotes padrão: | ||
− | + | /opt/intelFPGA/20.1/quartus/libraries/vhdl/ieee | |
::Os pacotes não padrão: | ::Os pacotes não padrão: | ||
− | + | /opt/intelFPGA/20.1/quartus/libraries/vhdl/mentor/arithmetic (Mentor Graphics) | |
− | + | /opt/intelFPGA/20.1/quartus/libraries/vhdl/synopsys/ieee (Synopsys) | |
*Os arquivos dessa biblioteca do padrão (versão 2008) estão apenas disponíveis a partir do Quartus II versão 16.0 instalado na IFSC_CLOUD? | *Os arquivos dessa biblioteca do padrão (versão 2008) estão apenas disponíveis a partir do Quartus II versão 16.0 instalado na IFSC_CLOUD? | ||
ls /opt/altera/16.0/quartus/libraries/vhdl/ieee/2008 | ls /opt/altera/16.0/quartus/libraries/vhdl/ieee/2008 | ||
− | + | * Exemplo 2.3 (VHDL e Modelsim) - programação de um circuito somador com registrador | |
− | + | : Realizar a simulação funcional do circuito | |
− | + | : Observar o "Technology Map" e o "RTL" do circuito | |
− | |||
− | |||
− | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
LIBRARY ieee; | LIBRARY ieee; | ||
Linha 438: | Linha 434: | ||
END ARCHITECTURE; | END ARCHITECTURE; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | :: Acrescente saídas para o sinal '''sum''' e para o sinal '''comp''', de modo a poder observar estes sinais no simulador | + | :: Acrescente saídas para o sinal '''sum''' e para o sinal '''comp''', de modo a poder observar estes sinais no simulador Modelsim e realize nova simulação funcional. |
{{fig|2.10|Código RTL do Exemplo 2.3| RTL_Ex2_3_Pedronib.png| 400 px |}} | {{fig|2.10|Código RTL do Exemplo 2.3| RTL_Ex2_3_Pedronib.png| 400 px |}} | ||
− | + | ;Encontro 10 (23 ago.) | |
− | + | *Exemplo de um '''contador''' em VHDL. [https://en.wikipedia.org/wiki/VHDL#Example:_a_counter COUNTER] na página de VHDL da Wikipedia. | |
− | + | <syntaxhighlight lang=vhdl> | |
− | + | library IEEE; | |
− | + | use IEEE.std_logic_1164.all; | |
− | + | use IEEE.numeric_std.all; -- for the unsigned type | |
− | |||
− | |||
− | |||
− | |||
− | + | entity COUNTER is | |
− | + | generic ( | |
− | + | WIDTH : in natural := 32); | |
− | + | port ( | |
− | ; | + | RST : in std_logic; |
− | + | CLK : in std_logic; | |
− | + | LOAD : in std_logic; | |
− | + | DATA : in std_logic_vector(WIDTH-1 downto 0); | |
− | + | Q : out std_logic_vector(WIDTH-1 downto 0)); | |
− | + | end entity COUNTER; | |
− | + | ||
+ | architecture RTL of COUNTER is | ||
+ | |||
+ | begin | ||
+ | |||
+ | process(all) is | ||
+ | begin | ||
+ | if RST then | ||
+ | Q <= (others => '0'); | ||
+ | elsif rising_edge(CLK) then | ||
+ | if LOAD='1' then | ||
+ | Q <= DATA; | ||
+ | else | ||
+ | Q <= std_logic_vector(unsigned(Q) + 1); | ||
+ | end if; | ||
+ | end if; | ||
+ | end process; | ||
− | + | end architecture RTL; | |
− | |||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
− | |||
− | :* | + | :*[[Restringir a frequencia máxima de clock no Quartus II]] |
− | + | :* Objetivos: Copiar e colar o código no Quartus; diferença entre analise e síntese e compilação; observar o RTL (usar UNGROUP); simulação funcional e simulação temporal (considerando o tempo de propagação). Em função da dificuldade na realização da simulação temporal com o Modelsim, será utilizado excepcionalmente o QSIM para este fim. | |
− | |||
− | |||
− | |||
− | + | *Ao realizar as simulações funcional e temporal do circuito '''Flip-Flop4''' ou do '''Counter''', será possível perceber que enquanto na simulação funcional, as mudanças ocorrem instantaneamente, na temporal, todos os tempos de propagação em vias e nos elementos lógicos são considerados. OBserve atentamente nas duas figuras a seguir as diferenças. | |
− | |||
− | |||
− | |||
− | + | {{fig|2.6|Simulação funcional com QSIM de 4 FF - 100ns| SIM1_4FF.png| 800 px |}} | |
− | |||
− | |||
− | + | {{fig|2.7|Simulação Temporal com QSIM de 4 FF - 100ns| SIM2_4FF.png| 800 px |}} | |
− | |||
− | : | + | :Note que na simulação funcional a mudança da saída Q ocorre no instante em que ocorre a borda de subida do clock ou no momento do reset. No entanto, no caso da simulação com timing, existem atrasos variáveos de cerca de ~6ns nestas mudanças. |
− | |||
− | |||
− | |||
− | : | + | ''IMPORTANTE:'' Na prática normalmente não é necessário fazer a simulação temporal, pois através do Time Quest Report é possível verificar se o circuito atende as restrições de tempo. |
− | |||
− | |||
− | * | + | * Para definir as restrições de tempo do clock por exemplo, pode ser adicionado um arquivo .sdc ao projeto definindo a frequência do clock esperada através da seguinte linha: |
− | |||
− | + | create_clock -name CLK50MHz -period 50MHz [get_ports {*}] | |
− | |||
− | + | *Ver pag. 3 a 24 de <ref name="PEDRONI2010b"> PEDRONI, Volnei A. '''Circuit Design and Simulation with VHDL'''; 2ª ed. Massachusetts-EUA:MIT, 2010. 608 p. ISBN 9780262014335 </ref> | |
− | |||
− | + | ;Encontro 11 e 12 (25 e 29 ago.) | |
− | + | :* utilizar o código do '''contador''' em VHDL. [https://en.wikipedia.org/wiki/VHDL#Example:_a_counter COUNTER] na página de VHDL da Wikipedia. | |
− | + | :* Definir a pinagem das chaves e leds conforme o kit a ser utilizado. | |
− | + | :* Perceber o problema do repique das chaves. | |
− | + | ::Ver [[Dicas de como eliminar o repique das chaves mecânicas]] | |
+ | :: Ler sobre o problema do repique das chaves mecânicas [https://my.eng.utah.edu/~cs5780/debouncing.pdf A Guide to Debouncing] | ||
+ | *Realizar [https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE3_-_Programa.C3.A7.C3.A3o_do_kit_Mercurio_IV AE3 - Programação do kit Mercurio IV]. | ||
+ | *Medir o repique da chave e a solução com osciloscópio. | ||
+ | {{collapse bottom}} | ||
− | + | ===Unidade 3 - Tipos de Dados e Operadores em VHDL=== | |
+ | * 10 ENCONTROS | ||
+ | {{collapse top | expand=true | Unidade 3 - Tipos de Dados e Operadores em VHDL}} | ||
+ | ;Encontro 13 (1 set.) | ||
+ | *Comentários no código (duplo traço --) | ||
+ | -- Isso eh uma linha de comentario | ||
+ | y <= a * b ; --o sinal y recebe o resultado da multiplicacao a x b | ||
+ | *Representação de caracteres, strings e números em VHDL. No circuito, os caracteres são representados através de bits de acordo com a [https://www.lookuptables.com/text/ascii-table tabela ASCII] básica (00 a 7F). A definição dessa tabela é feita o pacote '''[[standard.vhd]]''' da biblioteca '''std'''. | ||
+ | :*Caracteres (entre aspas simples) | ||
+ | caracter: 'A' 'x' '#' (com aspas simples) | ||
+ | :*Palavras (entre aspas duplas), é definida no VHDL como um vetor de caracteres. | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
− | + | type string is array (positive range <>) of character; | |
− | + | </syntaxhighlight> | |
+ | |||
+ | string: "IFSC" "teste" "teste123" | ||
− | + | :*Números em geral | |
+ | elemento ("bit") único: '0' '1' 'Z' (entre aspas simples) | ||
+ | vetor de elementos ("bits"): "0110" "101001Z" (entre aspas duplas) | ||
+ | vetor de 1 elemento ("bit"): "0" "1" (entre aspas duplas) | ||
+ | inteiros: 5 1101 1102 (sem aspas) | ||
+ | |||
+ | :*Números binários: | ||
+ | 0 -> '0' | ||
+ | 7 (em base 2) -> "0111" ou b"0111" ou B"0111" | ||
+ | 1023 (em base 2) -> "001111111111" ou b"1111111111" ou B"1111111111" | ||
+ | |||
+ | :*Números octais: | ||
+ | 44 (em base 8) -> 5*8^1 + 4*8^0 -> O"54" ou o"54" | ||
+ | 1023 (em base 8)-> 1*8^3 + 7*8^2 + 7*8^1 + 7*8^0 -> o"1777" 8#1777# | ||
− | - | + | :*Números Hexadecimais: |
− | + | 1023 (em base 16) -> 3*16^2 + 15*16^1 + 15*16^0 = X"3FF" ou x"3FF" 16#3FF# | |
− | -- | + | :*Números decimais: |
+ | 1023 -> 1023 ou 1_023 | ||
+ | 1000 -> 1000 ou 1_000 ou 1E3 ou 10#1000# | ||
+ | ::Cuidado ao usar o "_" pois algumas ferramentas não o reconhecem. | ||
− | + | :*Números em outras bases (de 2 a 16) | |
− | + | 85 (em base 5) -> (3*5^2 + 2*5^1 + 0*5^0) -> 5#320# | |
− | + | 1539 (em base 3) -> (2*3^2+0*3^1+1*3^0)*3^4 -> 3#201#E4 | |
− | |||
− | |||
− | + | *Tipos de dados em VHDL. | |
+ | :*Objetos de VHDL: '''CONSTANT''', '''SIGNAL''', '''VARIABLE''', '''FILE'''. | ||
+ | O objeto '''CONSTANT''' pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, PACKAGE_BODY, BLOCK, GENERATE, PROCESS, FUNCTION e PROCEDURE. | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
− | |||
− | |||
− | -- Variable sem valor default. | + | constant <constant_name> : <type> := <constant_value>; |
− | variable <name> : <type>; | + | |
+ | -- Declarações comuns de constantes | ||
+ | |||
+ | constant GND : std_logic := '0'; | ||
+ | constant VCC : std_logic := '1'; | ||
+ | constant SSD_0 : std_logic_vector(0 to 6) := "1111110"; | ||
+ | constant MAX : natural := 44; | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | O objeto '''SIGNAL''' pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, BLOCK, GENERATE. Os sinais não podem ser declarados no código sequencial (PROCESS, FUNCTION e PROCEDURE), mas podem ser usados. | ||
+ | |||
+ | <syntaxhighlight lang=vhdl> | ||
+ | -- Signal sem valor default | ||
+ | -- Para atribuir um valor a um signal use "<=" como operador. | ||
+ | |||
+ | signal <name> : <type>; | ||
+ | |||
+ | -- Signal com valor default | ||
+ | signal <name> : <type> := <default_value>; | ||
+ | |||
+ | -- Declarações comuns de signals | ||
+ | |||
+ | signal <name> : std_logic; | ||
+ | signal <name> : std_logic_vector(<msb_index> downto <lsb_index>); | ||
+ | signal <name> : integer; | ||
+ | signal <name> : integer range <low> to <high>; | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | O objeto '''VARIABLE''' (variável) só pode ser declarada e usada dentro do escopo no código sequencial (PROCESS, FUNCTION e PROCEDURE). | ||
+ | |||
+ | <syntaxhighlight lang=vhdl> | ||
+ | -- Variables devem ser declarada em process ou subprogramas. | ||
+ | -- Para atribuir um valor a um variable use ":=" como operador. | ||
+ | |||
+ | -- Variable sem valor default. | ||
+ | variable <name> : <type>; | ||
-- Variable com valor default. | -- Variable com valor default. | ||
Linha 603: | Linha 655: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
+ | |||
+ | ;Encontro 14 (5 set.) | ||
A biblioteca [[Std logic 1164.vhd]] define os tipos STD_(U)LOGIG, STD_(U)LOGIG_VECTOR. | A biblioteca [[Std logic 1164.vhd]] define os tipos STD_(U)LOGIG, STD_(U)LOGIG_VECTOR. | ||
Linha 650: | Linha 704: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
− | |||
A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED. | A biblioteca [[Numeric std.vhd]] define os tipos UNSIGNED e SIGNED. | ||
Linha 735: | Linha 787: | ||
* Tipos de dados predefinidos: FIXED e FLOAT (apenas conhecer) | * Tipos de dados predefinidos: FIXED e FLOAT (apenas conhecer) | ||
− | |||
− | |||
− | |||
* '''Desafio 1''' - Fazer um circuito que detecte se existe alguma vaga vazia em um lote de 9 vagas. A entrada '''x(n)''' está baixo '0' se a vaga está vazia, e alto '1' se tem carro. A saída '''y''' estará alta '1' sempre que houver uma ou mais vagas vazias, e em baixo '0' se não houver nenhuma vaga. | * '''Desafio 1''' - Fazer um circuito que detecte se existe alguma vaga vazia em um lote de 9 vagas. A entrada '''x(n)''' está baixo '0' se a vaga está vazia, e alto '1' se tem carro. A saída '''y''' estará alta '1' sempre que houver uma ou mais vagas vazias, e em baixo '0' se não houver nenhuma vaga. | ||
Linha 748: | Linha 797: | ||
{{fig|3.2| Simulação do contador de vagas | cntvagas9.png | 800 px |}} | {{fig|3.2| Simulação do contador de vagas | cntvagas9.png | 800 px |}} | ||
+ | ;Encontro 15 (6 set.) | ||
− | |||
− | |||
− | |||
− | |||
* Exemplo 3.1 Buffer Tri-state | * Exemplo 3.1 Buffer Tri-state | ||
:*Ver como funciona em [http://bibl.ica.jku.at/dc/build/html/basiccircuits/basiccircuits.html#figure-1] | :*Ver como funciona em [http://bibl.ica.jku.at/dc/build/html/basiccircuits/basiccircuits.html#figure-1] | ||
− | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
Linha 781: | Linha 826: | ||
::* Analise se seria possível modificar as portas para o tipo '''bit'''. | ::* Analise se seria possível modificar as portas para o tipo '''bit'''. | ||
:: '''Importante''': O terceiro estado 'Z' só pode ser usado em saídas, e a sua realização nos FPGAs só ocorre nos nós de I/O. | :: '''Importante''': O terceiro estado 'Z' só pode ser usado em saídas, e a sua realização nos FPGAs só ocorre nos nós de I/O. | ||
+ | ;Curiosidade: Existem circuitos comerciais que implementam essa função three-state [https://www.ti.com/lit/ds/symlink/sn74lvc16244a-q1.pdf?ts=1681232207751&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252FSN74LVC16244A-Q1 16 buffers], [https://www.ti.com/lit/ds/symlink/sn74lv244a-ep.pdf?ts=1681237777688&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252FSN74LV244A-EP 8 buffers], [https://www.ti.com/lit/ds/symlink/sn74auc1g126.pdf?ts=1681222704977&ref_url=https%253A%252F%252Fwww.google.com%252F 1 buffer]. Porque não utilizar um CPLD ou FPGA em seu lugar? | ||
+ | ;Encontro 16 (12 set.) | ||
:* Exemplo 3.2 Circuito com Saida "don't care" | :* Exemplo 3.2 Circuito com Saida "don't care" | ||
Linha 806: | Linha 853: | ||
* '''Desafio 3''' - Fazer um circuito que detecte se existe alguma vaga vazia em um lote de 9 vagas. A entrada '''x(n)''' está baixo '0' se a vaga está vazia, e alto '1' se tem carro. A saída '''y''' estará alta '1' sempre que houver uma ou mais vagas vazias, e em baixo '0' se não houver nenhuma vaga. Inspirado na descrição VHDL acima, tente resolver esse problema usando ''don't care''. | * '''Desafio 3''' - Fazer um circuito que detecte se existe alguma vaga vazia em um lote de 9 vagas. A entrada '''x(n)''' está baixo '0' se a vaga está vazia, e alto '1' se tem carro. A saída '''y''' estará alta '1' sempre que houver uma ou mais vagas vazias, e em baixo '0' se não houver nenhuma vaga. Inspirado na descrição VHDL acima, tente resolver esse problema usando ''don't care''. | ||
− | |||
:'''Importante''': O ''don't care'' não funciona como se espera para uma entrada, por isso, use ''don't care'' apenas para saídas. | :'''Importante''': O ''don't care'' não funciona como se espera para uma entrada, por isso, use ''don't care'' apenas para saídas. | ||
Linha 867: | Linha 913: | ||
{{collapse bottom}} | {{collapse bottom}} | ||
+ | |||
<center> | <center> | ||
{{Mensagem | {{Mensagem | ||
Linha 877: | Linha 924: | ||
|background colour=#F5FFFA}} | |background colour=#F5FFFA}} | ||
</center> | </center> | ||
+ | |||
:: Ver pag. 39 a 54 de <ref name="PEDRONI2010b"/> | :: Ver pag. 39 a 54 de <ref name="PEDRONI2010b"/> | ||
− | ;Encontro | + | ;Encontro 17 (15 set.) |
*Operadores em VHDL. | *Operadores em VHDL. | ||
:* Operadores predefinidos: Atribuição, Lógicos, Aritméticos, Comparação, Deslocamento, Concatenação, "Matching". | :* Operadores predefinidos: Atribuição, Lógicos, Aritméticos, Comparação, Deslocamento, Concatenação, "Matching". | ||
Linha 960: | Linha 1 008: | ||
{{fig|3.3| Simulação do conversor de Binário para BCD com 2 digitos | bin2bcdDU_modelsim.png | 1000 px |}} | {{fig|3.3| Simulação do conversor de Binário para BCD com 2 digitos | bin2bcdDU_modelsim.png | 1000 px |}} | ||
− | |||
+ | ;Encontro 18 (19 set.) | ||
;Operadores lógicos: | ;Operadores lógicos: | ||
São suportados nos tipos de dados: BIT, BIT_VECTOR, BOOLEAN, STD_(U)LOGIC, STD_(U)LOGIC_VECTOR, SIGNED e UNSIGNED. Com VHDL 2008 também suportado para BOOLEAN_VECTOR, UFIXED, SFIXED e FLOAT. | São suportados nos tipos de dados: BIT, BIT_VECTOR, BOOLEAN, STD_(U)LOGIC, STD_(U)LOGIC_VECTOR, SIGNED e UNSIGNED. Com VHDL 2008 também suportado para BOOLEAN_VECTOR, UFIXED, SFIXED e FLOAT. | ||
Linha 982: | Linha 1 030: | ||
:*SRL (''Shift Right Logic'') - Deslocamento a direita lógico (preenchimento com '0's das posições a esquerda. | :*SRL (''Shift Right Logic'') - Deslocamento a direita lógico (preenchimento com '0's das posições a esquerda. | ||
:*SLA (''Shift Left Arithmetic'') - Deslocamento a esquerda aritmético (posições liberadas da direita mantém o bit lsb) | :*SLA (''Shift Left Arithmetic'') - Deslocamento a esquerda aritmético (posições liberadas da direita mantém o bit lsb) | ||
− | :*SRA (''Shift Right Arithmetic'') - Deslocamento a | + | :*SRA (''Shift Right Arithmetic'') - Deslocamento a direita aritmético (posições liberadas da esquerda mantém o bit msb) |
:*ROL (''Rotate Left'') - Deslocamento circular a esquerda ( o bit que sai na esquerda é retornado na direita) | :*ROL (''Rotate Left'') - Deslocamento circular a esquerda ( o bit que sai na esquerda é retornado na direita) | ||
:*ROR (''Rotate Right'') - Deslocamento circular a direita ( o bit que sai na direita é retornado na esquerda) | :*ROR (''Rotate Right'') - Deslocamento circular a direita ( o bit que sai na direita é retornado na esquerda) | ||
Linha 1 049: | Linha 1 097: | ||
</i> | </i> | ||
+ | ;Encontro 20 (20 set.) | ||
:* '''ATTRIBUTE keep''' [https://www.intel.com/content/www/us/en/programmable/quartushelp/current/index.htm#hdl/vhdl/vhdl_file_dir_keep.htm] | :* '''ATTRIBUTE keep''' [https://www.intel.com/content/www/us/en/programmable/quartushelp/current/index.htm#hdl/vhdl/vhdl_file_dir_keep.htm] | ||
O atributo de síntese KEEP, sinaliza ao processo de "Analysis & Synthesis" para manter intacto um determinado signal ou componente. | O atributo de síntese KEEP, sinaliza ao processo de "Analysis & Synthesis" para manter intacto um determinado signal ou componente. | ||
Linha 1 118: | Linha 1 167: | ||
: Ver pag. 91 a 111 de <ref name="PEDRONI2010b"/> | : Ver pag. 91 a 111 de <ref name="PEDRONI2010b"/> | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | |||
− | |||
* Atributos predefinidos são definidos no padrão [https://ieeexplore-ieee-org.ez130.periodicos.capes.gov.br/stamp/stamp.jsp?tp=&arnumber=8938196 1076-2019 - IEEE Standard for VHDL Language Reference Manual]. Esse documento pode ser acesso via o portal Periódicos Capes acesso CAFE. | * Atributos predefinidos são definidos no padrão [https://ieeexplore-ieee-org.ez130.periodicos.capes.gov.br/stamp/stamp.jsp?tp=&arnumber=8938196 1076-2019 - IEEE Standard for VHDL Language Reference Manual]. Esse documento pode ser acesso via o portal Periódicos Capes acesso CAFE. | ||
Linha 1 158: | Linha 1 205: | ||
E'SIMPLE_NAME - The simple name, character literal, or operator symbol of the named entity | E'SIMPLE_NAME - The simple name, character literal, or operator symbol of the named entity | ||
+ | ;Encontro 21 (22 set.) | ||
* Atributos definidos pelo usuário; | * Atributos definidos pelo usuário; | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
Linha 1 164: | Linha 1 212: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | * Tipos definidos pelo usuário: | |
− | + | :* Escalares (Inteiros e Enumerados) | |
− | + | :* Tipos de Array 1D x 1D, 2D , 1D x 1D x 1D, 3D. Ver : [[Array em VHDL]] | |
Linha 1 217: | Linha 1 265: | ||
('0', '1', '1', '1')); -- 7 | ('0', '1', '1', '1')); -- 7 | ||
begin | begin | ||
− | + | -- slice1 <= table(row)(column); | |
− | + | -- slice2 <= table(row)(1 to 2); | |
− | + | -- slice3 <= table(row)); | |
− | + | -- slice4 <= table(1 TO 3)(column); | |
− | + | -- slice4 <= table(1)(column) & table(2)(column) & table(3)(column); | |
− | + | -- gen : for i in 1 to 3 generate | |
− | + | -- slice4(i) <= table(i)(column); | |
− | + | -- end generate; | |
end architecture; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
Linha 1 235: | Linha 1 283: | ||
{{collapse bottom}} | {{collapse bottom}} | ||
+ | |||
+ | ;Encontro 22 (29 set.) | ||
{{collapse top| bg=lightyellow | Exemplo 3.7: Array de bits 2D }} | {{collapse top| bg=lightyellow | Exemplo 3.7: Array de bits 2D }} | ||
O código abaixo cria um '''array''' de bits e utiliza as entradas "row" e "column" para fazer a leitura dos dados em uma tabela declarada como '''constant'''. | O código abaixo cria um '''array''' de bits e utiliza as entradas "row" e "column" para fazer a leitura dos dados em uma tabela declarada como '''constant'''. | ||
Linha 1 258: | Linha 1 308: | ||
--slice1 <= table(row, column); | --slice1 <= table(row, column); | ||
--slice2 <= table(row, 1 TO 2); | --slice2 <= table(row, 1 TO 2); | ||
− | --slice3 <= table(row | + | --slice3 <= table(row); |
--slice4 <= table(1 TO 3, column); | --slice4 <= table(1 TO 3, column); | ||
− | --slice4 <= table(1, column) & table(2, column) & | + | --slice4 <= table(1, column) & table(2, column) & table(3, column) |
--gen : for i in 1 to 3 generate | --gen : for i in 1 to 3 generate | ||
-- slice4(i) <= table(i, column); | -- slice4(i) <= table(i, column); | ||
Linha 1 316: | Linha 1 366: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
Como usar ARRAYs em portas?: | Como usar ARRAYs em portas?: | ||
* Declaração do TYPE em PACKAGE | * Declaração do TYPE em PACKAGE | ||
Linha 1 466: | Linha 1 515: | ||
;Sobrecarga de operadores: | ;Sobrecarga de operadores: | ||
+ | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
Linha 1 490: | Linha 1 540: | ||
;Desafio 5: Completar o contador de vagos usando um numero inteiro (1 para vaga, 0 para ocupado) nas entradas no lugar dos bits. | ;Desafio 5: Completar o contador de vagos usando um numero inteiro (1 para vaga, 0 para ocupado) nas entradas no lugar dos bits. | ||
− | ;Encontro | + | <!-- |
− | + | ;Encontro 25 (25 abr.) | |
− | ;Encontro | + | ;Encontro 26 (26 abr.) |
− | |||
* A implementação de circuitos aritméticos com operadores deve seguir as seguintes recomendações: | * A implementação de circuitos aritméticos com operadores deve seguir as seguintes recomendações: | ||
:* Para o uso dos operadores o mais adequado é utilizar o padrão industrial '''STD_LOGIC_VECTOR'''. Internamente os valores das portas devem ser convertidos ou para valores '''INTEGER''' ou para '''UNSIGNED'''/'''SIGNED'''. para tal é necessário utilizar o pacote '''numeric_std''' da biblioteca '''ieee'''. | :* Para o uso dos operadores o mais adequado é utilizar o padrão industrial '''STD_LOGIC_VECTOR'''. Internamente os valores das portas devem ser convertidos ou para valores '''INTEGER''' ou para '''UNSIGNED'''/'''SIGNED'''. para tal é necessário utilizar o pacote '''numeric_std''' da biblioteca '''ieee'''. | ||
Linha 1 611: | Linha 1 660: | ||
:*[[Uso do WaveDrom para gerar diagramas de tempo]] | :*[[Uso do WaveDrom para gerar diagramas de tempo]] | ||
+ | |||
+ | *[https://ieeexplore-ieee-org.ez130.periodicos.capes.gov.br/stamp/stamp.jsp?tp=&arnumber=8938196 IEEE Std 1076‐2019 IEEE Standard for VHDL Language: Reference Manual] - acesse via Periódicos Capes /Cafe | ||
--> | --> | ||
− | |||
{{collapse bottom}} | {{collapse bottom}} | ||
===Unidade 4 - Código Concorrente=== | ===Unidade 4 - Código Concorrente=== | ||
− | * | + | * 4 ENCONTROS |
{{collapse top| expand=true | Unidade 4 - Código Concorrente}} | {{collapse top| expand=true | Unidade 4 - Código Concorrente}} | ||
− | + | ||
− | ;Encontro | + | ;Encontro 24 (3 out.) |
*Código Concorrente. | *Código Concorrente. | ||
:* Uso de Operadores | :* Uso de Operadores | ||
Linha 1 735: | Linha 1 785: | ||
::Ver pag. 121 a 127 de <ref name="PEDRONI2010b"/> | ::Ver pag. 121 a 127 de <ref name="PEDRONI2010b"/> | ||
− | + | ;Encontro 25 (4 out.) | |
:* Uso da instrução FOR-GENERATE | :* Uso da instrução FOR-GENERATE | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
Linha 1 779: | Linha 1 829: | ||
architecture ifsc_v1 of vector_adder is | architecture ifsc_v1 of vector_adder is | ||
− | signal soma_sig : | + | signal soma_sig : unsigned(3 downto 0); |
begin | begin | ||
− | soma_sig <= | + | soma_sig <= unsigned(a(0)) + unsigned(a(1)) + unsigned(a(2)) + unsigned(a(3)); |
soma <= std_logic_vector(soma_sig); | soma <= std_logic_vector(soma_sig); | ||
end architecture; | end architecture; | ||
Linha 1 789: | Linha 1 839: | ||
begin | begin | ||
− | |||
end architecture; | end architecture; | ||
Linha 1 805: | Linha 1 854: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | ;Encontro | + | ;Encontro 26 (6 out.) |
* Conhecer o [[Código Gray]] | * Conhecer o [[Código Gray]] | ||
Linha 1 858: | Linha 1 907: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | ;Encontro | + | |
+ | ;Encontro 27 (10 out.) | ||
+ | |||
Outros exemplos a serem estudados: | Outros exemplos a serem estudados: | ||
* Porta AND e NAND generica (uso do FOR GENERATE) | * Porta AND e NAND generica (uso do FOR GENERATE) | ||
* Detector de paridade | * Detector de paridade | ||
− | |||
− | |||
*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 1 892: | Linha 1 941: | ||
{{fig|3.9| Unidade de Lógica e Aritmética | Alu_pedroni.png | 600 px | pag. 127 <ref name="PEDRONI2010b"/>}} | {{fig|3.9| Unidade de Lógica e Aritmética | Alu_pedroni.png | 600 px | pag. 127 <ref name="PEDRONI2010b"/>}} | ||
− | + | *Ver pag. 127 a 134 de <ref name="PEDRONI2010b"/> | |
− | + | ;Encontro 28 (17 out.): Aula de exercícios | |
− | + | * Lista de Exercícios: ver no Moodle [https://moodle.ifsc.edu.br/mod/wiki/view.php?id=56759 Estudos livres sem entrega de documentação (EL)] | |
+ | |||
{{collapse bottom}} | {{collapse bottom}} | ||
===Unidade 5 - Código Sequencial=== | ===Unidade 5 - Código Sequencial=== | ||
− | * | + | * 7 ENCONTROS |
{{collapse top| expand=true| Unidade 5 - Código Sequencial}} | {{collapse top| expand=true| Unidade 5 - Código Sequencial}} | ||
− | + | ;Encontro 29 (18 out.) | |
− | ;Encontro | ||
*Código Sequencial. | *Código Sequencial. | ||
:*Diferenças entre código concorrente e sequencial <=> circuitos combinacional e sequencial | :*Diferenças entre código concorrente e sequencial <=> circuitos combinacional e sequencial | ||
Linha 1 948: | Linha 1 997: | ||
end if; | end if; | ||
end process; | end process; | ||
− | + | </syntaxhighlight> | |
+ | {{fig|5.1|RTL de Flip-flop D de borda de subida, com reset assíncrono| FF_D_RST.png| 400 px | }} | ||
+ | <syntaxhighlight lang=vhdl> | ||
--Flip Flop tipo D com preset assincrono e sinal de enable, sensivel a borda de descida. | --Flip Flop tipo D com preset assincrono e sinal de enable, sensivel a borda de descida. | ||
process (clock, preset) | process (clock, preset) | ||
Linha 1 961: | Linha 2 012: | ||
end process; | end process; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | {{fig|5.2|RTL de Flip-flop D de borda de descida, com preset assíncrono e enable| FF_D_PRST.png| 400 px | }} | |
::* Comparar com Latch (sem clk'event). | ::* Comparar com Latch (sem clk'event). | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
Linha 1 974: | Linha 2 025: | ||
end process; | end process; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
+ | {{fig|5.3|RTL de Latch D de com reset assíncrono e enable ativo alto| LATCH_D_RST.png| 400 px | }} | ||
+ | * Na figura abaixo, note que o Latch é implementado utilizando a LUT do elemento lógico do FPGA, enquanto que o Flip-flop utiliza o componente já disponível neste elemento lógico. | ||
+ | *[[Evite os latches no projeto]] | ||
+ | |||
+ | {{fig|5.4|Comparação do ''Technology Map'' de um Latch_D (esquerda) com FF_D (direita)| FF_D_LATCH_D.png| 800 px | }} | ||
+ | |||
:*Ver pag. 151 a 156 de <ref name="PEDRONI2010b"/> | :*Ver pag. 151 a 156 de <ref name="PEDRONI2010b"/> | ||
− | + | :*[[Especificando o valor de Power-Up do flip-flop D]] | |
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
-- Flip Flop tipo D com reset síncrono sensível a borda de subida. | -- Flip Flop tipo D com reset síncrono sensível a borda de subida. | ||
Linha 1 989: | Linha 2 046: | ||
end if; | end if; | ||
end process; | end process; | ||
+ | </syntaxhighlight> | ||
+ | {{fig|5.5|RTL do Flip-flop D com reset assíncrono e reset síncrono| FF_D_RST_SINC_ASINC.png| 400 px | }} | ||
+ | *[[Como evitar o uso da lógica combinacional no reset síncrono]] | ||
− | + | *Exercício: Implemente um registrador com N FF_D no lugar de um único FF_D. | |
− | * | + | {{fig|5.6|RTL do Registrador (de 4 bits) com reset assíncrono| REG_RST.png| 400 px | }} |
+ | {{fig|5.7|Techonogy Map do Registrador (de 4 bits) com reset assíncrono| TM_REG_RST.png| 400 px | }} | ||
+ | * Faça a simulação funcional do DFFs e do Latch | ||
− | |||
− | |||
+ | ;Encontro 21 (20 out.) | ||
* Contador crescente 0-N (baseado no Ex.6.2), com N = 2^Mbits-1 (1 3 7 15) | * Contador crescente 0-N (baseado no Ex.6.2), com N = 2^Mbits-1 (1 3 7 15) | ||
:* Com ''overflow'' no valor máximo | :* Com ''overflow'' no valor máximo | ||
* Contador crescente 0-N (baseado no Ex.6.2), com N =/= 2^Mbits (5, 10) | * Contador crescente 0-N (baseado no Ex.6.2), com N =/= 2^Mbits (5, 10) | ||
− | |||
:* Com ''overflow'' no valor máximo | :* Com ''overflow'' no valor máximo | ||
+ | |||
+ | ;Encontro 33 (31 out.) | ||
* Converter os contadores para modo decrescente 0-N | * Converter os contadores para modo decrescente 0-N | ||
− | |||
:* Com ''underflow'' no valor máximo | :* Com ''underflow'' no valor máximo | ||
− | + | * Modificar os contadores para pararem no valor máximo(crescentes) e mínimo(decresces). | |
− | |||
− | |||
+ | * '''DESAFIO''': Faça um contador que conte de 0 a N, mas que seja crescente ou decrescente controlado por uma entrada DIR. | ||
+ | :* Se DIR = '1' a contagem é crescente se DIR = '0' a contagem é decrescente. | ||
+ | :* Ao atingir o valor máximo (ou mínimo) o contador deverá fazer overflow para o valor 0 (ou N). | ||
− | ;Encontro | + | |
− | Instruções do tipo '''LOOP''': LOOP incondicional, FOR-LOOP, WHILE-LOOP, NEXT, EXIT | + | ;Encontro 34 (1 nov.) |
+ | |||
+ | Instruções do tipo '''LOOP''': LOOP incondicional, FOR-LOOP, WHILE-LOOP, NEXT, EXIT | ||
*Instrução '''LOOP''' incondicional: | *Instrução '''LOOP''' incondicional: | ||
Linha 2 112: | Linha 2 176: | ||
*Ver pag. 161 a 164 de <ref name="PEDRONI2010b"/> | *Ver pag. 161 a 164 de <ref name="PEDRONI2010b"/> | ||
+ | ;Encontro 35 e 36 (7 e 9 nov.) | ||
* Carry-Ripple Adder (FOR-LOOP) (Ex 6.4) - apenas analisar. | * Carry-Ripple Adder (FOR-LOOP) (Ex 6.4) - apenas analisar. | ||
:* Um somador do tipo carry ripple utiliza o bloco básico '''full adder''' para construir somadores de qualquer número de bits. Os bits carry são adicionados aos blocos posteriores, produzindo um hardware combinário. | :* Um somador do tipo carry ripple utiliza o bloco básico '''full adder''' para construir somadores de qualquer número de bits. Os bits carry são adicionados aos blocos posteriores, produzindo um hardware combinário. | ||
Linha 2 118: | Linha 2 183: | ||
::<math> c_{k+1} = a_k . b_k + a_k . c_k + b_k . c_k </math> | ::<math> c_{k+1} = a_k . b_k + a_k . c_k + b_k . c_k </math> | ||
:: onde <math> c_{k+1} </math> é o '''carry out''', <math> c_{k} </math> é o '''carry in''' | :: onde <math> c_{k+1} </math> é o '''carry out''', <math> c_{k} </math> é o '''carry in''' | ||
+ | |||
+ | Esse somador pode ser implementado tanto com código sequencial como com código concorrente. Note que no primeiro caso o bit de '''carry''' se definido como '''variable''' pode ser reaproveitado. No segundo caso é necessário criar um vetor completo para conectar os '''carry_out''' de um estágio ao '''carry_in''' do próximo. | ||
+ | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
+ | library ieee; | ||
+ | use ieee.std_logic_1164.all; | ||
+ | |||
entity carry_ripple_adder is | entity carry_ripple_adder is | ||
− | generic (N : integer := | + | generic (N : integer := 3); |
port ( | port ( | ||
a, b : std_logic_vector (N-1 downto 0); | a, b : std_logic_vector (N-1 downto 0); | ||
− | cin : std_logic | + | cin : std_logic; |
− | s : out std_logic_vector (N downto 0); | + | s : out std_logic_vector (N-1 downto 0); |
− | cout : out std_logic | + | cout : out std_logic |
); | ); | ||
end entity; | end entity; | ||
− | architecture | + | architecture estrutural_sequencial_v1 of carry_ripple_adder is |
begin | begin | ||
-- Uso de um codigo sequencial para geracao de um circuito combinacional | -- Uso de um codigo sequencial para geracao de um circuito combinacional | ||
− | process (a, b, cin) | + | process (a, b, cin) is |
− | + | variable c : std_logic; | |
begin | begin | ||
− | c | + | c := cin; |
− | for i in 0 to N - 1 loop | + | for i in 0 to N-1 loop |
− | + | s(i) <= a(i) xor b(i) xor c; | |
− | + | c := (a(i) and b(i)) or (a(i) and c) or (b(i) and c); | |
− | s(i) <= a(i) xor b(i) xor c | ||
− | |||
− | c | ||
end loop; | end loop; | ||
− | cout <= c | + | cout <= c; |
end process; | end process; | ||
+ | end architecture; | ||
+ | |||
+ | architecture estrutural_concorrente_v1 of carry_ripple_adder is | ||
+ | signal c : std_logic_vector(N downto 0); | ||
+ | begin | ||
+ | -- Uso de um codigo concorrente para geracao de um circuito combinacional | ||
+ | c(0) <= cin; | ||
+ | l1: for i in 0 to N-1 generate | ||
+ | s(i) <= a(i) xor b(i) xor c(i); | ||
+ | c(i+1) <= (a(i) and b(i)) or (a(i) and c(i)) or (b(i) and c(i)); | ||
+ | end generate; | ||
+ | cout <= c(N); | ||
end architecture; | end architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | {{fig|5.1|RTL do carry_ripple_adder de 3 bits | RTL_carry_ripple_adder3.png| 800 px |}} | |
+ | |||
*Instrução '''WAIT''': WAIT UNTIL, WAIT FOR (simulação apenas), WAIT ON (não implementada no Quartus II). | *Instrução '''WAIT''': WAIT UNTIL, WAIT FOR (simulação apenas), WAIT ON (não implementada no Quartus II). | ||
Linha 2 160: | Linha 2 241: | ||
:Algumas instruções de '''WAIT''' serão utilizadas na criação de '''TestBench''' em VHDL para a simulação com o '''MODELSIM'''. | :Algumas instruções de '''WAIT''' serão utilizadas na criação de '''TestBench''' em VHDL para a simulação com o '''MODELSIM'''. | ||
+ | * Projetar um contador em BCD entre 0 e 99 ('''countBCD_DU.vhd'''), com entrada de clock, reset e saidas unidade(0 a 9) e dezena (0 a 9). Projete o contador para parar em qualquer valor de DU onde D é a dezena e U é a unidade. | ||
− | |||
:* versão 1 - contagem crescente. | :* versão 1 - contagem crescente. | ||
+ | {{fig|5.2|RTL do contador BCD 00 a 99 | RTL_countBCD00-99.png| 800 px |}} | ||
+ | {{fig|5.3|Simulação do contador BCD 00 a 99 | MODELSIM_countBCD00-99.png| 800 px |}} | ||
+ | |||
+ | * Projetar um divisor de clock que dado um clock de entrada de f Hz, produza na saída um sinal de clock de f/N onde N é um número inteiro ('''div_clk_N''') | ||
+ | |||
+ | *Projetar um conversor de BCD para SSD - display de sete segmentos ('''BCD2SSD.vhd'''). O circuito deve ter uma entrada que permite escolher se o display é do tipo anodo comum ou catodo comum. | ||
+ | |||
+ | <!-- | ||
+ | |||
:* versão 2 - contagem decrescente. | :* versão 2 - contagem decrescente. | ||
:* versão 3 - contagem crescente ou decrescente controlado por uma entrada DIR. Se DIR = '0' a contagem é crescente se DIR = '1' a contagem é decrescente. | :* versão 3 - contagem crescente ou decrescente controlado por uma entrada DIR. Se DIR = '0' a contagem é crescente se DIR = '1' a contagem é decrescente. | ||
+ | {{fig|5.4|RTL do contador bidirecional BCD 00 a 99 | RTL_bicountBCD00-99.png| 800 px |}} | ||
+ | {{fig|5.5|Simulação do contador bidirecional BCD 00 a 99| MODELSIM_bicountBCD00-99.png| 800 px |}} | ||
+ | |||
:* versão 4 - contagem crescente de 0 a 59 ou de 0 a 23. Essa versão será usado no relógio. | :* versão 4 - contagem crescente de 0 a 59 ou de 0 a 23. Essa versão será usado no relógio. | ||
Linha 2 170: | Linha 2 263: | ||
::Antes de implementar a versão 3 verifique no RTL das versões 1 e 2 as diferenças, e pense nas possibilidades de reutilização do hardware. O que é comum entre elas e o que precisa ser acrescentado na versão 3. | ::Antes de implementar a versão 3 verifique no RTL das versões 1 e 2 as diferenças, e pense nas possibilidades de reutilização do hardware. O que é comum entre elas e o que precisa ser acrescentado na versão 3. | ||
::Tente obter uma versão com o mínimo acréscimo em elementos lógicos. | ::Tente obter uma versão com o mínimo acréscimo em elementos lógicos. | ||
− | |||
− | |||
* Registrador de deslocamento (Ex.6.3) | * Registrador de deslocamento (Ex.6.3) | ||
− | {{fig| | + | {{fig|5.6| RTL do registrador de deslocamento (Ex.6.3) | RTL_ShifRegRight.png | 400 px |}} |
− | + | {{fig|5.7| Technology Map do registrador de deslocamento (Ex.6.3) | TM_ShifRegRight.png | 800 px |}} | |
:Versão 1 - Implementação com 4 FF D. | :Versão 1 - Implementação com 4 FF D. | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
Linha 2 232: | Linha 2 323: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | *Simule o Registrador de Deslocamento | + | *Simule o Registrador de Deslocamento visualizando os sinais internos para perceber o deslocamento. |
− | |||
Aproveitando a versão 3 ou 2 do Shift Register da aula anterior, projete e faça a simulação dos dois circuitos indicados a seguir: | Aproveitando a versão 3 ou 2 do Shift Register da aula anterior, projete e faça a simulação dos dois circuitos indicados a seguir: | ||
− | |||
* Embrião de um conversor serial para paralelo. | * Embrião de um conversor serial para paralelo. | ||
Linha 2 294: | Linha 2 383: | ||
;Encontro 37 (5 jul.): | ;Encontro 37 (5 jul.): | ||
* Preparação para a aula de laboratório (AE5 - Relógio HH-MM-SS Implementação, simulação e testes de hardware) | * Preparação para a aula de laboratório (AE5 - Relógio HH-MM-SS Implementação, simulação e testes de hardware) | ||
− | + | ||
;Aula 37 (02 mar): | ;Aula 37 (02 mar): | ||
* Preparação para a aula de laboratório [https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom(2021.2)_-_Prof._Marcos_Moecke#AE11_-_Laborat.C3.B3rio_de_programa.C3.A7.C3.A3o_de_FPGA_-_Timer_00_a_99 AE11 - Laboratório de programação de FPGA - Timer 00 a 99] | * Preparação para a aula de laboratório [https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom(2021.2)_-_Prof._Marcos_Moecke#AE11_-_Laborat.C3.B3rio_de_programa.C3.A7.C3.A3o_de_FPGA_-_Timer_00_a_99 AE11 - Laboratório de programação de FPGA - Timer 00 a 99] | ||
Linha 2 366: | Linha 2 455: | ||
===Unidade 6 - Projeto a nível de Sistema=== | ===Unidade 6 - Projeto a nível de Sistema=== | ||
− | * | + | * 3 ENCONTROS |
{{collapse top| expand=true | Unidade 6 - Projeto a nível de Sistema}} | {{collapse top| expand=true | Unidade 6 - Projeto a nível de Sistema}} | ||
− | ;Encontro | + | ;Encontro 37 (14 nov.) |
*Projeto a nível de Sistema. | *Projeto a nível de Sistema. | ||
:* O '''PACKAGE''' e '''PACKAGE BODY''': onde declarar e como usar. | :* O '''PACKAGE''' e '''PACKAGE BODY''': onde declarar e como usar. | ||
Linha 2 376: | Linha 2 465: | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
− | entity | + | entity countBCD_DU is |
− | generic ( | + | generic (max_D : natural := 9; max_U : natural := 9); |
port ( | port ( | ||
clk, rst : in std_logic; | clk, rst : in std_logic; | ||
− | + | clk_out : out std_logic; | |
+ | bcd_D, bcd_U : out std_logic_vector(3 downto 0) | ||
); | ); | ||
end entity; | end entity; | ||
Linha 2 387: | Linha 2 477: | ||
Será declarada como um COMPONENT | Será declarada como um COMPONENT | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
− | component | + | component countBCD_DU is |
− | generic ( | + | generic (max_D : natural := 9; max_U : natural := 9); |
port ( | port ( | ||
clk, rst : in std_logic; | clk, rst : in std_logic; | ||
− | + | clk_out : out std_logic; | |
+ | bcd_D, bcd_U : out std_logic_vector(3 downto 0) | ||
); | ); | ||
end component; | end component; | ||
Linha 2 399: | Linha 2 490: | ||
* Mapeamento por posição e nominal. | * Mapeamento por posição e nominal. | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
− | comp1 : | + | comp1 : countBCD_DU |
− | GENERIC MAP ( | + | GENERIC MAP (5, 9) |
− | PORT MAP (clk,rst, bcd_dezena, bcd_unidade); | + | PORT MAP (clk,rst, clk1sec, bcd_dezena, bcd_unidade); |
</syntaxhighlight> | </syntaxhighlight> | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
comp1 : contador_bcd_00_99 | comp1 : contador_bcd_00_99 | ||
− | GENERIC MAP ( | + | GENERIC MAP ( max_D => 5, max_U => 9) |
PORT MAP ( clk => clk, | PORT MAP ( clk => clk, | ||
rst => rst, | rst => rst, | ||
− | + | clk_out => clk1sec, | |
− | + | bcd_D => bcd_dezena, | |
+ | bcd_U => bcd_unidade); | ||
</syntaxhighlight> | </syntaxhighlight> | ||
Linha 2 418: | Linha 2 510: | ||
{{fig|5.1| RTL portas NAND genéricas | NAND8&NAND40.png | 400 px |}} | {{fig|5.1| RTL portas NAND genéricas | NAND8&NAND40.png | 400 px |}} | ||
− | * | + | * Construir o projeto do '''contador_ssd_00_99''' usando componentes projetados anteriormente |
{{fig|5.2| RTL do contador_ssd_00_99 usando componentes | contador_ssd_00_99_TL.png | 600 px |}} | {{fig|5.2| RTL do contador_ssd_00_99 usando componentes | contador_ssd_00_99_TL.png | 600 px |}} | ||
+ | ;Ver também: | ||
+ | *[[Display de 7 segmentos]] | ||
− | |||
− | |||
− | ; Encontro | + | ;Encontro 38 (17 nov.) |
+ | *[https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE4_-_Laborat.C3.B3rio_de_programa.C3.A7.C3.A3o_de_FPGA_-_Rel.C3.B3gio_HHMMSS AE4 - Laboratório de programação de FPGA - Relógio HHMMSS] | ||
+ | |||
+ | ;Encontro 39 (20 nov.) | ||
* Instanciação de '''COMPONENT''' com '''GENERATE'''. | * Instanciação de '''COMPONENT''' com '''GENERATE'''. | ||
Linha 2 437: | Linha 2 532: | ||
::* Ligação direta: ARCHITECTURE-ENTITY. | ::* Ligação direta: ARCHITECTURE-ENTITY. | ||
::* Ligação da instanciação dos componentes: COMPONENT-ENTITY(ARCHITECTURE). | ::* Ligação da instanciação dos componentes: COMPONENT-ENTITY(ARCHITECTURE). | ||
− | |||
*FUNCTION e PROCEDURE (são chamados de subprogramas), e podem ser construídos em um PACKAGE, ENTITY, ARCHITECTURE, ou PROCESS. | *FUNCTION e PROCEDURE (são chamados de subprogramas), e podem ser construídos em um PACKAGE, ENTITY, ARCHITECTURE, ou PROCESS. | ||
Linha 2 554: | Linha 2 648: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
* Exemplo: min_max Ex.9.4 | * Exemplo: min_max Ex.9.4 | ||
{{fig|6.1|Fluxograma da PROCEDURE min_max| fluxogramMinMax.png| 600 px | pag. 232 de <ref name="PEDRONI2010b"/> }} | {{fig|6.1|Fluxograma da PROCEDURE min_max| fluxogramMinMax.png| 600 px | pag. 232 de <ref name="PEDRONI2010b"/> }} | ||
Linha 2 629: | Linha 2 722: | ||
:*Exemplo: Detector de Paridade Ex. 8.3 | :*Exemplo: Detector de Paridade Ex. 8.3 | ||
:* Ver pag. 201 a 213 de <ref name="PEDRONI2010b"/> | :* Ver pag. 201 a 213 de <ref name="PEDRONI2010b"/> | ||
− | |||
<!-- | <!-- | ||
; Encontro 41 e 42 (16 jul. Sábado): | ; Encontro 41 e 42 (16 jul. Sábado): | ||
*[https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE7_-_Laborat.C3.B3rio_de_programa.C3.A7.C3.A3o_de_FPGA_-_Timer_000_a_999_.28vers.C3.A3o_2.29 AE7 - Laboratório de programação de FPGA - Timer 000 a 999 (versão 2) ] | *[https://wiki.sj.ifsc.edu.br/index.php/DLP29006-Engtelecom_(Di%C3%A1rio)_-_Prof._Marcos_Moecke#AE7_-_Laborat.C3.B3rio_de_programa.C3.A7.C3.A3o_de_FPGA_-_Timer_000_a_999_.28vers.C3.A3o_2.29 AE7 - Laboratório de programação de FPGA - Timer 000 a 999 (versão 2) ] | ||
− | |||
::* Exercícios: 9.1 a 9.4, 9.6 a 9.9 | ::* Exercícios: 9.1 a 9.4, 9.6 a 9.9 | ||
:* Ver pag. 213 a 239 de <ref name="PEDRONI2010b"/>) | :* Ver pag. 213 a 239 de <ref name="PEDRONI2010b"/>) | ||
Linha 2 681: | Linha 2 772: | ||
===Unidade 7 - Maquinas de Estado Finitas=== | ===Unidade 7 - Maquinas de Estado Finitas=== | ||
− | + | * 4 ENCONTROS | |
− | {{collapse top| expand=true | Unidade 7 - Maquinas de Estado Finitas}} | + | {{collapse top | expand=true | Unidade 7 - Maquinas de Estado Finitas}} |
− | + | ;Encontro 39 (24 nov.) | |
− | ; Encontro | + | * O que é uma FSM - Finite State Machine |
− | |||
− | |||
{{fig|7.1|Exemplo de diagrama de estados de uma FSM Fig11.1(a) e implementação em hardware da FSM Fig11.2(a)|Fig11_1_FSM.png|800 px|Figura 11.1 e 11.2 de <ref name="PEDRONI2010b"/>}} | {{fig|7.1|Exemplo de diagrama de estados de uma FSM Fig11.1(a) e implementação em hardware da FSM Fig11.2(a)|Fig11_1_FSM.png|800 px|Figura 11.1 e 11.2 de <ref name="PEDRONI2010b"/>}} | ||
− | + | * Modelo básico em VHDL de FSM | |
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
LIBRARY ieee; | LIBRARY ieee; | ||
Linha 2 696: | Linha 2 785: | ||
PORT ( | PORT ( | ||
clk, rst : IN STD_LOGIC; | clk, rst : IN STD_LOGIC; | ||
− | + | entradas : IN < data_type > ; | |
− | + | saidas : OUT < data_type >); | |
END entity; | END entity; | ||
---------------------------------------------------------- | ---------------------------------------------------------- | ||
Linha 2 712: | Linha 2 801: | ||
IF (rst = '1') THEN | IF (rst = '1') THEN | ||
pr_state <= A; | pr_state <= A; | ||
− | ELSIF (clk | + | ELSIF rising_edge(clk) THEN |
+ | -- apenas na borda do "clk" ocorre a mudança de estado da FSM | ||
pr_state <= nx_state; | pr_state <= nx_state; | ||
END IF; | END IF; | ||
END PROCESS; | END PROCESS; | ||
------Logica Combinacional da FSM:------------ | ------Logica Combinacional da FSM:------------ | ||
− | PROCESS (pr_state, | + | PROCESS (pr_state, entradas) |
BEGIN | BEGIN | ||
− | + | ------Valores default das saidas------------ | |
− | + | saidas <= < valor > ; | |
CASE pr_state IS | CASE pr_state IS | ||
WHEN A => | WHEN A => | ||
− | + | -- é necessário um WHEN para definir as "saidas" durante cada estado | |
− | IF ( | + | -- e analisar as "entradas" para definir o próximo estado |
+ | saidas <= < valor > ; -- apenas se diferente do valor default | ||
+ | IF (entradas = < valor >) THEN | ||
nx_state <= B; | nx_state <= B; | ||
... | ... | ||
Linha 2 731: | Linha 2 823: | ||
END IF; | END IF; | ||
WHEN B => | WHEN B => | ||
− | + | saidas <= < valor > ; -- apenas se diferente do valor default | |
− | IF ( | + | -- dependendo das "entradas", pode ser que hajam mais de um estados de destino |
+ | IF (entradas = < valor >) THEN | ||
nx_state <= C; | nx_state <= C; | ||
− | + | ELSIF (entradas = < valor >) THEN | |
+ | nx_state <= A; | ||
ELSE | ELSE | ||
nx_state <= B; | nx_state <= B; | ||
END IF; | END IF; | ||
+ | WHEN C => | ||
+ | saidas <= < valor > ; -- apenas se diferente do valor default | ||
+ | -- a passagem para outro estado pode não depender de nenhuma "entrada" | ||
+ | nx_state <= D; | ||
WHEN ... | WHEN ... | ||
+ | |||
+ | |||
END CASE; | END CASE; | ||
END PROCESS; | END PROCESS; | ||
------Seção de Saída (opcional):------- | ------Seção de Saída (opcional):------- | ||
+ | -- Essa seção visa garantir que a saida new_output esteja sincronizada com o clk. | ||
+ | -- Se isso não for importante, ela pode ser suprimida | ||
PROCESS (clk, rst) | PROCESS (clk, rst) | ||
BEGIN | BEGIN | ||
IF (rst = '1') THEN | IF (rst = '1') THEN | ||
− | new_output <= < | + | new_output <= < valor > ; |
− | ELSIF (clk | + | ELSIF rising_edge(clk) THEN --or falling_edge(clk) |
new_output <= output; | new_output <= output; | ||
END IF; | END IF; | ||
Linha 2 752: | Linha 2 854: | ||
END architecture; | END architecture; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
+ | ;Dica: Se ao discrever uma FSM, faltar algum estado, o Quartus dará erro durante a compilação. Para resolver temporariamente isso pode se usar antes de encerrar o case | ||
+ | <syntaxhighlight lang=vhdl> | ||
+ | WHEN others => | ||
+ | nx_state <= <initial_state>; | ||
+ | </syntaxhighlight> | ||
+ | |||
:* Usando o template acima descreva em VHDL a FSM indicada na Figura 11.1. | :* Usando o template acima descreva em VHDL a FSM indicada na Figura 11.1. | ||
:* Faça a simulação da FSM com Modelsim utilizando um testbench em VHDL que faça a FSM seguir os estados | :* Faça a simulação da FSM com Modelsim utilizando um testbench em VHDL que faça a FSM seguir os estados | ||
− | + | <center> | |
+ | <math> RST \to A \xrightarrow{\text{x=0}} A \xrightarrow{\text{x=1}} A \xrightarrow{\text{x=2}} B \xrightarrow{\text{x=2}} B \xrightarrow{\text{x=0}} C \xrightarrow{\text{x=0}} C \xrightarrow{\text{x=2}} C \xrightarrow{\text{x=1}} A \xrightarrow{\text{x=2}} B \xrightarrow{\text{x=1}} A </math> | ||
+ | </center> | ||
:: Ver pag. 277 a 280 de <ref name="PEDRONI2010b"/> | :: Ver pag. 277 a 280 de <ref name="PEDRONI2010b"/> | ||
− | :: | + | :: Note que o uso da atribuição manual do '''enum_encoding''' pode faz com que o compilador do Quartus não reconheça a FSM, mas use logica regular para representar o sistema. |
− | |||
− | |||
− | |||
− | |||
:* Máquina de vender doces | :* Máquina de vender doces | ||
::*Use o template da FSM para modelar o sistema mostrado na figurar a seguir. | ::*Use o template da FSM para modelar o sistema mostrado na figurar a seguir. | ||
Linha 2 776: | Linha 2 882: | ||
:: '''Dica''': para desenhar a FSM recomendo utilizar um software on-line para tal finalidade. Por Ex. [https://online.visual-paradigm.com/pt/ Visual Paradigm]. | :: '''Dica''': para desenhar a FSM recomendo utilizar um software on-line para tal finalidade. Por Ex. [https://online.visual-paradigm.com/pt/ Visual Paradigm]. | ||
− | |||
− | |||
− | |||
− | * Modelo de FSM temporizada | + | ;Encontro 40 (28 nov.) |
− | <syntaxhighlight lang=vhdl> | + | :* O problema de oscilando entre os estados em FSM. |
− | LIBRARY ieee; | + | |
− | USE ieee.std_logic_1164.ALL; | + | {{fig|7.5| FSM - alarme (oscilando entre os estados quando remoto é 1) |alarme_erro.png|500 px|Adaptado de Figura 11.9(a) de <ref name="PEDRONI2010b"/>}} |
− | ---------------------------------------------------------- | + | |
− | ENTITY < entity_name > IS | + | ::* Solução através do uso de FLAG |
− | PORT ( | + | |
− | clk, rst : IN STD_LOGIC; | + | {{fig|7.6| FSM - alarme (solução com flag) |alarme_flag.png|500 px|Adaptado de Figura 11.9(b) de <ref name="PEDRONI2010b"/>}} |
− | input : IN < data_type > ; | + | |
− | output : OUT < data_type >); | + | ::* Solução através do uso de estados de WAIT adicionais. |
+ | |||
+ | {{fig|7.7| FSM - alarme (solução com estados de WAIT) |alarme_wait.png|500 px|Adaptado de Figura 11.9(c) de <ref name="PEDRONI2010b"/>}} | ||
+ | |||
+ | {{fig|7.8| Simulação da FSM - alarme (solução com estados de WAIT) |simulation_alarme_wait.png|800 px|}} | ||
+ | |||
+ | :: Ver pag. 292 a 297 de <ref name="PEDRONI2010b"/> | ||
+ | *Exercício: Faça o download do arquivo simple_car_alarm.qar, disponível no Moodle da disciplina e realize as seguintes avaliações: | ||
+ | :#Perceba que existem 4 versões para o mesmo Alarme de Carro. Realize a simulação no ModelSim das 4 versões e perceba qual é a diferença de funcionamento desses circuitos. | ||
+ | :#Anote o número de elementos em cada versão. | ||
+ | :#Qual versão é a mais adequada na sua opinião? | ||
+ | :#Modifique a sua escolha para que o alarme não possa ser ativado se o "sensor" estiver em "1". | ||
+ | :#Analise o arquivo tb_vX.do e modifique-o para testar também essa nova condição. A simulação deve obrigatoriamente fazer o sistema passar por todos os estados e todas as transições. | ||
+ | :#Implemente a nova versão como uma nova arquitetura "fsm_v5", e escrever o arquivo de simulação "tbv5.do". | ||
+ | :#Salve as telas da simulação ("v5_sim.png"), tela da fsm ("v5_fsm.png"), tela do RTL ("v5_rtl.png"). | ||
+ | :#Acrescente os novos arquivos no projeto e salve o novo .qar | ||
+ | |||
+ | * Projeto de FSM temporizadas (nas quais as transições são ativadas também pelo tempo). | ||
+ | {{fig|7.9| Tipos de FSM (Condicional, Temporizada e Hibrida) |FSM_type.png|800 px|Figura 11.12 de <ref name="PEDRONI2010b"/>}} | ||
+ | |||
+ | * Modelo de FSM temporizada | ||
+ | <syntaxhighlight lang=vhdl> | ||
+ | LIBRARY ieee; | ||
+ | USE ieee.std_logic_1164.ALL; | ||
+ | ---------------------------------------------------------- | ||
+ | ENTITY < entity_name > IS | ||
+ | PORT ( | ||
+ | clk, rst : IN STD_LOGIC; | ||
+ | input : IN < data_type > ; | ||
+ | output : OUT < data_type >); | ||
END entity; | END entity; | ||
---------------------------------------------------------- | ---------------------------------------------------------- | ||
Linha 2 858: | Linha 2 990: | ||
:Ver pag. 298 a 301 de <ref name="PEDRONI2010b"/> | :Ver pag. 298 a 301 de <ref name="PEDRONI2010b"/> | ||
+ | ;Encontro 41 e 42 (29 nov. e 1 dez.) | ||
;Exemplo de FSM temporizada - semáforo temporizado: | ;Exemplo de FSM temporizada - semáforo temporizado: | ||
* Usando o template acima descreva em VHDL a FSM de um controlador de semáforo Regular indicado pela FSM da figura abaixo: | * Usando o template acima descreva em VHDL a FSM de um controlador de semáforo Regular indicado pela FSM da figura abaixo: | ||
Linha 2 863: | Linha 2 996: | ||
{{fig|7.11| Simulação do controlador de semáforo no Modelsim |Semaforo_FSM_v2_ModelSim.png|800 px|}} | {{fig|7.11| Simulação do controlador de semáforo no Modelsim |Semaforo_FSM_v2_ModelSim.png|800 px|}} | ||
− | + | <!-- | |
− | |||
{{collapse top| bg=lightyellow | Exercício - Semaforo}} | {{collapse top| bg=lightyellow | Exercício - Semaforo}} | ||
* Usando o template acima descreva em VHDL a FSM de um controlador de semáforo Regular da Figura 11.15 (pag. 304 de <ref name="PEDRONI2010b"/>). | * Usando o template acima descreva em VHDL a FSM de um controlador de semáforo Regular da Figura 11.15 (pag. 304 de <ref name="PEDRONI2010b"/>). | ||
Linha 2 877: | Linha 3 009: | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | |||
* Realize a simulação dos semáforos S1 e S2, destacando as saídas com as cores correspondentes, conforme mostrado abaixo: | * Realize a simulação dos semáforos S1 e S2, destacando as saídas com as cores correspondentes, conforme mostrado abaixo: | ||
{{fig|7.14| Simulação do controlador de semáforo no Modelsim |Semaforo_ModelSim.png|800 px|}} | {{fig|7.14| Simulação do controlador de semáforo no Modelsim |Semaforo_ModelSim.png|800 px|}} | ||
+ | --> | ||
− | + | Se quiser usar o ModelSim diretamente sem usar o Quartus, abra um terminal e digite: | |
+ | /opt/intelFPGA/20.1/modelsim_ae/linuxaloem/vsim (ou o caminho de instalação na sua maquina) | ||
− | + | ;Encontro 43 (5 dez.) | |
− | + | *Avaliação A2 | |
− | {{ | + | {{collapse bottom}} |
− | + | ===Unidade 8 - Testbench=== | |
− | + | * 2 ENCONTROS | |
− | + | {{collapse top| expand = true | Unidade 8 - Testbench}} | |
− | + | ; Encontro 43 (8 dez.): | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | ===Unidade 8 - Testbench=== | ||
− | {{collapse top| expand = true | Unidade 8 - Testbench}} | ||
− | |||
− | ; | ||
*Simulação de sistemas digitais com Modelsim e testbench em VHDL | *Simulação de sistemas digitais com Modelsim e testbench em VHDL | ||
:*Tipos de simulação: | :*Tipos de simulação: | ||
Linha 2 930: | Linha 3 036: | ||
::8) simulação temporal (usando o ModelSim e Matlab) com entrada VHDL e análise em VHDL da saída. | ::8) simulação temporal (usando o ModelSim e Matlab) com entrada VHDL e análise em VHDL da saída. | ||
− | :* | + | ;Geração automática do modelo do testbench em VHDL: |
− | / | + | Usaremos como exemplo o semáforo recém projetado para criar um testbench em VHDL para testar uma '''entity''' projetada em VHDL. |
+ | * O primeiro passo é abrir o projeto, que foi anteriormente simulado com um arquivo de script .do para criar agora uma simulação usando um testbench em VHDL. | ||
+ | * Esse processo pode ser feita manualmente, mas usaremos o comando do Quartus que permite gerar um modelo para o testbench. Selecione a '''entity''' TOP LEVEL e após fazer a '''Analysis & Synthesis''' selecione '''Processing > Start > Start Test Bench Template Writer'''. | ||
+ | * Neste passo deverá será gerado um arquivo '''<nome>.vht''' dentro da pasta '''simulation/modelsim'''. | ||
+ | * Abra o '''<nome>.vht'''arquivo, e inclua ele nos arquivos do projeto. | ||
+ | <blockquote style="background: lightblue; border: 3px solid black; padding: 1em;"> | ||
+ | ;ATENÇÃO: | ||
+ | Se ao invés de gerar um arquivo <nome>.vht (VDHL), for gerado o arquivo <nome>.vt (Verilog), isso indica que ao definir o projeto, não foi escolhido a linguagem correta para simulação. preste atenção na mensagem: | ||
+ | <pre> | ||
+ | Info (201000): Generated Verilog Test Bench File <caminho>/simulation/modelsim/<nome>.vt for simulation | ||
+ | </pre> | ||
+ | Para corrigir, selecione o VHDL, '''Assignments > Settings > EDA Tool Settings > {Tool Type = Simulation & Tool Name = ModelSim-Altera & Format(s) = <big>[VHDL]</big>} > [OK]''' | ||
+ | |||
+ | Depois disso repita o processo para gerar o template (modelo) e verifique se a mensagem mostrada é: | ||
+ | <pre> | ||
+ | Info (201002): Generated VHDL Test Bench File <caminho>/simulation/modelsim/<nome>.vht for simulation | ||
+ | </pre> | ||
+ | </blockquote> | ||
+ | |||
− | |||
− | |||
− | |||
− | |||
− | |||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
LIBRARY ieee; | LIBRARY ieee; | ||
Linha 3 089: | Linha 3 208: | ||
END PROCESS; | END PROCESS; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
− | |||
+ | * Após a criação do testbench, o projeto terá os arquivos '''semaforo.vhd''' e, '''semaforo.vht''', os quais serão utilizados no Modelsim para realizar a simulação. | ||
+ | * Abra o ModelSim a partir do Quartus '''Tools > Run Simulation Tool > RTL Simulation'''. | ||
+ | * Na pasta '''work''', deverão estar compiladas todas as entities do projeto, mas falta compilar o entity do testbench. Para compilar, o modo mais simples sem construir um projeto no ModelSim é: '''Compile > Compile > [File name = <nome>.vht] > [Compile] > [Done]'''. | ||
+ | * Após compilar o test_bench deverá estar na pasta '''work''' a nova entidade com o test_bench '''<nome>_vhd_tst''', a qual será usada na simulação. | ||
+ | * Escolha essa entidade para a simulação, e em seguida adicione os sinais que desejar da aba '''Objects''' na aba '''Wave'''. Se desejar adione outros sinais internos abrindo os componentes que compõe o projeto. | ||
+ | * Como a geração dos estimulos (sinais) será feita pelo testbench em VHDL, agora basta executar o comando '''run TEMPO''' (onde TEMPO = 1 sec | 100 [ps]| 10 ns) ou '''run -all''' (caso haja um tempo limite estabelecido no test_bench). | ||
+ | * Para facilitar a simulação no Modelsim recomenda-se criar também os arquivos de script '''tb_semaforo.do''', ou pelo menos criar o arquivo wave_vht.do para definir os sinais a serem mostrados e sua formatação. Note que no exemplo abaixo a compilação do <file_top_level>.vht é feita na pasta atual, pois ele é originalmente criado na pasta modelsim/simulation. | ||
+ | <syntaxhighlight lang=tcl> | ||
+ | vlib rtl_work | ||
+ | vmap work rtl_work | ||
+ | vcom -93 -work work {../../<file1>.vhd} | ||
+ | vcom -93 -work work {../../<file1>.vhd} | ||
+ | vcom -93 -work work {../../<file_top_level>.vhd} | ||
+ | vcom -93 -work work {<file_top_level>.vht} | ||
+ | vsim work.q2_vhd_tst | ||
+ | do wave_vht.do | ||
+ | run 110 ns | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Se quiser usar o ModelSim diretamente sem usar o Quartus, abra um terminal e digite: | ||
+ | /opt/intelFPGA/20.1/modelsim_ae/linuxaloem/vsim (ou o caminho de instalação na sua maquina) | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | |||
− | ==Avaliações== | + | ===Unidade 9 - Projeto Final=== |
− | Nas avaliações A1 e A2 | + | * 3 ENCONTROS |
+ | {{collapse top| expand = true | Unidade 9 - Projeto Final}} | ||
+ | ;Aula 44 a 47 (12 a 19 dez): | ||
+ | |||
+ | ;Projeto de Modernização Semafórica para a Grande Florianópolis - Soluções Inovadoras para o Tráfego Eficiente e Seguro: | ||
+ | O presente projeto busca por soluções semafóricas inovadoras, incluindo aprimoramentos específicos para o período noturno e economia de energia. O objetivo é proporcionar uma experiência mais segura e visível para veículos e pedestres ao cruzar vias durante o dia e a noite. | ||
+ | Como material auxiliar se sugere a leitura dinâmica do [https://www.gov.br/transportes/pt-br/assuntos/transito/arquivos-senatran/docs/Sinalizacao_semaforicavol_V_alterado.pdf Manual Brasileiro de Sinalização de trânsito: VOLUME V - Sinalização Semafórica] do CONTRAN. | ||
+ | *Para auxilio em nomenclatura e representações gráficas veja também [https://ecivilufes.files.wordpress.com/2013/07/aula9.pdf Sinalização semafórica: definições] - Universidade Presbiteriana Mackenzie | ||
+ | |||
+ | O projeto será desenvolvido por equipes de até 2 estudantes, e cada equipe deverá escolher uma dos cenários propostos, ou até mesmo um cenário diferenciado desses. Cada projeto deverá envolver obrigatoriamente: | ||
+ | |||
+ | * Uso de um conjunto de mostradores de 7 segmentos de dois ou mais dígitos. | ||
+ | * Uso de leds para indicar mostrar os semáforos. O uso das GPIOs com circuitos de LEDs de cores verde, vermelho e amarelo é encorajado. | ||
+ | * A equipe poderá utilizar ambos kits disponibilizados no laboratório | ||
+ | * Usar as chaves para simular os sensores e botoeiras (sinais de entrada). | ||
+ | * Uma ou mais máquinas de estados finitos | ||
+ | * Deverá ser usado um projeto hierárquico, onde a entidade top level deverá apenas ter a instanciação de componentes, e eventuais adaptações ao hardware do kit. | ||
+ | * Todos os componentes e o sistema completo devem ser testados através de simulação no Modelsim. | ||
+ | * Os testes reais do sistema completo no kit devem ser filmados para demonstrar o funcionamento. | ||
+ | * Fazer uma análise das vantagens e deficiencias da solução proposta. | ||
+ | |||
+ | ;Cenário 1 - Cruzamento de Via Preferencial com Via Secundária (Sensor de Veículo com Sinalização Piscante): | ||
+ | |||
+ | Nessa situação, a via secundária será liberada mediante a detecção de um veículo na área do sensor. A modernização incluirá a instalação de sensores na via secundária. Este sistema proporcionará uma abertura segura e eficiente quando necessário, ao mesmo tempo em que promove uma comunicação clara aos motoristas. A sinalização verde na via preferencial será configurada para piscar, alertando os condutores que o semáforo está sob controle do sensor de veículo na via secundária. Da mesma forma, na via secundária, o sinal ficará piscante em vermelho sempre que não houver veículo detectado pelo sensor. Ao ser identificado um veículo, o semáforo da via secundária mudará para vermelho, ao mesmo tempo que um contador regressivo indicará o tempo faltante para a abertura. Após o tempo mínimo programado para a via preferencial permanecer aberta, o semáforo da via secundária mudará para verde, indicando no contador regressivo o tempo restante de verde. Esse ajuste visa otimizar o fluxo de tráfego, garantindo a fluidez na via preferencial enquanto mantém a segurança na via secundária. A sinalização piscante proporcionará uma comunicação visual eficaz, informando os motoristas sobre o modo de operação baseado no sensor de veículo, contribuindo para uma navegação segura e eficiente no cruzamento entre a via preferencial e a secundária. | ||
+ | |||
+ | ;Cenário 2 - Travessia Controlada por Botoeira com Sinalização Noturna, Sinalização Piscante, Avisos Sonoros: | ||
+ | |||
+ | Visa garantir uma travessia de pedestres diurna e noturna segura e consciente. Ao acionar a botoeira, será ativada uma iluminação branca sobre a faixa de passagem zebrada e nas áreas de espera dos pedestres, assegurando melhor visibilidade e segurança para o pedestre a noite. Simultaneamente, o semáforo emitirá sinais visuais e sonoros, indicando ao pedestre que o botão foi acionado com sucesso e alertando motoristas sobre a intenção de travessia. Durante a fase de liberação para veículos, o semáforo do pedestre permanecerá vermelho, economizando energia até que o botão seja acionado. Após a solicitação, os grupos focais do pedestre exibirão luz verde em ambos os lados da via, enquanto o semáforo dos carros exibirá sinal vermelho, garantindo a máxima segurança para os pedestres e reforçando a prioridade de travessia. | ||
+ | |||
+ | Para orientar pedestres de maneira eficaz, o semáforo do pedestre apresentará um contador regressivo, indicando o tempo restante para a travessia. O tempo total de travessia será ajustável, permitindo personalização conforme as necessidades locais. Nos últimos 30% do tempo, o sinal verde do semáforo do pedestre piscará, visualmente alertando que o tempo para a travessia está se encerrando. É importante ressaltar que a iluminação estará ativa apenas durante o tempo em que a botoeira foi acionada até 5 segundos após o término do tempo de travessia. Este ajuste visa otimizar o consumo de energia e garantir que a iluminação cumpra sua função apenas quando necessária. | ||
+ | |||
+ | ;Cenário 3 - Sinalização Semafórica para Cruzamento com Passagem de Pedestres Controlada por Botoeira e Sincronizada com Vias Veiculares: | ||
+ | |||
+ | Este projeto visa apresentar uma solução para um cruzamento de vias, com a passagem de pedestres controlada por botoeira, integrada de maneira sincronizada com o fluxo de veículos. Abaixo, detalhamos as características tanto para pedestres quanto para carros. | ||
+ | Fase Inicial: Os semáforos veiculares iniciam em sinal amarelo piscante em ambas as vias. O semáforo para pedestres permanece apagado até a ativação da botoeira, visando a economia de energia. apenas um led vermelho no centro da botoeira deve estar piscando para induzir o pedestre a acionar a boteira. Uma placa sobre a botoeira informa que é necessário acionar o botão para solicitar a passagem. | ||
+ | Funcionamento no modo veicular sem solicitação de pedestre: O cruzamento deve alternar entre vermelho, amarelo e verde conforme programação para otimizar o fluxo de carros. O ciclo de passagem de pedestre deve ser iniciado se alguma das 4 boteiras existentes nos cantos do cruzamento for acionada. | ||
+ | Solicitação de pedestre: Ao ser acionada uma das botoeiras dos Pedestres, se for a noite, será ativada a iluminação branca sobre a faixa de passagem zebrada e nas áreas de espera dos pedestres, assegurando melhor visibilidade e segurança para o pedestre a noite. Simultaneamente, o semáforo emitirá sinais sonoros, indicando ao pedestre que o botão foi acionado com sucesso e alertando motoristas sobre a intenção de travessia. Durante a fase de espera para dos pedestres, o semáforo do pedestre, que estava apagado economizando energia, acenderá em vermelho e mostrara um contador regresivo indicando o tempo faltante para a liberação da travessia. Na liberação, que é sincronizada com as vias, os grupos focais de pedestre exibirão luz verde em ambos os lados das faixas de pedestres, e indicará o tempo restante num contador regressivo. Enquanto isso, os semáforos dos carros exibirão sinal vermelho em todas as direções, garantindo a máxima segurança para os pedestres. Nos últimos 30% do tempo, sinal verde para pedestres piscará, alertando visualmente sobre término iminente da travessia. Ao término do tempo de travessia configurado, semáforo para pedestres entra em vermelho piscante por 5 segundos, indicando retorno ao modo veicular. Se botoeira for acionada novamente, inicia-se novo ciclo, sincronizando travessia de pedestres com o fluxo veicular. | ||
+ | |||
+ | Essa sinalização semafórica integrada visa proporcionar uma travessia segura e eficiente para pedestres, ao mesmo tempo em que otimiza o fluxo veicular, contribuindo para um ambiente de tráfego mais fluido e seguro no cruzamento das vias de carros. | ||
+ | |||
+ | ;BONUS: | ||
+ | * 2 pontos na Avaliação A1 ou A2: implementar uma melhoria no semáforo fazendo ele progressivo, com 6 lampadas verdes e 6 vermelhas no Cenário 1, 2 ou 3 | ||
+ | * 1 pontos na Avaliação A1 ou A2: implementar uma melhoria para liberar o transito para ambulância que esteja atendendo a uma emergência no Cenário 1, 2 ou 3. | ||
+ | Para saber as especificações exatas dessas características pergunte ao professor. | ||
+ | |||
+ | Após a conclusão do projeto, a equipe deverá gravar um vídeo explicando o projeto usando o hardware projetado. Também deve ser feita a defesa por cada membro da equipe do projeto, devendo estar apto a responder sobre o código e também sobre o processo e metodologia. | ||
+ | |||
+ | {{collapse bottom}} | ||
+ | |||
+ | ==Avaliações== | ||
+ | Nas avaliações A1 e A2 vocês poderão consultar apenas as folhas entregues: | ||
<!-- | <!-- | ||
*[[Media:VHDL_QRC-Qualis.pdf | VHDL QUICK REFERENCE CARD]] - Qualis | *[[Media:VHDL_QRC-Qualis.pdf | VHDL QUICK REFERENCE CARD]] - Qualis | ||
Linha 3 110: | Linha 3 297: | ||
::Ao final das avaliações o aluno deverá enviar a avaliação para a plataforma Moodle com os arquivos solicitados. | ::Ao final das avaliações o aluno deverá enviar a avaliação para a plataforma Moodle com os arquivos solicitados. | ||
;Data das avaliações: | ;Data das avaliações: | ||
− | *A1 - Unidade 1 a Unidade 4: dia | + | *A1 - Unidade 1 a Unidade 4: dia XX/XX |
− | *A2 - Unidade 5 a Unidade 7: dia XX/ | + | *A2 - Unidade 5 a Unidade 7: dia XX/XX |
− | *PF - | + | *PF - Entrega do projeto final: dia 15/12 |
− | *R12 - Recuperação A1 e A2 : dia | + | *R12 - Recuperação de A1 e A2 : dia 12/12 |
<!-- | <!-- | ||
Linha 3 165: | Linha 3 352: | ||
== Atividade relâmpago (AR) == | == Atividade relâmpago (AR) == | ||
− | As atividades relâmpago devem ser entregues no Moodle da disciplina. | + | 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. |
− | |||
<!-- | <!-- | ||
===AR1 - Vagas de garagem (código concorrente) === | ===AR1 - Vagas de garagem (código concorrente) === | ||
Linha 3 199: | Linha 3 385: | ||
== Atividade extra-classe (AE) == | == Atividade extra-classe (AE) == | ||
− | A | + | 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 possuem BÔNUS que são adicionados aos conceitos das avaliações A1 e A2. Para os BÔNUS só serão considerados projetos entregues no prazo. |
+ | <!-- | ||
===AE1 - Palavras-cruzadas INTRODUÇÃO=== | ===AE1 - Palavras-cruzadas INTRODUÇÃO=== | ||
{{collapse top | bg=lightyellow | AE1 - Palavras-cruzadas INTRODUÇÃO}} | {{collapse top | bg=lightyellow | AE1 - Palavras-cruzadas INTRODUÇÃO}} | ||
{{collapse bottom}} | {{collapse bottom}} | ||
+ | --> | ||
===AE2 - Conhecendo os dispositivos lógicos programáveis=== | ===AE2 - Conhecendo os dispositivos lógicos programáveis=== | ||
− | {{collapse top | + | {{collapse top | bg=lightyellow | AE2 - Conhecendo os dispositivos lógicos programáveis}} |
;Objetivos: | ;Objetivos: | ||
− | *Conhecer o Quartus | + | *Conhecer o Quartus Prime e as características dos dispositivos lógicos programáveis |
*Analisar os tempos de propagação em um circuito combinacional | *Analisar os tempos de propagação em um circuito combinacional | ||
*Alterar configurações do compilador | *Alterar configurações do compilador | ||
*Fazer a simulação funcional e temporal de um circuito combinacional. | *Fazer a simulação funcional e temporal de um circuito combinacional. | ||
− | ; | + | ;Atividades: |
− | *'''PASSO 1:''' Realize a atividade descrita em [[Conhecendo os dispositivos lógicos programáveis]] | + | *'''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 | + | :*Ao escolher a família de FPGAS, escolha inicialmente um dispositivo da família '''Max II'''. Anote o código desse dispositivo. |
:*Capture as telas solicitadas e depois utilize-as no relatório da atividade. | :*Capture as telas solicitadas e depois utilize-as no relatório da atividade. | ||
:*Anote o tempo utilizado para cada uma das etapas do processo de compilação. | :*Anote o tempo utilizado para cada uma das etapas do processo de compilação. | ||
Linha 3 223: | Linha 3 411: | ||
:*Ao final salve o projeto em um arquivo QAR (sugestão PJ1.QAR) | :*Ao final salve o projeto em um arquivo QAR (sugestão PJ1.QAR) | ||
− | *'''PASSO 2''': Repita a atividade descrita em [[Conhecendo os dispositivos lógicos programáveis]], trocando a família e dispositivo a ser usado na implementação. Escolha nesta vez um dispositivos da família '''Cyclone IV E''' ou '''Stratix II GX'''. Anote o código desse dispositivo. | + | *'''PASSO 2''': Repita a atividade descrita em [[Conhecendo os dispositivos lógicos programáveis - QUARTUS PRIME]], trocando a família e dispositivo a ser usado na implementação. Escolha nesta vez um dispositivos da família '''Cyclone IV E''' ou '''Stratix II GX'''. Anote o código desse dispositivo. |
:*Observe as mudanças que ocorrem tanto no tipo de Elemento Lógico disponível, no Chip Planner, no Pin Planner, e no circuito dos pinos de I/O. Note que estes FPGAs também apresenta novos componentes, tais como: Memória, Multiplicadores, DSP, PLL, DLL, etc. Verifique se consegue encontra-los no leiaute mostrado no Chip Planner, e documente aqueles que encontrar. | :*Observe as mudanças que ocorrem tanto no tipo de Elemento Lógico disponível, no Chip Planner, no Pin Planner, e no circuito dos pinos de I/O. Note que estes FPGAs também apresenta novos componentes, tais como: Memória, Multiplicadores, DSP, PLL, DLL, etc. Verifique se consegue encontra-los no leiaute mostrado no Chip Planner, e documente aqueles que encontrar. | ||
:*Compare os resultados obtidos nos procedimentos do PASSO 1 e PASSO 2. | :*Compare os resultados obtidos nos procedimentos do PASSO 1 e PASSO 2. | ||
− | *'''PASSO 3''': Realize o procedimento descrito em [[Medição de tempos de propagação em circuitos combinacionais]] | + | *'''PASSO 3''': Realize o procedimento descrito em [[Medição de tempos de propagação em circuitos combinacionais - Quartus Prime]] |
:*Ao escolher a família de FPGAS, escolha um dispositivo FPGA da família '''Cyclone IV E'''. Anote o código desse dispositivo. | :*Ao escolher a família de FPGAS, escolha um dispositivo FPGA da família '''Cyclone IV E'''. Anote o código desse dispositivo. | ||
:*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. | ||
Linha 3 237: | Linha 3 425: | ||
:*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 | + | *'''PASSO 4''': Realize a simulação funcional de um dos projetos '''CI74161''' ou do '''cálculo da distância de Hamming''' |
− | |||
− | |||
:*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. | ||
Linha 3 248: | Linha 3 434: | ||
#A entrega será feita através do Moodle da disciplina. Observe o prazo de entrega. | #A entrega será feita através do Moodle da disciplina. Observe o prazo de entrega. | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | + | ||
===AE3 - Programação do kit Mercurio IV=== | ===AE3 - Programação do kit Mercurio IV=== | ||
{{collapse top | bg=lightyellow | AE3 - Programação do kit Mercurio IV}} | {{collapse top | bg=lightyellow | AE3 - Programação do kit Mercurio IV}} | ||
Linha 3 264: | Linha 3 450: | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
+ | library IEEE; | ||
+ | use IEEE.std_logic_1164.all; | ||
+ | use IEEE.numeric_std.all; | ||
+ | |||
entity counter is | entity counter is | ||
generic (WIDTH : in natural := 4); | generic (WIDTH : in natural := 4); | ||
Linha 3 271: | Linha 3 461: | ||
LOAD : in std_logic; | LOAD : in std_logic; | ||
DATA : in std_logic_vector(WIDTH-1 downto 0); | DATA : in std_logic_vector(WIDTH-1 downto 0); | ||
− | R0 : out std_logic | + | R0 : out std_logic; |
Q : out std_logic_vector(WIDTH-1 downto 0)); | Q : out std_logic_vector(WIDTH-1 downto 0)); | ||
end entity; | end entity; | ||
architecture ifsc_v1 of counter is | architecture ifsc_v1 of counter is | ||
− | signal Q_aux : | + | signal Q_aux : std_logic_vector(WIDTH-1 downto 0); |
begin | begin | ||
process(RST,CLK) is | process(RST,CLK) is | ||
Linha 3 298: | Linha 3 488: | ||
;Passo 2: | ;Passo 2: | ||
*[[Preparando para gravar o circuito lógico no FPGA]] | *[[Preparando para gravar o circuito lógico no FPGA]] | ||
+ | :*Escolher a FAMILY: '''Cyclone® IV E''' | ||
:* Escolher o DEVICE: '''EP4CE30F23C7''' | :* Escolher o DEVICE: '''EP4CE30F23C7''' | ||
− | :* | + | :* Configurar como entrada e saída do FPGA os seguintes pinos: |
CLK: PIN_Y17 ou PIN_V21 | CLK: PIN_Y17 ou PIN_V21 | ||
DATA[3]: PIN_H18 | DATA[3]: PIN_H18 | ||
Linha 3 392: | Linha 3 583: | ||
:* Apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito nos Passos 3 e 5 | :* Apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito nos Passos 3 e 5 | ||
* 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}} | ||
Linha 3 420: | Linha 3 610: | ||
{{fig|AE4(d)|Exemplo de tempo máximo de propagação | bin2bcd_propagation_delay.png| 600 px |}} | {{fig|AE4(d)|Exemplo de tempo máximo de propagação | bin2bcd_propagation_delay.png| 600 px |}} | ||
− | |||
*Se quiser o(a) estudante pode apresentar dois projetos, sendo um para o '''menor tempo máximo de propagação''' e outro para '''menor área ocupada''' (número de elementos lógicos). | *Se quiser o(a) estudante pode apresentar dois projetos, sendo um para o '''menor tempo máximo de propagação''' e outro para '''menor área ocupada''' (número de elementos lógicos). | ||
Linha 3 441: | Linha 3 630: | ||
:* Mostre o número de elementos lógicos usados. | :* Mostre o número de elementos lógicos usados. | ||
:* Mostre qual o tempo máximo de propagação. | :* Mostre qual o tempo máximo de propagação. | ||
− | |||
;Bônus: | ;Bônus: | ||
Linha 3 460: | Linha 3 648: | ||
*Realizar um projeto hierárquico. | *Realizar um projeto hierárquico. | ||
− | ;Passo 1 - Projeto do Relogio_HHMMSS: | + | ;Consulte: |
+ | *[[Preparando para gravar o circuito lógico no FPGA]] | ||
+ | *[[Interfaces de entrada e saída da DE2-115]] | ||
+ | *[[Display de 7 segmentos]] | ||
+ | |||
+ | ====Passo 1 - Projeto do Relogio_HHMMSS:==== | ||
*Projete um relógio para indicar hora (HH), minuto (MM) e segundo (SS), mostrando as unidades e dezenas em 6 [[Display de 7 segmentos]], usando os seguintes componentes: | *Projete um relógio para indicar hora (HH), minuto (MM) e segundo (SS), mostrando as unidades e dezenas em 6 [[Display de 7 segmentos]], usando os seguintes componentes: | ||
:* Divisor de clock para obter um sinal de período de 1 segundo. ('''div_clk''') | :* Divisor de clock para obter um sinal de período de 1 segundo. ('''div_clk''') | ||
Linha 3 513: | Linha 3 706: | ||
<syntaxhighlight lang=vhdl> | <syntaxhighlight lang=vhdl> | ||
entity relogio_HHMMSS IS | entity relogio_HHMMSS IS | ||
− | -- O valor do fclk2 corresponde a metade do periodo do clock de entrada em Hz | + | -- O valor do fclk2 corresponde a metade do periodo do clock de entrada em Hz |
− | generic (fclk2 : natural := 50); -- ao simular o circuito utilize um valor baixo para acelerar a simulaçao | + | generic (fclk2 : natural := 50); -- ao simular o circuito utilize um valor baixo para acelerar a simulaçao |
− | -- generic (fclk2 : natural := 25000000); -- ao implementar no hardware use o valor do clock em Hz | + | -- generic (fclk2 : natural := 25000000); -- ao implementar no hardware use o valor do clock em Hz |
− | port | + | port |
− | ( | + | ( |
− | clk_1sec: in STD_LOGIC; | + | clk_1sec: in STD_LOGIC; |
− | rst_SW: in STD_LOGIC; | + | rst_SW: in STD_LOGIC; |
− | ligar_SW: in STD_LOGIC; | + | ligar_SW: in STD_LOGIC; |
− | ssd_DS, ssd_DM, ssd_DH: out STD_LOGIC_VECTOR(6 downto 0); | + | ssd_DS, ssd_DM, ssd_DH: out STD_LOGIC_VECTOR(6 downto 0); |
− | ssd_US, ssd_UM, ssd_UH: out STD_LOGIC_VECTOR(6 downto 0) | + | ssd_US, ssd_UM, ssd_UH: out STD_LOGIC_VECTOR(6 downto 0) |
− | ); | + | ); |
− | end entity; | + | end entity; |
− | </syntaxhighlight> | + | </syntaxhighlight> |
− | + | ||
− | {{fig| | + | {{fig|AE4.a|RTL do Relógio Digital de 24 horas| Rtl_relogio24h.png| 800 px |}} |
− | + | ||
− | + | ====Passo 2 - Simule os componentes e o relógio completo:==== | |
− | + | ||
− | * Efetue a simulação funcional do '''div_clock''', definindo a entrada de '''clk_in''' como um sinal de 100 Hz, e realizando a simulação para produzir um clk_out de 1Hz. Certifique-se que a duração do sinal alto é de apenas 1 período do sinal de clk_in. | + | * Efetue a simulação funcional do '''div_clock''', definindo a entrada de '''clk_in''' como um sinal de 100 Hz, e realizando a simulação para produzir um clk_out de 1Hz. Certifique-se que a duração do sinal alto é de apenas 1 período do sinal de clk_in. |
− | + | ||
− | * Efetue a simulação funcional do '''contador_bcd''' fazendo a contagem de 00 a 99 e também de 00 a DU, onde DU é um valor qualquer configurável pelo genéricos D e U. O contador só deverá contar se o '''enable_in''' estiver ALTO. Durante a mudança de DU para 00 o '''enable_out''' deverá ir para ALTO. Na simulação use um clock de 1 segundo, e faça uma simulação de pelo menos 120 segundos. | + | * Efetue a simulação funcional do '''contador_bcd''' fazendo a contagem de 00 a 99 e também de 00 a DU, onde DU é um valor qualquer configurável pelo genéricos D e U. O contador só deverá contar se o '''enable_in''' estiver ALTO. Durante a mudança de DU para 00 o '''enable_out''' deverá ir para ALTO. Na simulação use um clock de 1 segundo, e faça uma simulação de pelo menos 120 segundos. |
− | + | ||
− | * Efetue a simulação do '''bcd2ssd''' testando o circuito para as estradas bcd_in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9). Para os valores inválidos de entrada (10, 11, 12, 13, 14, 15), a saída deve mostrar "E" (de erro). | + | * Efetue a simulação do '''bcd2ssd''' testando o circuito para as estradas bcd_in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9). Para os valores inválidos de entrada (10, 11, 12, 13, 14, 15), a saída deve mostrar "E" (de erro). |
− | + | ||
− | * Nas simulações dos circuitos sequencias é necessário iniciar o circuito com um RESET de 10 ps. | + | * Nas simulações dos circuitos sequencias é necessário iniciar o circuito com um RESET de 10 ps. |
− | + | ||
− | * Realize a simulação do relógio completo '''relogio_HHMMSS''' durante 48 horas. Para esta simulação é importante configurar o divisor de clock para realizar uma divisão com um fator menor que aquele a ser usado no circuito final (veja o comentário no código acima). | + | * Realize a simulação do relógio completo '''relogio_HHMMSS''' durante 48 horas. Para esta simulação é importante configurar o divisor de clock para realizar uma divisão com um fator menor que aquele a ser usado no circuito final (veja o comentário no código acima). |
+ | |||
+ | {{fig|AE4.b|Simulação funcional do Relógio Digital de 24 horas| Sim_relogio24h.png| 800 px |}} | ||
+ | |||
+ | {{fig|AE4.c|Simulação funcional do Relógio Digital de 24 horas - detalhe enable 1sec| Sim_relogio24h_enable.png| 800 px |}} | ||
+ | |||
+ | ====Passo 3 - Implemente o relógio no kit DE2-115:==== | ||
+ | |||
+ | *Após verificar que a simulação do circuito está funcionando, configurar um FPGA para implementar este circuito. Existem duas opções de kit disponíveis com displays de sete segmentos. As informações necessárias estão em [[Preparando para gravar o circuito lógico no FPGA]]. Neste caso iremos usar o kit DE2-115 da TERASIC, pois precisamos de 6 mostradores de 7 segmentos. | ||
+ | |||
+ | * Analise no diagrama esquemático como funcionam as chaves e também o mostrador de sete segmentos. Note que no projeto o signal RST foi descrito como normalmente ALTO, por isso dependendo da chave que usar pode ser necessário acrescentar um inversor neste sinal para que funcione corretamente. O [[Display de 7 segmentos]] da DE2-115 é do tipo anodo comum (aplicando um nível lógico '0' no pino correspondente fará com que o segmento acenda, enquanto a aplicação do nível lógico '1' fará com com que o segmento apague). | ||
+ | |||
+ | *Anote a pinagem que será utilizada para conectar o circuito projetado no FPGA aos circuitos externos do kit (mostradores, chaves e leds). | ||
+ | |||
+ | {{collapse top| definição dos pinos}} | ||
+ | {| class="wikitable sortable" style="text-align:center;" | ||
+ | |- style="font-weight:bold; background-color:#c0c0c0;" | ||
+ | ! To | ||
+ | ! Direction | ||
+ | ! Location | ||
+ | |- | ||
+ | | clk50MHz | ||
+ | | Input | ||
+ | | PIN_Y2 | ||
+ | |- | ||
+ | | clk_1sec_LED | ||
+ | | Output | ||
+ | | PIN_F17 | ||
+ | |- | ||
+ | | rst_sw | ||
+ | | Input | ||
+ | | PIN_AB28 | ||
+ | |- | ||
+ | | ssd_DHH[0] | ||
+ | | Output | ||
+ | | PIN_AD17 | ||
+ | |- | ||
+ | | ssd_DHH[1] | ||
+ | | Output | ||
+ | | PIN_AE17 | ||
+ | |- | ||
+ | | ssd_DHH[2] | ||
+ | | Output | ||
+ | | PIN_AG17 | ||
+ | |- | ||
+ | | ssd_DHH[3] | ||
+ | | Output | ||
+ | | PIN_AH17 | ||
+ | |- | ||
+ | | ssd_DHH[4] | ||
+ | | Output | ||
+ | | PIN_AF17 | ||
+ | |- | ||
+ | | ssd_DHH[5] | ||
+ | | Output | ||
+ | | PIN_AG18 | ||
+ | |- | ||
+ | | ssd_DHH[6] | ||
+ | | Output | ||
+ | | PIN_AA14 | ||
+ | |- | ||
+ | | ssd_DMM[0] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DMM[1] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DMM[2] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DMM[3] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DMM[4] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DMM[5] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DMM[6] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DSS[0] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DSS[1] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DSS[2] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DSS[3] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DSS[4] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DSS[5] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_DSS[6] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UHH[0] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UHH[1] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UHH[2] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UHH[3] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UHH[4] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UHH[5] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UHH[6] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UMM[0] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UMM[1] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UMM[2] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UMM[3] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UMM[4] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UMM[5] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_UMM[6] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_USS[0] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_USS[1] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_USS[2] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_USS[3] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_USS[4] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_USS[5] | ||
+ | | Output | ||
+ | | | ||
+ | |- | ||
+ | | ssd_USS[6] | ||
+ | | Output | ||
+ | | | ||
+ | |} | ||
+ | {{collapse bottom}} | ||
− | + | *Dica para testar o relógio sem aguardar 24 horas. Acelere o clock de entrada do contador de segundos de 60 (ou 1440 vezes), com isso o sistema realizará a contagem de 00:00:00 a 23:59:59 em 24 minutos (ou 1 minuto). | |
− | + | ====Passo 4 - Entregas:==== | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
*Documentar o experimento em um relatório técnico que contenha no mínimo: | *Documentar o experimento em um relatório técnico que contenha no mínimo: | ||
:*identificação (título, disciplina, data, autores); | :*identificação (título, disciplina, data, autores); | ||
:*introdução; | :*introdução; | ||
− | :* | + | :*Descrição dos componentes utilizados e do sistema completo. Cada componente deve ser descrito em termos funcionais, e também deve ter uma simulação que demonstre o seu funcinamento. |
:*resultados obtidos (com imagens dos itens importantes) e análise dos resultados; | :*resultados obtidos (com imagens dos itens importantes) e análise dos resultados; | ||
− | :*pinagem utilizada na configuração do FPGA | + | :*apresente tabelas da pinagem utilizada na configuração do FPGA, número de elementos lógicos usados em cada componente e pelo sistema completo. |
− | |||
− | |||
− | |||
− | |||
:*conclusão. | :*conclusão. | ||
:*apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito | :*apêndice (se desejar pode ser disponibilizados vídeos do funcionamento do circuito | ||
Linha 3 573: | Linha 3 951: | ||
*O arquivo QAR contendo o projeto | *O arquivo QAR contendo o projeto | ||
*Os arquivos para simulação (DO) necessárias para simular o sistema '''relogio_HHMMSS''' e seus componentes. | *Os arquivos para simulação (DO) necessárias para simular o sistema '''relogio_HHMMSS''' e seus componentes. | ||
− | * O arquivo SOF usado na programação do FPGA. | + | *O arquivo SOF usado na programação do FPGA. |
<center> {{#ev:youtube|orjy0GURH_U}} </center> | <center> {{#ev:youtube|orjy0GURH_U}} </center> | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− |
Edição atual tal como às 09h20min de 1 de março de 2024
Registro on-line das aulas
Unidade 1 - Introdução a disciplina
- 6 ENCONTROS
Unidade 1 - Introdução a disciplina |
---|
|
Unidade 2 - Introdução ao VHDL e ambienta EDA - QUARTUS
- 10 ENCONTROS
Unidade 2 - Introdução ao VHDL e ambienta EDA - QUARTUS |
---|
library library_name;
use library_name.package_name.all;
entity entity_name is
[generic (
cons_name1: const_type const_value;
cons_name2: const_type const_value;
...
cons_nameN: const_type const_value);]
[port (
signal_name1: mode signal_type;
signal_name2: mode signal_type;
...
signal_nameN: mode signal_type);]
[declarative_part]
[begin
statement_part]
end [entity] [entity_name];
architecture arch_name of entity_name is
[declarative_part]
begin
statement_part
end [architecture] [arch_name];
library std;
use std.standard.all;
entity nand_gate is
port (a, b: in bit; x: out bit);
end entity;
architecture nome_arch of nand_gate is
begin
x <= a nand b;
end architecture;
entity mux_novo is
port
(
-- Input ports
X: in bit_vector (3 downto 0);
S : in bit_vector (1 downto 0);
-- Output ports
Y : out bit
);
end entity mux_novo;
-- Implementação com lógica pura
architecture v_logica_pura of mux_novo is
begin
Y <= (X(0) and (not S(1)) and (not S(0))) or
(X(1) and (not S(1)) and (S(0))) or
(X(2) and (S(1)) and (not S(0))) or
(X(3) and (S(1)) and (S(0)));
end architecture Logica_pura;
-- Implementação com WHEN ELSE
architecture v_WHEN of mux_novo is
begin
Y <= X(0) when S = "00" else
X(1) when S = "01" else
X(2) when S = "10" else
X(3);
end architecture v_WHEN;
-- Implementação com WITH SELECT
architecture v_WITH_SELECT of mux_novo is
begin
with S select
Y <= X(0) when "00", -- note o uso da ,
X(1) when "01",
X(2) when "10",
X(3) when others; -- note o uso de others, para todos os demais valores.
-- Não pode ser substituido por "11" mesmo que o signal seja bit_vector.
end architecture v_WITH_SELECT;
-- Implementação com IF ELSE
architecture v_IF_ELSE of mux_novo is
begin
-- Uma arquitetura vazia como essa é denominada de STUB,
-- Pode ser utilizada em um projeto durante para conferir as conexões externas.
-- Posteriormente a arquitetura será descrita.
end architecture v_IF_ELSET;
-- Design Unit que associa a architecture com a entity
configuration cfg_ifsc of mux_novo is
-- for v_WITH_SELECT end for;
for v_WHEN end for;
end configuration;
Figura 2.1 - Código RTL do mux 4x1 v_logica_pura Figura 2.2 - Código RTL do mux 4x1 v_WHEN Figura 2.3 - Código RTL do mux 4x1 v_WITH_SELECT
Figura 2.4 - Technology Map do mux 4x1 para a família Cyclone
Figura 2.5 - Elemento Lógico usado no mux 4x1 para a família Cyclone (node properties)
No entanto se utilizarmos um dispositivo FPGA da família Stratix III, que tem LUT tem 6 entradas, será necessário apenas 1 LE, conforme ilustrado a seguir. Figura 2.5 - Technology Map do mux 4x1 para a família Stratix III
-- Declaração das bibliotecas e pacotes
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-- Especificação de todas as entradas e saídas do circuito
ENTITY flip_flop IS
PORT (d, clk, rst: IN STD_LOGIC;
q: OUT STD_LOGIC);
END;
-- Descrição de como o circuito deve funcionar
ARCHITECTURE flip_flop OF flip_flop IS
BEGIN
PROCESS (clk, rst)
BEGIN
IF (rst='1') THEN
q <= '0';
ELSIF (clk'EVENT AND clk='1') THEN
q <= d;
END IF;
END PROCESS;
END;
Figura 2.2 - Código RTL do Exemplo 2.2
Figura 2.3 - Technology Map do Exemplo 2.2
Figura 2.4 - Chip Planner do Exemplo 2.2
Figura 2.5 - RTL 4 FF
ls /opt/intelFPGA/20.1/quartus/libraries/vhdl/std
/opt/intelFPGA/20.1/quartus/libraries/vhdl/ieee
/opt/intelFPGA/20.1/quartus/libraries/vhdl/mentor/arithmetic (Mentor Graphics) /opt/intelFPGA/20.1/quartus/libraries/vhdl/synopsys/ieee (Synopsys)
ls /opt/altera/16.0/quartus/libraries/vhdl/ieee/2008
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY registered_comp_add_v1 IS
PORT (clk: IN STD_LOGIC;
a, b: IN INTEGER RANGE 0 TO 7;
reg_comp: OUT STD_LOGIC;
reg_sum: OUT INTEGER RANGE 0 TO 15);
END ENTITY;
ARCHITECTURE ifsc_v1 OF registered_comp_add_v1 IS
SIGNAL comp: STD_LOGIC;
SIGNAL sum: INTEGER RANGE 0 TO 15;
BEGIN
comp <= '1' WHEN a>b ELSE '0';
sum <= a + b;
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
reg_comp <= comp;
reg_sum <= sum;
END IF;
END PROCESS;
END ARCHITECTURE;
Figura 2.10 - Código RTL do Exemplo 2.3
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all; -- for the unsigned type
entity COUNTER is
generic (
WIDTH : in natural := 32);
port (
RST : in std_logic;
CLK : in std_logic;
LOAD : in std_logic;
DATA : in std_logic_vector(WIDTH-1 downto 0);
Q : out std_logic_vector(WIDTH-1 downto 0));
end entity COUNTER;
architecture RTL of COUNTER is
begin
process(all) is
begin
if RST then
Q <= (others => '0');
elsif rising_edge(CLK) then
if LOAD='1' then
Q <= DATA;
else
Q <= std_logic_vector(unsigned(Q) + 1);
end if;
end if;
end process;
end architecture RTL;
Figura 2.6 - Simulação funcional com QSIM de 4 FF - 100ns Figura 2.7 - Simulação Temporal com QSIM de 4 FF - 100ns
IMPORTANTE: Na prática normalmente não é necessário fazer a simulação temporal, pois através do Time Quest Report é possível verificar se o circuito atende as restrições de tempo.
create_clock -name CLK50MHz -period 50MHz [get_ports {*}]
|
Unidade 3 - Tipos de Dados e Operadores em VHDL
- 10 ENCONTROS
Unidade 3 - Tipos de Dados e Operadores em VHDL | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
-- Isso eh uma linha de comentario y <= a * b ; --o sinal y recebe o resultado da multiplicacao a x b
caracter: 'A' 'x' '#' (com aspas simples)
type string is array (positive range <>) of character;
string: "IFSC" "teste" "teste123"
elemento ("bit") único: '0' '1' 'Z' (entre aspas simples) vetor de elementos ("bits"): "0110" "101001Z" (entre aspas duplas) vetor de 1 elemento ("bit"): "0" "1" (entre aspas duplas) inteiros: 5 1101 1102 (sem aspas)
0 -> '0' 7 (em base 2) -> "0111" ou b"0111" ou B"0111" 1023 (em base 2) -> "001111111111" ou b"1111111111" ou B"1111111111"
44 (em base 8) -> 5*8^1 + 4*8^0 -> O"54" ou o"54" 1023 (em base 8)-> 1*8^3 + 7*8^2 + 7*8^1 + 7*8^0 -> o"1777" 8#1777#
1023 (em base 16) -> 3*16^2 + 15*16^1 + 15*16^0 = X"3FF" ou x"3FF" 16#3FF#
1023 -> 1023 ou 1_023 1000 -> 1000 ou 1_000 ou 1E3 ou 10#1000#
85 (em base 5) -> (3*5^2 + 2*5^1 + 0*5^0) -> 5#320# 1539 (em base 3) -> (2*3^2+0*3^1+1*3^0)*3^4 -> 3#201#E4
O objeto CONSTANT pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, PACKAGE_BODY, BLOCK, GENERATE, PROCESS, FUNCTION e PROCEDURE. constant <constant_name> : <type> := <constant_value>;
-- Declarações comuns de constantes
constant GND : std_logic := '0';
constant VCC : std_logic := '1';
constant SSD_0 : std_logic_vector(0 to 6) := "1111110";
constant MAX : natural := 44;
O objeto SIGNAL pode ser declarado na parte declarativa da ENTITY, ARCHITECTURE, PACKAGE, BLOCK, GENERATE. Os sinais não podem ser declarados no código sequencial (PROCESS, FUNCTION e PROCEDURE), mas podem ser usados. -- Signal sem valor default
-- Para atribuir um valor a um signal use "<=" como operador.
signal <name> : <type>;
-- Signal com valor default
signal <name> : <type> := <default_value>;
-- Declarações comuns de signals
signal <name> : std_logic;
signal <name> : std_logic_vector(<msb_index> downto <lsb_index>);
signal <name> : integer;
signal <name> : integer range <low> to <high>;
O objeto VARIABLE (variável) só pode ser declarada e usada dentro do escopo no código sequencial (PROCESS, FUNCTION e PROCEDURE). -- Variables devem ser declarada em process ou subprogramas.
-- Para atribuir um valor a um variable use ":=" como operador.
-- Variable sem valor default.
variable <name> : <type>;
-- Variable com valor default.
variable <name> : <type> := <default_value>;
-- Declarações comuns de variables
variable <name> : std_logic;
variable <name> : std_logic_vector(<msb_index> downto <lsb_index>);
variable <name> : integer;
variable <name> : integer range <low> to <high>;
Exemplos de declaração de CONSTANT, SIGNAL, VARIABLE, inicializando o valor usando o agregados CONSTANT a: BIT_VECTOR(5 DOWNTO 0) := (OTHERS => '0'); -- "000000"
CONSTANT b: BIT_VECTOR(7 DOWNTO 0) := (7 => '0', OTHERS => '1'); -- "01111111"
CONSTANT c: BIT_VECTOR(7 DOWNTO 0) := (7 => '0', 6 DOWNTO 0 => '1'); -- "01111111"
CONSTANT d: BIT_VECTOR(7 DOWNTO 0) := "01111111";
SIGNAL e: STD_LOGIC_VECTOR(7 DOWNTO 0); -- Not initialized
SIGNAL f: STD_LOGIC_VECTOR(1 TO 8) := (2|3|8 => '1', 4 => 'Z', OTHERS => '0' ); -- "011Z0001"
VARIABLE g: BIT_VECTOR(1 TO 16); -- Not initialized
VARIABLE h: BIT_VECTOR(1 TO 16) := (1 TO 8 => '1', OTHERS => '0'); -- "1111111100000000"
A biblioteca standard.vhd define os tipos BIT, BIT_VECTOR, BOOLEAN, INTEGER, NATURAL, POSITIVE, CHARACTER, STRING. package standard is
type boolean is (false,true);
type bit is ('0', '1');
type severity_level is (note, warning, error, failure);
type integer is range -2147483647 to 2147483647;
type real is range -1.0E308 to 1.0E308;
type time is range -2147483648 to 2147483647
units
fs;
ps = 1000 fs;
ns = 1000 ps;
us = 1000 ns;
ms = 1000 us;
sec = 1000 ms;
min = 60 sec;
hr = 60 min;
end units;
subtype natural is integer range 0 to integer'high;
subtype positive is integer range 1 to integer'high;
type string is array (positive range <>) of character;
type bit_vector is array (natural range <>) of bit;
A biblioteca Std logic 1164.vhd define os tipos STD_(U)LOGIG, STD_(U)LOGIG_VECTOR. PACKAGE std_logic_1164 IS
TYPE std_ulogic IS ( 'U', -- Uninitialized
'X', -- Forcing Unknown
'0', -- Forcing 0
'1', -- Forcing 1
'Z', -- High Impedance
'W', -- Weak Unknown
'L', -- Weak 0
'H', -- Weak 1
'-' -- Don't care
);
TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic;
SUBTYPE std_logic IS resolved std_ulogic;
TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic;
A biblioteca Std logic 1164.vhd ainda define algumas funções importantes como a rising_edge que determina se um sinal está na borda de subida (usado em sinais de clock). -------------------------------------------------------------------
-- conversion functions
-------------------------------------------------------------------
FUNCTION To_bit ( s : std_ulogic; xmap : BIT := '0') RETURN BIT;
FUNCTION To_bitvector ( s : std_logic_vector ; xmap : BIT := '0') RETURN BIT_VECTOR;
FUNCTION To_StdULogic ( b : BIT ) RETURN std_ulogic;
FUNCTION To_StdLogicVector ( b : BIT_VECTOR ) RETURN std_logic_vector;
-------------------------------------------------------------------
-- edge detection
-------------------------------------------------------------------
FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
-------------------------------------------------------------------
-- edge detection
-------------------------------------------------------------------
FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN IS
-- altera built_in builtin_rising_edge
BEGIN
RETURN (s'EVENT AND (To_X01(s) = '1') AND
(To_X01(s'LAST_VALUE) = '0'));
END;
A biblioteca Numeric std.vhd define os tipos UNSIGNED e SIGNED. package NUMERIC_STD is
type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
type SIGNED is array (NATURAL range <>) of STD_LOGIC;
A biblioteca Numeric std.vhd ainda define os operadores (abs, "+", "-", "*", "/", rem, mod, sll, slr, ror, rol), comparações ("=", '/=', ">", ">=", "<", "<=") e operadores lógicos (not, and, nand, or, nor, xor, xnor) para os tipos SIGNED e UNSIGNED. Além disso também define algumas funções muito utilizadas como: --============================================================================
-- RESIZE Functions
--============================================================================
function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;
function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED;
--============================================================================
-- Conversion Functions
--============================================================================
function TO_INTEGER (ARG: UNSIGNED) return NATURAL;
function TO_INTEGER (ARG: SIGNED) return INTEGER;
function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED;
function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED;
Figura 3.1 - Simulação do indicador de vagas
Figura 3.2 - Simulação do contador de vagas
library ieee;
use ieee.std_logic_1164.all;
entity tri_state is
generic (N: NATURAL := 1);
port
(
input : in std_logic_vector(N-1 downto 0);
ena : in std_logic;
output : out std_logic_vector(N-1 downto 0);
);
end entity;
architecture tri_state of tri_state is
begin
output <= input when ena = '1' else "Z";
end architecture;
library ieee;
use ieee.std_logic_1164.all;
entity Ex3_2 is
port
(
x : in STD_LOGIC_VECTOR(1 downto 0);
y : out STD_LOGIC_VECTOR(1 downto 0)
);
end entity;
architecture un3 of Ex3_2 is
begin
y <= "00" when x = "00" else
"01" when x = "10" else
"10" when x = "01" else
"--";
end architecture;
x = "1----" -- não funciona em VHDL
std_match(x, "1----") -- funciona em VHDL
Ler e guardar a página sobre Aritmética com vetores em VDHL
São suportados nos tipos de dados: INTEGER, NATURAL, POSITIVE, SIGNED e UNSIGNED. Com VHDL 2008 também suportado para UFIXED, SFIXED e FLOAT. soma (+) subtração (-) multiplicação (*) divisão (/) exponenciação (**) valor absoluto (ABS) resto (REM remainder) módulo (MOD) Não há restrições para síntese de circuitos com os operadores, exceto para "**" que necessita de expoente estático (a**5) ou base estática (5**a). O operador x/y é a divisão inteira com sinal.
O operador ABS x retorna o valor absoluto de x.
O operador x REM y retorna o resto de x/y com sinal de x. Esse operador realiza a operação x REM y = x - (x/y)*y.
O operador x MOD y retorna o resto de x/y com sinal de y. Esse operador realiza a operação x MOD y = x REM y + a*y, onde a = 1 quando o sinal de x é diferente do sinal de y, e a = 0 se os sinais de x e y são iguais.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity bin2bcd is
port
(
A : in std_logic_vector (6 downto 0);
sd, su : out std_logic_vector (3 downto 0)
);
end entity;
architecture ifsc_v1 of bin2bcd is
signal A_uns : unsigned (6 downto 0);
signal sd_uns, su_uns : unsigned (6 downto 0);
begin
sd <= std_logic_vector(resize(sd_uns, 4));
su <= std_logic_vector(resize(su_uns, 4));
sd_uns <= A_uns/10;
su_uns <= A_uns rem 10;
A_uns <= unsigned(A);
end architecture;
architecture ifsc_v2 of bin2bcd is
begin
-- Implemente o circuito usando a definição de REM que é: x REM y = x - (x/y)*y
end architecture;
configuration bin2bcd_cfg of bin2bcd is
--A instrução '''configuration''' associa a '''entity''' bin2bcd a '''architecture'''.
for ifsc_v1 end for;
--Para associar a '''entity''' bin2bcd a '''architecture''' ifsc_v2 comente a linha acima e descomente a linha abaixo.
-- for ifsc_v2 end for;
end configuration;
Figura 3.2 - RTL do conversor de Binário para BCD com 2 digitos Figura 3.3 - Simulação do conversor de Binário para BCD com 2 digitos
São suportados nos tipos de dados: BIT, BIT_VECTOR, BOOLEAN, STD_(U)LOGIC, STD_(U)LOGIC_VECTOR, SIGNED e UNSIGNED. Com VHDL 2008 também suportado para BOOLEAN_VECTOR, UFIXED, SFIXED e FLOAT. NOT AND NAND OR NOR XOR XNOR Apenas o operador NOT tem precedência sobre os demais y <= a AND b XOR c -- é equivalente a (a AND b) XOR c y <= NOT a AND b -- é equivalente a (NOT a) AND b. y <= a NAND b -- é equivalente a NOT (a AND b)
signal a: bit_vector(7 downto 0) := "01100101"; y <= a SLL 2; -- y <= "10010100" (y <= a(5 downto 0) & "00";) y <= a SLA 2; -- y <= "10010111" (y <= a(5 downto 0) & a(0) & a(0);) y <= a ROL 2; -- y <= "10010101" (y <= a(5 downto 0) & a(7 downto 6);) y <= a ROR 2; -- y <= "01011001" (y <= a(1 downto 0) & a(7 downto 2);)
Igualdade (=) Diferença (/=) Menor que (<) Menor ou igual que (<=) Maior que (>) Maior ou igual que (>=)
Igualdade (?=) Diferença (?/=) Menor que (?<) Menor ou igual que (?<=) Maior que (?>) Maior ou igual que (?>=)
Em VHDL existem diversos atributos de sintese que controlam a forma como o processo de "Analysis & Synthesis" é realizado pelo Quartus II. Uma listagem completa pode ser encontrada em:
type fruit is (apple, orange, pear, mango);
attribute enum_encoding : string;
attribute enum_encoding of fruit : type is "11 01 10 00";
entity foo is
port (sel : in std_logic;
data : in std_logic_vector(3 downto 0);
o : out std_logic);
end foo;
architecture rtl of foo is
attribute chip_pin : string;
attribute chip_pin of sel : signal is "C4";
attribute chip_pin of data : signal is "D1, D2, D3, D4";
begin
-- Specify additional code
end architecture;
O uso desse atributo sobrepõe a atribuição dos pinos através da IDE do Quartus II, e por isso não é recomendável. O atributo de síntese chip_pin pode ser usado apenas em portas da entidade "top-level" do projeto. .
O atributo de síntese KEEP, sinaliza ao processo de "Analysis & Synthesis" para manter intacto um determinado signal ou componente. signal a,b,c : std_logic;
attribute keep: boolean;
attribute keep of a,b,c: signal is true;
signal a,b,c : std_logic;
attribute preserve: boolean;
attribute preserve of a,b,c: signal is true;
signal reg1: std_logic;
attribute noprune: boolean;
attribute noprune of reg1: signal is true;
Para cada atributo existe uma descrição completa como mostrado a seguir. P'LEFT Kind: Value. Prefix: Any prefix P that is appropriate for an object with a scalar type or subtype T, or an alias thereof, or that denotes any scalar type or subtype T. Result type: Same type as T. Result: The left bound of T. A seguir estão listados alguns dos atributos mais utilizados.
P'LEFT - The left bound of T. P'RIGHT - The right bound of T. P'HIGH - The upper bound of T. P'LOW - The lower bound of T. P'ASCENDING - It is TRUE if T is defined with an ascending range; FALSE otherwise. P'LENGTH - maximum(0, T’POS(T’HIGH) – T’POS(T’LOW) + 1) P'RANGE - The range T'LEFT to T'RIGHT if the range of T is ascending, or the range T'LEFT downto T'RIGHT if the range of T is descending P'REVERSE_RANGE - The range T'RIGHT downto T'LEFT if the range of T is ascending, or the range T'RIGHT to T'LEFT if the range of T is descending T'POS(X) - The position number of the value of the parameter T'VAL(X) - The value whose position number is the universal_integer value corresponding to X.
A'LEFT [(N)] - Left bound of the Nth index range of A A'RIGHT [(N)] - Right bound of the Nth index range of A A'HIGH [(N)] - Upper bound of the Nth index range of A A'LOW [(N)] - Lower bound of the Nth index range of A. A'RANGE [(N)] - The range A'LEFT(N) to A'RIGHT(N) if the Nth index range of A is ascending, or the range A'LEFT(N) downto A'RIGHT(N) if the Nth index range of A is descending A'REVERSE_RANGE [(N)] - The range A'RIGHT(N) downto A'LEFT(N) if the Nth index range of A is ascending, or the range A'RIGHT(N) to A'LEFT(N) if the Nth index range of A is descending. A'LENGTH [(N)] - Number of values in the Nth index range A'ASCENDING [(N)] - TRUE if the Nth index range of A is defined with an ascending range; FALSE otherwise.
S'EVENT - A value that indicates whether an event has just occurred on signal S. S'LAST_VALUE - For a signal S, if an event has occurred on S in any simulation cycle, S'LAST_VALUE returns the value of S prior to the update of S in the last simulation cycle in which an event occurred; otherwise, S'LAST_VALUE returns the current value of S.
E'SIMPLE_NAME - The simple name, character literal, or operator symbol of the named entity
attribute attribute_name: attribute_type;
attribute attribute_name of entity_tag [signature]: entity_class is value;
A retirada de fatias (SLICES) dos ARRAYs só pode ser feita se o array foi definido com um vetor de vetores (1Dx1D ou 1Dx1Dx1D). Ainda assim é necessário respeitar a ordem dos índices do VETOR. No caso abaixo é ascendente (TO), e dentro dos limites (1 to 4). type a1Dx1D_bit is array (1 to 3) of BIT_VECTOR(1 to 4);
type a2D_bits is array (1 to 3, 1 to 4) of bit; type a3D_bits is array (1 to 3, 1 to 4, 1 to 2) of bit;
slice3 <= table(row, 1) & table(row, 2) & & table(row, 3) & & table(row, 4);
slice4 <= table(1, column) & table(2, column) & table(3, column);
gen1 : for j in 1 to 4 generate
slice3(j) <= table(row, j);
end generate;
gen2 : for i in 1 to 3 generate
slice4(i) <= table(i, column);
end generate;
Como usar ARRAYs em portas?:
-----Package:------------
-- File: my_pkg.vhd
-------------------------
package my_data_types is
type a1Dx1D_bit_vector is array (0 to 3) of BIT_VECTOR(7 downto 0);
end my_data_types;
-----Main code: --------
-- File: mux1Dx1D.vhd
-------------------------
use work.my_data_types.all;
entity mux1Dx1D is
port (
x : in a1Dx1D_bit_vector;
sel : integer range 0 to 3;
y : out BIT_VECTOR(7 downto 0)
);
end entity;
architecture pedroni of mux1Dx1D is
begin
y <= x(sel);
end architecture;
Ver pag. 60 a 73 de [2]
Enquanto que em um ARRAY todos os elementos devem ser obrigatoriamente do mesmo tipo, em um RECORD (Registro) os elementos podem ser de tipos diferentes. type memory_access is record
address : integer range 0 to 255;
block : integer range 0 to 3;
data : BIT_VECTOR(15 downto 0);
end record;
--Escrita no RECORD
constant endereco : memory_access := (34, 3, "010011110101011");
--Acesso ao RECORD
signal address_lido : integer range 0 to 255;
signal block_lido : integer range 0 to 3;
signal data_lido : bit_vector(15 downto 0);
address_lido <= endereco.address;
block_lido <= endereco.block;
data_lido <= endereco.data;
entity record_example is
port (
flag : out BIT_VECTOR(1 to 4);
sum : out natural range 0 to 15
);
end entity;
architecture record_example of record_example is
type pair is record
a, b : natural range 0 to 7;
end record;
type stack is array (1 to 4) of pair;
constant matrix : stack := ((1, 2), (3, 4), (5, 6), (7, 0));
begin
gen : for i in 1 to 4 generate
flag(i) <= '1' when matrix(i).a > matrix(i).b else '0';
end generate;
sum <= matrix(1).a + matrix(1).b;
end architecture;
A declaração de SUBTYPE é usada para restringir as declarações de TYPE. Abaixo estão alguns exemplos. subtype natural is integer range 0 to integer'HIGH;
subtype positive is integer range 1 to integer'HIGH;
subtype my_integer is integer range - 32 to 31;
A declaração ALIAS define um nome alternativo para uma entidade ou objeto. ALIAS new_name [: specifications] IS original_name [signature];
SIGNAL data_bus: STD_LOGIC_VECTOR(31 DOWNTO 0);
--bus1 is a new name for data_bus:
ALIAS bus1 IS data_bus;
--bus2 is a new name for data_bus, but with a modified range:
ALIAS bus2: STD_LOGIC_VECTOR(32 DOWNTO 1) IS data_bus;
--bus3 is another name for data_bus, with an ascending range:
ALIAS bus3: STD_LOGIC_VECTOR(1 TO 32) IS data_bus;
--upper_bus1 is a new name for the upper half of data_bus
ALIAS upper_bus1 IS data_bus(31 DOWNTO 16);
--upper_bus2 is a new name for the upper half of data_bus, but
--with a modified range:
ALIAS upper_bus2: STD_LOGIC_VECTOR(17 TO 32) IS data_bus(31 DOWNTO 16);
--lower_bus1 is a new name for the lower half of data_bus
ALIAS lower_bus1 IS data_bus(15 DOWNTO 0);
--lower_bus2 is a new name for the lower half of data_bus, but
--with a modified range:
ALIAS lower_bus2: STD_LOGIC_VECTOR(1 TO 16) IS data_bus(15 DOWNTO 0);
function ADD_UNSIGNED (L, R: UNSIGNED; C: STD_LOGIC) return UNSIGNED is
constant L_LEFT: INTEGER := L'LENGTH-1;
alias XL: UNSIGNED(L_LEFT downto 0) is L;
alias XR: UNSIGNED(L_LEFT downto 0) is R;
variable RESULT: UNSIGNED(L_LEFT downto 0);
variable CBIT: STD_LOGIC := C;
begin
for I in 0 to L_LEFT loop
RESULT(I) := CBIT xor XL(I) xor XR(I);
CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I));
end loop;
return RESULT;
end ADD_UNSIGNED;
function "+" (a : integer; b : bit) return integer is
begin
if (b = '1') then return a + 1;
else
return a;
end if;
end "+";
function "+" (a : integer; b : std_logic) return integer is
begin
if (b = '1') then return a + 1;
else
return a;
end if;
end "+";
|
Unidade 4 - Código Concorrente
- 4 ENCONTROS
Unidade 4 - Código Concorrente | ||
---|---|---|
<optional_label>: <target> <=
<value> when <condition> else
<value> when <condition> else
<value> when <condition> else
...
<value>;
Warning (13012): Latch ... has unsafe behavior
<optional_label>: with <expression> select
<target> <=
<value> when <choices>,
<value> when <choices>,
<value> when <choices>,
...
<value> when others;
Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression
configuration which_mux of mux4x1 is
-- for operators_only end for;
-- for operators_only_alias end for;
for with_WHEN end for;
-- for with_SELECT end for;
end configuration;
label: FOR identificador IN faixa GENERATE
[Parte_Declarativa
BEGIN]
Instruções_concorrentes
...
END GENERATE [label];
---------------------
-- FILE my_pkg.vhd --
---------------------
library ieee;
use ieee.std_logic_1164.all;
package my_pkg is
type a_slv is array(natural range <>) of std_logic_vector (3 downto 0);
end package;
---------------------------
-- FILE vector_adder.vhd --
---------------------------
library ieee work;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.my_pkg.all;
entity vector_adder is
generic (N : natural := 4);
port (
a : in a_slv (0 to N-1);
soma : out std_logic_vector (3 downto 0));
end entity;
-- Versão que realiza a soma diretamente, mas que precisa modificar o código de acordo com o número de entradas.
architecture ifsc_v1 of vector_adder is
signal soma_sig : unsigned(3 downto 0);
begin
soma_sig <= unsigned(a(0)) + unsigned(a(1)) + unsigned(a(2)) + unsigned(a(3));
soma <= std_logic_vector(soma_sig);
end architecture;
-- Versão que realiza a soma usando um FOR GENERATE
architecture ifsc_v2 of vector_adder is
begin
end architecture;
---------------------------
-- FILE vector_adder.vhd --
---------------------------
configuration ifsc_cfg of vector_adder is
-- for ifsc_v1 end for;
for ifsc_v2 end for;
end configuration;
-------------------------
-- File: bin2gray.vhd --
-------------------------
entity bin2gray is
generic (N : natural := 4 )
port
(
g : out std_logic_vector(____)
b : in std_logic_vector(____)
)
end entity
architecture ifsc_v1 of ____ is
begin
end architecture
architecture ifsc_v2 of ____ is
begin
end architecture
-------------------------
-- File: gray2bin.vhd --
-------------------------
entity gray2bin is
generic (N : natural := 4 )
port
(
g : in std_logic_vector(____)
b : out std_logic_vector(____)
)
end entity
architecture ifsc_v1 of ____ is
begin
end architecture
architecture ifsc_v2 of ____ is
begin
end architecture
Outros exemplos a serem estudados:
----------------------
-- File: alu.vhd --
----------------------
entity ua is
generic (N : natural := 4);
port
(
a, b : in std_logic(? downto 0);
cin : in std_logic;
opcode : in std_logic(? downto 0);
y : out std_logic(? downto 0)
);
end entity;
architecture alu of alu is
begin
end architecture;
Figura 3.9 - Unidade de Lógica e Aritmética
|
Unidade 5 - Código Sequencial
- 7 ENCONTROS
Unidade 5 - Código Sequencial |
---|
[rótulo:] PROCESS [(lista_de_sensibilidade)] [IS]
[parte_declarativa]
BEGIN
afirmação_sequencial;
afirmação_sequencial;
...
END PROCESS [rótulo];
[rótulo:] IF condição THEN
afirmação_sequencial;
afirmação_sequencial;
...
ELSIF condição THEN
afirmação_sequencial;
afirmação_sequencial;
...
ELSE
afirmação_sequencial;
afirmação_sequencial;
...
END IF [rótulo];
--Flip Flop tipo D com reset assincrono, sensivel a borda de subida.
process (clock,reset)
begin
if (reset = '1') then
q <= '0';
-- elsif (clock'event and clock = '1') then or
elsif (rising_edge(clock)) then
q <= d;
end if;
end process;
Figura 5.1 - RTL de Flip-flop D de borda de subida, com reset assíncrono --Flip Flop tipo D com preset assincrono e sinal de enable, sensivel a borda de descida.
process (clock, preset)
begin
if (preset = '1') then
q <= '1';
elsif (falling_edge(clock)) then
if (enable = '1') then
q <= d;
end if;
end if;
end process;
Figura 5.2 - RTL de Flip-flop D de borda de descida, com preset assíncrono e enable
--Latch tipo D com reset assincrono.
process (enable, reset, d)
begin
if (reset = '1') then
q <= '0';
elsif (enable='1')) then
q <= d;
end if;
end process;
Figura 5.3 - RTL de Latch D de com reset assíncrono e enable ativo alto
Figura 5.4 - Comparação do Technology Map de um Latch_D (esquerda) com FF_D (direita)
-- Flip Flop tipo D com reset síncrono sensível a borda de subida.
-- Modifique a descrição para que o reset_ass seja assíncrono e reset_sinc seja síncrono.
-- Note que a função rising_edge(clock) é equivalente a (clock'event and clock'last_value = '0' and clock = '1'))
process (clock, reset)
begin
if (reset = '1') then
q <= '0';
elsif (clock'event and clock'last_value = '0' and clock = '1')) then
q <= d;
end if;
end process;
Figura 5.5 - RTL do Flip-flop D com reset assíncrono e reset síncrono
Figura 5.6 - RTL do Registrador (de 4 bits) com reset assíncrono Figura 5.7 - Techonogy Map do Registrador (de 4 bits) com reset assíncrono
Instruções do tipo LOOP: LOOP incondicional, FOR-LOOP, WHILE-LOOP, NEXT, EXIT
[rótulo:] LOOP
afirmação_sequencial;
afirmação_sequencial;
...
END LOOP [rótulo];
[rótulo:] FOR identificador IN faixa LOOP
afirmação_sequencial;
afirmação_sequencial;
...
END LOOP [rótulo];
[rótulo:] WHILE condição LOOP -- Executa as "afirmações enquanto a "condição" for verdadeira
afirmação_sequencial;
afirmação_sequencial;
...
END LOOP [rótulo];
[rótulo:] [FOR identificador IN faixa] LOOP
afirmação_sequencial;
EXIT [rótulo] [WHEN condição]; -- Se a "condição" é verdadeira, termina o "LOOP"
afirmação_sequencial;
...
END LOOP [rótulo];
[rótulo:] [FOR identificador IN faixa] LOOP
afirmação_sequencial;
NEXT [rótulo] [WHEN condição]; -- Se a "condição" é verdadeira, não executa as linhas até a linha "END LOOP"
-- e incrementa o "identificador".
afirmação_sequencial;
...
END LOOP [rótulo];
[rótulo:] CASE expressão IS
WHEN valor => atribuições; -- valor único
...
WHEN valor1 | valor2 | ... | valorN => atribuições; -- lista de valores
...
WHEN valor1 TO valor2 => atribuições; -- faixa de valores
...
END CASE;
entity leading_zeros is
generic (N : natural := 8);
port
( ________ : in std_logic_vector(0 to N-1);
count : out integer range 0 to N
);
end entity;
architecture ____ of leading_zeros is
begin
process (data)
variable count : integer ____ 0 to N
begin
count := 0;
for i ___ data'range ____
case data(i) is
when '0' => count := count + 1;
when _____ => exit;
end ___
end ____
zeros <= count;
end process;
end _______;
Esse somador pode ser implementado tanto com código sequencial como com código concorrente. Note que no primeiro caso o bit de carry se definido como variable pode ser reaproveitado. No segundo caso é necessário criar um vetor completo para conectar os carry_out de um estágio ao carry_in do próximo. library ieee;
use ieee.std_logic_1164.all;
entity carry_ripple_adder is
generic (N : integer := 3);
port (
a, b : std_logic_vector (N-1 downto 0);
cin : std_logic;
s : out std_logic_vector (N-1 downto 0);
cout : out std_logic
);
end entity;
architecture estrutural_sequencial_v1 of carry_ripple_adder is
begin
-- Uso de um codigo sequencial para geracao de um circuito combinacional
process (a, b, cin) is
variable c : std_logic;
begin
c := cin;
for i in 0 to N-1 loop
s(i) <= a(i) xor b(i) xor c;
c := (a(i) and b(i)) or (a(i) and c) or (b(i) and c);
end loop;
cout <= c;
end process;
end architecture;
architecture estrutural_concorrente_v1 of carry_ripple_adder is
signal c : std_logic_vector(N downto 0);
begin
-- Uso de um codigo concorrente para geracao de um circuito combinacional
c(0) <= cin;
l1: for i in 0 to N-1 generate
s(i) <= a(i) xor b(i) xor c(i);
c(i+1) <= (a(i) and b(i)) or (a(i) and c(i)) or (b(i) and c(i));
end generate;
cout <= c(N);
end architecture;
Figura 5.1 - RTL do carry_ripple_adder de 3 bits
[rótulo:] WAIT UNTIL <condition>;
[rótulo:] WAIT ON sensitivity_list;
[rótulo:] WAIT FOR time_expression;
Figura 5.2 - RTL do contador BCD 00 a 99 Figura 5.3 - Simulação do contador BCD 00 a 99
|
Unidade 6 - Projeto a nível de Sistema
- 3 ENCONTROS
Unidade 6 - Projeto a nível de Sistema |
---|
Assim a entity contador_bcd_00_99 entity countBCD_DU is
generic (max_D : natural := 9; max_U : natural := 9);
port (
clk, rst : in std_logic;
clk_out : out std_logic;
bcd_D, bcd_U : out std_logic_vector(3 downto 0)
);
end entity;
Será declarada como um COMPONENT component countBCD_DU is
generic (max_D : natural := 9; max_U : natural := 9);
port (
clk, rst : in std_logic;
clk_out : out std_logic;
bcd_D, bcd_U : out std_logic_vector(3 downto 0)
);
end component;
comp1 : countBCD_DU
GENERIC MAP (5, 9)
PORT MAP (clk,rst, clk1sec, bcd_dezena, bcd_unidade);
comp1 : contador_bcd_00_99
GENERIC MAP ( max_D => 5, max_U => 9)
PORT MAP ( clk => clk,
rst => rst,
clk_out => clk1sec,
bcd_D => bcd_dezena,
bcd_U => bcd_unidade);
Figura 5.1 - RTL portas NAND genéricas
Figura 5.2 - RTL do contador_ssd_00_99 usando componentes
gen: for i in 0 to 7 generate
comp: flip_flop port map (clk, rst, d(i), q(i));
end generate;
A instrução ASSERT é útil para verificar as entradas de um subprograma. Seu propósito não é criar circuito, mas assegurar que certos requisitos são atendidos durante a síntese e/ou simulação. Pode ser condicional ou incondicional (condição_booleana = FALSE). A sintaxe da instrução é: [rótulo:] assert condição_booleana
[report mensagem]
[severity nivel_severidade];
A mensagem pode ser criada usando STRINGs que podem ser concatenadas. O nível de severidade pode ser NOTE (para passar informação para o compilador/simulator), WARNING (para informar que algo não usual ocorreu), ERROR (para informar que alguma condição não usual "sério" ocorreu), ou FAILURE (para informar que uma condição não aceitável ocorreu). Normalmente o compilador para quando ocorre um ERROR ou FAILURE. ERROR é o valor "default" [10].
function nome_funçao (lista_parametros_entrada) return tipo_saida is
declarações
begin
afirmações sequenciais
return value;
end function;
procedure nome_procedimento (lista_parâmetros_entrada, lista_parâmetros_saída) is
declarações
begin
afirmações sequenciais
end procedure;
function log2c (n : integer) return integer is
variable m , p : integer;
begin
m := 0;
p : = 1;
while p < n loop
m : = m + 1;
p := p * 2;
end loop;
return m;
end log2c;
-- FILE: comparator.vhd
-- Fonte: PEDRONI, Volnei A. Circuit Design and Simulation with VHDL; 2 ed. Massachusetts-EUA:MIT, 2010.
library ieee;
use ieee.numeric_std.all;
use work.my_package.all;
entity organizer is
generic (size : natural := 3);
port
(
x : in UNSIGNED(2 to 5);
y : out UNSIGNED(size - 1 downto 0)
);
end entity;
architecture organizer of organizer is
begin
y <= order_and_fill(x, size);
end architecture;
-- FILE: my_pkg.vhd
-- Fonte: PEDRONI, Volnei A. Circuit Design and Simulation with VHDL; 2 ed. Massachusetts-EUA:MIT, 2010. 608 p. ISBN 9780262014335
library ieee;
use ieee.numeric_std.all;
package my_package is
function order_and_fill (input : UNSIGNED; bits : natural) return UNSIGNED;
end package;
package body my_package is
function order_and_fill (input : UNSIGNED; bits : natural) return UNSIGNED is
variable a : UNSIGNED(input'LENGTH - 1 downto 0);
variable result : UNSIGNED(bits - 1 downto 0);
begin
assert (input'LENGTH <= bits)
report "Improper input size!"
severity FAILURE;
if (input'LEFT > input'RIGHT) then
a := input;
else
for i in a'range loop
a(i) := input(input'LEFT + i);
end loop;
end if;
if (a'LENGTH < bits) then
result(bits - 1 downto a'LENGTH) := (others => '0');
result(a'LENGTH - 1 downto 0) := a;
else
result := a;
end if;
return result;
end function;
end package body;
Figura 6.1 - Fluxograma da PROCEDURE min_max -- FILE: comparator.vhd
-- Fonte: PEDRONI, Volnei A. Circuit Design and Simulation with VHDL; 2 ed. Massachusetts-EUA:MIT, 2010.
use work.my_package.all;
entity comparator is
port
(
a, b, c : in integer range 0 to 255;
min, max : out integer range 0 to 255
);
end entity;
architecture comparator of comparator is
begin
min_max(a, b, c, min, max);
end architecture;
-- FILE: my_pkg.vhd
-- Fonte: PEDRONI, Volnei A. Circuit Design and Simulation with VHDL; 2 ed. Massachusetts-EUA:MIT, 2010.
package my_package is
procedure min_max (
signal a, b, c : in integer;
signal min, max : out integer
);
end package;
package body my_package is
procedure min_max (
signal a, b, c : in integer range 0 to 255;
signal min, max : out integer range 0 to 255) is
begin
if (a >= b) then
if (a >= c) then
max <= a;
if (b >= c) then
min <= c;
else
min <= b;
end if;
else
max <= c;
min <= b;
end if;
else
if (b >= c) then
max <= b;
if (a >= c) then
min <= c;
else min <= a;
end if;
else
max <= c;
min <= a;
end if;
end if;
end procedure;
end package body;
|
Unidade 7 - Maquinas de Estado Finitas
- 4 ENCONTROS
Unidade 7 - Maquinas de Estado Finitas |
---|
Figura 7.1 - Exemplo de diagrama de estados de uma FSM Fig11.1(a) e implementação em hardware da FSM Fig11.2(a)
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
----------------------------------------------------------
ENTITY < entity_name > IS
PORT (
clk, rst : IN STD_LOGIC;
entradas : IN < data_type > ;
saidas : OUT < data_type >);
END entity;
----------------------------------------------------------
ARCHITECTURE < architecture_name > OF < entity_name > IS
TYPE state IS (A, B, C, ...);
SIGNAL pr_state, nx_state : state;
-- ATTRIBUTE ENUM_ENCODING : STRING; --optional attribute
-- ATTRIBUTE ENUM_ENCODING OF state : TYPE IS "sequential";
-- ATTRIBUTE SYN_ENCODING OF state : TYPE IS "safe";
BEGIN
------Logica Sequencial da FSM:------------
PROCESS (clk, rst)
BEGIN
IF (rst = '1') THEN
pr_state <= A;
ELSIF rising_edge(clk) THEN
-- apenas na borda do "clk" ocorre a mudança de estado da FSM
pr_state <= nx_state;
END IF;
END PROCESS;
------Logica Combinacional da FSM:------------
PROCESS (pr_state, entradas)
BEGIN
------Valores default das saidas------------
saidas <= < valor > ;
CASE pr_state IS
WHEN A =>
-- é necessário um WHEN para definir as "saidas" durante cada estado
-- e analisar as "entradas" para definir o próximo estado
saidas <= < valor > ; -- apenas se diferente do valor default
IF (entradas = < valor >) THEN
nx_state <= B;
...
ELSE
nx_state <= A;
END IF;
WHEN B =>
saidas <= < valor > ; -- apenas se diferente do valor default
-- dependendo das "entradas", pode ser que hajam mais de um estados de destino
IF (entradas = < valor >) THEN
nx_state <= C;
ELSIF (entradas = < valor >) THEN
nx_state <= A;
ELSE
nx_state <= B;
END IF;
WHEN C =>
saidas <= < valor > ; -- apenas se diferente do valor default
-- a passagem para outro estado pode não depender de nenhuma "entrada"
nx_state <= D;
WHEN ...
END CASE;
END PROCESS;
------Seção de Saída (opcional):-------
-- Essa seção visa garantir que a saida new_output esteja sincronizada com o clk.
-- Se isso não for importante, ela pode ser suprimida
PROCESS (clk, rst)
BEGIN
IF (rst = '1') THEN
new_output <= < valor > ;
ELSIF rising_edge(clk) THEN --or falling_edge(clk)
new_output <= output;
END IF;
END PROCESS;
END architecture;
WHEN others =>
nx_state <= <initial_state>;
Figura 7.2 - FSM - Máquina de vender doces (diagrama de estados) Figura 7.3 - FSM - Máquina de vender doces (diagrama de estados com default
Figura 7.4 - FSM - Máquina de vender doces (simulação)
Figura 7.5 - FSM - alarme (oscilando entre os estados quando remoto é 1)
Figura 7.6 - FSM - alarme (solução com flag)
Figura 7.7 - FSM - alarme (solução com estados de WAIT) Figura 7.8 - Simulação da FSM - alarme (solução com estados de WAIT)
Figura 7.9 - Tipos de FSM (Condicional, Temporizada e Hibrida)
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
----------------------------------------------------------
ENTITY < entity_name > IS
PORT (
clk, rst : IN STD_LOGIC;
input : IN < data_type > ;
output : OUT < data_type >);
END entity;
----------------------------------------------------------
ARCHITECTURE < architecture_name > OF < entity_name > IS
TYPE state IS (A, B, C, ...);
SIGNAL pr_state, nx_state : state;
signal timer: integer range 0 to MAX;
-- ATTRIBUTE ENUM_ENCODING : STRING; --optional attribute
-- ATTRIBUTE ENUM_ENCODING OF state : TYPE IS "sequential";
BEGIN
------Logica Sequencial da FSM:------------
PROCESS (clk, rst)
variable count: integer range o to MAX;
BEGIN
IF (rst = '1') THEN
pr_state <= A;
count := 0;
ELSIF (clk'EVENT AND clk = '1') THEN
count := count + 1;
if (count >= timer) then
pr_state <= nx_state;
count := 0;
end if;
END IF;
END PROCESS;
------Logica Combinacional da FSM:------------
PROCESS (pr_state, input)
BEGIN
------Valores default das saidas------------
output <= < value >;
------Valores default do timer------------
timer <= <value>;
CASE pr_state IS
WHEN A =>
output <= < value > ; -- apenas se diferente do valor default
IF (input =< value >) THEN
timer <= <value>; -- apenas se diferente do valor default
nx_state <= B;
...
ELSE
timer <= <value>; -- apenas se diferente do valor default
nx_state <= A;
END IF;
WHEN B =>
output <= < value > ; -- apenas se diferente do valor default
IF (input =< value >) THEN
timer <= <value>; -- apenas se diferente do valor default
nx_state <= C;
...
ELSE
timer <= <value>; -- apenas se diferente do valor default
nx_state <= B;
END IF;
WHEN ...
END CASE;
END PROCESS;
------Seção de Saída (opcional):-------
PROCESS (clk, rst)
BEGIN
IF (rst = '1') THEN
new_output <= < value > ;
ELSIF (clk'EVENT AND clk = '1') THEN --or clk='0'
new_output <= output;
END IF;
END PROCESS;
END architecture;
Figura 7.10 - Diagrama de estados do controlador de semáforo Figura 7.11 - Simulação do controlador de semáforo no Modelsim Se quiser usar o ModelSim diretamente sem usar o Quartus, abra um terminal e digite: /opt/intelFPGA/20.1/modelsim_ae/linuxaloem/vsim (ou o caminho de instalação na sua maquina)
|
Unidade 8 - Testbench
- 2 ENCONTROS
Unidade 8 - Testbench |
---|
Usaremos como exemplo o semáforo recém projetado para criar um testbench em VHDL para testar uma entity projetada em VHDL.
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY semaforo_vhd_tst IS
END semaforo_vhd_tst;
ARCHITECTURE semaforo_arch OF semaforo_vhd_tst IS
-- constants
-- signals
SIGNAL ativar : STD_LOGIC;
SIGNAL clk : STD_LOGIC;
SIGNAL lam1 : STD_LOGIC;
SIGNAL lam2 : STD_LOGIC;
SIGNAL lvd1 : STD_LOGIC;
SIGNAL lvd2 : STD_LOGIC;
SIGNAL lvm1 : STD_LOGIC;
SIGNAL lvm2 : STD_LOGIC;
SIGNAL rst : STD_LOGIC;
COMPONENT semaforo
PORT (
ativar : IN STD_LOGIC;
clk : IN STD_LOGIC;
lam1 : OUT STD_LOGIC;
lam2 : OUT STD_LOGIC;
lvd1 : OUT STD_LOGIC;
lvd2 : OUT STD_LOGIC;
lvm1 : OUT STD_LOGIC;
lvm2 : OUT STD_LOGIC;
rst : IN STD_LOGIC
);
END COMPONENT;
BEGIN
i1 : semaforo
PORT MAP (
-- list connections between master ports and signals
ativar => ativar,
clk => clk,
lam1 => lam1,
lam2 => lam2,
lvd1 => lvd1,
lvd2 => lvd2,
lvm1 => lvm1,
lvm2 => lvm2,
rst => rst
);
init : PROCESS
-- variable declarations
BEGIN
-- code that executes only once
WAIT;
END PROCESS init;
always : PROCESS
-- optional sensitivity list
-- ( )
-- variable declarations
BEGIN
-- code executes for every event on sensitivity list
WAIT;
END PROCESS always;
END semaforo_arch;
vcom -93 -work work {../../semaforo.vhd}
vsim work.semaforo
do wave_curto.do
force -freeze sim:/semaforo/rst 1 0, 0 10
force -freeze sim:/semaforo/clk 1 0, 0 {0.5sec} -r 1sec
force -freeze sim:/semaforo/ativar 0 0, 1 10.3sec, 0 55.5sec, 1 70sec, 0 106.22sec, 1 120sec
run 150sec
-- DECLARAR
constant tclk: time := 1 ns;
signal clk : std_logic := '0';
-- CLOCK COM PERIODO DE 2*tclk (COM CÓDIGO CONCORRENTE)
clk <= not clk after tclk;
-- CLOCK COM PERIODO DE 2*tclk (COM CÓDIGO SEQUENCIAL)
PROCESS
BEGIN
clk <= '1';
wait for tclk;
clk <= '0';
wait for tclk;
END PROCESS;
-- DECLARAR
constant treset: time := 100 ps;
signal reset : std_logic;
-- RESET COM DURAÇÃO DE treset (COM CÓDIGO CONCORRENTE)
reset <= '1', '0' after treset;
-- RESET COM DURAÇÃO DE treset (COM CÓDIGO SEQUENCIAL)
PROCESS
BEGIN
reset <= '1';
wait for treset;
reset <= '0';
wait;
END PROCESS;
-- DECLARAR
constant t_a: time := 100 ps;
constant Nbits: natural := 8;
signal a : std_logic_vector(Nbits-1 downto 0);
-- GERAÇÂO DO SINAL a = [0 1 2 3 4 ...] COM DURAÇÃO DE t_a em cada valor (COM CÓDIGO SEQUENCIAL)
PROCESS
BEGIN
for i in 0 to 2**Nbits-1 loop
a <= std_logic_vector(to_unsigned(i,Nbits));
wait for t_a;
end loop;
END PROCESS;
No exemplo abaixo é utilizado um tipo de Linear-feedback shift register -- DECLARAR
constant t_a: time := 100 ps;
constant Nbits: natural := 8;
signal a : std_logic_vector(Nbits-1 downto 0) := (0 => '1', 3 => '1', others => '0');
-- GERAÇÂO DO SINAL a COM DURAÇÃO DE t_a em cada valor (COM CÓDIGO SEQUENCIAL)
-- USANDO UM CONTADOR LFSR
PROCESS
BEGIN
for i in 0 to 2**Nbits-1 loop
a <= (a(0) xor a(2) xor a(3) xor a(4)) & a(Nbits-1 downto 1); -- para 8 bits
wait for t_a;
end loop;
END PROCESS;
vlib rtl_work
vmap work rtl_work
vcom -93 -work work {../../<file1>.vhd}
vcom -93 -work work {../../<file1>.vhd}
vcom -93 -work work {../../<file_top_level>.vhd}
vcom -93 -work work {<file_top_level>.vht}
vsim work.q2_vhd_tst
do wave_vht.do
run 110 ns
Se quiser usar o ModelSim diretamente sem usar o Quartus, abra um terminal e digite: /opt/intelFPGA/20.1/modelsim_ae/linuxaloem/vsim (ou o caminho de instalação na sua maquina) |
Unidade 9 - Projeto Final
- 3 ENCONTROS
Unidade 9 - Projeto Final |
---|
O presente projeto busca por soluções semafóricas inovadoras, incluindo aprimoramentos específicos para o período noturno e economia de energia. O objetivo é proporcionar uma experiência mais segura e visível para veículos e pedestres ao cruzar vias durante o dia e a noite. Como material auxiliar se sugere a leitura dinâmica do Manual Brasileiro de Sinalização de trânsito: VOLUME V - Sinalização Semafórica do CONTRAN.
O projeto será desenvolvido por equipes de até 2 estudantes, e cada equipe deverá escolher uma dos cenários propostos, ou até mesmo um cenário diferenciado desses. Cada projeto deverá envolver obrigatoriamente:
Nessa situação, a via secundária será liberada mediante a detecção de um veículo na área do sensor. A modernização incluirá a instalação de sensores na via secundária. Este sistema proporcionará uma abertura segura e eficiente quando necessário, ao mesmo tempo em que promove uma comunicação clara aos motoristas. A sinalização verde na via preferencial será configurada para piscar, alertando os condutores que o semáforo está sob controle do sensor de veículo na via secundária. Da mesma forma, na via secundária, o sinal ficará piscante em vermelho sempre que não houver veículo detectado pelo sensor. Ao ser identificado um veículo, o semáforo da via secundária mudará para vermelho, ao mesmo tempo que um contador regressivo indicará o tempo faltante para a abertura. Após o tempo mínimo programado para a via preferencial permanecer aberta, o semáforo da via secundária mudará para verde, indicando no contador regressivo o tempo restante de verde. Esse ajuste visa otimizar o fluxo de tráfego, garantindo a fluidez na via preferencial enquanto mantém a segurança na via secundária. A sinalização piscante proporcionará uma comunicação visual eficaz, informando os motoristas sobre o modo de operação baseado no sensor de veículo, contribuindo para uma navegação segura e eficiente no cruzamento entre a via preferencial e a secundária.
Visa garantir uma travessia de pedestres diurna e noturna segura e consciente. Ao acionar a botoeira, será ativada uma iluminação branca sobre a faixa de passagem zebrada e nas áreas de espera dos pedestres, assegurando melhor visibilidade e segurança para o pedestre a noite. Simultaneamente, o semáforo emitirá sinais visuais e sonoros, indicando ao pedestre que o botão foi acionado com sucesso e alertando motoristas sobre a intenção de travessia. Durante a fase de liberação para veículos, o semáforo do pedestre permanecerá vermelho, economizando energia até que o botão seja acionado. Após a solicitação, os grupos focais do pedestre exibirão luz verde em ambos os lados da via, enquanto o semáforo dos carros exibirá sinal vermelho, garantindo a máxima segurança para os pedestres e reforçando a prioridade de travessia. Para orientar pedestres de maneira eficaz, o semáforo do pedestre apresentará um contador regressivo, indicando o tempo restante para a travessia. O tempo total de travessia será ajustável, permitindo personalização conforme as necessidades locais. Nos últimos 30% do tempo, o sinal verde do semáforo do pedestre piscará, visualmente alertando que o tempo para a travessia está se encerrando. É importante ressaltar que a iluminação estará ativa apenas durante o tempo em que a botoeira foi acionada até 5 segundos após o término do tempo de travessia. Este ajuste visa otimizar o consumo de energia e garantir que a iluminação cumpra sua função apenas quando necessária.
Este projeto visa apresentar uma solução para um cruzamento de vias, com a passagem de pedestres controlada por botoeira, integrada de maneira sincronizada com o fluxo de veículos. Abaixo, detalhamos as características tanto para pedestres quanto para carros. Fase Inicial: Os semáforos veiculares iniciam em sinal amarelo piscante em ambas as vias. O semáforo para pedestres permanece apagado até a ativação da botoeira, visando a economia de energia. apenas um led vermelho no centro da botoeira deve estar piscando para induzir o pedestre a acionar a boteira. Uma placa sobre a botoeira informa que é necessário acionar o botão para solicitar a passagem. Funcionamento no modo veicular sem solicitação de pedestre: O cruzamento deve alternar entre vermelho, amarelo e verde conforme programação para otimizar o fluxo de carros. O ciclo de passagem de pedestre deve ser iniciado se alguma das 4 boteiras existentes nos cantos do cruzamento for acionada. Solicitação de pedestre: Ao ser acionada uma das botoeiras dos Pedestres, se for a noite, será ativada a iluminação branca sobre a faixa de passagem zebrada e nas áreas de espera dos pedestres, assegurando melhor visibilidade e segurança para o pedestre a noite. Simultaneamente, o semáforo emitirá sinais sonoros, indicando ao pedestre que o botão foi acionado com sucesso e alertando motoristas sobre a intenção de travessia. Durante a fase de espera para dos pedestres, o semáforo do pedestre, que estava apagado economizando energia, acenderá em vermelho e mostrara um contador regresivo indicando o tempo faltante para a liberação da travessia. Na liberação, que é sincronizada com as vias, os grupos focais de pedestre exibirão luz verde em ambos os lados das faixas de pedestres, e indicará o tempo restante num contador regressivo. Enquanto isso, os semáforos dos carros exibirão sinal vermelho em todas as direções, garantindo a máxima segurança para os pedestres. Nos últimos 30% do tempo, sinal verde para pedestres piscará, alertando visualmente sobre término iminente da travessia. Ao término do tempo de travessia configurado, semáforo para pedestres entra em vermelho piscante por 5 segundos, indicando retorno ao modo veicular. Se botoeira for acionada novamente, inicia-se novo ciclo, sincronizando travessia de pedestres com o fluxo veicular. Essa sinalização semafórica integrada visa proporcionar uma travessia segura e eficiente para pedestres, ao mesmo tempo em que otimiza o fluxo veicular, contribuindo para um ambiente de tráfego mais fluido e seguro no cruzamento das vias de carros.
Para saber as especificações exatas dessas características pergunte ao professor. Após a conclusão do projeto, a equipe deverá gravar um vídeo explicando o projeto usando o hardware projetado. Também deve ser feita a defesa por cada membro da equipe do projeto, devendo estar apto a responder sobre o código e também sobre o processo e metodologia. |
Avaliações
Nas avaliações A1 e A2 vocês poderão consultar apenas as folhas entregues:
- VHDL Quick Reference - SynthWorks
- VHDL Types and Operators Quick Reference - SynthWorks
- ModelSim Quick Reference - SynthWorks
- Tabelas das figuras 3.6, 3.10 e 4.1 do livro do Pedroni.
- Arquivo:Numeric std conversions.png
- Dica use também como fonte de consulta os templates do Quartus.
- Ao final das avaliações o aluno deverá enviar a avaliação para a plataforma Moodle com os arquivos solicitados.
- Data das avaliações
- A1 - Unidade 1 a Unidade 4: dia XX/XX
- A2 - Unidade 5 a Unidade 7: dia XX/XX
- PF - Entrega do projeto final: dia 15/12
- R12 - Recuperação de A1 e A2 : dia 12/12
Atividade relâmpago (AR)
As atividades relâmpago devem ser entregues no Moodle da disciplina. A não entrega dessas atividades não gera nenhum desconto, apenas geram pontos de BÔNUS que são adicionados aos conceitos das avaliações A1 a AN.
Atividade extra-classe (AE)
A média ponderada das atividades extra-classe será considerada no cálculo do conceito final da UC. A entrega das mesmas será feita pelo Moodle, e cada dia de atraso irá descontar 0,2 na nota da atividade. Muitas dessas atividades também possuem BÔNUS que são adicionados aos conceitos das avaliações A1 e A2. Para os BÔNUS só serão considerados projetos entregues no prazo.
AE2 - Conhecendo os dispositivos lógicos programáveis
AE2 - Conhecendo os dispositivos lógicos programáveis |
---|
|
AE3 - Programação do kit Mercurio IV
AE3 - Programação do kit Mercurio IV |
---|
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
entity counter is
generic (WIDTH : in natural := 4);
port (
RST : in std_logic;
CLK : in std_logic;
LOAD : in std_logic;
DATA : in std_logic_vector(WIDTH-1 downto 0);
R0 : out std_logic;
Q : out std_logic_vector(WIDTH-1 downto 0));
end entity;
architecture ifsc_v1 of counter is
signal Q_aux : std_logic_vector(WIDTH-1 downto 0);
begin
process(RST,CLK) is
begin
if RST = '1' then
Q_aux <= (others => '0');
elsif rising_edge(CLK) then
if LOAD= '1' then
Q_aux <= DATA;
else
Q_aux <= std_logic_vector(unsigned(Q_aux) + 1);
end if;
end if;
end process;
-- Adaptacao feita devido a matriz de leds acender com ZERO
Q <= not Q_aux;
-- Para acender um led eh necessario colocar ZERO na linha correspondente da matriz.
R0 <= '0';
end architecture;
CLK: PIN_Y17 ou PIN_V21 DATA[3]: PIN_H18 DATA[2]: PIN_H20 DATA[1]: PIN_K21 DATA[0]: PIN_J21 LOAD: PIN_Y22 Q[3]: PIN_J6 Q[2]: PIN_K8 Q[1]: PIN_J8 Q[0]: PIN_L8 RST: PIN_W21 R0: PIN_F10
-- insira na declaração das portas da entity a linha
LCD_BACKLIGHT: out std_logic;
-- insira na architecture a linha
LCD_BACKLIGHT <= '0';
LCD_BACKLIGHT: PIN_V10
entity COUNTER_db is
...
CLK50MHz : in std_logic;
...
end entity
architecture ifsc_v2 of COUNTER_db is
...
signal CLK_db: std_logic := '0';
...
begin
-- debouncer de 10ms
process (CLK50MHz, CLK, RST, CLK_db) is
constant max_cnt: natural := 500000; -- 500000 10ms para clk 20ns
variable cnt_db : integer range 0 to max_cnt-1;
begin
if (RST = '1') then
cnt_db := 0;
CLK_db <= '0';
elsif ((CLK = '0') and (CLK_db = '0')) or
((CLK = '1') and (CLK_db = '1')) then
cnt_db := 0;
elsif (rising_edge(CLK50MHz)) then
if (cnt_db = max_cnt - 1) then
CLK_db <= not CLK_db;
else
cnt_db := cnt_db + 1;
end if;
end if;
end process;
...
-- Troque no process(RST,CLK) a entrada '''CLK''' do circuito anterior pela entrada '''CLK_db'''
CLK50MHz: PIN_T1
create_clock -name CLK50MHz -period 50MHz [get_ports -no_case {clk*}]
|
AE4 - Conversor de binário para BCD
AE4 - Conversor de binário para BCD |
---|
Neste laboratório remoto, os alunos deverão implementar uma solução do para um circuito conversor de binário para BCD (bin2bcd) com entrada binária variando entre 0 a 9999.
Figura AE4(a) - Exemplo de simulação funcional de 0 a 9999
Figura AE4(b) - Obtendo o número de elementos no "Flow Summary" Figura AE4(c) - Obtendo o número de elementos no "Resource Usage Summary"
Figura AE4(d) - Exemplo de tempo máximo de propagação
|
AE5 - Laboratório de programação de FPGA - Relógio HHMMSS
AE5 - Laboratório de programação de FPGA - Relógio HHMMSS | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Passo 1 - Projeto do Relogio_HHMMSS:
component div_clk is
generic (fclk2 : natural := 50); -- frequencia para simulacao
port (
clk_in : in std_logic;
rst : in std_logic;
clk_out : out std_logic
);
end component;
component contador_bcd is
generic (max_dezena : natural := 5; max_unidade : natural := 9);
port (
clk: in std_logic;
rst: in std_logic;
fim: out std_logic;
bcd_unidade, bcd_dezena : out std_logic_vector(3 downto 0)
);
end component;
Para esse contador pode ser usado o desenvolvido em aula, mas ele precisa ser modificado para permitir que o clock seja síncrono em todos os flip-flops. Assim é necessário usar um sinal de enable_in para habilitar a contagem durante um período de clock. Também será necessário gerar o sinal de enable_out para habilitar a contagem do próximo contador.
component bcd2ssd is
generic (ac_ccn : natural := 0);
port (
bcd_in : in std_logic_vector(3 downto 0);
ssd_out : out std_logic_vector(6 downto 0)
);
end component;
entity relogio_HHMMSS IS
-- O valor do fclk2 corresponde a metade do periodo do clock de entrada em Hz
generic (fclk2 : natural := 50); -- ao simular o circuito utilize um valor baixo para acelerar a simulaçao
-- generic (fclk2 : natural := 25000000); -- ao implementar no hardware use o valor do clock em Hz
port
(
clk_1sec: in STD_LOGIC;
rst_SW: in STD_LOGIC;
ligar_SW: in STD_LOGIC;
ssd_DS, ssd_DM, ssd_DH: out STD_LOGIC_VECTOR(6 downto 0);
ssd_US, ssd_UM, ssd_UH: out STD_LOGIC_VECTOR(6 downto 0)
);
end entity;
Figura AE4.a - RTL do Relógio Digital de 24 horas Passo 2 - Simule os componentes e o relógio completo:
Figura AE4.b - Simulação funcional do Relógio Digital de 24 horas Figura AE4.c - Simulação funcional do Relógio Digital de 24 horas - detalhe enable 1sec Passo 3 - Implemente o relógio no kit DE2-115:
Passo 4 - Entregas:
|
- ↑ PEDRONI, Volnei A. Eletrônica digital moderna e VHDL; 1ª ed. Rio de Janeiro:Elsevier, 2010. 619p. . ISBN 9788535234657
- ↑ 2,00 2,01 2,02 2,03 2,04 2,05 2,06 2,07 2,08 2,09 2,10 2,11 2,12 2,13 2,14 2,15 2,16 2,17 2,18 2,19 2,20 2,21 2,22 2,23 2,24 2,25 PEDRONI, Volnei A. Circuit Design and Simulation with VHDL; 2ª ed. Massachusetts-EUA:MIT, 2010. 608 p. ISBN 9780262014335