Sebenta Sistemas Logicos v13

Universidade Nova de Lisboa
Sistemas Lógicos I
Sistemas Lógicos II
Documento de trabalho (RASCUNHO)
Pedro Alexandre da Costa Sousa

João Paulo Branquinho Pimentão
2023-04-02
1
ÍNDICE GERAL
Índice geral............................................................................................................................................. 1
Índice figuras .......................................................................................................................................... 8
Índice tabelas ....................................................................................................................................... 11
Índice circuitos ..................................................................................................................................... 13
Agradecimento..................................................................................................................................... 16
Introdução ........................................................................................................................................... 17
Um sistema ...................................................................................................................................... 17
Sistema binário ................................................................................................................................ 18
A variável binária ......................................................................................................................... 18
Verdade e falso ............................................................................................................................ 18
O significado da variável binária ................................................................................................... 19
Bases numéricas............................................................................................................................... 19
Números inteiros ......................................................................................................................... 19
Base binária ................................................................................................................................. 19
Tabela de equivalência Base decimal e binária............................................................. 20
Base octal .................................................................................................................................... 20
Base Hexadecimal ........................................................................................................................ 21
Tabela de equivalência Decimal, Octal, binário e hexadecimal ..................................... 22
Conversão da base decimal para outra base ................................................................................. 22
Os números fraccionários ............................................................................................................. 23
Representação – Sistemas númericos ............................................................................................... 24
Exercícios ..................................................................................................................................... 24
Números negativos .......................................................................................................................... 25
Módulo de sinal (ou sinal-magnitude)........................................................................................... 25
Complemento para 1 (C1) de N bits .............................................................................................. 25
Complemento para 2 (C2) de N bits .............................................................................................. 27
Limites de faixa ............................................................................................................................ 27
Aritmética modular e a subtração ................................................................................................ 28
Códigos não numéricos .................................................................................................................... 29
Código binário de sete cores ........................................................................................................ 29
Código de cores RGB .................................................................................................................... 29
Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

retificação. Nós sabemos. Enviar comentários para pas@fct.unl.pt
2
ASCII – Código alfanumerico de caracteres ................................................................................... 30

Os Circuitos integrados..................................................................................................................... 31
Os circuitos integrados e as portas lógicas .................................................................................... 31
O pinout....................................................................................................................................... 32
Fanout ......................................................................................................................................... 32
Os três estados (tristate) .............................................................................................................. 33
Bus de dados................................................................................................................................ 33
Active high e active low ................................................................................................................ 34
Dualidade .................................................................................................................................... 34
Placa de montagem...................................................................................................................... 34
As funções digitais ............................................................................................................................ 34
Tabelas de Verdade ...................................................................................................................... 35
Tabelas de verdade e diagramas de Venn ..................................................................................... 35
Funções com uma variável ........................................................................................................... 35
Função identidade (74LS07) ........................................................................................ 35
Função Inversora (74LS04)........................................................................................... 37
Funções com duas variáveis ......................................................................................................... 38
A função disjunção ou soma booleano - OR (74LS32) ................................................... 38

A função conjunção - AND (74LS08) ............................................................................. 39
A função XOR (74LS86) ................................................................................................ 41
Portas universais .......................................................................................................................... 42
O NAND....................................................................................................................... 42
O NOR ......................................................................................................................... 43
Portas lógicas (Resumo) ............................................................................................................... 45
Exercícios ..................................................................................................................................... 45
Resoluções ................................................................................................................................... 46
Implementação simplificada de portas ......................................................................................... 48
Expressões lógicas ............................................................................................................................ 49
Exercício ...................................................................................................................................... 49
Propriedades da álgebra booleana ............................................................................................... 49
Elemento neutro ......................................................................................................... 49
Elemento absorvente .................................................................................................. 49
idempotência .............................................................................................................. 50

3
Complemento ............................................................................................................. 50
Involução ou dupla negação ........................................................................................ 50
Comutativa.................................................................................................................. 50
Associativa .................................................................................................................. 50
distributiva .................................................................................................................. 50
leis de Morgan............................................................................................................. 50
Teoremas ..................................................................................................................................... 51
Teorema da absorção .................................................................................................. 51
Teorema do consenso ................................................................................................. 51
Mais Teoremas Úteis ................................................................................................... 51
O desenho de circuitos ..................................................................................................................... 51
Obter expressões a partir de circuitos .......................................................................................... 52
Exercício ...................................................................................................................................... 52
Simplificação de expressões ............................................................................................................. 53
Exemplos de simplificações .......................................................................................................... 53
Funções booleanas....................................................................................................................... 55
Exercícios ..................................................................................................................................... 55
Forma Canónica ............................................................................................................................... 56
Os Mintermos .............................................................................................................................. 56
Os maxtermos.............................................................................................................................. 56
A ordem normalizada ................................................................................................................... 57
Primeira forma canónica ............................................................................................. 57
segunda forma canónica.............................................................................................. 59
Exercícios ..................................................................................................................................... 60
Resolução .................................................................................................................... 60
Simplificação de funções .................................................................................................................. 61
Exercícios ..................................................................................................................................... 62
Resolução .................................................................................................................... 62
Mapa de Karnaugh (mapa-K) ............................................................................................................ 62
Simplificação de funções em mapas-K .......................................................................................... 64
Mapas de Karnaugh com uma variável ......................................................................................... 66
Mapas de karnaughcom duas variáveis......................................................................................... 67
Mapas de karnaugh com 3 variáveis ............................................................................................. 68

4
E em mapas com 4 variáveis ......................................................................................................... 68

Exercícios ..................................................................................................................................... 70
Resoluções ................................................................................................................................... 71
Mapas com cinco variáveis ........................................................................................................... 76
Mapas com seis variáveis ............................................................................................................. 78
Funções incompletas (don’t careS) ................................................................................................... 79
Exercício ...................................................................................................................................... 80
Resolução .................................................................................................................... 80
multiplexadorES e Decodificadores................................................................................................... 82
O multiplexador ........................................................................................................................... 83
Multiplexador de duas entradas de selecção ............................................................... 84
Implementação de Funções Lógicas com Multiplexadores ............................................................ 84
Ampliação da Capacidade de um Sistema Multiplexador .............................................................. 85
Desmultiplexador ......................................................................................................................... 86
Descodificadores.......................................................................................................................... 86
Implementação de Funções Lógicas com Descodificadores .......................................... 87
Ampliação da Capacidade de um Decodificador ........................................................... 88
Codificador de prioridades ........................................................................................................... 89
Exercícios ..................................................................................................................................... 89
Aritmética ........................................................................................................................................ 90
Comparador ................................................................................................................................. 90
Somador ...................................................................................................................................... 92
Semi-somadores.......................................................................................................... 92
Somador completo ...................................................................................................... 93
Subtracção .................................................................................................................. 94
Exercício ...................................................................................................................................... 94
Componentes de memória ................................................................................................................... 96
Componentes tipo latch ................................................................................................................... 96
Latch............................................................................................................................................ 96
Latch com enable ......................................................................................................................... 98
D-Latch ........................................................................................................................................ 99
FLIP-FLOPs (edge triggered) ............................................................................................................ 100
O clock ....................................................................................................................................... 100

5
Flip-flop D (clock) ....................................................................................................................... 100

Flip-flop JK (clock) ...................................................................................................................... 102
Circuíto integrado Flip-flop J-K (74LS76) .................................................................... 102
Flip-flop T (clock) ........................................................................................................................ 103
Exercícios ................................................................................................................................... 104
ResoluçÕES ................................................................................................................................ 105
Máquinas de estado sincronas........................................................................................................ 107
Implementar máquinas de estado .............................................................................................. 108
Modelo Moore e diagrama de estados ...................................................................... 108

Modelo Mealy ........................................................................................................... 110
A tabela de excitação dos latch SR e do FFJK .............................................................. 111
Um contador .............................................................................................................................. 112
Implementação com FF SR ......................................................................................... 113
Exemplo de aplicação de Máquinas de estado: Controlo do motor ............................................. 114
Circuito com flip-flops D ............................................................................................ 116
Circuito com flip-flops JK ........................................................................................... 117
contador ascendente e descendente (Up/Down) ........................................................................ 117
Circuito com flip-flops D ............................................................................................ 118
Detector de sequência ............................................................................................................... 119
Detector de sequência 101 sem sobreposição ........................................................... 119

Detector de sequência 101 com sobreposição ........................................................... 120
Exercícios ................................................................................................................................... 121
Introdução ao CPU.............................................................................................................................. 123
O CPU - Primeiras noções ............................................................................................................... 123
O registo de 8 bits sincrono ........................................................................................................ 124
A escrita .................................................................................................................... 124
A leitura .................................................................................................................... 126
A limpeza (reset) ....................................................................................................... 126
O incremento ............................................................................................................ 127
O complemento ........................................................................................................ 129
juntando as operações .............................................................................................. 130
Simulação do registo de 1 bit ..................................................................................... 130
Finalmente os 8 bits ................................................................................................................... 131

6
Simulação do registo de 8 bits ................................................................................... 132

Interligando registos através de BUS de dados............................................................................ 132
A memória ......................................................................................................................................... 133
Quatro endereços de um bit ........................................................................................................... 133
A escrita..................................................................................................................................... 133
A leitura ..................................................................................................................................... 134
Enable da RAM........................................................................................................................... 134
Uma memória de quatro bytes ....................................................................................................... 134
Uma memória de N bytes ............................................................................................................... 135
Interligando os registos e a memória .............................................................................................. 135
Usando a plataforma.................................................................................................................. 136
A ALU – Unidade aritmética e lógica ................................................................................................... 138
A Identidade .............................................................................................................................. 139
A Soma ...................................................................................................................................... 139
O controlador ..................................................................................................................................... 140
AS Duas fases do controlador ......................................................................................................... 141
O IP (Instruction Pointer) ............................................................................................................ 141
o IR (Instruction RegistEr). .......................................................................................................... 142
MAR (Memory Address Register)................................................................................................ 142
O Primeiro controlador .............................................................................................................. 142
A inicialização ............................................................................................................ 142
A fase de FETCH......................................................................................................... 143
Diagrama temporal ................................................................................................... 143
A fase de EXECUTE ..................................................................................................................... 144
O clock da máquina de estados e da plataforma ............................................................................. 145
A primeira versão do nosso CPU ......................................................................................................... 147
Ler e Escrever da memória variáveis e constantes........................................................................... 147
Instruções de salto ......................................................................................................................... 148
As FLAGS ........................................................................................................................................ 150
FLAG Zero .................................................................................................................................. 150
FLAG sinal .................................................................................................................................. 150
FLAG Overflow ........................................................................................................................... 150
FLAG CARRY (e vai um) ............................................................................................................... 151

7
FLAG PARIDADE ......................................................................................................................... 151

FLAG interrupção ....................................................................................................................... 151
Uma ALU com FLAGS ...................................................................................................................... 151
O Registo das FLAGS ....................................................................................................................... 152
Arquitectura V3 .................................................................................................................................. 154
Glossário ............................................................................................................................................ 155
Bibliografia ......................................................................................................................................... 156

8
ÍNDICE FIGURAS
Figura 1 - Sinal analógico e sinal digital ................................................................................................. 17

Figura 2 - Níveis de tensão e valores lógicos .......................................................................................... 18
Figura 3 – Subtração em código complementos de (3-2) e (2-3) ............................................................ 29
Figura 4 – Tabela de ASCII ..................................................................................................................... 31
Figura 5 - Circuitos integrados............................................................................................................... 32
Figura 6 - Pinout dos circuitos integrados mais usuais ........................................................................... 32
Figura 7 - Diagrama de Venn e tabela de verdade para três variáveis..................................................... 35
Figura 8 - Diagrama de Venn da função identidade ............................................................................... 36
Circuito 7 – Figura 9 – Layout do circuito integrado do 74LS07 .............................................................. 36
Figura 10 - Diagrama de Venn da função inversora................................................................................ 37
Figura 11 – Layout do circuito integrado do 74LS04 .............................................................................. 38
Figura 12 - Diagrama de Venn da função disjunção de duas variáveis .................................................... 39
Figura 14 - Diagrama de Venn da função conjunção de duas variáveis ................................................... 40
Figura 16 - Diagrama de Venn da função conjunção exclusivo de duas variáveis .................................... 41
Figura 18 – porta lógica NAND .............................................................................................................. 42
Figura 19 - Diagrama de Venn da função NAND de duas variáveis ......................................................... 42
Figura 20 – porta lógica NOR................................................................................................................. 43
Figura 21 – Funções lógicas principais (símbolo, tabela de verdade e expressão booleana) .................... 45
Figura 22 – Implementação de 𝑭𝟏𝑪, 𝑩, 𝑨 = 𝑪𝑩𝑨 + 𝑪𝑩𝑨 + 𝑪𝑩𝑨 + 𝑪𝑩𝑨 só com portas NAND ............ 46
Figura 23 – Implementação de 𝑭𝟐𝑫, 𝑪, 𝑩, 𝑨 = 𝑫𝑪𝑩𝑨 + 𝑫𝑪𝑩𝑨 + 𝑫𝑪𝑩𝑨 + 𝑫𝑪𝑩𝑨 + 𝑫𝑪𝑩𝑨 + 𝑫𝑪𝑩𝑨 só
com portas NAND ................................................................................................................................. 47
Figura 24 – Mapa-k e tabela de verdade de 3 variáveis.......................................................................... 63
Figura 26 – Células adjacentes num mapa com 4 variáveis .................................................................... 65
Figura 27 – Mapa-k e tabela de verdade de função a AND de 2 variáveis, 𝑭(𝑩, 𝑨) = 𝟑 .......................... 65
Figura 28 – Mapa-k e tabela de verdade de 𝑭(𝑩, 𝑨) = 𝟏, 𝟑 ................................................................... 65
Figura 29 – Mapa-k e tabela de verdade de 1 variável ........................................................................... 66
Figura 31 – Mapa-k da função OR ......................................................................................................... 67

9
Figura 32 – Mapa-k de 3 variáveis com exemplos de agrupamentos de duas células .............................. 68

Figura 33 – Mapa-k de 3 variáveis com exemplos de agrupamentos de quatro células........................... 68
Figura 34 – Mapa-k de 4 variáveis ......................................................................................................... 69
Figura 35 – Exemplos de mapa-k de quatro variáveis com um único literal em SDP. .............................. 69
Figura 36 – Exemplos de mapa-k de quatro variáveis com um único literal em PDM. ............................. 70
Figura 37 – Tabela de verdade e Mapa-k de 𝑭𝑫, 𝑪, 𝑩, 𝑨 = 𝟎, 𝟏 ............................................................ 71
Figura 38 – Tabela de verdade e Mapa-k de 𝑭𝑫, 𝑪, 𝑩, 𝑨 = 𝟎, 𝟏, 𝟐, 𝟑 ..................................................... 71
Figura 39 – Tabela de verdade e Mapa-k de 𝑭𝑫, 𝑪, 𝑩, 𝑨 = 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓 ............................................ 72
Figura 40 – Tabela de verdade e Mapa-k de 𝑭𝑫, 𝑪, 𝑩, 𝑨 = 𝟎, 𝟏, 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓..................................... 73
Figura 41 – Tabela de verdade e Mapa-k de 𝑭𝑫𝑪𝑩𝑨 = 𝟎, 𝟏, 𝟒, 𝟓, 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓 com agrupamentos de
uns e de zeros ...................................................................................................................................... 74
Figura 42 –Mapa-k de 𝑭𝑪, 𝑩, 𝑨 = 𝑪. 𝑩 + 𝑪. 𝑨 + 𝑩. 𝑨 ............................................................................ 75
Figura 43 –Mapa-k de 𝑭𝑫, 𝑪, 𝑩, 𝑨 = 𝑪. 𝑩. 𝑨 + 𝑫. 𝑪. 𝑩 + 𝑨 ................................................................... 75
Figura 44 –Mapa-k de 𝑭𝑪, 𝑩, 𝑨 = (𝟏, 𝟑, 𝟒, 𝟔, 𝟕) .................................................................................... 75
Figura 45 –Mapa-k de 𝑭𝑫, 𝑪, 𝑩, 𝑨 = (𝑫 + 𝑪). (𝑫 + 𝑩 + 𝑨).................................................................. 76
Figura 46 – Mapa-k para funções com cinco variáveis ........................................................................... 76
Figura 47 – Mapa-k para a função 𝑭𝑬, 𝑫, 𝑪, 𝑩, 𝑨 = 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓 ........................................................ 77
Figura 48 – Mapa-k para a função 𝑭𝑬, 𝑫, 𝑪, 𝑩, 𝑨 = 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓, 𝟐𝟔, 𝟐𝟕, 𝟑𝟎, 𝟑𝟏 ................................ 77
Figura 49 – Mapa-k para a função 𝑭𝑬, 𝑫, 𝑪, 𝑩, 𝑨 = 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓, 𝟏𝟖, 𝟏𝟗, 𝟐𝟐, 𝟐𝟑, 𝟐𝟔, 𝟐𝟕, 𝟑𝟎, 𝟑𝟏 ........ 77
Figura 50 – Mapa-k para a função 𝑭𝑬, 𝑫, 𝑪, 𝑩, 𝑨 = 𝟓, 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓, 𝟏𝟖, 𝟏𝟗, 𝟐𝟐, 𝟐𝟑, 𝟐𝟔, 𝟐𝟕, 𝟑𝟎, 𝟑𝟏..... 78
Figura 51 – Mapa-k para funções com seis variáveis.............................................................................. 79
Figura 52 – Chave selectora de oito posições e representação do Multiplexador de oito entradas ......... 83
Figura 53 – Símbolo lógico de Latch SR com entradas active high e active low respectivamente ............ 97
Figura 54 – Símbolo lógico de LATCH SR com enable active high ........................................................... 98
Figura 55 – Diagrama temporal do FF SR com enable ............................................................................ 99
Figura 56 – Símbolo lógico de Latch D com enable ............................................................................... 99
Figura 57 – Diagrama temporal do D latch .......................................................................................... 100
Figura 58 – O sinal quadrado clock ...................................................................................................... 100
Figura 59 – Símbolo lógico de Flip-Flop D com disparo em flanco ascendente e descendente .............. 101
Figura 60 – Diagrama temporal do comportamento do FFD de disparo ascendente. ............................ 101
Figura 61 – Diagrama temporal do FF JK. Na figura, a última linha corresponde à negação do valor da saída
Q (!Q=Q’=𝑸). ...................................................................................................................................... 102
Figura 62 – Símbolo lógico 74LS76 ...................................................................................................... 103

10
Figura 63 – Modelo de operação, diagrama lógico e símbolos lógicos (Copyright Datasheet de ON

Semiconductor) .................................................................................................................................. 103
Figura 64 – Pinout do 74LS76 .............................................................................................................. 103
Figura 65 – Diagrama temporal do FF T ............................................................................................... 104
Figura 66 – Diagrama geral de uma máquina de estados ..................................................................... 107
Figura 67 – Diagrama geral de uma máquina de estados com FF-D...................................................... 107
Figura 68 - Notação gráfica no modelo de Moore................................................................................ 109
Figura 69 – Exemplo de um diagrama de máquina de estados modelo Moore ..................................... 109
Figura 70 - Notação gráfica no modelo de Mealy................................................................................. 110
Figura 71 - Exemplo de máquina de estados Mealy ............................................................................. 111
Figura 72 - Diagrama de estados Moore de contador crescente de dois bits ........................................ 112
Figura 73 – Representação do sistema de armazenamento de água .................................................... 115
Figura 74 - Diagrama de estados Moore para controlador do motor com dois sensores....................... 115
Figura 75 - Diagrama de estados para contador crescente e decrescente de dois bits. ......................... 118
Figura 76 - Diagrama de estados de detector de sequência 101 sem sobreposição. ............................. 120
Figura 77 - Diagrama de estados de detector de sequência 101 com sobreposição. ............................. 121
Figura 78 – Configuração de sinais no Xilinx ........................................................................................ 130
Figura 79 – simulação do registo de 1 bit ............................................................................................ 131
Figura 80 – simulação do registo de 8 bits ........................................................................................... 132
Figura 81 – Esquema de quatro registos interligados por BUS de dados............................................... 132
Figura 82 – Esquema da RAM de 4 bits................................................................................................ 135
Figura 83 – Plataforma com 4 registos (A,B,C,D) e uma memória......................................................... 136
Figura 84 – Instruções Assembly, opcode e carregamento na memória ............................................... 141
Figura 85 – O controlador com as duas fases FETCH e EXECUTE .......................................................... 142
Figura 86 - Diagrama temporal da fase FETCH do controlador. ............................................................ 144
Figura 87 - Diagrama temporal de representação de atrasos de sinais. ................................................ 146
Figura 88 – Arquitectura V1 - Primeira versão do nosso processador. .................................................. 147
Figura 89 – ALU com sinais de FLAGS. ................................................................................................. 152
Figura 90 – O registo das FLAGS e as suas entradas. ............................................................................ 153
Figura 91 – Arquitectura V2. ............................................................................................................... 154

11
ÍNDICE TABELAS
Tabela 1 - Equivalência decimal-binário ................................................................................................ 20

Tabela 2 - Equivalência decimal, binário, octal e hexadecimal ............................................................... 22
Tabela 3 – Código de sete cores ............................................................................................................ 29
Tabela 4 – Código RGB de codificação de cores ..................................................................................... 30
Tabela 5 - Tabela de verdade para duas entradas e uma saída............................................................... 35
Tabela 6 - Função identidade ................................................................................................................ 36
Tabela 7 - Função inversora .................................................................................................................. 37
Tabela 8 - Função da porta lógica disjunção de duas variáveis ............................................................... 38
Tabela 9 - Função da porta lógica conjunção de duas variáveis .............................................................. 39
Tabela 10 – Diagrama temporal de uma conjunção de duas variáveis .................................................... 40
Tabela 11 - Função da porta lógica disjunção exclusiva de duas variáveis .............................................. 41
Tabela 12 - Função da porta lógica NAND de duas variáveis .................................................................. 42
Tabela 13 - Função da porta lógica NOR de duas variáveis ..................................................................... 43
Tabela 14 – Teoremas úteis .................................................................................................................. 51
Tabela 15 – Tabela de verdade da função 𝑭(𝑪, 𝑩, 𝑨) = 𝑪 + 𝑩𝑨........................................................... 55
Tabela 16 – Mintermos para as variáveis B e A ...................................................................................... 56
Tabela 17 – Maxtermos para as variáveis B e A ..................................................................................... 57
Tabela 18 – Os maxtermos e mintermos para as variáveis D,C,B e A ...................................................... 57
Tabela 19 – Tabela de verdade da função 𝑭(𝑫𝑪𝑩𝑨) = 𝟎, 𝟒, 𝟕, 𝟏𝟓 ........................................................ 58
Tabela 20 – Tabela de verdade da função 𝑭(𝑪𝑩𝑨) = 𝟏 ........................................................................ 58
Tabela 21 – Tabela de verdade da função 𝑭(𝑪𝑩𝑨) = 𝟎, 𝟏, 𝟒, 𝟔, 𝟕 ......................................................... 59
Tabela 22 – Tabela de verdade da função 𝑮(𝑪, 𝑩, 𝑨) = 𝟎, 𝟏, 𝟒, 𝟔, 𝟕 ...................................................... 61
Tabela 23 – Tabela de verdade de multiplexador de três entradas de selecção com enable active low .. 83
Tabela 24 – Tabela de verdade do descodificador com três entradas de selecção e enable active low ... 87
Tabela 25 – Tabela de verdade do Latch SR ........................................................................................... 96
Tabela 26 – Tabela de verdade do Flip-Flip D com clock de disparo em flanco ascendente................... 101
Tabela 27 – Tabela de verdade do Flip-Flip JK com clock de disparo em flanco ascendente .................. 102
Tabela 28 – Tabela de verdade do Flip-Flip T com clock de disparo em flanco ascendente ................... 104
Tabela 29 – Tabela de verdade para implementação de Flip-Flip T com FF-D ....................................... 104
Tabela 30 - A tabela de verdade e de excitação dos Flip-flop SR .......................................................... 111
Tabela 31 - A tabela de verdade e de excitação dos Flip-flop JK ........................................................... 112
Tabela 32 – Tabela de excitação do Flip-Flip JK .................................................................................... 125

12
Tabela 33 – Tabela de estado seguinte em função de “write” e “data_in” ........................................... 125

Tabela 34 – Tabela de excitação de J e K em função de “write” e “data_in” ......................................... 125
Tabela 35 – Tabela de estado seguinte em função de “reset” .............................................................. 126
Tabela 36 – Tabela de excitação de J e K em função de “reset” ........................................................... 127
Tabela 37 – Tabela de estado seguinte em função de “complement” .................................................. 129
Tabela 38 – Tabela de excitação de J e K em função de “reset” ........................................................... 129
Tabela 39 – Exemplo de codificação de instruções .............................................................................. 141
Tabela 40 – Fase FETCH ...................................................................................................................... 143
Tabela 41 – Escrevendo e lendo da memória ...................................................................................... 148
Tabela 42 – Soma de duas variáveis sem carry .................................................................................... 149
Tabela 43 – Soma de duas variáveis sem carry .................................................................................... 149

13
ÍNDICE CIRCUITOS
Circuito 1 - variável binária ................................................................................................................... 18

Circuito 2 - Representação de fan-out ................................................................................................... 33
Circuito 3 - portas tri-state.................................................................................................................... 33
Circuito 4 - A noção de bus e tri-states .................................................................................................. 34
Circuito 5 - A placa de montagem (breadboard) .................................................................................... 34
Circuito 6 - Porta lógica identidade ....................................................................................................... 36
Circuito 7 – Figura 9 – Layout do circuito integrado do 74LS07 .............................................................. 36
Circuito 8 – Porta lógica inversora......................................................................................................... 37
Circuito 9 - Porta lógica OR ................................................................................................................... 38
Circuito 10 - Porta lógica AND ............................................................................................................... 39
Circuito 11 - Porta lógica XOR ............................................................................................................... 41
Circuito 12 - Implementação das portas lógicas principais com NANDs .................................................. 43
Circuito 13 - Implementação das portas lógicas principais com NORs .................................................... 44
Circuito 14 – Implementação simplificada da porta lógica AND ............................................................. 48
Circuito 15 – Implementação simplificada da porta lógica OR ................................................................ 48
Circuito 16 – Implementação simplificada da porta lógica NOT ............................................................. 48
Circuito 17 – Implementação simplificada da porta lógica NAND ........................................................... 48
Circuito 18 – Desenho do circuito 𝑭𝑫, 𝑪, 𝑩, 𝑨 = 𝑫 + 𝑩. 𝑪. 𝑩 + 𝑨........................................................ 52
Circuito 19 – Expressão booleana a partir do circuito lógico. ................................................................. 52
Circuito 20 – Dois circuitos a mesma função. ........................................................................................ 54
Circuito 21 – O circuito lógico da função 𝑭(𝑪, 𝑩, 𝑨) = 𝑪 + 𝑩𝑨 ............................................................ 55
Circuito 22 – O circuito lógico da função 𝑭(𝑪𝑩𝑨) = 𝟎, 𝟏, 𝟒, 𝟔, 𝟕 .......................................................... 59
Circuito 23 - Multiplexador com uma entrada de selecção .................................................................... 84
Circuito 24 - Multiplexador com duas entradas de selecção .................................................................. 84
Circuito 25 – Implementação da função 𝑭(𝑫𝑪𝑩𝑨) = 𝟏, 𝟒, 𝟓, 𝟕, 𝟖, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓 com multiplexador.......... 85
Circuito 26 – Ampliação de multiplexadores.......................................................................................... 86
Circuito 27 – Um desmultiplexador com três entradas de selecção e enable.......................................... 86
Circuito 28 – Um descodificador com três entradas de selecção e enable. ............................................. 87
Circuito 29 – Implementação de função com descodificador. ................................................................ 88
Circuito 30 – Ampliação de um descodificador. ..................................................................................... 88
Circuito 31 – Implementação de função com um descodificador de 2 entradas de selecção................... 90

14
Circuito 32 – Circuito diferença entre dois bits de peso 0. ..................................................................... 91

Circuito 33 – Circuito comparador de dois números com 4 bits. ............................................................ 91
Circuito 34 – Circuito comparador igualdade e diferença modular ......................................................... 92
Circuito 35 – Ligação de módulos de comparação de dois bits com transporte ...................................... 92
Circuito 36 – Circuito Semi-somador ..................................................................................................... 93
Circuito 37 – Circuito somador completo .............................................................................................. 94
Circuito 38 – Circuito somador/subtrator .............................................................................................. 94
Circuito 39 – Implementação do circuito somador/subtrator de dois números de 4 bits ........................ 95
Circuito 40 – Latch SR implementado com NORs ................................................................................... 97
Circuito 41 – Latch SR implementado com NANDs................................................................................. 97
Circuito 42 – Circuito LATCH SR com Enable active high com NORs ....................................................... 98
Circuito 43 – Circuito D latch com NANDs ............................................................................................. 99
Circuito 44 – Circuito FF D com clock implementado com Latch D ....................................................... 101
Circuito 45 – Circuito FF D com clock com portas lógicas ..................................................................... 102
Circuito 46 – Circuito base do contador crescente de 2 bits com FF SR ................................................ 114
Circuito 47 – Circuito contador crescente de 2 bits com FF SR ............................................................. 114
Circuito 48 – Circuito de máquina de estados controladora de motor para enchimento de tanque de água
com FFD ............................................................................................................................................. 116
Circuito 49 – Circuito de máquina de estados controladora de motor para enchimento de tanque de água
com FFJK ............................................................................................................................................ 117
Circuito 50 – Circuito contador ascendente e descendente com FFD. .................................................. 119
Circuito 51 – Circuito da operação de escrita de um bit. ...................................................................... 126
Circuito 52 – Circuito da operação leitura de um bit. ........................................................................... 126
Circuito 53 – Circuito da operação de leitura de um bit. ...................................................................... 127
Circuito 54 – Circuito da operação de incremento de um bit. .............................................................. 129
Circuito 55 – Circuito da operação de complemento de um bit. ........................................................... 130
Circuito 56 – Registo de um bit com as cinco operações base. ............................................................. 130
Circuito 57 – Registo de oito bits......................................................................................................... 131
Circuito 58 – A RAM de quatro elementos de um bit ........................................................................... 133
Circuito 59 – Enable da RAM. .............................................................................................................. 134
Circuito 60 – A primeira ALU com registo temporário, somador e operação unitária. .......................... 138
Circuito 61 – Implementação da FLAG zero com NOR de 8 entradas. ................................................... 150
Circuito 62 – Implementação da Paridade com XOR de 8 entradas. ..................................................... 151

15

16
AGRADECIMENTO
Agradecemos a todos os alunos que contribuíram com comentários, sugestões, exercícios e revisões de
gralhas, a saber:
Ana Margarida Tomé Gonçalves, 59769
Beatriz Antunes Monteiro de Sousa, 59924
Gonçalo Miguel Lanita Pereira, 65688
João Pedro Freixo Castro Ferreira, 60325
João Nuno Colaço Borges, 64087

17
INTRODUÇÃO
Este texto foi desenvolvido como material de apoio às disciplinas de SLI (sistemas lógicos I) e SLII (Sistemas
lógicos II).
Ao longo deste texto vamos apresentar os sistemas digitais e terminaremos a projectar um CPU didático
de oito bits (um byte).
UM SISTEMA
Existem centenas de definições formais para a palavra sistema. Tentemos uma.
Um sistema visa atingir um objectivo e é composto por um conjunto de partes que constituem o todo.
Um sistema possuí variáveis de entrada e de saída. Os dados recolhidos através das variáveis de entrada
são transformados em resultados disponibilizados variáveis de saída através de uma função de
transformação.
Um sistema pode incluir outros sistemas.
Os sistemas analógicos trabalham com sinais contínuos que variam ao longo do tempo. Estes sinais variam
num intervalo contínuo de tensão, corrente, pressão, etc.
Os sistemas digitais, apesar de também trabalharem com sinais contínuos, podem ser aproximados a
sistemas binários, ou seja, que só processam dois valores (tipicamente 0 e 1).
Figura 1 - Sinal analógico e sinal digital
Os sistemas digitais devido à natureza da sua construção são pouco exigentes com a qualidade dos sinais
elétricos. Na verdade, adaptam-se tão bem a sinais degradados que nos permitem fazer uma abstração
digital. As margens de segurança garantem o seu bom funcionamento em ambientes com muito ruído
eletrónico. Esta característica permite que ignoremos que operam sobre tensões e correntes analógicas.

18
Figura 2 - Níveis de tensão e valores lógicos
Alterações substanciais às entradas e nas saídas não influenciam o comportamento do sistema desde que
estejam dentro das margens de segurança. Pequenos erros nas entradas dos sistemas analógicos podem
induzem erros nas saídas.
SISTEMA BINÁRIO
O sistema digital mais simples é o sistema binário. O sistema binário só admite dois símbolos para cada
dígito. O símbolo 0, Baixo/LOW associad ao valor falso e o símbolo 1, Alto/High associado a verdade.
E claro está, podemos usar lógica booleana como suporte matemático para tudo o que construímos.
Esta representação numérica apesar de parecer redutora por comparação à base decimal é a base dos
computadores. Esta é a razões da afirmação de um computador ser uma máquina binária.
A VARIÁVEL BINÁRIA
Uma variável binária só pode ter dois valores, verdade ou falso. Como associamos o valor verdade à tensão
de +5 volts, um led acenderá sempre que a variável tiver o valor verdade, e estará apagado no caso
contrário.
Circuito 1 - variável binária
VERDADE E FALSO
Um – Verdade: associado a uma tensão superior a 3,5V (normalmente a 5V)

19
Zero – Falso: associado à tensão abaixo de 0,7V (normalmente a 0V)
O SIGNIFICADO DA VARIÁVEL BINÁRIA

Como ler uma variável binária é uma pergunta que se estende a: como ler um conjunto de variáveis
binárias. Na verdade, a pergunta mais ampla é:
Qual o significado de uma sequência de símbolos? Por exemplo, qual é o significado da sequência
01100101.
Se perguntarmos a qualquer pessoa, e assumindo que não se engana na posição dos zeros e uns
responderá: Um milhão cem mil cento e um, porque assumirá a base decimal que usamos diariamente.
Porém, no mundo digital o valor depende da codificação assumida, por exemplo, qual a base numérica,
ou a tabela de codificação. Em ASCII (American Standard Code for Information Interchange) corresponde
a letra “e”, e em hexadecimal a 065H.
Desta forma, a resposta à pergunta tem de ser outra pergunta, qual a codificação usada?
BASES NUMÉRICAS
NÚMEROS INTEIROS
Considere o número N escrito como aprendeu no primeiro ciclo, ou mesmo antes (base 10), ou seja, em
decimal. Ex. 567 = 500 + 60 + 7 = 7 + 60 +500
Este número pode ser escrito da forma 𝑎0 × 100 + 𝑎1 × 101 + 𝑎2 × 102 desde que garantido que 𝑎𝑖 =
0,1,2,3,4,5,6,7,8,9 ou seja, que ai pode tomar todos os valores entre 0 e o valor da base de numeração
menos um; no caso decimal temos 10-1=9.
567 = 7 × 100 + 6 × 101 + 5 × 102
No caso geral de uma base b, qualquer número N poderá ser descrito nessa base sob a forma
𝑛
𝑁 = ∑ 𝑎𝑖 × 𝑏 𝑖
𝑖=0
Em que 𝑎𝑖 = 0,1, … , (𝑏 − 1) e n depende da dimensão do número em causa.
As bases que mais nos interessam são a decimal, porque é a base usado pelos seres humanos, a base
binária (usada pelos processadores) e as bases octal e hexadecimal, que por serem múltiplas da base
binária permitem representações mais condensadas.
BASE BINÁRIA
𝑎𝑖 = 0,1
𝑏=2
A base binária suporta os sistemas digitais. Como já discutimos, tudo é representado de forma binária nos
sistemas de computação, sendo que é essencial dominar esta representação. Considere o número 𝑁 =

20
1 × 20 + 1 × 21 + 0 × 22 + 1 × 23 que na base 2 (binário) poderá ser escrito do seguinte modo N=1011

e cujo valor em decimal será 1 + 2 + 8 = 11.
TABELA DE EQUIVALÊNCIA BASE DECIMAL E BINÁRIA
5 bit 4 bit 3 bit 2 bit 1 bit

Decimal 16 8 4 2 1
00 0 0 0 0 0
01 0 0 0 0 1
02 0 0 0 1 0
03 0 0 0 1 1
04 0 0 1 0 0
05 0 0 1 0 1
06 0 0 1 1 0
07 0 0 1 1 1
08 0 1 0 0 0
09 0 1 0 0 1
10 0 1 0 1 0
11 0 1 0 1 1
12 0 1 1 0 0
13 0 1 1 0 1
14 0 1 1 1 0
15 0 1 1 1 1
16 1 0 0 0 0
Tabela 1 - Equivalência decimal-binário
BASE OCTAL
𝑎𝑖 = 0,1,3,4,5,6,7
𝑏=8
A base octal (8) é múltipla da base binária (2), desta forma podemos tirar partido de uma codificação mais
eficaz.
𝑎0 × 20 + 𝑎1 × 21 + 𝑎2 × 22 + 𝑎3 × 23 + 𝑎4 × 24 + 𝑎5 × 25 + ⋯ =
= (𝑎0 × 20 + 𝑎1 × 21 + 𝑎2 × 22 ) × (23 )0 + (𝑎3 × 20 + 𝑎4 × 21 + 𝑎5 × 22 ) × (23 )1 + ⋯ =
= (𝑎0 × 20 + 𝑎1 × 21 + 𝑎2 × 22 ) × 80 + (𝑎3 × 23 + 𝑎4 × 24 + 𝑎5 × 25 ) × 81 + ⋯
Exemplo:
(001011)2 =
= 1 × 20 + 1 × 21 + 0 × 22 + 1 × 23 + 0 × 24 + 0 × 25 =
= (1 × 20 + 1 × 21 + 0 × 22 ) × (23 )0 + (1 × 20 + 0 × 21 + 0 × 22 ) × (23 )1 =

21
= (011)2 × 80 + (001)2 × 81 =
= 3 × 80 + 1 × 81 = (13)8
=3+8=(11)10
O maior número que se pode representar com um só dígito na base octal é o número 7, o que está de
acordo com a regra anteriormente apresentada, 𝑎𝑖 = 0,1, … , (𝑏 − 1), que neste caso será 𝑎𝑖 = 0,1, … ,7
uma vez que a base é 8 (b=8).
Desta forma, qualquer número representado na base binária pode ser convertido na base octal
realizando agrupamentos de 3 dígitos. A agregação é realizada da direita para a esquerda, ou seja, dos
bits menos significativos para os mais significativos. No último agrupamento podem faltar dígitos para
obtermos um agrupamento de 3 e nesse caso são adicionados zeros à esquerda (que como sabem não
alteram o valor numérico).
BASE HEXADECIMAL
𝑎𝑖 = 0,1,3,4,5,6,7,8,9, 𝐴, 𝐵, 𝐶, 𝐷, 𝐸, 𝐹
𝑏 = 16
A base hexadecimal (16) é múltipla da base binária (2), podemos, à semelhança da base octal, tirar partido
de uma codificação mais compacta.
𝑎0 × 20 + 𝑎1 × 21 + 𝑎2 × 22 + 𝑎3 × 23 + 𝑎4 × 24 + 𝑎5 × 25 + ⋯
= (𝑎0 × 20 + 𝑎1 × 21 + 𝑎2 × 22 + 𝑎3 × 23 ) × (24 )0
+ (𝑎4 × 20 + 𝑎5 × 21 + 𝑎6 × 22 + 𝑎7 × 23 ) × (24 )1 =
= (𝑎0 × 2 + 𝑎1 × 21 + 𝑎2 × 22 + 𝑎3 × 23 ) × 160 + (𝑎4 × 24 + 𝑎5 × 25 + 𝑎6 × 26 + 𝑎7 × 27 ) × 161
0
Exemplo:
(001011)2 =
= 1 × 2 + 1 × 2 + 0 × 22 + 1 × 23 + 0 × 24 + 0 × 25 =
0 1
= (1 × 2 + 1 × 2 + 0 × 22 + 1 × 23 ) × (24 )0 + (0 × 20 + 0 × 21 + 0 × 22 + 0 × 23 ) × (24 )1 =
0 1
= (1011)2 × 160 + (0000)2 × 161 =

= B × 160 + 0 × 161 = (0B)16
=11+0=(11)10
O maior número que se pode representar com um só dígito na base hexadecimal é o número 15, o que
está de acordo com a regra anteriormente apresentada, 𝑎𝑖 = 0,1, … , (𝑏 − 1), que neste caso será 𝑎𝑖 =
0,1, … ,15 uma vez que a base é 16 (b=16).

22
Desta forma, qualquer número representado na base binária pode ser convertido na base hexadecimal
realizando agrupamentos de 4 dígitos. A agregação é realizada da direita para a esquerda, ou seja, dos
bits menos significativos para os mais significativos. No último agrupamento podem faltar dígitos para
obtermos um agrupamento de 4 e nesse caso são adicionados zeros à esquerda.
Como a base hexadecimal contém mais símbolos do que a base decimal recorremos às primeiras letras
do alfabeto para representar os dígitos superiores a 9. Resulta desta forma que passamos a ter números
que contêm letras!
TABELA DE EQUIVALÊNCIA DECIMAL, OCTAL, BINÁRIO E HEXADECIMAL
Decimal Binário Octal Hexadecimal

0 0000 0 0
1 0001 1 1
2 0010 2 2
3 0011 3 3
4 0100 4 4
5 0101 5 5
6 0110 6 6
7 0111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
Tabela 2 - Equivalência decimal, binário, octal e hexadecimal
CONVERSÃO DA BASE DECIMAL PARA OUTRA BASE

O modo de conversão da base decimal para uma qualquer base, consiste em dividir o valor decimal pelo
valor da sua nova base em que se pretende escrever o número, até obter um quociente inferior à base.
A título de exemplo usamos o método para encontrar a representação do número 11 na base octal, binária
e ternária.
Base 2:
11 DIV 2 = 5 RESTO=1
5 DIV 2 = 2 RESTO=1
2 DIV 2 = 1 RESTO=0
1 DIV 2 = 0 RESTO=1
=> 1110 = 10112
Base 3:
3 DIV 3 = 1 RESTO=0
1 DIV 3 = 0 RESTO=1
=> 1110 = 1023

23
Base 8:
=> 1110 = 138
De notar, que quando temos uma sequência de divisões para obter o número, o resultado pela
concatenação do último quociente obtido (aquele que é menor que a base) com os restos de todas as
divisões realizadas pela ordem inversa pela qual foram realizadas, sendo que o resto da primeira divisão
representa o dígito de maior peso e o quociente da última divisão representa o dígito de menor peso.
OS NÚMEROS FRACCIONÁRIOS
É necessário representar números fraccionários nos sistemas digitais. A sua representação segue a mesma
lógica dos números inteiros. À semelhança da base decimal usamos um somatório de potências do valor
da base, contudo, agora elevadas a números negativos. Estaremos assim a realizar somas de valores
fraccionários que, no seu total, nunca ultrapassam o valor um.
Seja o número N escrito na base 10:
𝑁10 = 0.123 = 1 × 10−1 + 2 × 10−2 + 3 × 10−3

= 0.1 + 0.02 + 0.003
Na base b, a parte fraccionária de um número N será escrito sob a forma:

𝑛
𝑁 = ∑ 𝑎𝑖 × 𝑏 −𝑖
𝑖=0
, em que, uma vez mais, 𝑎𝑖 = 0,1, … , (𝑏 − 1)
Desta forma resulta por exemplo que o número 𝑁2 = 0.101 é equivalente a

1 0 1
𝑁10 = 1 × 2−1 + 0 × 2−2 + 1 × 2−3 = + + = 0.5 + 0 + 0.125 = 0.62510
2 2 8
A conversão de um número decimal menor que um e maior que zero em binário, pode ser conseguida
utilizando o artificio de multiplicar (e dividir simultaneamente) de forma sucessiva o numero pela potência
de 2.
1
0.625 × 2 × = 1.250 × 2−1 = 1 × 2−1 + 0.250 × 2−1
2
1
0.250 × 2 × = 0.5 × 2−1
2
1
0.5 × 2 × = 1 × 2−1
2
portanto
0.625 = 1 × 2−1 + (0.5 × 2−1 )2−1 = 1 × 2−1 + (1 × 2−1 ) × 2−1 × 2−1 =
24
1 × 2−1 + 1 × 2−3 = (0.101)2
O resultado da parte fraccionária na base b=2 é então obtido utilizando os dígitos um e zero (parte inteira)
do resultado de cada multiplicação, que deverão ser colocados a seguir à vírgula (“0,”) pela ordem pela
qual foram obtidos, assim, o digito que resulta da primeira divisão será o que fica mais próximo da virgula
e o resultado da última o que fica mais afastado da virgula.
Por fim, o processo termina quando no resultado da multiplicação já não se obtém qualquer parte
fraccionária, ou quando entramos em ciclo; i.e. ficamos a repetir a mesma multiplicação (caso em que os
processos resultam numa dízima infinita por exemplo 0.4566666666666(6).
De um modo semelhante é possível obter qualquer número fraccionário representado na base 10 numa
base b multiplicando e dividindo sucessivamente.
Exemplo:
1 1
𝑁10 = 0.625 = 0.625 × 8 × = 5 × = 5 × 8−1
8 8
0.62510 = 0.58
REPRESENTAÇÃO – SISTEMAS NÚMERICOS
A representação de um número é um sistema posicional de dígitos. Um número de base b é representado

pela cadeia de dígitos:
𝑁𝑏 = (𝐴𝑛−1 𝐴𝑛−2 … 𝐴1 𝐴𝑜 . 𝐴−1 𝐴−2 … 𝐴−𝑚+1 𝐴−𝑚 )𝑏
em que 0 ≤ 𝐴𝑖 ≤ 𝑏 e onde o «.» é o ponto da base.
A cadeia de dígitos representa o número:

𝑛−1 𝑚
𝑁𝑏 = ∑ 𝐴𝑖 × 𝑏 𝑖 + ∑ 𝐴−𝑗 × 𝑏 −𝑗
𝑖=0 𝑗=1
inteiro . fraccional
EXERCÍCIOS
Converter para decimal os seguintes números binários
a) 101110
b) 110110100
c) 1110101.11
d) 100001.001
e) 1110000.1001
Converter para decimal os seguintes números

f) (12121)3
g) (4310)5
h) (4310)7

25
i) (1A8)12
Converter para binário, octal e hexadecimal os seguintes números decimais
j) 1213
k) 673.25
l) 1998
Preencher a tabela anexa, efectuando as conversões necessárias
base 2 base 8 base 10 base 16

11010111
225
2AC5
NÚMEROS NEGATIVOS
Até este momento todas as bases representam números positivos. Porém, a utilização de números
inteiros obriga a codificar também números negativos.
As representações que apresentamos têm em comum serem códigos de magnitude, ou seja reservam o
bit de maior peso para indicar o sinal. Nestes sistemas o bit a “0” indica um número positivo, e caso
contrário, o bit a “1”, indica um número negativo.
MÓDULO DE SINAL (OU SINAL-MAGNITUDE)

Esta aproximação é pouco útil para os sistemas digitais, mas é intuitiva para os leitores que conhecem
código binário. O bit de maior peso indica o sinal e os restantes bits o número em módulo. Este código é
simétrico, existem tantos positivos como negativos. Como inconveniente surgem dois zeros, o zero
positivo e o zero negativo.
Temos assim a seguinte faixa de representação:
(−2𝑁−1 + 1) ≤ 𝑋 ≤ (2𝑁−1 − 1)
A título de exemplo:
com 8 bits números na faixa: −127 ≤ 𝑋 ≤ 127
com 16 bits números na faixa: −32767 ≤ 𝑋 ≤ 32767
Os números são assim lidos como os números binários com a diferença que interpretamos o bit de maior
peso como o sinal do número.
A representação dos números 12 e -12 :
12: 00001100 devendo ser lido (0)0001100
-12: 10001100 devendo ser lido (1)0001100
COMPLEMENTO PARA 1 (C1) DE N BITS

26
Nesta representação o bit de maior peso continua a representar o sinal e os restantes bits o módulo.
Sempre que o bit de maior peso é “0” estamos uma vez mais na presença de um número positivo e os (N-
1) bits da direita representam o módulo em binário.
No caso do bit de maior peso ser negativo, os bits da direita representam o número complemento
(simétrico) do número que se obtém pela inversão de todos os bits. A obtenção do número original é
conseguida pela repetição da operação de inversão dos números.
A simetria do número regista a distância do número maior número possível de ser representado, o seja o
números com os bits todos a “1”.
Voltando ao exemplo anterior, 12 e -12 :
12: 00001100 devendo ser lido (0)0001100
-12: 11110011 devendo ser lido (1)0001100 (em que os bits de menor peso são invertidos para
os interpretarmos).
Continuamos a ter dois zeros e uma faixa simétrica contudo a sua utilização é mais simples em operações
matemáticas.
A faixa continua a ser −2𝑁−1 + 1 ≤ 𝑋 ≤ 2𝑁−1 − 1
O complemento de 1 (C1) de N bits é o complemento de base diminuído N (Diminished Radix Complement

of N)
(𝑟 𝑛 − 1) − 𝑁
Calculemos o C1 de 115, pela fórmula obtemos 𝑟 = 2, 𝑛 = 8, 𝑁 = (01110011)2
28 = 1000 0000 = 256
(repare que o número 256 não se consegue escrever com 8 bits, o maior é 255)
28 − 1 = 1000 0000 − 0000 0001 = 1111 1111
Podemos agora obter o código C1 pela subtracção de 115
Como o primeiro termo está fixo e tem sempre todos os bits a “1” pois é o maior número possível de ser
representado na base, neste exemplo 255, a subtração é sempre bit a bit e só tem duas possibilidades:
1-1=0 (inverte o bit do número)
1-0=1 (inverte o bit do número)
Ou seja, a representação em complemento para 1 de um número obtém-se pela inversão dos bits.

27
COMPLEMENTO PARA 2 (C2) DE N BITS

Nesta representação o bit de maior peso continua a representar o sinal e os restantes bits o módulo.
Sempre que o bit de maior peso é “0” estamos uma vez mais na presença de um número positivo e os (N-
1) bits da direita representam o módulo em binário.
No caso do bit de maior peso ser “1” estamos na presença de um número negativo, os bits da direita
representam o número complemento (simétrico) do número que se obtém pela inversão de todos os bits
e soma de “1”. A obtenção do número original é conseguida pela repetição da operação de inversão dos
números e soma de “1”.
A simetria neste caso regista a distância ao número 2𝑁 , o seja o total de números diferentes que podemos
representar com N bits.
Voltando ao exemplo anterior, 12 e -12 :
12: 00001100 devendo ser lido (0)0001100
-12: 11110100 devendo ser lido (1)0001100 (os bits de menor peso são invertidos e adicionados
de um para os interpretarmos).
Nesta representação só temos um zero, que é por definição da base positivo e par, e faixa é agora
assimétrica. A maior vantagem é que esta representação simplifica as operações matemáticas.
A faixa é agora −2𝑁−1 ≤ 𝑋 ≤ 2𝑁−1 − 1
O complemento de 2 (C2) de N bits é o complemento de base N (Radix Complement of N)
𝑟𝑛 − 𝑁
Que é código de complemento C1 adicionado de um:
𝐶1 + 1 = ((𝑟 𝑛 − 1) − 𝑁) + 1 = 𝑟 𝑛 − 𝑁
Logo a obtenção de um número em código C2 é obtida adicionando 1 à sua codificação em C1.
Temos duas regras práticas para obter os números em C2:
1) Invertemos todos os bits e somamos 1

2) Copiamos os bits a zero da direita até ao primeiro 1 (inclusive) e invertemos os restantes bits
(mais significativos).
LIMITES DE FAIXA
Só conseguimos representar números que estão dentro da faixa de representação de uma base. Porém,
não nos podemos esquecer que sempre que realizamos manipulações algébricas podemos obter
resultados que excedem o limite dos operandos.
Exemplos da faixa sem sinal:

28
Números decimais com três dígitos têm uma faixa 0 ≤ 𝑋 ≤ 103−1 − 1; 𝑖. 𝑒. 0 ≤ 𝑋 ≤ 999
Números binários com oito dígitos têm uma faixa 0 ≤ 𝑋 ≤ 28−1 − 1 = (1111 1111)2 = (255)10
A simples operação de soma pode ultrapassar os limites dos operados. A soma entre dois números
decimais com dois dígitos, se um dos operandos for o “99”, só não ultrapassa a faixa se o segundo
operando for zero. Nos restantes 98 casos a faixa dos operandos é ultrapassada. Claro que no caso da
multiplicação é muito mais fácil ultrapassar as faixas de resultado.
Nestes casos estamos na presença de overflows, ou seja, o resultado não cabe na representação
escolhida.
Os casos de overflow têm de ser tratados com muito atenção. No caso da soma veremos que o carry pode
ser utilizado para obter o resultado, contudo o caso da multiplicação é mais complicado.
ARITMÉTICA MODULAR E A SUBTRAÇÃO

Sendo mod a operação módulo que encontra o resto de uma divisão inteira. Exceder a faixa da base é
equivalente a utilizar aritmética modular, ou seja, é como se depois de realizarmos a operação intermédia
com todos os dígitos necessários aplicássemos o módulo para obtermos o resultado. Vulgarmente,
afirmamos que excedemos a base e “deu a volta”.
Esta característica intrínseca do limite das bases pode ser descrita da seguinte forma 𝐴 + 𝐵 =
(𝐴 + 𝐵) 𝑚𝑜𝑑 𝑁, 𝑁 = 𝑟 𝑛 sendo N o primeiro número que excede a base.
Ex1: 99+24=123 mod 100=23
Ex2: 1100 + 0111 = 10011 mod 10000 = 0011
O que se verifica para a soma, aplica-se para qualquer outra operação uma vez que o número de bits que
temos para representar o nosso resultado está determinado à partida. n bits de dados impõem 𝑚𝑜𝑑 𝑁,
𝑁 = 𝑟 𝑛 𝑜𝑢 𝑛𝑜 𝑐𝑎𝑠𝑜 𝑏𝑖𝑛á𝑟𝑖𝑜 2𝑛
Aplicando este princípio à subtração obtemos (𝐴 − 𝐵) 𝑚𝑜𝑑 𝑁 = (𝐴 + 𝑁 − 𝐵) 𝑚𝑜𝑑 𝑁, 𝑁 = 𝑟 𝑛 pois

𝑁 𝑚𝑜𝑑 𝑁 = 0.
Acontece que N-B é o código complemento para dois. Logo, a subtração de dois números binários B a A
(A-B) pode ser obtido pela soma de A com código complemento para dois de B.
Nota: Relembre C2 de B é 2𝑛 − 𝐵
Observe a representação das subtrações 3-2 e 2-3 com os números representados respeitando a sua
distância relativa.

29
Figura 3 – Subtração em código complementos de (3-2) e (2-3)
CÓDIGOS NÃO NUMÉRICOS
Os processadores necessitam de códigos não numéricos. Um código de base não numérica define uma
conversão entre sequências de bits e um conjunto de elementos. Tendo n dígitos binários (vulgo bits), um
código binário é um mapeamento entre os elementos de um conjunto de conceitos e cada uma das
sequências de bits.
Com o passar do tempo, ou por processos formais de normalização internacional, alguns códigos
adquirem o papel de normas internacionais.
CÓDIGO BINÁRIO DE SETE CORES

É o possível criar códigos muito simples para descrever um sistema de cores. Repare que nesta codificação
a sequência de bits “100” não tem cor atribuída:
Cor Código binário

Vermelho 000
Laranja 001
Amarelo 010
Verde 011
Azul 101
Indigo 110
Violeta 111
Tabela 3 – Código de sete cores
CÓDIGO DE CORES RGB

O código RGB é usado nos computadores para codificar cores. Este código faz uso de três cores diferentes
o Vermelho (R), o verde (G) e o azul (B). A cor é codificada num vector que contém três valores que variam
de [0,255]. Quanto maior o valor da cor maior será a sua influência na cor final.

30
Tabela 4 – Código RGB de codificação de cores
Os números representados na figura a seguir ao # são o valor das 3 componentes em hexadecimal (dois
dígitos por cor), pela ordem RGB.
Este código tem muitas características interessantes, ficam aqui as mais simples:
• o preto corresponde a ausência de intensidade em todas as cores,

• o branco à máxima intensidade em todas as cores,
• a gama de cinzento acontece sempre que todas as cores têm a mesma intensidade,
• transformar uma imagem a cores para “preto e branco” obtêm-se calculando o valor médio da
intensidade das três cores I=(R+G+B)/3 para cada pixel.
ASCII – CÓDIGO ALFANUMERICO DE CARACTERES

O significado de ASCII é American Standard Code for Information Interchange. Como o nome indica esta
norma foi criada para servir de suporte a trocas de informação.
Originalmente este código usava uma codificação de sete bits para representar caracteres. O ASCII de
sete bits contém:
• 94 caracteres gráficos visíveis

• 34 caracteres não visiveis.
Alguns caracteres não visiveis são comandos (e.g. BELL, ACK), outros caracteres de alinhamento de texto
(e.g. BS = Backspace, CR = carriage return)

31
Figura 4 – Tabela de ASCII
OS CIRCUITOS INTEGRADOS
OS CIRCUITOS INTEGRADOS E AS PORTAS LÓGICAS

As portas lógicas são disponibilizadas em circuitos integrados que são essencialmente implementados à
custa de díodos e transístores. Estamos habituados a observar estes componentes sempre que abrimos
um aparelho digital, ou pelo menos nos filmes.
Um circuito integrado (CI) disponibiliza um conjunto de portas lógicas.
Os CIs são classificados, de acordo com a sua capacidade, em:
SSI (small scale integration): de 1 a 20 portas lógicas – ANDs, Ors e NOTs;

32
MSI (medium scale integration): 20 a 200 portas lógicas – descodificadores, registos e

contadores;
LSI (large scale integration): 200 a 200.000 portas lógicas – memórias de capacidade reduzida e
PLDs (programmable logic devices) simples;
VLSI (very large scale integration): mais de 1 milhão de transístores – microprocessadores,

memórias e PLDs complexas.
Estes circuitos integrados apresentam um funcionamento genérico muito semelhantes apesar de terem
funções muito distintas conforme a sua categoria.
Figura 5 - Circuitos integrados
Os circuitos integrados, para funcionarem, têm de estar correctamente alimentados, com o pino VCC a +5
Volts e o GND a zero Volts. Lembre-se: sem estarem alimentados os integrados não funcionam.
Os restantes contactos dependem da função que implementam e da disposição das portas.
O PINOUT
O pinout descreve a disposição dos terminais dos integrados. A imagem seguinte ilustra um integrado DIP
(Dual In-line Pin package)
Figura 6 - Pinout dos circuitos integrados mais usuais
FANOUT
Os CI têm uma especificação técnica que deve ser analisada em detalhe antes da sua utilização em
projectos. Há, contudo, uma característica muito importante que muitas vezes surpreende quem têm
pouca experiência na sua utilização: o parâmetro de Fan-out. O Fan-out de um CI define a capacidade de

33
impor valores à saída para outro CI. Na verdade, limita o número de portas lógicas que podem ser ligadas
a uma saída de um CI. Esta limitação está relacionada com a capacidade de fornecer corrente da porta
lógica para garantir os valores lógicos necessários a jusante.
Circuito 2 - Representação de fan-out
OS TRÊS ESTADOS (TRISTATE)

Na lógica booleana só existem dois valores possíveis, verdadeiro ou falso.
Contudo, nos implementações digitais práticas necessitamos de um terceiro valor que corresponde à não
existência de valor. É apelidado de alta impedância e não corresponde a nenhuma diferença de potencial
de tensão. Equivale a não ter nada ligado.
Circuito 3 - portas tri-state
BUS DE DADOS
As portas tristate permitem ligar várias saídas a um mesmo fio. Surge assim a noção de BUS que consiste
num fio que é partilhado por vários componentes e que permite ligações de M para N.

34
Circuito 4 - A noção de bus e tri-states
ACTIVE HIGH E ACTIVE LOW

Associamos a activação ao valor lógico UM e desactivação ao valor lógico ZERO. Esta lógica é chamada
active high. Contudo, nada nos impede definir que um dispositivo é activado na presença do valor ZERO.
Neste caso, é apelidado de active low.
DUALIDADE
Alguns teoremas podem ser apresentados aos pares. A versão primária dum teorema pode ser obtida da
versão secundária trocando “0” com “1” e “·” com “+”.
Princípio da dualidade: qualquer teorema ou identidade da Álgebra de Boole continua a ser verdadeiro
quando se trocam todos os “0” com “1” e todos os “·” com “+”.
PLACA DE MONTAGEM
A placa de montagem permite construir os circuitos lógicos com os circuitos integrados. Este é a típica
placa de montagem e o esquema das interligações existentes entre os vários orifícios.
Circuito 5 - A placa de montagem (breadboard)
AS FUNÇÕES DIGITAIS

35
TABELAS DE VERDADE
As tabelas de verdade são um instrumento muito útil para descrever funções que dependem de variáveis.
Repare que a tabela de verdade apresenta todas as combinações possíveis para as duas variáveis. A
primeira linha identifica o nome das variáveis e das funções. Neste caso temos duas variáveis de entrada
(A e B) e uma função de saída (F).
B A F
0 0 0
0 1 1
1 0 1
1 1 1
Tabela 5 - Tabela de verdade para duas entradas e uma saída
As variáveis são geralmente denotadas pelas letras A, B, C, D, E ou X, Y, Z e as funções são representadas

por letras pelas letras F, G, H. Esta tabela implementa a função booleana disjunção (OR).
TABELAS DE VERDADE E DIAGRAMAS DE VENN

A tabela de verdade e o diagrama de Venn para três variáveis.
C B A F
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
Figura 7 - Diagrama de Venn e tabela de verdade para três variáveis
FUNÇÕES COM UMA VARIÁVEL

Só existem duas funções possíveis quando usamos uma única variável binária, a função identidade e a
negação.
FUNÇÃO IDENTIDADE (74LS07)

A função identidade apresenta à saída o valor da entrada. Este é o nosso primeiro sistema digital tão
simples como útil. Quase todos os sistemas acendem uma luz de presença quando estão ligados.

36
A F
0 0
1 1
Tabela 6 - Função identidade
Circuito 6 - Porta lógica identidade
O diagrama de Venn da porta é o mais simples de todos e corresponde a sinalizar as zonas em que a
variável é verdadeira (apresentadas na figura seguinte a azul escuro).
Figura 8 - Diagrama de Venn da função identidade
A sua implementação em tecnologia TTL pode ser realizada usando a porta identidade presente no
circuito integrado 74LS07. O símbolo da porta lógica é o triangulo com um vértice sinalizando a saída.
Circuito 7 – Figura 9 – Layout do circuito integrado do 74LS07

37
FUNÇÃO INVERSORA (74LS04)

Esta função visa inverter o valor da variável de entrada. “Verdadeiro” vira “falso”, e “falso” vira
”verdadeiro”. Esta função é muitas vezes apelidada de negação ou através da operação lógica booleana,
função NOT.
A F
0 1
1 0
Tabela 7 - Função inversora
Circuito 8 – Porta lógica inversora
Repare que a saída F está invertida tendo por base a variável de entrada, o A. O símbolo é o triangulo
seguido de um círculo.
Figura 10 - Diagrama de Venn da função inversora
Observe o diagrama de Venn e compare com a porta identidade. Chegará à conclusão que são o
“negativo” um do outro.
O circuito integrado TTL que disponibiliza as portas NOT tem a referência 74LS04 e cada circuito integrado
contém 6 portas.

38
Figura 11 – Layout do circuito integrado do 74LS04
FUNÇÕES COM DUAS VARIÁVEIS

Vamos agora ver as operações básicas que podemos implementar com duas variáveis binárias
A FUNÇÃO DISJUNÇÃO OU SOMA BOOLEANO - OR (74LS32)

A ou B A or B A˅B AᴜB A+B
A função disjunção ou produto booleano (OR) assume o valor verdade sempre que uma das variáveis é
verdadeira. Desta forma, só apresenta o valor falso quando as duas variáveis são falsas.
B A F
0 0 0
0 1 1
1 0 1
1 1 1
Tabela 8 - Função da porta lógica disjunção de duas variáveis
Circuito 9 - Porta lógica OR
A representação em diagrama de Venn da função disjunção (OR) apresenta o valor verdade na reunião
das zonas que representam as variáveis a verdade (zonas assinaladas a azul e verde na figura seguinte).

39
Figura 12 - Diagrama de Venn da função disjunção de duas variáveis
O circuito integrado TTL que disponibiliza as portas OR tem a referência 74LS32. Cada circuito integrado
contém 4 portas lógicas OR independentes com duas entradas e uma saída.
A FUNÇÃO CONJUNÇÃO - AND (74LS08)

AeB A AND B AᴧB AႶB A.B
A função conjunção ou multiplicação booleana (AND) assume o valor verdade somente quando ambas as
variáveis são verdadeiras. Desta forma, as restantes combinações de variáveis são falsas.
B A F
0 0 0
0 1 0
1 0 0
1 1 1
Tabela 9 - Função da porta lógica conjunção de duas variáveis
Circuito 10 - Porta lógica AND

40
Tabela 10 – Diagrama temporal de uma conjunção de duas variáveis
A representação em diagrama de Venn da função conjunção (AND) apresenta o valor verdade na

intercepção das duas variáveis com o valor verdade (a zona mais escura da imagem seguinte).
Figura 14 - Diagrama de Venn da função conjunção de duas variáveis
O circuito integrado TTL que disponibiliza as portas AND tem a referência 74LS08. Cada circuito integrado
contém 4 portas lógicas AND independentes com duas entradas e uma saída.

41
A FUNÇÃO XOR (74LS86)

A função disjunção exclusiva (exclusive-or – XOR) assume o valor verdade quando um número ímpar de
variáveis forem verdadeiras. As restantes combinações de variáveis são falsas.
B A F
0 0 0
0 1 1
1 0 1
1 1 0
Tabela 11 - Função da porta lógica disjunção exclusiva de duas variáveis
Circuito 11 - Porta lógica XOR
O símbolo das expressões lógicas XOR é o da soma dentro de um círculo.
Corresponde à expressão algébrica 𝐵̅ . 𝐴 + 𝐵. 𝐴̅
Figura 16 - Diagrama de Venn da função conjunção exclusivo de duas variáveis
O circuito integrado TTL que disponibiliza as portas XOR tem a referência 74LS86. Cada circuito integrado
contém 4 portas lógicas XOR independentes com duas entradas e uma saída.

42
PORTAS UNIVERSAIS
As portas NAND e NOR são muitas vezes apelidadas por portas lógicas universais porque podem ser
utilizadas para reproduzir todas as funções booleanas.
Esta propriedade é muito interessante pois, no limite, permite reduzir a nossa necessidade de armazém
a um tipo único de porta.
O NAND
O NAND é a negação da conjunção.
B A F
0 0 1
0 1 1
1 0 1
1 1 0
Tabela 12 - Função da porta lógica NAND de duas variáveis
O símbolo das expressões lógicas NAND é o símbolo do AND seguido de uma circunferência.
Figura 18 – porta lógica NAND
Corresponde à expressão algébrica ̅̅̅̅̅

𝐴. 𝐵
Figura 19 - Diagrama de Venn da função NAND de duas variáveis
É possível a implementação das portas lógicas principais só com recurso a portas NAND.

43
Circuito 12 - Implementação das portas lógicas principais com NANDs
É assim possível representar qualquer função booleana usando somente portas lógicas NANDS.
O NOR
O NOR é a negação da disjunção.
B A F
0 0 1
0 1 0
1 0 0
1 1 0
Tabela 13 - Função da porta lógica NOR de duas variáveis
O símbolo das expressões lógicas NOR é o símbolo do OR seguido de uma circunferência.
Figura 20 – porta lógica NOR
Implementação das portas lógicas principais com NORs.

44
Circuito 13 - Implementação das portas lógicas principais com NORs

45
PORTAS LÓGICAS (RESUMO)

Um resumo sobre as portas lógicas:
Figura 21 – Funções lógicas principais (símbolo, tabela de verdade e expressão booleana)
EXERCÍCIOS
1. Obtenha o circuito com portas NAND de duas entradas para as seguintes funções.
𝐹1(𝐶, 𝐵, 𝐴) = 𝐶̅ 𝐵̅ 𝐴̅ + 𝐶̅ 𝐵𝐴̅ + 𝐶̅ 𝐵𝐴 + 𝐶𝐵𝐴
̅ 𝐶̅ 𝐵̅ 𝐴̅ + 𝐷
𝐹2(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷 ̅ 𝐶̅ 𝐵𝐴̅ + 𝐷𝐶̅ 𝐵̅ 𝐴̅ + 𝐷𝐶̅ 𝐵𝐴̅ + 𝐷𝐶𝐵𝐴̅ + 𝐷𝐶𝐵𝐴

46
2. Obtenha o circuito das mesmas funções agora com portas NOR de duas entradas.
̅ 𝐶̅ 𝐵̅ 𝐴̅ + 𝐷
𝐹2(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷 ̅ 𝐶̅ 𝐵𝐴̅ + 𝐷𝐶̅ 𝐵̅ 𝐴̅ + 𝐷𝐶̅ 𝐵𝐴̅ + 𝐷𝐶𝐵𝐴̅ + 𝐷𝐶𝐵𝐴
RESOLUÇÕES
1. Obtenha o circuito com portas NAND de duas entradas para as seguintes funções.

= C̅𝐴̅(𝐵̅ + 𝐵) + 𝐵𝐴(𝐶̅ + 𝐶) =
= C̅. 𝐴̅. 1 + 𝐵. 𝐴. 1 = C̅. 𝐴̅ + 𝐵. 𝐴

̅̅̅̅̅̅̅̅̅̅̅̅̅̅
= C̅. 𝐴̅ + 𝐵. 𝐴
̅̅̅̅̅̅̅̅̅̅̅
̅̅̅̅̅
̅ . 𝐴̅. ̅̅̅̅̅
=C 𝐵. 𝐴
A que corresponde o esquema seguinte implementado com NANDS
̅𝑩
Figura 22 – Implementação de 𝑭𝟏(𝑪, 𝑩, 𝑨) = 𝑪 ̅𝑨
̅+𝑪
̅ 𝑩𝑨
̅+𝑪
̅ 𝑩𝑨 + 𝑪𝑩𝑨 só com portas NAND
Vejamos o caso da função F2
𝐹2(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷 ̅ 𝐶̅ 𝐵̅ 𝐴̅ + 𝐷
̅ 𝐶̅ 𝐵𝐴̅ + 𝐷𝐶̅ 𝐵̅ 𝐴̅ + 𝐷𝐶̅ 𝐵𝐴̅ + 𝐷𝐶𝐵𝐴̅ + 𝐷𝐶𝐵𝐴 =
=𝐷̅ 𝐶̅ 𝐴̅(𝐵̅ + 𝐵) + 𝐷𝐶̅ 𝐴̅(𝐵̅ + 𝐵) + 𝐷𝐶𝐵(𝐴 ̅̅̅ + 𝐴) =
̅ ̅ ̅ ̅ ̅
= 𝐷𝐶 𝐴 + 𝐷𝐶 𝐴 + 𝐷𝐶𝐵 = ̅
(𝐷 ̅ ̅
+ 𝐷)𝐶 𝐴 + 𝐷𝐶𝐵 =
̅ ̅ ̅̅̅̅̅̅̅̅̅̅̅̅̅
̅ ̅ ̅̅̅̅̅̅̅̅̅̅̅
̅̅̅̅
̅ 𝐴̅. 𝐷𝐶𝐵
̅̅̅̅̅̅
= 𝐶 𝐴 + 𝐷𝐶𝐵 = 𝐶 𝐴 + 𝐷𝐶𝐵 = 𝐶

47
̅𝑪
Figura 23 – Implementação de 𝑭𝟐(𝑫, 𝑪, 𝑩, 𝑨) = 𝑫 ̅𝑩
̅𝑨̅+𝑫
̅𝑪̅ 𝑩𝑨
̅ + 𝑫𝑪
̅𝑩̅𝑨
̅ + 𝑫𝑪
̅ 𝑩𝑨
̅ + 𝑫𝑪𝑩𝑨
̅ + 𝑫𝑪𝑩𝑨 só com portas NAND
2. E agora com portas NOR.
A função F1
𝐹1(𝐶, 𝐵, 𝐴) = 𝐶̅ 𝐵̅ 𝐴̅ + 𝐶̅ 𝐵𝐴̅ + 𝐶̅ 𝐵𝐴 + 𝐶𝐵𝐴 = C̅. 𝐴̅ + 𝐵. 𝐴

= ̅̅̅̅̅̅̅̅̅̅̅̅̅̅
C̅. 𝐴̅ + 𝐵. 𝐴
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
= ̿̿̿̿̿̿̿ ̿̿̿̿̿̿̿̿
(C̅. 𝐴̅) + (𝐵. 𝐴)
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
̅̅̅̅̅̅̅̅ ̅̅̅̅̅̅̅̅
=𝐶 +𝐴+𝐵 +𝐴
Vejamos agora o caso da função F2
𝐹2(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷 ̅ 𝐶̅ 𝐵̅ 𝐴̅ + 𝐷̅ 𝐶̅ 𝐵𝐴̅ + 𝐷𝐶̅ 𝐵̅ 𝐴̅ + 𝐷𝐶̅ 𝐵𝐴̅ + 𝐷𝐶𝐵𝐴̅ + 𝐷𝐶𝐵𝐴 = 𝐶̅ 𝐴̅ + 𝐷𝐶𝐵

=𝐶̿̿̿̿
̅ 𝐴̅ + 𝐷𝐶
̿̿̿̿ 𝐵 = 𝐶 ̿̿̿̿ ̿̿̿̿ 𝐵 = ̿̿̿̿̿̿̿̿
̅ 𝐴̅ + 𝐷𝐶 𝐶̅ + 𝐴̅ + ̅̅̅̅̅̅̅̅̅̅
(𝐷̅ + 𝐶̅ )𝐵
̿̿̿̿̿̿̿̿̿̿̿̿̿
= ̿̿̿̿̿̿̿̿
𝐶̅ + 𝐴̅ + ̅̅̅̅̅̅̅̅̅̅
(𝐷̅ + 𝐶̅ ). 𝐵
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
̅̅̅̅̅̅̅̅̅̅̅
= ̿̿̿̿̿̿̿̿
𝐶̅ + 𝐴̅ + ̅̅̅̅̅̅̅̅̅̅
(𝐷̅ + 𝐶̅ ) + 𝐵̅
̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿̿
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
̅̅̅̅̅̅̅̅̅̅̅
= ̿̿̿̿̿̿̿̿
𝐶̅ + 𝐴̅ + ̅̅̅̅̅̅̅̅̅̅
(𝐷̅ + 𝐶̅ ) + 𝐵̅

48
IMPLEMENTAÇÃO SIMPLIFICADA DE PORTAS

Para quem tem curiosidade aqui tem implementações simplificadas das portas lógicas AND, OR, NOT e
NAND à custa de resistências, díodos e transístores.
Circuito 14 – Implementação simplificada da porta lógica AND
Circuito 15 – Implementação simplificada da porta lógica OR
Circuito 16 – Implementação simplificada da porta lógica NOT
Circuito 17 – Implementação simplificada da porta lógica NAND

49
EXPRESSÕES LÓGICAS
Como na álgebra comum é possível combinar operações construindo expressões lógicas. O resultado de
uma expressão lógica é calculado aplicando as operações lógicas respeitando as precedências algébricas
(isto é, as conjunções – AND – têm precedência sobre as disjunções – OR –). Os parênteses são usados
para indicar a ordem das operações ou alterar precedências.
As expressões lógicas são compostas por constantes, variáveis, operações e parênteses.
Analise com atenção o nosso primeiro exemplo:
̅ + (0 . 1) = 0 + (0 . 1) = 0 + 0 = 0
1
E agora com variáveis:
𝐴̅ . 𝐵 + 𝐴. 𝐵̅
EXERCÍCIO
Calcule o valor da expressão para as quatro combinações possíveis das variáveis A e B na expressão
𝐴̅ . 𝐵 + 𝐴. 𝐵̅ .
PROPRIEDADES DA ÁLGEBRA BOOLEANA

Como na álgebra comum é possível definir propriedades que nos permitem a manipulação das expressões
com vista a obter representações mais uteis. Normalmente expressões mais simplificadas, mas nem
sempre, como veremos.
A conjunção e a disjunção são operações duais, i.e. tem propriedades semelhantes nas operações
complementares e invertendo as constantes.
Na prática partindo de uma propriedade obtemos a sua expressão dual trocando as disjunções por
conjunções e os zeros por um, e vice-versa.
Apresentaremos todas as propriedades em dual.
ELEMENTO NEUTRO
𝐴+0 = 𝐴
𝐴×1 =𝐴
O zero (0) é o elemento neutro da disjunção e o um (1) é o elemento neutro da conjunção.
ELEMENTO ABSORVENTE
𝐴+1 = 1
𝐴×0 =0

50
O um (1) é o elemento absorvente da disjunção e o zero (0) é o elemento absorvente da conjunção.
IDEMPOTÊNCIA
Uma operação diz-se com propriedade de idempotência caso possa ser aplicadas diversas vezes sem que
o valor do resultado se altere após a aplicação inicial.
𝐴+𝐴=𝐴
𝐴×𝐴 =𝐴
COMPLEMENTO
𝐴 + 𝐴̅ = 1
𝐴 × 𝐴̅ = 0
INVOLUÇÃO OU DUPLA NEGAÇÃO
𝐴̿ = 𝐴
COMUTATIVA
𝐴+𝐵 = 𝐵+𝐴
𝐴×𝐵 =𝐵×𝐴
ASSOCIATIVA
(𝐴 + 𝐵) + 𝐶 = 𝐴 + (𝐵 + 𝐶)
(𝐴 × 𝐵) × 𝐶 = 𝐴 × (𝐵 × 𝐶)
DISTRIBUTIVA
𝐴 × (𝐵 + 𝐶) = (𝐴 × 𝐵) + (𝐴 × 𝐶)
𝐴 + (𝐵 × 𝐶) = (𝐴 + 𝐵) × (𝐴 + 𝐶)
A última propriedade não é válida para decimal.
LEIS DE MORGAN
As leis de Morgan são uteis na simplificação de expressões que envolvem negações.
̅̅̅̅̅̅̅̅
𝐴 + 𝐵 = 𝐴̅ × 𝐵̅
̅̅̅̅̅̅̅̅
𝐴 × 𝐵 = 𝐴̅ + 𝐵̅
Que pode ser generalizada para:
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
𝐴 + 𝐵 + 𝐶 + ⋯ = 𝐴̅ × 𝐵̅ × 𝐶̅ × …
̅
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
𝐴 × 𝐵 × 𝐶 × … = 𝐴̅ + 𝐵̅ + 𝐶̅ + …
̅

51
TEOREMAS
Alguns teoremas úteis.
TEOREMA DA ABSORÇÃO
𝐴+𝐴×𝐵 =𝐴
A demonstração do teorema de absorção não é difícil, contudo é necessário saber começar. Aqui fica a
demonstração:
𝐴+𝐴×𝐵 =
(𝐴 × 1) + 𝐴 × 𝐵 =
𝐴 × (1 + 𝐵) =
𝐴×1=
𝐴
TEOREMA DO CONSENSO
𝐴𝐵 + 𝐴̅𝐶 + 𝐵𝐶 = 𝐴𝐵 + 𝐴̅𝐶
A demonstração
𝐴𝐵 + 𝐴̅𝐶 + 𝐵𝐶 =
𝐴𝐵 + 𝐴̅𝐶 + 1. 𝐵𝐶 =
𝐴𝐵 + 𝐴̅𝐶 + (𝐴 + 𝐴̅). 𝐵𝐶 =
𝐴𝐵 + 𝐴̅𝐶 + 𝐴𝐵𝐶 + 𝐴̅𝐵𝐶 =
𝐴𝐵 + 𝐴𝐵𝐶 + 𝐴̅𝐶 + 𝐴̅𝐶𝐵 =
𝐴𝐵(1 + 𝐶) + 𝐴̅𝐶 (1 + 𝐵) =
𝐴𝐵 + 𝐴̅𝐶
MAIS TEOREMAS ÚTEIS
Minimização 𝐴𝐵 + 𝐴̅𝐵 = 𝐵 (𝐴 + 𝐵)(𝐴̅ + 𝐵) = 𝐵

Absorção 𝐴 + 𝐴𝐵 = 𝐴 𝐴(𝐴 + 𝐵) = 𝐵
Simplificação 𝐴 + 𝐴̅𝐵 = 𝐴 + 𝐵 𝐴(𝐴̅ + 𝐵) = 𝐴. 𝐵
Tabela 14 – Teoremas úteis
O DESENHO DE CIRCUITOS
O desenho de circuitos implica conhecimentos dos símbolos booleanos e das suas respectivas portas
lógicas. O circuito lógico uma vez montado executará a função teórica.

52
O método para resolução passa por desenhar todas as variáveis presentes na expressão assim como todas
as portas lógicas presentes na expressão. Partindo das variáveis desenham-se as portas lógicas
construindo a expressão lógica passo a passo. É essencial respeitar as prioridades dos ANDs sobre os ORs
e claro respeitar os parênteses. Devemos assim começar sempre pelos parêntices, caso existam, seguidos
pelos ANDs e finalmente pelos ORs.
Para exemplificar, será obtido o circuito que executa a expressão 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = (𝐷 + 𝐵). 𝐶. (𝐵 + 𝐴).
Para o primeiro parêntese tem-se uma soma booleana A+B, logo o circuito que o executa será uma porta
OR. Para o segundo, tem-se outra soma booleana B+D, logo o circuito será uma porta OR. Posteriormente
tem-se a multiplicação booleana de dois parênteses juntamente com a variável C, sendo o circuito que
executa esta multiplicação booleana uma porta AND. Para finalizar, unem-se as respectivas ligações
obtendo o circuito completo.
Circuito 18 – Desenho do circuito 𝑭(𝑫, 𝑪, 𝑩, 𝑨) = (𝑫 + 𝑩). 𝑪. (𝑩 + 𝑨)
OBTER EXPRESSÕES A PARTIR DE CIRCUITOS

Por vezes é necessário recuperar as expressões a partir dos circuitos lógico. A aproximação mais simples
é começar a recuperar a expressão das entradas para as saídas.
Exemplo:
Circuito 19 – Expressão booleana a partir do circuito lógico.
EXERCÍCIO
Desenhe os circuitos lógicos das seguintes expressões:
1. 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
̅̅̅̅̅
(𝐵. 𝐴) + (𝐷.̅̅̅̅̅
𝐶)

53
2. 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = (𝐶 + 𝐵̅ + 𝐴). ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅

(𝐷̅ + 𝐶 + 𝐴)
3. 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = (𝐵 . (𝐶 + 𝐴). 𝐶. ̅̅̅̅̅̅̅̅̅̅
̅ (𝐵 + 𝐴)
4. 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = (𝐶. ̅̅̅̅̅̅̅̅̅̅ ̅̅̅̅̅
(𝐴 + 𝐵)+(𝐷. 𝐵 . ((𝐷. 𝐵) + 𝐴̅)))
Prove as equivalências usando tabelas de verdade e manipulação algébrica:
5. ̅B
A ̅ + AB + A ̅B = A ̅+B
6. A ̅̅̅̅̅̅̅̅̅̅̅̅̅̅
̅ + A . (A
̅B + B ̅C) = A ̅ + B + C̅
7. ̅ ̅ ̅ ̅ ̅
BA + CB + CA = CA + B ̅ ̅ ̅A
8. (B + A)(C + A ̅) = CA + A ̅B
Construa a tabela de verdade e desenhe o circuito lógico para as seguintes expressões:
9. A + (A . B)
10. A . (A + B)
11. (A + B) (A + C)
12. AB + A(B ̅ + C) + B(B + C)
Simplifique usando as leis de Morgan e desenhe os circuitos lógicos para os dois circuitos.
̅̅̅̅̅̅ + (E
13. CBA ̅̅̅̅̅̅̅
+D̅) = E ̅D + C̅ + B
̅+A ̅
̅̅̅̅̅̅̅̅̅̅̅̅
14. C(B + A) = C̅ + B ̅. A
̅
̅̅̅̅
15. C + B + A + (DE) = ̅
̅̅̅̅̅̅̅̅̅̅̅̅̅ ̅ E + D + C̅. B
̅. A
̅
SIMPLIFICAÇÃO DE EXPRESSÕES
Os sistemas digitais são implementados através de portas lógicas. Quanto mais portas lógicas uma
expressão necessitar, mais circuitos integrados serão necessários e como consequência maior será o custo
do sistema. Quando se repete um sistema milhões de vezes qualquer pequena economia pode
representar muito dinheiro.
A simplicidade compensa e o esforço de procurar a expressão com menor número de termos é um

exercício essencial.
A simplificação de funções realiza-se através das propriedades e dos teoremas que estivemos a discutir
até agora.
Identificaremos o mecanismo de simplificação para SDP (Somas de Produtos) e PDS (Produtos de Somas)
minimais.
Assumindo que todas as portas lógicas estão disponíveis o objectivo de quem projecta é obter o circuito
mais simplificado.
EXEMPLOS DE SIMPLIFICAÇÕES

54
1. Simplifique a seguinte expressão e represente os dois circuitos lógicos.
(𝐶 + 𝐵) 𝐴 + 𝐵 (𝐵 + 𝐶) + 𝐵𝐴
Como não há nenhuma propriedade que se possa aplicar de imediato é necessário começar a manipular
a expressão.
aplicando a lei distributiva:
𝐶𝐴 + 𝐵𝐴 + 𝐵𝐵 + 𝐶𝐵 + 𝐵𝐴
aplicando a regra BB=B:
𝐶𝐴 + 𝐵𝐴 + 𝐵 + 𝐶𝐵 + 𝐵𝐴
aplicando a regra BA+BA=BA:
𝐶𝐴 + 𝐵𝐴 + 𝐵 + 𝐶𝐵
aplicando a regra B+BA=B aos dois últimos termos:
𝐶𝐴 + 𝐵
Esta é a expressão mais simplificada possível.
Em seguida apresentamos o desenho dos dois circuitos lógicos. Repare que apesar das diferenças de
complexidade os dois realizam a mesma função.
Circuito 20 – Dois circuitos a mesma função.
Conforme for adquirindo experiência na aplicação das regras e leis booleanas começará a realizar diversos
passos de uma vez. Quanto mais praticar maior será a sua capacidade.
Simplifique a seguinte expressão e represente os dois circuitos lógicos.
̅ A(C + DB) + B̅ A
C[B ̅]
aplique a lei distributiva
̅AC + B
C[B ̅ADB + B
̅A̅]
̅. B = 0
aplique a regra B
̅AC + A. 0. D + B
C[B ̅A̅]

55
aplique o elemento absorvente da multiplicação

C[B̅AC + B
̅A̅]
aplique a lei distributiva
̅AC + C B
CB ̅A̅
aplique a regra C.C=C
̅A + C B
CB ̅A̅
coloque em evidência
̅ (A + A
CB ̅)
̅=1
Aplique a regra A + A
̅ (1)
CB
Aplique a regra A.1=A
̅
CB
Obtemos assim a expressão lógica mais simplificada.
FUNÇÕES BOOLEANAS
Uma função booleana pode ser representada por equações booleanas, tabelas de verdade ou diagramas
lógicos. A mesma função tem várias representações booleanas e diagramas lógicos. Umas melhores que
outras. Contudo, só existe uma tabela de verdade. As tabelas de verdade são únicas para cada função.
𝐹(𝐶, 𝐵, 𝐴) = 𝐶 + 𝐵̅ 𝐴
C B A 𝐹(𝐶, 𝐵, 𝐴) = 𝐶 + 𝐵̅ 𝐴
0 0 0 0
0 0 1 1
0 1 0 0
0 1 1 0
1 0 0 1
1 0 1 1
1 1 0 1
1 1 1 1
̅𝑨
Tabela 15 – Tabela de verdade da função 𝑭(𝑪, 𝑩, 𝑨) = 𝑪 + 𝑩
̅𝑨
Circuito 21 – O circuito lógico da função 𝑭(𝑪, 𝑩, 𝑨) = 𝑪 + 𝑩
EXERCÍCIOS
Construa as tabelas de verdade para as seguintes expressões:
1. 𝐹(𝐶, 𝐵, 𝐴) = 𝐶. (𝐵 + 𝐴)

56
2. 𝐺(𝐶, 𝐵, 𝐴) = 𝐶. 𝐵 + 𝐶 . 𝐴
3. Compare as tabelas F(C,B,A) e G(C,B,A)
Simplifique a função e construa as tabelas de verdade:
4. 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷𝐶̅ + 𝐷𝐵̅ 𝐶 + 𝐷𝐵𝑌 + 𝐷𝐵𝐴̅
5. Considere que tem dois pontos P1(X1,Y1) e P2(X2,Y2) no espaço cartesiano. Os pontos são
definidos pelas variáveis X1, Y1, X2 e Y2 que só admitem o valor lógico ‘0’ e ‘1’.
A função booleana F(X1,Y1,X2,Y2) assume o valor lógico ‘1’ sempre que a distância euclidiana
entre os pontos P1 e P2 seja maior do que uma unidade; e ‘0’ restantes casos.
FORMA CANÓNICA
A forma canónica é útil para especificar as funções booleanas porque tem uma correspondência com as
tabelas de verdade e permite comparações por igualdade.
Existem duas formas canónicas: a SDP (soma de produtos) – soma de mintermos- e PDS (produtos de
somas) – produtos de maxtermos.
Quer nos mintermos, quer nos maxtermos, todas as variáveis têm de estar presentes e respeitar a ordem
pela qual surgem na tabela de verdade.
OS MINTERMOS
Os mintermos são termos de conjunção que incluem todas as variáveis, sendo que estas estão presentes
na sua forma natural ou em complemento. Desta forma em cada termo encontraremos todas as variáveis
na sua forma natural (e.g. 𝐴) ou em complemento (e.g. 𝐴̅).
Existem 2𝑛 mintermos possíveis para n variáveis. A título de exemplo para duas variáveis temos assim
quatro mintermos (22 ) ,a saber:
Ambas em complemento 𝐵̅ . 𝐴̅ Posição 0 da tabela de verdade

A natural e B em complemento 𝐵. 𝐴 Posição 1 da tabela de verdade
A em complemento e B natural 𝐵. 𝐴̅ Posição 2 da tabela de verdade
Ambas naturais 𝐵. 𝐴 Posição 3 da tabela de verdade
Tabela 16 – Mintermos para as variáveis B e A
OS MAXTERMOS
Em dual, com os mintermos, os maxtermos são termos de disjunção que incluem todas as variáveis, sendo
que estas estão presentes na sua forma natural ou em complemento.
Uma vez mais, em cada termo encontraremos todas as variáveis na sua forma natural (e.g. 𝐴) ou em
complemento (e.g. 𝐴̅).

57
Existem 2𝑛 maxtermos possíveis para n variáveis. A título de exemplo para duas variáveis temos assim
quatro maxtermos (22 ) ,a saber:
Ambas naturais 𝐵+𝐴 Posição 0 da tabela de verdade

A natural e B em complemento 𝐵 + 𝐴̅ Posição 1 da tabela de verdade
A em complemento e B natural 𝐵+𝐴 Posição 2 da tabela de verdade
Ambas em complemento 𝐵̅ + 𝐴̅ Posição 3 da tabela de verdade
Tabela 17 – Maxtermos para as variáveis B e A
A ORDEM NORMALIZADA
Os maxtermos e mintermos são activados por uma, e exclusivamente uma, combinação possível de
valores das variáveis, a qual podemos designar de padrão binário. Activar no Mintermo é fazer com que
o valor do mintermo seja 1 e no caso do maxtermo com que seja 0.
Index Padrão Mintermo Maxtermo

0 0000 ̅ . 𝐶̅ . 𝐵̅ . 𝐴̅
𝑚00 = 𝐷 𝑀00 = 𝐷 + 𝐶 + 𝐵 + 𝐴
1 0001 ̅ . 𝐶̅ . 𝐵̅ . 𝐴
𝑚01 = 𝐷 𝑀01 = 𝐷 + 𝐶 + 𝐵 + 𝐴
2 0010 ̅ . 𝐶̅ . 𝐵. 𝐴̅
𝑚02 = 𝐷 𝑀02 = 𝐷 + 𝐶 + 𝐵 + 𝐴
3 0011 ̅ . 𝐶̅ . 𝐵. 𝐴
𝑚03 = 𝐷 𝑀03 = 𝐷 + 𝐶 + 𝐵 + 𝐴
4 0100 ̅ . 𝐶. 𝐵̅ . 𝐴̅
𝑚04 = 𝐷 𝑀04 = 𝐷 + 𝐶 + 𝐵 + 𝐴
5 0101 ̅ . 𝐶. 𝐵̅ . 𝐴
𝑚05 = 𝐷 𝑀05 = 𝐷 + 𝐶 + 𝐵 + 𝐴
6 0110 ̅ . 𝐶. 𝐵. 𝐴̅
𝑚06 = 𝐷 𝑀06 = 𝐷 + 𝐶 + 𝐵 + 𝐴
7 0111 ̅ . 𝐶. 𝐵. 𝐴
𝑚07 = 𝐷 𝑀07 = 𝐷 + 𝐶 + 𝐵 + 𝐴
8 1000 𝑚08 = 𝐷. 𝐶̅ . 𝐵̅ . 𝐴̅ 𝑀08 = 𝐷 + 𝐶 + 𝐵 + 𝐴
9 1001 𝑚09 = 𝐷. 𝐶̅ . 𝐵̅ . 𝐴 𝑀09 = 𝐷 + 𝐶 + 𝐵 + 𝐴
10 1010 𝑚10 = 𝐷. 𝐶̅ . 𝐵. 𝐴̅ 𝑀10 = 𝐷 + 𝐶 + 𝐵 + 𝐴
11 1011 𝑚11 = 𝐷. 𝐶̅ . 𝐵. 𝐴 𝑀11 = 𝐷 + 𝐶 + 𝐵 + 𝐴
12 1100 𝑚12 = 𝐷. 𝐶. 𝐵̅ . 𝐴̅ 𝑀12 = 𝐷 + 𝐶 + 𝐵 + 𝐴
13 1101 𝑚13 = 𝐷. 𝐶. 𝐵̅ . 𝐴 𝑀13 = 𝐷 + 𝐶 + 𝐵 + 𝐴
14 1110 𝑚14 = 𝐷. 𝐶. 𝐵. 𝐴̅ 𝑀14 = 𝐷 + 𝐶 + 𝐵 + 𝐴
15 1111 𝑚15 = 𝐷. 𝐶. 𝐵. 𝐴 𝑀15 = 𝐷 + 𝐶 + 𝐵 + 𝐴
Tabela 18 – Os maxtermos e mintermos para as variáveis D,C,B e A
Repare que quando DCBA=0101 o único mintermo que assume o valor verdade é
̅ . 𝐶. 𝐵̅ . 𝐴 e todos os restantes são falsos. Por sua vez no sistema dual o único maxtermo que
𝑚05 = 𝐷
assume valor falso é 𝑀05 = 𝐷 + 𝐶 + 𝐵 + 𝐴 , os restantes maxtermos assumem valor verdade.
Caso duvide desta afirmação, experimente todos os valores possíveis em cada termo.
PRIMEIRA FORMA CANÓNICA

O somatório de mintermos pode ser usado para representar uma função booleana.
Analisemos um primeiro exemplo:

58
𝐹(𝐷𝐶𝐵𝐴) = ∑(0,4,7,15) = 𝑚0 + 𝑚4 + 𝑚7 + 𝑚15
Corresponde aos mintermos:
̅ . 𝐶̅ . 𝐵̅ . 𝐴̅ + 𝐷
𝐹(𝐷𝐶𝐵𝐴) = 𝐷 ̅ . 𝐶. 𝐵̅ . 𝐴̅ + 𝐷
̅ . 𝐶. 𝐵. 𝐴 + 𝐷. 𝐶. 𝐵. 𝐴
E por sua vez à tabela de verdade:
DCBA F
índice
0 0000 1
1 0001 0
2 0010 0
3 0011 0
4 0100 1
5 0101 0
6 0110 0
7 0111 1
8 1000 0
9 1001 0
10 1010 0
11 1011 0
12 1100 0
13 1101 0
14 1110 0
15 1111 1
Tabela 19 – Tabela de verdade da função 𝑭(𝑫𝑪𝑩𝑨) = ∑(𝟎, 𝟒, 𝟕, 𝟏𝟓)
Dica: Uma forma simples de preencher a tabela de verdade a partir da expressão é fazer uma tabela com
a coluna de índice e a DCBA e preencher a coluna de resultado F atribuindo o valor verdade (1) nos índices
identificados no somatório. As restantes posições livres assumem o valor falso (0).
Note a capacidade de compactação da representação canónica por comparação com as alternativas

anteriores.
Vamos partir da 𝐹(𝐶𝐵𝐴) = 1 para analisar a representação canónica. A tabela de verdade é simples.
CBA F
000 1
001 1
010 1
011 1
100 1
101 1
110 1
111 1
Tabela 20 – Tabela de verdade da função 𝑭(𝑪𝑩𝑨) = 𝟏
E a sua representação canónica também, incluí dos os termos:

59
𝐹(𝐶𝐵𝐴) = ∑(0,1,2,3,4,5,6,7) =
𝐶 . 𝐵 . 𝐴 + 𝐶 . 𝐵 . 𝐴 + 𝐶 . 𝐵. 𝐴̅ + 𝐶̅ . 𝐵. 𝐴 + 𝐶. 𝐵̅ . 𝐴̅ + 𝐶. 𝐵̅ . 𝐴 + 𝐶. 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴
̅ ̅ ̅ ̅ ̅ ̅
Qualquer outra função que tenha termos falsos verá os respectivos mintermos retirados do somatório.
Alteremos agora a função para 𝐹(𝐶𝐵𝐴) = ∑(0,1,4,6,7) . A nova função passou agora a ter somente cinco
uns.
A nova tabela de verdade:
CBA F
000 1
001 1
010 0
011 0
100 1
101 0
110 1
1111 1
Tabela 21 – Tabela de verdade da função 𝑭(𝑪𝑩𝑨) = ∑(𝟎, 𝟏, 𝟒, 𝟔, 𝟕)
E da sua representação canónica são retirados os mintermos dos padrões a zero, 0010, 0011, 0101.
𝐹(𝐶𝐵𝐴) = ∑(0,1,4,6,7) = 𝐶̅ . 𝐵̅ . 𝐴̅ + 𝐶̅ . 𝐵̅ . 𝐴 + 𝐶. 𝐵̅ . 𝐴̅ + 𝐶. 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴
A implementação de circuitos lógicos na forma de soma de produtos:
Circuito 22 – O circuito lógico da função 𝑭(𝑪𝑩𝑨) = ∑(𝟎, 𝟏, 𝟒, 𝟔, 𝟕)
Recorde que a ordem das variáveis, i.e. do seu peso, é relevante.
SEGUNDA FORMA CANÓNICA

Representemos agora 𝐹(𝐶𝐵𝐴) = ∏(2,3,5) = ∑(0,1,4,6,7) como um produtório de maxtermos.
Relembremos que cada padrão binário só activa o seu respectivo maxtermo. Não esquecer que activar
nos maxtermos corresponde a obter o valor zero. O que num produto de maxtermos garante

60
imediatamente que a função tem o valor falso (0). Se nenhum maxtermo é activado estamos na presença
de uma combinação de variáveis para a qual a função tem valor verdade.
∏(2,3,5) =
= 𝑀2 . 𝑀3 . 𝑀5 =
(𝐶 + 𝐵̅ + 𝐴)(𝐶 + 𝐵̅ + 𝐴̅)(𝐶̅ + 𝐵 + 𝐴̅)
Repare que existem sempre duas representações canónica para cada função sendo complementares:
𝐹 = ∏(1,2,3,5,6,8,9,10,11,12,13,14) =
= 𝑀1 . 𝑀2 . 𝑀3 . 𝑀5 . 𝑀6 . 𝑀8 . 𝑀9 . 𝑀10 . 𝑀11. 𝑀12. 𝑀13 . 𝑀14=
= ∑(0,4,7,15)
EXERCÍCIOS
1. Preencha as tabelas. Repare que cada célula da tabela dos mintermos está em complemento na
tabela dos maxtermos.
BA 𝑚0 𝑚1 𝑚2 𝑚3 BA 𝑀1 𝑀2 𝑀3 𝑀4
00 00
01 01
10 10
11 11
2. Elabore a tabela de verdade e a expressão algébrica para 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,4,7,15)
3. Elabore a tabela de verdade e a expressão algébrica para 𝐹(𝐸, 𝐷, 𝐶, 𝐵, 𝐴) = ∑(2,9,17,23)
4. Elabore a tabela de verdade e a expressão algébrica para 𝐹(𝐶, 𝐵, 𝐴) = ∏(0,2,3,5,6)
5. Encontre a forma canónica SDP da função 𝐹(𝐶, 𝐵, 𝐴) = 𝐵𝐴 + 𝐶̅ 𝐴 + 𝐶𝐴̅
6. Encontre a forma canónica PDS da função 𝐹(𝐶, 𝐵, 𝐴) = 𝐶. (𝐶 + 𝐴̅)
7.
RESOLUÇÃO
5. A forma canónica SDP da função 𝐹(𝐶, 𝐵, 𝐴) = 𝐵𝐴 + 𝐶̅ 𝐴 + 𝐶𝐴̅
𝐹(𝐶, 𝐵, 𝐴) = 𝐵𝐴 + 𝐶̅ 𝐴 + 𝐶𝐴̅
𝐹(𝐶, 𝐵, 𝐴) = (𝐶 + 𝐶̅ )𝐵𝐴 + 𝐶̅ (𝐵 + 𝐵̅ )𝐴 + 𝐶(𝐵 + 𝐵̅ )𝐴̅
𝐹(𝐶, 𝐵, 𝐴) = 𝐶𝐵𝐴 + 𝐶̅ 𝐵𝐴 + 𝐶̅ 𝐵𝐴 + 𝐶̅ 𝐵̅ 𝐴 + 𝐶𝐵𝐴̅ + 𝐶𝐵̅ 𝐴̅
𝐹(𝐶, 𝐵, 𝐴) = 𝐶̅ 𝐵̅ 𝐴 + 𝐶̅ 𝐵𝐴 + 𝐶𝐵̅ 𝐴̅ + 𝐶𝐵𝐴̅ + 𝐶𝐵𝐴
𝐹(𝐶, 𝐵, 𝐴) = ∑(1,3,4,6,7)
6. A forma canónica PDS da função 𝐹(𝐶, 𝐵, 𝐴) = 𝐶. (𝐶 + 𝐴̅)
𝐶. (𝐶 + 𝐴̅) = 𝐶. 𝐶 + 𝐶. 𝐴̅ = 𝐶 + 𝐶𝐴̅ = 𝐶(1 + 𝐴̅) = 𝐶

𝐶 = 𝐶 + 0 = 𝐶 + 𝐵. 𝐵̅ =

61
̅) =
= (C + B)(C + B
̅) + 0) =
= ((C + B) + 0)((C + B
̅ )((C + B
= ((C + B) + AA ̅) + AA
̅) =
̅)(C + B
= (C + B + A)(C + B + A ̅ + 𝐴)(C + B
̅ + 𝐴̅)
̅) = 𝐗. 𝐗 + 𝐗. 𝐘
Nota: (𝐗 + 𝐘)(𝐗 + 𝐘 ̅ + 𝒀. 𝑿 + 𝒀. 𝐘
̅= X . (1+𝐘
̅ + 𝒀)+ 𝒀. 𝐘
̅ = 𝐗 + 𝒀. 𝐘
̅
SIMPLIFICAÇÃO DE FUNÇÕES
O objectivo de quem implementa circuitos é tentar encontrar o sistema mais simples de implementar.
Quanto menos portas, mais simples a implementação e claro menores os custos, até de manutenção.
A simplificação de funções pode ser realizada por manipulação algébrica. Contudo, à técnicas que nos
permitem obter as funções num formato simplificado.
Recorrendo uma vez mais à função 𝐺(𝐶, 𝐵, 𝐴) = ∑(0,1,4,6,7) . A sua forma canónica como observamos
é:
𝐺(𝐶, 𝐵, 𝐴) = ∑(0,1,4,6,7) = 𝐶̅ . 𝐵̅ . 𝐴̅ + 𝐶̅ . 𝐵̅ . 𝐴 + 𝐶. 𝐵̅ . 𝐴̅ + 𝐶. 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴=
𝐶̅ . 𝐵̅ . 𝐴̅ + 𝐶̅ . 𝐵̅ . 𝐴 + 𝐶. 𝐵̅ . 𝐴̅ + 𝐶. 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴
𝐶̅ . 𝐵̅ . (𝐴̅ + 𝐴) + 𝐶. 𝐴̅(𝐵̅ + 𝐵) + 𝐶. 𝐵(𝐴̅ + 𝐴)=
𝐶̅ . 𝐵̅ . +𝐶. 𝐴̅ + 𝐶. 𝐵
Se observarmos com atenção a tabela de verdade conseguimos identificar as simplificações.
CBA F
000 1
001 1
010 0
011 0
100 1
101 0
110 1
111 1
Tabela 22 – Tabela de verdade da função 𝑮(𝑪, 𝑩, 𝑨) = ∑(𝟎, 𝟏, 𝟒, 𝟔, 𝟕)
Repare que os dois primeiros termos da função (000 e 001) assumem ambos o valor verdade. Só há uma
variável que muda de valor o A. C e B valem 0 nestes dois padrões. Ou seja, sabendo que as variáveis C e
B têm o valor zero podemos ignorar o valor de A (𝐴̅ + 𝐴) porque temos a certeza que a função assumirá
o valor verdade.

62
As duas restantes simplificações são realizadas através dos pares de padrões (110,111) e (100,110). O
último padrão é mais difícil de identificar porque não estão em sequência na tabela de verdade. É por isso
que surge a representação dos mapas de Karnaugh e a sua simplificação para representação de funções.
EXERCÍCIOS
Simplifique as seguintes expressões:
1. 𝐹1(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷 ̅ . 𝐶. 𝐵. 𝐴̅ + 𝐷
̅ . 𝐶. 𝐵. 𝐴 + 𝐷. 𝐶. 𝐵. 𝐴̅ + 𝐷. 𝐶. 𝐵. 𝐴
2. ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
𝐹2(𝐶, 𝐵, 𝐴) = 𝐶 . 𝐵̅ . 𝐴̅ + 𝐶. 𝐵̅ . 𝐴̅ + 𝐶̅ . 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴̅
3. 𝐹3(𝐶, 𝐵, 𝐴) = 𝐶̅ . 𝐵̅ . 𝐴̅ + 𝐶̅ . 𝐵̅ . 𝐴 + 𝐶. 𝐵. 𝐴̅ + 𝐶. 𝐵̅ . 𝐴̅
4. 𝐹4(𝐶, 𝐵, 𝐴) = 𝐶̅ . 𝐵̅ . 𝐴 + 𝐶̅ . 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴
5. 𝐹5(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷. 𝐶. 𝐵. 𝐴 + 𝐷. 𝐶. 𝐵̅ . 𝐴 + 𝐷. 𝐶. 𝐵̅ . 𝐴̅ + 𝐷. 𝐶̅ . 𝐵. 𝐴 + 𝐷 ̅ . 𝐶. 𝐵. 𝐴 + 𝐷
̅ . 𝐶. 𝐵. 𝐴̅ +
̅ . 𝐶. 𝐵̅ . 𝐴 + 𝐷
𝐷 ̅ . 𝐶̅ . 𝐵̅ . 𝐴
RESOLUÇÃO
1. 𝐹1(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷 ̅ . 𝐶. 𝐵. 𝐴̅ + 𝐷
̅ . 𝐶. 𝐵. 𝐴 + 𝐷. 𝐶. 𝐵. 𝐴̅ + 𝐷. 𝐶. 𝐵. 𝐴 =
𝐹1(𝐷, 𝐶, 𝐵, 𝐴) = 𝐶. 𝐵 (𝐷 ̅ . 𝐴̅ + 𝐷
̅ . 𝐴 + 𝐷. 𝐴̅ + 𝐷. 𝐴) =
̅ (𝐴 ̅
= 𝐶. 𝐵 (𝐷. + 𝐴) + 𝐷. + 𝐴)) = (𝐴 ̅
= 𝐶. 𝐵 (𝐷 ̅ + 𝐷) =
= 𝐶. 𝐵
2. 𝐹2(𝐶, 𝐵, 𝐴) = 𝐶̅ . 𝐵̅ . 𝐴̅ + 𝐶. 𝐵̅ . 𝐴̅ + 𝐶̅ . 𝐵. 𝐴̅ + 𝐶. 𝐵. 𝐴̅ =
= 𝐴̅. (𝐶̅ . 𝐵̅ + 𝐶. 𝐵̅ + 𝐶̅ . 𝐵 + 𝐶. 𝐵) =
= 𝐴̅. (𝐵̅ . (𝐶̅ . +𝐶) + 𝐵. (𝐶̅ + 𝐶)) =
= 𝐴̅. (𝐵̅ . (1) + 𝐵. (1)) =
= 𝐴̅. (𝐵̅ + 𝐵) =
= 𝐴̅
MAPA DE KARNAUGH (MAPA-K)
O mapa de Karnaugh (mapa-k) é uma técnica utilizada para simplificação de expressões booleanas com
mais de 2 variáveis. Inicialmente proposto por Veitch foi modificado por Karnaugh, sendo conhecido
como Diagrama de Veitch ou por Mapa de Karnaugh (ou mapa-k). À semelhança das tabelas de verdade,
o mapa-k descreve os estados da saída de um circuito lógico. É assim muito simples transferir informações
de uma tabela de verdade para o mapa-k.
Embora a representação de uma função lógica pela Tabela Verdade seja única, quando expressa
algebricamente, ela pode aparecer em várias formas diferentes. Acresce que a simplificação da forma
canónica através de manipulações em álgebra booleana é complexa, fácil de errar e difícil de sistematizar;
isto é, não existe um caminho único a seguir, para se alcançar a melhor simplificação.
Por seu lado, a simplificação através do mapa-k permite um método sistemático de obtenção das
expressões booleanas em SDP ou PDS minimais.
O objectivo último de obter as formas minimais é reduzir o número de portas lógicas, tornando os circuitos
menos dispendiosos e mais eficientes.

63
O mapa-k é uma matriz bidimensional em que cada célula corresponde a um termo da tabela de verdade.
O mapa-k é composto de células quadradas dispostas em linhas e colunas, em número de potências de 2,
dependendo do número de variáveis que compõem a função lógica.
As células são dispostas no mapa por ordem de Gray, isto é, cada valor da linha ou coluna só deve variar
em um bit para as linhas ou colunas adjacentes (propriedade de adjacência). A propriedade de adjacência
só se verifica para duas variáveis por dimensão. Como estamos limitados ao papel, logo a duas dimensões,
o máximo que podemos representar de forma simples são mapas com quatro variáveis.
Assim os mapas-k são utilizados para funções com 2, 3 ou 4 variáveis correspondendo a 4, 8 ou 16 células,
respectivamente, tal como acontece com as linhas da respectiva tabela de verdade. Existe uma
correspondência unívoca entre cada linha da tabela de verdade e uma célula do mapa-K. Para diagramas
com mais células (32 e 64), é mais difícil identificar as simplificações, contudo ainda é possível, como
veremos, usar este método.
Para aquelas expressões com mais de 6 variáveis, os métodos computadorizados são os melhores (ver
processo tabular de Quine-McCluskey).
Apresenta-se de seguida o mapa para três variáveis. Repare como só muda uma variável de cada vez
quando transita de uma célula para uma célula adjacente. O preenchimento do mapa pode ser feito de
forma mecânica caso esteja construído sempre da mesma forma.
Adoptamos sempre a mesma distribuição de variáveis para permitir “automatizar” o preenchimento dos
mapas. Repare as colunas no mapa seguem a sequência 0,1,3,2 para a primeira coluna e 4,5,7,6 para a
segunda.
Figura 24 – Mapa-k e tabela de verdade de 3 variáveis
O mapa para quatro variáveis ainda é possível representar numa matriz bidimensional.

64
A sequência de preenchimento volta a repetir-se com quatro variáveis. Reparemos que também a ordem
das colunas segue a mesma sequência. Esta sequência é consequência do código de Gray.
SIMPLIFICAÇÃO DE FUNÇÕES EM MAPAS-K

A propriedade de adjacência é crucial para tirarmos partido da representação em mapa-k no momento
de extracção dos termos que representam as expressões lógicas.
Se observarmos duas células adjacentes na horizontal ou vertical verificaremos que muda exclusivamente
o valor de uma variável. As restantes estão fixas. Logo, no caso de o valor da função ser estável, a variável
que muda pode ser eliminada. Está operação está suportada na propriedade booleana do complemento,
a título de exemplo 𝐹(𝐶, 𝐵, 𝐴) = 𝐶𝐵𝐴 + 𝐶𝐵𝐴̅ = 𝐶𝐵(𝐴 + 𝐴̅) = 𝐶𝐵.
Para garantirmos a melhor simplificação devemos agrupar as células em número de potências de 2 tendo
por objectivo de incluir todos os valores no menor número de grupos possível. Os agrupamentos só
podem ser realizados no sentido horizontal e vertical, nunca na diagonal.
Por outras palavras, e para um mapa-k de quatro variáveis, num agrupamento de duas células adjacentes,
sabemos que uma e só uma variável tem o seu valor natural e complementar. Logo num agrupamento de
duas células num mapa-k de 4 variáveis podemos extrair um termo só com três variáveis, deixando cair a
variável que muda.

65
Figura 26 – Células adjacentes num mapa com 4 variáveis
Seguindo o mesmo raciocínio, num grupo de quatro (22 ) células adjacentes obtêm-se duas variáveis
estáveis e as quatro combinações das restantes, pelo que conseguimos extrair termos somente com duas
variáveis.
Em grupos de oito (23 ) células adjacentes obtemos uma variável estável e as oito combinações das
restantes, assim, deste tipo de agrupamento extraímos termos somente com uma variável.
E por ai fora.
Analisemos a seguinte função descrita através da tabela de verdade e do mapa-k.
Figura 27 – Mapa-k e tabela de verdade de função a AND de 2 variáveis, 𝑭(𝑩, 𝑨) = ∑(𝟑)
Só existe uma célula que apresenta o valor um. Desta forma a expressão faz recurso de todas as vaiáveis
e corresponde ao termo que apresenta 1 quando ambas a variáveis são A=B=1, logo 𝐹 = 𝐵𝐴. O que é
esperado pois a tabela de verdades corresponde à porta AND de duas entradas.
Analisemos agora outra função descrita através da tabela de verdade e do mapa-k.
Figura 28 – Mapa-k e tabela de verdade de 𝑭(𝑩, 𝑨) = ∑(𝟏, 𝟑)

66
̅ 𝑨 = 𝐴(𝐵 + 𝐵̅ ) = 𝐴
𝐹(𝐵, 𝐴) = 𝐵𝐴 + 𝑩
Note: Se optar por retirar os termos sem agrupar em potencias de dois, obtém a representação na
primeira forma canónica ou na segunda forma canónica (SDP ou PDM), caso opte, respectivamente,
pelos uns ou pelos zeros.
Em resumo, e para todos os mapas-k:
• Permitem o recurso a um método sistemático para simplificação de expressões lógicas e

obtenção das expressões SDP ou PDS minimais;
• Estão diretamente relacionados com uma Tabela Verdade;
• Agrupar os 1 do mapa gera uma expressão no formato soma de produtos, que dará 1 sempre
que um dos termos dê o valor 1, dado que eles estão ligados por disjunções e 0 em todos os
outros casos;
• Agrupar os 0 do mapa gera uma expressão no formato produto de somas, que dará 0 sempre
que um dos termos dê o valor 0, dado que eles estão ligados por conjunções e um em todos os
restantes casos;
• Optar sempre por agrupar o valor mais presente no mapa;
• Os grupos têm que ter conjuntos de elementos adjacentes em número de potências de 2;
• Os grupos devem ser formados apenas por valores adjacentes;
• Todos os valores devem pertencer a pelo menos um grupo;
• No limite um grupo pode só ter uma célula se não for adjacente a mais nenhuma célula de igual
valor
• Pode reutilizar células que já façam parte de um grupo para ciar um segundo grupo maior (termo
com menos variáveis). Porém, não deve incluir todas as células de um grupo noutro maior, neste
caso o termo com o grupo menor pode e deve ser removido.
MAPAS DE KARNAUGH COM UMA VARIÁVEL

Neste mapa existe pouco a dizer. Na verdade, uma função com uma variável não chega a dar trabalho.
Mas aqui fica.
Figura 29 – Mapa-k e tabela de verdade de 1 variável
Neste exemplo conclui-se imediatamente que a função é independente da variável A e é constante

valendo sempre verdade (1). Contudo, o princípio verifica-se: um agrupamento de uns, potência de 2 com
a maior dimensão possível.

67
NOTA: Só existem 4 funções possíveis numa função com uma variável, constante a 1, constante a 0,
identidade ou complemento.
MAPAS DE KARNAUGHCOM DUAS VARIÁVEIS

Analisemos agora o mapa-k aplicado a uma função com duas variáveis.
A primeira linha corresponde aos pares, i.e. às posições da tabela de verdade em que a variável A é igual
a 0. A segunda linha, corresponde aos impares, ou seja às posições em que a variável A é igual a 1. Quanto
às colunas, a primeira corresponde ao conjunto em que a variável B é igual a 0, enquanto a segunda
coluna, corresponde ao conjunto em que a variável B é igual a 1. A interseção entre a linha e a coluna
corresponde, tal como acontecia nas tabelas de verdade, a um mintermo ou a um maxtermo dependendo
se o valor de saída da função é 1 ou 0, respectivamente.
Desta forma é fácil fazer a correspondência entre a tabela de verdade e o mapa-k, basta para tal transferir
o valor da tabela para o mapa respeitando as posições. A primeira linha da tabela, A=0 B=0, corresponde
a m0; a segunda linha, A=0 B=1, corresponde a m1, a terceira linha corresponde a m2 e a terceira linha
corresponde a m3.
No primeiro exemplo temos 𝐹(𝐵, 𝐴) = ∑(0,1).
Repare que se retirarmos na forma SDP temos:
𝐹(𝐵𝐴) = 𝐵̅ . 𝐴̅ + 𝐵̅ . 𝐴 =
= ̅𝐵 (𝐴 + 𝐴̅) =
= 𝐵̅
Analisemos agora 𝐹(𝐵, 𝐴) = ∑(1,2,3). Neste caso, só existe uma posição com o valor 0 e as restantes 3
assumem o valor 1. Desta forma obtemos o mapa-k:
Figura 31 – Mapa-k da função OR

68
Obtemos assim dois grupos de 2 células, desde que usemos o mintermo m3 (A=1, B=1) nos dois grupos.
Na construção dos grupos podemos utilizar o mesmo mintermo em vários agrupamentos. Relembre-se
que não pode deixar nenhuma célula com valor 1 sem grupo. Se um mintermo estiver isolado deverá ser
considerado num agrupamento de 1 (também uma potencia de 2). Do agrupamento na vertical resulta
B=1 e da horizontal A=1, logo 𝑆 = 𝐵 + 𝐴.
MAPAS DE KARNAUGH COM 3 VARIÁVEIS

Exemplos de mapas com agrupamentos para extração de termos em mapas com três variáveis.
Figura 32 – Mapa-k de 3 variáveis com exemplos de agrupamentos de duas células
E agora termos com duas variáveis:
Figura 33 – Mapa-k de 3 variáveis com exemplos de agrupamentos de quatro células
E EM MAPAS COM 4 VARIÁVEIS

Mapas-k de quatro variáveis. Repare que a propriedade de células adjacentes está uma vez mais garantida
logo podemos extrair os valores simplificados.

69
Figura 34 – Mapa-k de 4 variáveis
Observe agora o poder de simplificação dos mapas com quatro variáveis.
Figura 35 – Exemplos de mapa-k de quatro variáveis com um único literal em SDP.
O mesmo raciocínio pode ser feito para a extracção por agrupamentos de “zero” contudo neste caso
estamos a criar expressões booleanas do tipo PDM, segunda forma canónica. Observe as funções
complementares da figura anterior.

70
Figura 36 – Exemplos de mapa-k de quatro variáveis com um único literal em PDM.
EXERCÍCIOS
1. Apresente a tabela de verdade, o mapa de Karnaugh e a expressão algébrica simplificada para
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1)
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,2,3)
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(10,11,14,15)
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,10,11,14,15)
5. Apresente para a 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,4,5,10,11,14,15) a tabela de verdade, o mapa de
Karnaugh e as expressões algébricas simplificadas em SDP (agrupando 1s) e PDS (agrupando 0s).
No final desenhe os circuitos e analise a complexidade das implementações.
6. Apresente para a 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∏(0,1,8,9,10,11) a tabela de verdade, o mapa de Karnaugh e
as expressões algébricas simplificadas em SDP (agrupando 1s) e PDS (agrupando 0s). No final
desenhe os circuitos e analise a complexidade das implementações.
7. Construa o mapa-k da função 𝐹(𝐶, 𝐵, 𝐴) = 𝐶. 𝐵 + 𝐶. 𝐴 + 𝐵̅ . 𝐴̅
8. Contrua o mapa-k da função 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = 𝐶̅ . 𝐵. 𝐴 + 𝐷̅ . 𝐶. 𝐵 + 𝐴̅
9. Simplifique a 𝐹(𝐶, 𝐵, 𝐴) = ∏(1,3,4,6,7) através de mapa-k
10. Construa o mapa-k da função 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = (𝐷 + 𝐶̅ ). (𝐷̅ + 𝐵 + 𝐴̅)

71
RESOLUÇÕES
1. ̅ . 𝐶̅ . 𝐵̅ . 𝐴̅ +
A tabela de verdade, o mapa-k e a expressão simplificada da 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷
̅ . 𝐶̅ . 𝐵̅ . 𝐴 = 𝐷
𝐷 ̅ . 𝐶̅ . 𝐵̅ . (𝐴̅ + 𝐴) = 𝐷
̅ . 𝐶̅ . 𝐵̅
Figura 37 – Tabela de verdade e Mapa-k de 𝑭(𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟎, 𝟏)
̅ . 𝐶̅ . 𝐵̅
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1) = 𝐷
2. A tabela de verdade, o mapa de Karnaugh e a expressão algébrica simplificada para

𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,2,3)
Figura 38 – Tabela de verdade e Mapa-k de 𝑭(𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟎, 𝟏, 𝟐, 𝟑)
̅ . 𝐶̅
𝐹(𝐷, 𝐶𝐵𝐴) = ∑(0,1,2,3) = 𝐷

72

𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(10,11,14,15)
Figura 39 – Tabela de verdade e Mapa-k de 𝑭(𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓)
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(10,11,14,15) = 𝐷. 𝐵

𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,10,11,14,15)

73
Figura 40 – Tabela de verdade e Mapa-k de 𝑭(𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟎, 𝟏, 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓)
̅ . 𝐶̅ . 𝐵̅ + 𝐷. 𝐵
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,10,11,14,15) = 𝐷
5. Apresente para a 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,4,5,10,11,14,15) a tabela de verdade, o mapa de

Karnaugh e as expressões algébricas simplificadas em SDP (agrupando 1s) e PDS (agrupando 0s).
No final desenhe os circuitos e analise a complexidade das implementações.

74
Figura 41 – Tabela de verdade e Mapa-k de 𝑭(𝑫𝑪𝑩𝑨) = ∑(𝟎, 𝟏, 𝟒, 𝟓, 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓) com agrupamentos de uns e de zeros
Expressão booleana simplificada por SDP:
̅ . 𝐵̅ + 𝐷. 𝐵
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∑(0,1,4,5,10,11,14,15) = 𝐷
Expressão booleana simplificada por PDS:
̅ + 𝐵). (𝐷 + 𝐵̅ )
𝐹(𝐷𝐶𝐵𝐴) = ∑(0,1,4,5,10,11,14,15) = (𝐷
Os circuitos são implementados com o mesmo número de portas lógicas de duas entradas. A sua
dificuldade de montagem é assim equivalente.
Repare, ainda, que as expressões são equivalentes:
̅ + 𝐵). (𝐷 + 𝐵̅ ) =
(𝐷
̅. 𝐷 + 𝐷
=𝐷 ̅ . 𝐵̅ + 𝐵. 𝐷 + 𝐵. 𝐵̅ )=
=𝐷̅ . 𝐵̅ + 𝐵. 𝐷
7. O mapa-k da função 𝐹(𝐶, 𝐵, 𝐴) = 𝐶. 𝐵 + 𝐶. 𝐴 + 𝐵̅ . 𝐴̅

75
̅. 𝑨
Figura 42 –Mapa-k de 𝑭(𝑪, 𝑩, 𝑨) = 𝑪. 𝑩 + 𝑪. 𝑨 + 𝑩 ̅
8. O mapa-k da função 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = 𝐶̅ . 𝐵. 𝐴 + 𝐷

̅ . 𝐶. 𝐵 + 𝐴̅
̅ . 𝑩. 𝑨 + 𝑫
Figura 43 –Mapa-k de 𝑭(𝑫, 𝑪, 𝑩, 𝑨) = 𝑪 ̅ . 𝑪. 𝑩 + 𝑨
̅
9. O mapa-k e a função simplificada de 𝐹(𝐶, 𝐵, 𝐴) = ∏(1,3,4,6,7)
Figura 44 –Mapa-k de 𝑭(𝑪, 𝑩, 𝑨) = ∏(𝟏, 𝟑, 𝟒, 𝟔, 𝟕)
𝐹(𝐶, 𝐵, 𝐴) = ∏(1,3,4,6,7) = (𝐶´ + 𝐵´). (𝐶 + 𝐴′ ). (𝐶′ + 𝐴)

76
10. O mapa-k da função 𝐹(𝐷, 𝐶, 𝐵, 𝐴) = (𝐷 + 𝐶̅ ). (𝐷

̅ + 𝐵 + 𝐴̅)
̅ ). (𝑫
Figura 45 –Mapa-k de 𝑭(𝑫, 𝑪, 𝑩, 𝑨) = (𝑫 + 𝑪 ̅ +𝑩+𝑨
̅)
MAPAS COM CINCO VARIÁVEIS

O mapa-k de 5 variáveis pode ser representado como dois mapas de 4, em que num dos mapas a quinta
variável toma o valor 0 e no outro toma o valor 1. Neste caso, para além das regras de adjacência dos
mapas de 4 variáveis passamos a ter adjacência da variável E (a quinta) entre duas células na mesma
localização de D, C, B, A, sendo que nesse caso a variável E é eliminada.
Figura 46 – Mapa-k para funções com cinco variáveis
Simplifiquemos então a função 𝑭(𝑬, 𝑫, 𝑪, 𝑩, 𝑨) = ∑(10,11,14,15)

77
Figura 47 – Mapa-k para a função 𝑭(𝑬, 𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓)
Obtemos assim a função simplificada 𝐹(𝐸, 𝐷, 𝐶, 𝐵, 𝐴) = ∑(10,11,14,15) = 𝐸̅ . 𝐷𝐵
Repare que a função canónica minimal obtida incluí a variável “E” complementada porque o agrupamento
está localizado no mapa E=0.
Observemos agora a função 𝑭(𝑬, 𝑫, 𝑪, 𝑩, 𝑨) = ∑(10,11,14,15,26,27,30,31)
Figura 48 – Mapa-k para a função 𝑭(𝑬, 𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓, 𝟐𝟔, 𝟐𝟕, 𝟑𝟎, 𝟑𝟏)
Obtemos aqui a função simplificada 𝐹(𝐸, 𝐷, 𝐶, 𝐵, 𝐴) = ∑(10,11,14,15,26,27,30,31) = 𝐷𝐵
Neste caso a variável “E” desaparece porque existem dois grupos idênticos nos dois quadros. Devemos
imaginar os quadros sobrepostos.
Simplifiquemos agora a função 𝑭(𝑬, 𝑫, 𝑪, 𝑩, 𝑨) = ∑(10,11,14,15,18,19,22,23,26,27,30,31)
Figura 49 – Mapa-k para a função 𝑭(𝑬, 𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓, 𝟏𝟖, 𝟏𝟗, 𝟐𝟐, 𝟐𝟑, 𝟐𝟔, 𝟐𝟕, 𝟑𝟎, 𝟑𝟏)
A função simplificada é 𝐹(𝐸, 𝐷, 𝐶, 𝐵, 𝐴) = ∑(10,11,14,15,18,19,22,23,26,27,30,31) = 𝐷𝐵 + 𝐸𝐵. Dois

grupos com oito células correspondem a dois termos com literais com duas variáveis.

78
Simplifiquemos agora a função 𝐹(𝐸, 𝐷, 𝐶, 𝐵, 𝐴) = ∑(5, 10,11,14,15,18,19,22,23,26,27,30,31)
Parece a mesma função mas não é, tem mais um termo. Lançando no mapa os valores obtemos os
seguintes mapas e agrupamentos de “1”:
Figura 50 – Mapa-k para a função 𝑭(𝑬, 𝑫, 𝑪, 𝑩, 𝑨) = ∑(𝟓, 𝟏𝟎, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓, 𝟏𝟖, 𝟏𝟗, 𝟐𝟐, 𝟐𝟑, 𝟐𝟔, 𝟐𝟕, 𝟑𝟎, 𝟑𝟏)
A função simplificada resultando é assim:
𝐹(𝐸, 𝐷, 𝐶, 𝐵, 𝐴) = ∑(5, 10,11,14,15,18,19,22,23,26,27,30,31) = 𝐸𝐵 + 𝐵𝐷 + 𝐸̅ 𝐷

̅ 𝐶𝐵̅A
MAPAS COM SEIS VARIÁVEIS

O mapa-k de 6 variáveis pode ser representado como quatro mapas de 4 que correspondem
respectivamente ao valor das duas variáveis de maior peso. Neste caso, para além das regras de
adjacência dos mapas de 4 variáveis passamos a ter adjacência para as duas outras variáveis.

79
Figura 51 – Mapa-k para funções com seis variáveis
FUNÇÕES INCOMPLETAS (DON’T CARES)
Os don’t care são um conceito muito eficaz e útil na obtenção de funções simplificadas. Este conceito é
útil quando estamos na presença de funções incompletas, i.e. funções cujo domínio não cobre todos os
valores possíveis de todas as variáveis. Por essa razão a tabela de verdade completa e o respectivo mapa-
k possuem termos indefinidos. Estamos a falar de termos para os quais não há valor definido na função.
São casos em que a combinação do valor das variáveis não tem significado. Nestas situações é irrelevante
em fase de projecto assumir um valor de verdade ou falso (1 ou 0). Seja qual for o valor definido nunca
terá utilidade por definição.
A título de exemplo no código BCD (Binary Coded Decimal – dígitos decimais entre 0 e 9), os termos 1010,
1011, 1100, 1101, 1110, e 1111 são inválidos (porque representam dígitos para além do 9). Estes termos
devem ser assinados como don’t care.
Em vez de forçarmos valores de forma aleatória é útil assinalarmos estas situações como indefinidos. As
situações são normalmente assinaladas com uma cruz (X), o menos (-) ou o phi(Φ). Uma vez lançados nos
mapa-k as células marcadas como don’t care são substituídas por um 1 ou 0 conforme seja mais útil na
obtenção de grupos maiores no processo de simplificação. A escolha dos valores para as células permite
que umas tenham valor 1 ou outras valor 0.
À notação actual acrescentamos uma lista d que indica as posições don’t care.

80
A título de exemplo para a função que identifica se um digito BCD é par todos os termos acima de 9 são
don’t cares. Logo teríamos a seguinte descrição:
𝐹(𝐷𝐶𝐵𝐴) = ∑(0,2,4,6,8) + 𝑑(10,11,12,13,14,15)
𝐹(𝐷𝐶𝐵𝐴) = ∏(1,3,7,7,9) + 𝑑(10,11,12,13,14,15)
Atrasamos a definição do valor para o momento em que extraímos a função algébrica conforme nossa
conveniência com vista à obtenção da SDP ou PDS mínima.
Repare que quando obtemos a expressão algébrica os termos don’t care passam a ter valores definidos,
apesar de por definição de problema estas situações serem impossiveis de acontecer uma vez
implementado o circuíto estas posições assumem os valores atribuidos no momento da simplificação.
O seu estudo dos valores de don’t care é aconselhado verificando se a sua ocorrencia pode causar alguma
falha ou comportamento problemático. Não esquecer que podem acontecer avarias.
NOTA: Não confundir don’t cares com tristates.
EXERCÍCIO
1. Simplifique a função par acima descrita, na forma SDP mínima usando K-maps.
2. Temos 4 sensores que detectam o estado de um paciente. Os sensores são independentes e
assinalam a existência de uma situação preocupante. Crie um sistema que tenha duas funções
informativas que assinalam:
M – Assume do valor da maioria dos sensores.
E – Assinala que dois sensores estão activos e dois inactivos.
Atenção: No caso de empate não há maioria!
3. Obtenha a expressão mais simplificada na forma SDP (somas de produtos) através da utilização
de mapa de Karnaugh.
a. 𝐹(𝐷𝐶𝐵𝐴) = ∑(2,3,9,10,12,13) + 𝑑(1,8,11)
RESOLUÇÃO
1. A função simplificada (Par) para 𝐹(𝐷𝐶𝐵𝐴) = ∑(0,2,4,6,8) + 𝑑(10,11,12,13,14,15)

81
𝐹(𝐷𝐶𝐵𝐴) = 𝐴̅
Curiosidade: Detecta os pares em dígitos para além de BCD.
2. O problema indica um caso de duas funções com quatro variáveis de entrada. A solução foi
desenhada usando don´t cares no caso dos empates. São apresentadas duas soluções para a
função maioria.

82
Retirar a função Empate do mapa-k pelos “1” não permite nenhuma simplificação de termos porque estão
todos isolados. Obtemos assim a função 𝐸(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷𝐶𝐵̅ 𝐴̅ + 𝐷
̅ 𝐶𝐵̅ 𝐴 + 𝐷𝐶̅ 𝐵̅ 𝐴 + 𝐷
̅ 𝐶̅ 𝐵𝐴 + 𝐷
̅ 𝐶𝐵𝐴̅ +
̅ 𝐶̅ 𝐵̅ 𝐴
𝐷
Para a função maioria são apresentadas duas soluções equivalentes:
𝐵(𝐷, 𝐶, 𝐵, 𝐴) = 𝐷𝐶 + 𝐵𝐴
𝑀(𝐷, 𝐶, 𝐵, 𝐴) = 𝐶𝐴 + 𝐷𝐵
MULTIPLEXADORES E DECODIFICADORES
Em princípio quanto maior a complexidade das funções maior será a necessidade de portas lógicas.
O uso de multiplexadores, decodificadores e PALs (Arrays Lógicos Programáveis) são opções viáveis por
opção às portas lógicas.

83
As equações lógicas têm tendência em ocultar a função que está a ser implementada o que não acontece
quando usamos multiplexadores e decodificadores.
O MULTIPLEXADOR
O multiplexador (multiplexer ou MUX) implementa eletronicamente um mecanismo de selecção de
dados.
Analisemos um multiplexador de três entradas de selecção (oito entradas de dados) uma saída com
enable. A cada momento uma e só uma entrada é seleccionada e o seu valor é apresentado à saída.
Figura 52 – Chave selectora de oito posições e representação do Multiplexador de oito entradas
Repare que, caso a entrada enable esteja a 1, é irrelevante o valor apresentado nas entradas de selecção
S2,S1,S0. O valor à saída Y fica fixo a 0. Este integrado tem um enable active low. Apresenta o
funcionamento com o enable igual a zero.
̅
𝑬 C B A Y ̅
𝒀
0 0 0 0 D0 ̅̅̅̅
𝐷0
0 0 0 1 D1 ̅̅̅̅
𝐷1
0 0 1 0 D2 ̅̅̅̅
𝐷2
0 0 1 1 D3 ̅̅̅̅
𝐷3
0 1 0 0 D4 ̅̅̅̅
𝐷4
0 1 0 1 D5 ̅̅̅̅
𝐷5
0 1 1 0 D6 ̅̅̅̅
𝐷6
0 1 1 1 D7 ̅̅̅̅
𝐷7
1 X X X 0 1
Tabela 23 – Tabela de verdade de multiplexador de três entradas de selecção com enable active low
Este tipo de circuito integrado tem múltiplas aplicações na selecção de sinais, mas também pode ser
utilizado na implementação de funções.
A implementação de um multiplexador com uma entrada de selecção seria:
𝑌 = 𝐼1 𝑆 + 𝐼0 𝑆̅

84
Circuito 23 - Multiplexador com uma entrada de selecção
MULTIPLEXADOR DE DUAS ENTRADAS DE SELECÇÃO

𝑌 = 𝐼3 𝑆1 𝑆0 + 𝐼2 𝑆1 𝑆̅0 + 𝐼1 𝑆̅1 𝑆0 + 𝐼0𝑆̅1 𝑆̅0
Circuito 24 - Multiplexador com duas entradas de selecção
IMPLEMENTAÇÃO DE FUNÇÕES LÓGICAS COM MULTIPLEXADORES

A implementação de funções com 𝑛 variáveis de entrada com multiplexadores com o mesmo número de
entradas de selecção é imediata, desde que se tenha o cuidado de manter a ordem. A cada entrada do
multiplexador corresponde uma linha da tabela de verdade.
EXERCÍCIO
1. Implemente a função seguinte usando um multiplexador de 4 entradas de selecção.
𝐹(𝐷𝐶𝐵𝐴) = ∑(1,4,5,7,8,11,14,15)
Index DCBA F

85
0 0000 0
1 0001 1
2 0010 0
3 0011 0
4 0100 1
5 0101 1
6 0110 0
7 0111 1
8 1000 1
9 1001 0
10 1010 0
11 1011 1
12 1100 0
13 1101 0
14 1110 1
15 1111 1
Circuito 25 – Implementação da função 𝑭(𝑫𝑪𝑩𝑨) = ∑(𝟏, 𝟒, 𝟓, 𝟕, 𝟖, 𝟏𝟏, 𝟏𝟒, 𝟏𝟓) com multiplexador.
Repare que a implementação é uma aplicação directa dos valores presentes na tabela de verdade.
2. Implemente a mesma função agora com um multiplexador de 3 entradas de selecção.

AMPLIAÇÃO DA CAPACIDADE DE UM SISTEMA MULTIPLEXADOR

86
É possível construir multiplexadores de maior capacidade, a partir de multiplexadores de menor

capacidade.
Circuito 26 – Ampliação de multiplexadores.
A variável A é usada para selecionar a entrada do multiplexador do andar de saída (andar superior).
Quando A=0 fica selecionado o multiplexador de cima e com A=1 o multiplexador de baixo. Os dois
primeiros multiplexadores partilham as variáveis B e C.
A título de exemplo quando B=C=1 são selecionadas as entradas I3 e I7 para D0 e D1, respectivamente do
multiplexador de saída.
DESMULTIPLEXADOR
O desmultiplexador (DEMUX) realiza a função inversa de um multiplexador. Transfere a entrada para a
saída identificada pelas variáveis de selecção.
Circuito 27 – Um desmultiplexador com três entradas de selecção e enable.
DESCODIFICADORES

87
Um descodificador identifica através de uma das suas saídas quais as entradas de selecção que estão a
ser utilizadas. Dito de outra forma, activa uma das suas saídas em função das entradas de selecção. A
activação pode ser a zero, mantendo as restantes saídas a um, ou vice versa. Opcionalmente, pode existir
uma entrada de activação (enable).
Circuito 28 – Um descodificador com três entradas de selecção e enable.
Esta é a tabela que descreve o decodificador.
̅
𝑬 C B A ̅̅̅̅
𝑺𝟎 ̅̅̅̅
𝑺𝟏 ̅̅̅̅
𝑺𝟐 ̅̅̅̅
𝑺𝟑 ̅̅̅̅
𝑺𝟒 ̅̅̅̅
𝑺𝟓 ̅̅̅̅
𝑺𝟔 ̅̅̅̅
𝑺𝟕
0 0 0 0 0 1 1 1 1 1 1 1
0 0 0 1 1 0 1 1 1 1 1 1
0 0 1 0 1 1 0 1 1 1 1 1
0 0 1 1 1 1 1 0 1 1 1 1
0 1 0 0 1 1 1 1 0 1 1 1
0 1 0 1 1 1 1 1 1 0 1 1
0 1 1 0 1 1 1 1 1 1 0 1
0 1 1 1 1 1 1 1 1 1 1 0
1 X X X 1 1 1 1 1 1 1 1
Tabela 24 – Tabela de verdade do descodificador com três entradas de selecção e enable active low
IMPLEMENTAÇÃO DE FUNÇÕES LÓGICAS COM DE SCODIFICADORES

Uma das aplicações dos descodificadores é a implementação de funções lógicas. As variáveis da tabela de
verdade devem ser utilizadas como entradas de selecção, uma vez mais, pela mesma ordem com que

88
aparecem na tabela de verdade; isto, é, a variável mais à esquerda na tabela deve ser utilizada como
entrada de selecção de maior peso. Só assim se garante o correcto funcionamento do circuíto. No caso
do descodificador ter saídas activas a um basta reunir as saídas relevantes com um OR. No caso do
descodificador ter saídas activas a zero basta reunir as saídas relevantes com um NAND.
𝐹1(𝐶, 𝐵, 𝐴) = 𝐶𝐵𝐴 + 𝐶𝐵 ′ 𝐴′ + 𝐶 ′ 𝐵′ 𝐴
𝐹2(𝐶, 𝐵, 𝐴) = 𝐶′𝐵′𝐴′ + 𝐶′𝐵𝐴′ + 𝐶𝐵′𝐴′
Circuito 29 – Implementação de função com descodificador.
Repare que para funções que partilhem variáveis basta utilizar um descodificar.
AMPLIAÇÃO DA CAPACIDADE DE UM DECODIFICADOR

Tal como aconteceu com os multiplexadores também com os descodificadores é possível criar
componentes com maior capacidade usando descodificadores com menos entradas.
Circuito 30 – Ampliação de um descodificador.

89
CODIFICADOR DE PRIORIDADES
Um codificador de prioridades é um componente que apresenta às saídas o valor em binário que
corresponde à entrada considerada mais prioritária. No caso de nenhuma entrada estar seleccionada a
saída vazio (V) é activada. Temos assim para 2𝑛 entradas para 2𝑛 + 1 saídas.
Vamos implementar um codificar com 5 entradas de prioridade, logo 3 saídas de codificação de prioridade
e uma saída V auxiliar activa a zero.
Entradas Saídas
D4 D3 D2 D1 D0 A2 A1 A0 V
0 0 0 0 0 X X X 0
0 0 0 0 1 0 0 0 1
0 0 0 1 X 0 0 1 1
0 0 1 X X 0 1 0 1
0 1 X X X 0 1 1 1
1 X X X X 1 0 0 1
Caso não consiga retirar as funções pode usar os mapas-k, mas não é difícil ler directamente a tabela e
fazer a optimização. Experimente antes de ver as funções.
𝐴2 = 𝐷4
𝐴1 = ̅̅̅̅
𝐷4. 𝐷3 + ̅̅̅̅
𝐷4. ̅̅̅̅
𝐷3. 𝐷2 = ̅̅̅̅𝐷4. (𝐷3 + ̅̅̅̅
𝐷3. 𝐷2) = ̅̅̅̅𝐷4. (𝐷3 + 𝐷2)
̅̅̅̅. 𝐷3 + 𝐷4
𝐴0 = 𝐷4 ̅̅̅̅. 𝐷3
̅̅̅̅. 𝐷2
̅̅̅̅. 𝐷1 = 𝐷4
̅̅̅̅. (𝐷3 + 𝐷3
̅̅̅̅. 𝐷2
̅̅̅̅. 𝐷1) = 𝐷4
̅̅̅̅. (𝐷3 + 𝐷2
̅̅̅̅. 𝐷1)
𝑉 = 𝐷4 + 𝐷3 + 𝐷2 + 𝐷1 + 𝐷0
EXERCÍCIOS
1. Implemente a função F(D,C,B,A) utilizando um e só um descodificador com duas entradas
seleção/endereço (para quatro linhas de saída) e a lógica adicional elementar que considerar
necessária.
𝐹(𝐷, 𝐶, 𝐵, 𝐴) = ∏(0,1,7,8,12,13,14)
Resolução:
A tabela de verdade e as funções usando as variáveis DC como entradas de selecção:
DCBA F DC como entradas de selecção

0000 0
0001 0
𝐹0 = 𝐵
0010 1
0011 1
0100 1
0101 1
𝐹1 = ̅̅̅̅̅
𝐵. 𝐴
0110 1
0111 0
1000 0 𝐹2 = 𝐵 + 𝐴

90
1001 1
1010 1
1011 1
1100 0
1101 0
𝐹3 = 𝐵. 𝐴
1110 0
1111 1
Obtemos o seguinte circuito:
Circuito 31 – Implementação de função com um descodificador de 2 entradas de selecção
ARITMÉTICA
COMPARADOR
O circuito comparador visa verificar se duas palavras binárias são iguais ou diferentes. A comparação é
realizada bit a bit. Dito por outra forma, duas palavras são iguais se todos os bits são iguais.
Alias, tal como acontece na comparação em decimal. Dois números são iguais, quando todos os algoritmos
dos dois números são iguais. Não esquecer que este circuito pode ser utilizado para comparar letras,
instruções, etc. Por isso usamos “palavra”.

91
A comparação de dois bits pode ser realizada através de uma porta XOR (ou XNOR).
Circuito 32 – Circuito diferença entre dois bits de peso 0.
Pela funcionalidade do XOR a saída Differença é activada quando as entradas forem diferentes. A
utilização da porta XNOR implementaria por complementaridade a saída igualdade, se não é diferente é
igual.
O passo seguinte é comparar mais bits. Projectemos um circuito comparador para duas palavras de 4 bits.
Numa aproximação não modular podemos comparar bit a bit e ligar a saída dos quatro XOR a uma porta
lógica OR.
O próximo exemplo é um comparador de 4-bits que efectua o OR entre as saídas de 4 portas XOR.
Circuito 33 – Circuito comparador de dois números com 4 bits.
Recorde que na figura anterior, o Resultado do comparador é a função “Diferente”. Na realidade duas
palavras de 4 bits são diferentes se os bits de menor peso das duas palavras são diferentes ou os dois bits
de peso 21 das duas palavras forem diferentes, ou os dois bits de peso 22 das duas palavras forem
diferentes ou os dois bits de peso 22 das duas palavras forem diferentes.
O problema desta aproximação que não é modular é a expansão. A pergunta que se pode fazer a seguir é
“e se quisermos mais bits? ” Quatro, cinco ou seis bits ou mais.
Numa aproximação modular temos que projectar o circuito tendo em consideração que a comparação de
dois bits será utilizada para comparar duas palavras com N bits.

92
À luz desta nova aproximação podemos comparar os bits do mesmo peso, mas só declaramos igualdade
caso o andar anterior também o tenha feito. Resulta assim que ficamos com um comparador de bits com
uma entrada que recebe a informação se os andares de menor peso são iguais ou distintos.
Circuito 34 – Circuito comparador igualdade e diferença modular
Resolvemos assim o nosso problema de forma modular e a comparação de números com N bits realiza-
se à custa de N componentes.
Circuito 35 – Ligação de módulos de comparação de dois bits com transporte
Repare que a entrada de menor peso está ligada a VCC (+5V) o que na verdade quer dizer que todos os
bits inferiores ao bit de peso 0 (20 ) são iguais entre si. O que podemos assumir como verdade universal:
dado que não há bits anteriores a este, podemos assumir que são todos iguais entre si.
SOMADOR
A soma é uma operação base em todos os sistemas. A partir da soma podemos construímos a subtração,
multiplicação, somatório, etc.
Um somador é um circuito que adiciona duas palavras seguindo as regras da adição.
SEMI-SOMADORES
Como fizemos no comparador vamos começar por adicionar dois bits. A este circuito chamamos semi-
somador. Como soma dois bits, tem como resultados possíveis em decimal 0,1 ou 2, o que nos obriga a
ter dois bits como resultado.
A B T S Decimal
0 0 0 0 0
0 1 0 1 1

93
1 0 0 1 1
1 1 1 0 2
O bit resultado da soma do bit A com o bit B é representado em binário pela Soma (S) e o Transporte (T).
O transporte (Carry) é o famoso “e vai um” que aprendemos na primária. Retirando as expressões em
lógica booleana obtemos:
𝑆 = 𝐴⨁𝐵 = +𝐴𝐵̅ + 𝐴̅𝐵

𝑇 = 𝐴. 𝐵
Circuito 36 – Circuito Semi-somador
SOMADOR COMPLETO
A construção do somador completo tem de entrar em conta com o transporte da soma dos bits anteriores
(o “e vai um”). Para além das entradas dos dois bits passamos a ter também o transporte. Existem agora
3 variáveis e quatro resultados possíveis: 0,1,2,3. O resultado continua assim a ser a dois bits, a soma e o
transporte para o andar seguinte. Obtemos assim a seguinte tabela de verdade:
Tin A B Tout S Decimal

0 0 0 0 0 0
0 0 1 0 1 1
0 1 0 0 1 1
0 1 1 1 0 2
1 0 0 0 1 1
1 0 1 1 0 2
1 1 0 1 0 2
1 1 1 1 1 3
𝑆 = 𝐴 ⨁ 𝐵 ⨁ 𝐶𝑖𝑛
𝑇𝑜𝑢𝑡 = 𝐴. 𝐵 + 𝐴. 𝑇𝑖𝑛 + 𝐵. 𝑇𝑖𝑛

94
Circuito 37 – Circuito somador completo
SUBTRACÇÃO
A subtração pode ser realizada através da adição desde que se transforme o número a subtrair em
complemento para 2. Como é sabido o complemento para 2 obtém-se invertendo todos os bits e
adicionando o valor 1. Neste sentido o somador completo é o instrumento ideal para construir o nosso
subtrator. Basta inverter todos os bits do número a subtrair e garantir o valor um na entrada de
transporte. Verifique o esquema eléctrico.
Circuito 38 – Circuito somador/subtrator
Recorde que em qualquer circuito as entradas devem estar todas ligadas (a variáveis de entrada, à saída
de outros circuitos, a VCC ou GND). Nunca se devem deixar entradas “no ar”; i.e. sem qualquer ligação ou
o circuito pode comportar-se de forma errática. Em oposição, saídas que não vão ser utilizadas por
circuitos a jusante devem ser deixadas “no ar”; i.e. sem qualquer ligação, sob pena de virmos a produzir
curto-circuitos. Nunca mas nunca, deve uma saída de um circuito ser ligada a VCC ou GND.
EXERCÍCIO
1. Implemente um Somador/Subtrator de dois números de quatro bits.

95
Circuito 39 – Implementação do circuito somador/subtrator de dois números de 4 bits

96
COMPONENTES DE MEMÓRIA
Os sistemas implementados com as funções booleanas usadas até este momento não têm noção de
estado, i.e. as saídas dependem exclusivamente do valor das suas entradas. Contudo, há diversos
problemas em que é necessário ter uma noção de estado, ou seja, de memória do que já ocorreu.
A análise temporal faz sentido nestes circuitos.
COMPONENTES TIPO LATCH
Estes componentes reagem às entradas no momento em que elas são alteradas contudo, devido à sua
capacidade de memória, o seu comportamento é muito distinto dos circuitos booleanos “puros” (também
designados como combinatórios).
LATCH
O objectivo é construir um componente que registe o valor de um bit, ou seja, que memorize “um” ou
“zero”.
Repare que pela primeira vez temos a noção de valor de estado, a saída Q, que mantém o seu valor até
que uma das suas entradas seja acionada; i.e. que uma das entradas deixe de ser 0. Note que a
representação Qt significa o valor da saída Q no instante t e Qt-𝛅 significa o valor da saídas Q no instante
anterior a t.
S R Qt ̅𝒕
𝑸
0 0 Qt-𝛅 ̅̅̅̅̅̅
𝑄𝑡−𝛿
0 1 0 1
1 0 1 0
1 1 X X
Tabela 25 – Tabela de verdade do Latch SR
A grande novidade, em relação aos circuitos anteriores, é que para a mesma combinação de entradas a
saída pode ser diferente.
Repare que enquanto as entradas S e R mantiverem o seu valor a zero, (primeira posição da tabela de
verdade) o valor de saída não se altera mas pode ser zero, ou um. Depende se anteriormente foi realizada
a operação de reset (forçar zero) ou set (forçar um).

97
Podemos assim interpretar a tabela de verdade como operações que queremos realizar sobre o nosso
componente:
• Manter: S=R=0 mantem o valor anterior.

• Reset: S=0 e R=1 força a saída a “zero”.
• Set: S=1 e R=0 força a saída a “um”.
• Impossível: S=R=1 comportamento indeterminado. É impossível forçar o componente a zero e
um em simultâneo.
Mais uma vez, R=S=0 não define o valor da saída, somente assegura que o valor anterior se mantém.
Para construirmos a capacidade de memória faremos recurso a um mecanismo de realimentação.
Implementação com NOR:
Circuito 40 – Latch SR implementado com NORs
Implementação com NAND:
Circuito 41 – Latch SR implementado com NANDs
Figura 53 – Símbolo lógico de Latch SR com entradas active high e active low respectivamente

98
LATCH COM ENABLE

Vamos agora adicionar uma entrada de enable.
Neste caso o enable bloqueia a reacção do componente às entradas S e R. Com o enable inactivo o
componente mantém o valor.
A forma mais simples de obter esse comportamento na implementação com NORS é garantir que sempre
que o enable está a zero, as entradas do Latch ficam forçados a “zero” mantendo o estado anterior.
Circuito 42 – Circuito LATCH SR com Enable active high com NORs
Figura 54 – Símbolo lógico de LATCH SR com enable active high
Análise temporal com o Enable a “um”.
Com o enable a variar. Verifique que o componente só está sensível as entradas S e R quando o enable
está activo; i.e. a um.

99
Figura 55 – Diagrama temporal do FF SR com enable
D-LATCH
O objectivo agora é ter uma entrada (D) que é memorizada quando o enable está activo.
Circuito 43 – Circuito D latch com NANDs
O símbolo:
Figura 56 – Símbolo lógico de Latch D com enable
O diagrama temporal.

100
Figura 57 – Diagrama temporal do D latch
FLIP-FLOPS (EDGE TRIGGERED)
Os componentes latch memorizam durante um período, o que não é apropriado para a criação de circuitos
lógicos sequenciais síncronos. Não basta que as entradas estejam bloqueadas até à activação do enable.
Nos sistemas síncronos necessitamos que a memorização seja realizada num determinado instante.
Este instante é assinalado na mudança de valor de uma variável muito especial chamada de clock (relógio).
O flip-flop pode ser de flanco ascendente (passagem de 0 para 1) ou de flanco descendente (passagem de
1 para 0).
As alterações de estado ocorrem exclusivamente no instante da transição do clock. Esta propriedade é

essencial para conseguirmos obter sistemas síncronos. Sistemas em que temos a garantia que todas as
eventuais alterações nos seus componentes ocorrem de forma síncrona; i.e no mesmo instante.
O CLOCK
O clock é uma onda cíclica. Normalmente associamos o clock a uma onda quadrada. Num período de clock
existem sempre duas transições. A transição ascendente (0 para 1) e a transição descente (1 para 0). Os
dispositivos que podem reagir à transição ascendente, são apelidados de dispositivos de flanco
ascendente, ou de flanco descendente se reagirem na transição de um para zero.
Figura 58 – O sinal quadrado clock
FLIP-FLOP D (CLOCK)
A diferença entre um flip-flop D e um D- latch reside na definição de quando é que o estado (à sua saída
Q) muda. O flip-flop é um componente com clock. As alterações de estado são determinadas somente no
flanco do clock.

101
Figura 59 – Símbolo lógico de Flip-Flop D com disparo em flanco ascendente e descendente
Este componente só é sensível à entrada D no momento da transição do clock.
Entradas Saídas Comentário

D CLK Q Q’
1 1 0 SET
0 0 1 RESET
Tabela 26 – Tabela de verdade do Flip-Flip D com clock de disparo em flanco ascendente
No diagrama temporal é possível verificar que as saídas do Flip-flop só são afectadas no momento da
transição ascendente do clock. Note também, na figura seguinte, que as transições de valores não são
imediatas todos os circuitos levam algum tempo a reagir e estabilizar os valores desde o instante em que
as suas entradas mudam de valor.
Figura 60 – Diagrama temporal do comportamento do FFD de disparo ascendente.
Uma implementação possível de Filip-flop D com clock é conseguida com dois D latch. Esta implementação
é denominada latch D mestre-escravo.
Circuito 44 – Circuito FF D com clock implementado com Latch D

102
Circuito 45 – Circuito FF D com clock com portas lógicas
FLIP-FLOP JK (CLOCK)
O flip-flop J-K é mais versátil que o flip flop D. Não tem a entrada de dados. Tem duas entradas, chamadas
de J e K. Em tudo semelhantes ao S-R contudo a situação J = K = 1 está descrita e realiza a operação de
inversão de estado (Toggle) no momento da transição do clock.

J K CLK Q Q’
0 0 Qt-1 Q’ t-1 Mantém
0 1 0 1 RESET
1 0 1 0 SET
1 1 Q’t-1 Qt-1 Troca
Tabela 27 – Tabela de verdade do Flip-Flip JK com clock de disparo em flanco ascendente
̅ ).
Figura 61 – Diagrama temporal do FF JK. Na figura, a última linha corresponde à negação do valor da saída Q (!Q=Q’=𝑸
CIRCUÍTO INTEGRADO FLIP-FLOP J-K (74LS76)

103
Figura 62 – Símbolo lógico 74LS76
Figura 63 – Modelo de operação, diagrama lógico e símbolos lógicos (Copyright Datasheet de ON Semiconductor)
Figura 64 – Pinout do 74LS76
FLIP-FLOP T (CLOCK)
O flip-flop T só tem uma entrada que indica se deve manter o estado ou inverter. Descrito de outra forma
ou mantém o valor memorizado ou inversão esse valor (Toggle) no momento da transição do clock.
Repare que na tabela são apresentados as saídas Q e Q’.

104

T CLK Q Q’
0 Qt-1 Q’ t-1 Mantém
1 Q’t-1 Qt-1 Troca
Tabela 28 – Tabela de verdade do Flip-Flip T com clock de disparo em flanco ascendente
Apresentamos agora como implementar um FF-T usando um FF-D.
Quando T=0 queremos ter à entrada do D o valor memorizado, no caso contrário, T=1 queremos forçar
em D o inverso do valor memorizado.
T Q D
0 0 0
0 1 1
1 0 1
1 1 0
Tabela 29 – Tabela de verdade para implementação de Flip-Flip T com FF-D
Extraindo a função obtemos a expressão:
𝐷 = 𝑄 𝑋𝑂𝑅 𝑇
Figura 65 – Diagrama temporal do FF T
EXERCÍCIOS
1. Para o FF JK com preset e clear (activos a 1) desenhe a forma de onda das saídas Q e 𝑄̅

105
2. Para o FF JK presete e clear (activos a zero) e clock com disparo em flanco descendente desenhe
da forma de onda das saídas Q e 𝑄̅
3. Assinale a resposta correcta. Quando nos referimos à entrada CLK de um flip-flop, o termo
disparo no flanco ascendente significa que:
a. essa entrada não é activada por nenhuma parte do sinal de pulso.
b. essa entrada é activada pela transição de zero para um do sinal de clock.
c. o flip-flop está a trabalhar em modo assíncrono.
d. essa entrada é activada por um sinal sinusoidal.
4. Construa um contador binário reversível de três bits
5. Projecte um contador síncrono módulo 6 com saída de transporte (carry) usando FF JK
RESOLUÇÕES
1.
2.

106

107
MÁQUINAS DE ESTADO SINCRONAS
Os sistemas construídos com máquinas de estados síncronas são definidos através de um conjunto de
estados finitos, das transições entre estados condicionadas em função das suas entradas, e das acções ou
saídas de cada estado. As máquinas de estado são síncronas porque as transições entre estados
acontecem ao ritmo do clock, ou seja na transição ascendente ou descendente um sinal de clock.
Para construirmos máquinas de estado síncronas juntamos circuitos de lógica booleana combinacional e
elementos de memória.
Figura 66 – Diagrama geral de uma máquina de estados
Nestes sistemas as saídas são função das entradas e do estado corrente. Por outras palavras, as saídas a
cada momento dependem das entradas, assim como do estado corrente.
Usando um flip-flop D com clock para ajudar a visualizar este sistema:
Figura 67 – Diagrama geral de uma máquina de estados com FF-D
Repare que as saídas passam a depender do bloco final (lógica de saída) que tem dois elementos de
entrada:
• as variáveis de entrada
• e a saída do elemento de memória (estado actual).

108
À entrada dos flip-flops está sempre a lógica que define qual o estado seguinte. Contudo, a mudança de
estado só ocorre na transição do clock.
Entre transições o estado corrente está estável, porém as entradas, que são independentes, podem
induzir alterações nas saídas e no estado futuro. O comportamento das saídas passa assim a poder ser
diferente para as mesmas entradas, dependendo do estado, o que não acontece na lógica combinacional
pura, em que para as mesmas entradas temos sempre as mesmas saídas.
Se as entradas mudarem o seu valor ao longo de um período (o que pode ocorrer inclusive diversas vezes)
podem induzir distintos estados futuros (à entrada dos flip-flops), contudo estes estados não acontecerão
porque ocorrem entre transições do sinal de clock.
IMPLEMENTAR MÁQUINAS DE ESTADO

A implementação de máquinas de estados segue os seguintes passos:
1) Interpretação: Nesta fase procuramos eliminar ambiguidades tendo como objectivo definir
quais, quantos e qual o comportamento de:
a. Variáveis de entrada
b. Variáveis de saída
c. Estados
2) Definição do Diagrama de estados: o desenho do diagrama de estado é realizado normalmente
com o recurso ao modelo de Moore ou Mealy. O seu desenho permite visualizar pela primeira
vez a máquina de estado que desejamos e esclarecer todas as situações possíveis.
3) Codificação dos estados: definição de quantos FF necessitamos e atribuir a cada estado o seu
um código único.
4) Tabela de transições: descrição em forma tabular da máquina de estados tendo em
consideração o estado presente e o estado futuro (como função das entradas e do estado
presente).
5) Flip-flops: definir quais os flip-flops a utilizar. Esta fase depende essencialmente da
disponibilidade. Lembre-se que apesar do FF JK de ter uma tabela de excitação mais complicada
gera circuitos muito simples devido à sua elevada expressividade (e à possibilidade de obter as
mesmas saídas com duas configurações possíveis da entrada, sabendo que o FF se encontra num
dado estado; tal facto permite a utilização de don't-care em cada linha da tabela de excitação, o
que vai aumentar a simplificação, como veremos mais à frente).
6) Tabela de excitação: tendo em consideração os FF, criar a tabela que descreve os valores a forçar
às entradas que garantam que o próximo estado é especificado na tabela de transições.
7) Extracção de funções: Nesta última fase realizamos a simplificação das funções de entrada dos
FF e das saídas.
MODELO MOORE E DIAGRAMA DE ESTADOS

No modelo de descrição máquina de estados Moore as saídas dependem exclusivamente dos estados.
Dito de outra forma, as saídas são estáveis em cada estado.
A formalização de uma máquina de estado é assim:

109
𝑀𝑀𝑜𝑜𝑟𝑒 = (𝑄, 𝐸𝑛𝑡, 𝑆𝑎𝑖, 𝑡𝑟𝑎𝑛, 𝑟𝑒𝑠, 𝑞0 )
onde,
𝑄: conjunto de estados
𝐸𝑛𝑡: conjunto de variáveis de entrada
𝑆𝑎𝑖: conjunto de variáveis de saída
𝑡𝑟𝑎𝑛: 𝑄𝑥𝐸𝑛𝑡 → 𝑄, função de transição de estados
𝑟𝑒𝑠: 𝑄 → 𝑠𝑎𝑖, função de resposta
𝑞0 ∈ 𝑄: estado inicial
Graficamente, adoptamos a seguinte notação:
Figura 68 - Notação gráfica no modelo de Moore
Um exemplo de uma máquina de estados representada em diagrama modelo Moore:
Figura 69 – Exemplo de um diagrama de máquina de estados modelo Moore
Repare que neste diagrama:
• as variáveis nos arcos definem a condição de transição (variáveis de entrada).

• no estado superior o estado tem o nome Q0 e as saídas assumem o valor 01
• as saídas dependem exclusivamente do estado.

110
MODELO MEALY
No modelo Mealy as saídas dependem do estado e das entradas. Dito de outra forma, para o mesmo
estado as saídas podem mudar em resposta a alterações às entradas.
A formalização de uma máquina de estado é assim:
𝑀𝑀𝑒𝑎𝑙𝑦 = (𝑄, 𝐸𝑛𝑡, 𝑆𝑎𝑖, 𝑡𝑟𝑎𝑛, 𝑟𝑒𝑠, 𝑞0 )
onde,
𝑄: conjunto de estados
𝐸𝑛𝑡: conjunto de variáveis de entrada
𝑆𝑎𝑖: conjunto de variáveis de saída
𝑡𝑟𝑎𝑛: 𝑄𝑥𝐸𝑛𝑡 → 𝑄, função de transição de estados
𝑟𝑒𝑠: 𝑄𝑥𝐸𝑛𝑡 → 𝑠𝑎𝑖, função de resposta
𝑞0 ∈ 𝑄: estado inicial
Graficamente, adoptamos a seguinte notação:
Figura 70 - Notação gráfica no modelo de Mealy
Um exemplo que um diagrama de estados Mealy:

111
Figura 71 - Exemplo de máquina de estados Mealy
Como pode verificar para um mesmo estado a saída pode ver o seu valor alterado pois depende do estado,
mas igualmente do valor da variável representada no arco. Repare na resposta da saída para cada estado:
• Q0 as saídas assumem o valor 01.

• Q2 as saídas assumem valor 11
• Q1 as saídas assumem valor 00
A TABELA DE EXCITAÇÃO DOS LATCH SR E DO FFJK

A construção da tabela de excitação dos FF é um auxiliar precioso na construção das tabelas de excitação
das máquinas de estado. Só existem quatro casos possíveis:
• 0->0 – transita de zero para zero (mantém zero)

• 0->1 – transita de zero para um (força um)
• 1->0 – transita de um para zero (força zero)
• 1->1 – transita de um para um (mantém um)
Repare que ficar no mesmo estado é garantir que à entrada do FF estão as entradas que asseguram que
o valor do FF fica inalterado. Existe uma acção de escrita no FF mesmo que o valor da saída fique idêntico.
A construção tabela de excitação é realizada seleccionando a acção, ou acções, que forçam o

comportamento desejado. Sempre que existem duas acções possíveis para forçar o comportamento
desejado estamos na presença de don’t cares.
A tabela de excitação do FF-SR:
Tabela de verdade Tabela de excitação

S R Acção Qt -> Qt+1 Acção S R
Mantém
0 0 Qt Mantém 0->0 0 X
Limpa
0 1 0 Limpa 0->1 Marca 1 0
1 0 1 Marca 1->0 Limpa 0 1
Mantém
1 1 - NA 1->1 X 0
Marca
Tabela 30 - A tabela de verdade e de excitação dos Flip-flop SR

112
Relembre que ao contrário do FF-SR, que não possui comportamento para as duas entradas a um, o FF-JK
inverte o seu estado. Desta forma obtemos uma tabela de excitação com mais don’t cares que conduz
naturalmente a funções mais simplificadas.
Tabela de verdade Tabela de excitação

J K Acção Qt -> Qt+1 Acção J K
Matém
0 0 Qt Mantém 0->0 0 X
limpa
Marca
0 1 0 Limpa 0->1 1 X
Inverte
Limpa
1 0 1 Marca 1->0 X 1
Inverte
̅̅̅ Mantém
1 1 𝑄𝑡 Inverte 1->1 X 0
Marca
Tabela 31 - A tabela de verdade e de excitação dos Flip-flop JK
Estamos agora em condições de construir a tabela de excitação do próximo estado combinado a tabela
de transições com a tabela de excitação.
UM CONTADOR
Um contador é uma máquina de estados que incrementa sequencialmente o valor das suas saídas até
atingir o máximo retornando depois ao início. Resulta assim num ciclo infinito de estados finitos.
Consideremos um contador com a seguinte sequência 00->01->10->11->00. A descrição desta máquina

de estados pode ser realizada através do seguinte diagrama de estados.
Figura 72 - Diagrama de estados Moore de contador crescente de dois bits
Nota: Não é possível contar se não tivermos memória do número anterior.
Podemos agora construir a tabela de transições, ou seja, uma descrição de qual o estado seguinte tendo
em conta o estado corrente e as entradas. Neste caso não existem entradas.
A tabela de transições é assim:

113
Estado Próximo
corrente estado
Q1t Q0 t Q1t+1 Q0 t+1
0 0 0 1
0 1 1 0
1 0 1 1
1 1 0 0
A tabela de transições é uma descrição do diagrama de estados. Não há qualquer ambiguidade. Em cada
estado corrente Q1t Q0t sabemos sempre qual será o estado futuro.
O próximo passo é contruirmos a tabela de excitação que descreve os valores das entradas dos flip-flops
que asseguram o comportamento desejado. A tabela de excitação depende dos flip-flops.
IMPLEMENTAÇÃO COM FF SR
Estamos agora em condições de contruir a tabela de transição do próximo estado.
Se pensarmos nas transições que queremos obter podemos construir a seguinte tabela auxiliar:
S R
0->0 0 X
0->1 1 0
1->0 0 1
1->1 X 0
As primeiras quatro colunas são uma cópia da tabela de transições. As seguintes são os valores que temos
de impor às entradas dos FF SR para garantir que o seu próximo estado é o que esperamos (tabela de
excitação).
Estado corrente Próximo estado Entradas FF 1 Entradas FF 0

Q1t Q0 t Q1t+1 Q0 t+1 S1 R1 S0 R0
0 0 0 1 0 X 1 0
0 1 1 0 1 0 0 1
1 0 1 1 X 0 1 0
1 1 0 0 0 1 0 1
Neste momento a implementação do circuito é uma questão de extrair as funções lógicas. Vamos obter
quatro funções algébricas para as nossas quatro entradas. Para auxiliar a visualização deste processo
vamos desenhar as tabelas de verdade.
FF1 FF1 FF0 FF0

Q1 Q0 S1 Q1 Q0 R1 Q1 Q0 S0 Q1 Q0 R0
0 0 0 0 0 X 0 0 1 0 0 0
0 1 1 0 1 0 0 1 0 0 1 1
1 0 X 1 0 0 1 0 1 1 0 0
1 1 0 1 1 1 1 1 0 1 1 1
Podemos assim tirar as funções:

114
FF1:
𝑆1 = 𝑄1 ⊕ 𝑄0
𝑅1 = ̅̅̅̅̅̅̅̅̅̅̅̅
𝑄1 ⊕ 𝑄0
FF0:
𝑆0 = ̅̅̅̅
𝑄0
𝑅0 = 𝑄0
A nossa máquina de estados está quase finalizada. Só falta montar as peças. Sabemos que vamos usar
dois FF SR que partilham o clock e cujas saídas Q serão o nosso contador. Antes de extrairmos as funções
sabíamos assim que obteríamos um circuito com a seguinte forma:
Circuito 46 – Circuito base do contador crescente de 2 bits com FF SR
Aplicando as funções obtemos o circuito contador que pretendíamos:
Circuito 47 – Circuito contador crescente de 2 bits com FF SR
EXEMPLO DE APLICAÇÃO DE MÁQUINAS DE ESTADO: CONTROLO DO MOTOR

Considere que queremos controlar um motor que tem como função encher um tanque de água.
Queremos ligar o motor para encher o tanque, e manter o motor desligado durante o consumo de água
até o taque chegar ao nível de reserva (B=0) altura em que devemos voltar a ligar o motor.

115
O exercício parece simples, mas não tem solução com lógica combinacional. Temos de usar máquinas de
estado. É necessário saber se o motor está ligado ou desligado.
Figura 73 – Representação do sistema de armazenamento de água
Tentemos com lógica booleana combinacional, ligamos o motor enquanto o sensor de topo não detectar
água, e desligamos quando o tanque estiver cheio.
T B P
0 0 1
0 1 1
1 0 X
1 1 0
O problema surge neste momento. Quando consumirem água o sensor de topo fica seco, e caímos
imediatamente na situação T=0 e B=1 ligando o motor. Ficávamos assim com um sistema que depois de
encher o taque ligava e desligava o motor durante o consumo de água mantendo sempre o tanque cheio,
e o motor a arrancar e a desligar. Não é o que se pretende. Relembramos que queremos ligar o motor
para encher o tanque, e manter o motor desligado durante o consumo de água até o taque chegar ao
nível de reserva (B=0). É necessário saber se o tanque está a encher ou a vazar.
O diagrama de estados para um sistema síncrono que permite esta operação é o seguinte:
Figura 74 - Diagrama de estados Moore para controlador do motor com dois sensores

116
A tabela de verdade:
Repare que até este momento a aproximação é genérica. Não se discute qual o tipo de flip-flops a usar.
O próximo passo necessita dessa definição.
CIRCUITO COM FLIP-FLOPS D

A implementação com flip-flops-D é directa.
Retirando as funções:
𝐷 = 𝑇𝐵 + 𝑄𝑡 𝐵
𝑃 = ̅̅̅
𝑄𝑡
O circuito:
Circuito 48 – Circuito de máquina de estados controladora de motor para enchimento de tanque de água com FFD

117
CIRCUITO COM FLIP-FLOPS JK

No caso de optarmos por usar um flip-flop JK obtemos a seguinte tabela de excitação para J e K.
A construção do mapa-k é agora uma operação simples:
E as funções em resultado da flexibilidade dos FF JK são extraordinariamente simples.
𝐽=𝑇
𝐾 = 𝐵̅
𝑃 = ̅̅̅
𝑄𝑡
Obtemos assim o circuito final.
Circuito 49 – Circuito de máquina de estados controladora de motor para enchimento de tanque de água com FFJK
CONTADOR ASCENDENTE E DESCENDENTE (UP/DOWN)

Criemos um circuito contador ascendente e descendente. Para simplificar comecemos por contar até três,
i.e. na sequência ascendente: 0->1->2->0->1->… e na sequência descendente: 2->1->0->2->1->…

118
Verifique que é impossível projectar este sistema sem a noção de memória.
Da análise do enunciado fica claro que necessitamos de três estados, um para cada número.
Necessitamos de uma variável de entrada para decidir se contamos de forma ascendente ou descendente.
O diagrama de estados para um sistema síncrono:
Figura 75 - Diagrama de estados para contador crescente e decrescente de dois bits.
A cada clock existe uma mudança de estado em função da variável UP.
A tabela de verdade:
CIRCUITO COM FLIP-FLOPS D

A implementação com flip-flops-D é directa. A entrada D tem de ficar com o estado futuro.

119
Obtemos desta vez dois mapas-k:
Retirando as funções:
𝐷0 = ̅̅̅ ̅̅̅̅̅̅̅̅̅̅1)
𝑄0 . (𝑈𝑃⨁𝑄
𝑄1 . (𝑈𝑃⨁𝑄0 ̅ )
𝐷1 = ̅̅̅
O circuito:
Circuito 50 – Circuito contador ascendente e descendente com FFD.
DETECTOR DE SEQUÊNCIA
Um detector de sequência é uma máquina de estados que tem uma só entrada que é interpretada como
um vector de bits, i.e. uma sequência de bits, cujos valores são lidos na transição de estado. Uma máquina
detectora de sequência activa a saída sempre que identifica um padrão específico.
Existem dois tipos de detectores de sequência:
• Com sobreposição: um subpadrão de uma sequência pode ser reutilizado na seguinte.

• Sem sobre posição: não se reutilizam subpadrões.
DETECTOR DE SEQUÊNCIA 101 SEM SOBREPOSIÇÃO

120
Figura 76 - Diagrama de estados de detector de sequência 101 sem sobreposição.
Note ainda que a progressão de estados ocorre à medida que vamos sucedendo que avançamos na
máquina de estados. O estado “State1” pode ser identificado como o estado em que o último dígito que
identificámos foi o dígito “1” (que é efectivamente o primeiro dígito da nossa sequência “101”). Enquanto
continuarmos a receber “1” continuamos no mesmo estado.
Quando recebemos um zero já avançámos mais um passo na nossa sequência (“State2” – que pode ser
interpretado como: “Já recebemos 01”). Neste ponto a chegada de um novo zero interrompe o processo
de detecção de sequência e faz-nos voltar ao início. No entanto receber um “1” neste estado completa a
nossa sequência e avançamos para o estado “State3” onde temos a detecção da sequência colocando a
saída “O” a um.
No “State3” a chegada do próximo dígito pode dar origem a duas situações. Se o dígito é um zero temos
de continuar à procura de um “1” para iniciar uma nova sequência. Se o dígito é um “1” pode ser o início
de uma nova sequência e retornamos ao estado “State1” que é aquele que diz que já recebemos um “1”
e o processo de deteção de uma nova sequência pode continuar.
DETECTOR DE SEQUÊNCIA 101 COM SOBREPOSIÇÃO

121
Figura 77 - Diagrama de estados de detector de sequência 101 com sobreposição.
EXERCÍCIOS
1. Contrua um contador binário reversível de três bits; por reversível entende-se que depende de uma
variável de controlo “UP” que quando toma o valor “1” faz com que o contador conte em ordem
crescente e quando toma o valor “0” faz com que o contador conte em ordem decrescente.
2. Projecte um sistema para controlar um semáforo de transito em que reservamos 5 unidades de
tempo para o vermelho, 7 para o verde e 2 para o amarelo.
3. Acrescente ao sistema anterior um botão de pedido de paragem de peão e altere o seu
funcionamento para que esteja sempre a apresentar o valor verde até que o botão seja activado.
Quando for detectado o semáforo deve efectuar o ciclo apresentado no exercício 2.
4. Projecte um contador síncrono módulo 6 (portanto entre 0 e 5) com saída de transporte (carry)
usando FF JK
5. Descreva sucintamente o comportamento da máquina de estados, construa a tabela de transições e
de saídas, implemente e desenhe os circuitos usando FFD e FFJK.
6. Projecte uma máquina de estados síncrona que permita criar um sistema de segurança que desliga o
motor da serra de corte de pão sempre que a tampa de protecção é aberta. O sistema têm duas
entradas, porta aberta (sim ou não) e ligar motor (sim ou não). A entrada porta aberta é activada por
sensor, e ordem de ligar e desligar motor é por intervenção do utilizador.
7. Descreva sucintamente o comportamento da máquina de estados, construa a tabela de transições e

de saídas, implemente e desenhe os circuitos usando FFd e FFJK.
8. Considere um equipamento de venda de água que aceita moedas de 50 cêntimos e 1 Euro. Uma
garrafa custa 1,5 euros. Construa uma máquina de estados que tenha duas entradas E50
(50centimos), E1(1 euro) para os tipos de moedas, as saídas V (venda) e D50 (devolve 50 cêntimos) e
D1 (devolve 1 euro) e que active a saída V sempre que a máquina alcança o valor de 1,5 euros,
devolvendo o valor das moedas em excesso (ou seja, activação dos respectivas saías D).

122
9. Construa um sistema comparador de números de dois bits que surgem sequencialmente. O objectivo
é ter duas saídas, C-crescente e D-decrescente que assinalam se os números apresentadas na
entradas X1 e X0 que representam um valor bináro N de 2 bits estão a aumentar ou diminuir. Se os
números forem iguais C e D devem assumir o valor zero.

123
INTRODUÇÃO AO CPU
Este texto foi desenvolvido como material de apoio as aulas de Sistemas Lógicos II do curso de Engenharia
Electrotécnica e de Computadores.
Ao longo deste texto vamos projectar um CPU didático de oito bits (um byte).
Assumimos que os leitores possuem conhecimentos de Sistemas Lógicos I, dito de outra forma, que
conhecem a lógica booleana, portas lógicas e implementação de funções, que conhecem Flip flops com
os quais são capazes de implementar máquinas de estado. São estes os conhecimentos básicos que
permitem projectar o CPU que numa primeira definição vamos descrever como uma máquina de estados
genérica que executa instruções arquivadas na memória.
Esta tarefa parece difícil contudo é este o nosso desafio para 14 semanas em ambiente de aula. Dar uma
visão global aos nossos alunos dos principais elementos que fazem parte de um computador pessoal com
especial ênfase no CPU, na Memória, e na capacidade de comunicação com dispositivos (os periféricos)
via polling e mecanismo de tratamento interrupções.
Evoluiremos das máquinas de Estado implementadas à custa de tabelas de verdade e de mapas de

Karnaugh para a construção de uma máquina estado genérica capaz de ser programável através da
memória.
Os componentes principais que fazem parte de um computador pessoal são o CPU, a Memória e os
periféricos (monitor, teclado, rato, etc.).
Nunca perdendo o objetivo final de construir um CPU que possa ser integrado num ambiente que se
assemelha a um computador pessoal teremos de iniciar este caminho de forma incremental.
O CPU - PRIMEIRAS NOÇÕES
Um CPU executa essencialmente 3 tarefas:
• transferência de informação entre registos ou entre um registo e a memória,

• operações aritméticas e lógicas,
• e controlo de fluxo, ou seja, definir qual a próxima instrução a ser executada
Para obtermos estas funcionalidades vamos decompor o CPU em dois elementos essenciais: i) uma
arquitetura, sobre a qual podemos executar operações e ii) uma máquina de Estados a que chamaremos
o controlador capaz de gerar os sinais que controlam o funcionamento da arquitetura por forma a
executar tarefas solicitadas pelo programador através de sequências de instruções (ou operações.
Desenharemos uma arquitetura de 8 bits, ou seja, 1 byte. Esta decisão afecta a quantidade de informação
que podemos armazenar (256 símbolos distintos) e também a capacidade de endereçamento (espaço de
memória e de periféricos) que passam a ter 256 posições distintas (a que correspondem 256 endereços
distintos).
A arquitectura terá um módulo que será responsável por efetuar operações aritméticas e lógicas: a ALU
(unidade aritmética e lógica).

124
Para além dos registos de uso comum disponíveis ao programador, usaremos diversos registos de uso
exclusivo pelo CPU e implementaremos mais tarde uma pilha (stack).
O denominador comum a todos estes requisitos é a existência de capacidade de memória de 8 bits (1

byte). Neste sentido vamos começar por criar um registo genérico capaz de memorizar a informação e
sobre o qual podemos realizar operações básicas (leitura, escrita, incremento, decremento, limpeza e
complemento).
O REGISTO DE 8 BITS SINCRONO

A capacidade de memória é essencial para a criação de máquinas de estado. Obtivemos memória através
da utilização de FILPFLOPS (FF). Os FF foram criados com o recurso ao mecanismo de realimentação na
lógica booleana e asseguram a capacidade de armazenar valores.
Como já foi referido anteriormente um byte são oito bits. Oito bits independentes que são vistos em
conjunto. Simplifica a construção do registo pensarmos nos bits de forma individual. Se preferir como um
conjunto de bits. Todas as operações que efetuamos sobre um registo de 1 byte podem ser observadas
como sendo realizadas em cada bit de forma independente, e em paralelo.
Neste sentido, podemos reduzir o problema da construção de um registo de oito bits à construção de um
registo de um bit. Uma vez construído o registo de um bit a criação de um registo oito bits consiste na
utilização de oito registos de um bit e fazer com que respondam a um mesmo conjunto de sinais em
simultâneo. Vamos assim criar as operações básicas somente para um bit.
Para o funcionamento do nosso registo de um bit assumimos os seguintes pressupostos:
1. as ações básicas são activadas por sinais que tenham o valor verdade, ou um.
2. as ações são mutuamente exclusivas; em cada instante, no máximo, um sinal de controlo estará
activo.
3. os sinais todos a zero configuram a situação em que o registo não altera a sua situação na
transição do clock. Mantem o valor memorizado.
Desta forma, por especificação, não está descrito o comportamento do registo no caso de mais de um
sinal estar activo.
É com o recurso a um flip-flop JK de um bit com clock que construiremos o registo de 8 bits síncrono.
A ESCRITA
A operação de escrita tem como função memorizar os dados de entrada. Neste sentido o nosso objetivo
é conseguir gravar um bit para mais tarde poder consultar o seu valor. A existência do clock garante o
sincronismo da acção.
Para que possamos escrever um valor no registo teremos uma entrada de dados que denominaremos
“data_in” na qual colocaremos o valor que pretendemos escrever. A acção de escrita é despoletada pela
existência do valor um na entrada de controlo que denominaremos “write”. A escrita efectiva acontecerá
quando o sinal de write estiver a um e existir um clock.

125
Se existir um clock e o sinal de write estiver a zero, por desenho, pretendemos que o FF mantenha o valor
que tinha anteriormente.
Considerando que utilizamos para o nosso registo de um bit um FF JK (a escolha de JK prende-se com a
flexibilidade que este FF demonstra para as várias operações que vamos considerar) a tabela de excitação
do mesmo, introduzida na Tabela 27, pode ser simplificada como se apresenta na seguinte tabela.
J K 𝑸𝒕+𝝏
0 0 𝑄𝑡
0 1 0
1 0 1
1 1 ̅̅̅
𝑄𝑡
Tabela 32 – Tabela de excitação do Flip-Flip JK
Para a operação de escrita (write) o comportamento pretendido é o seguinte:
• Se “write”=0, independentemente do valor de “data_in” então o FF mantém o estado

• Se “write”=1 então
o Se “data_in” = 0 o FF tem de assumir o valor 0
o Se “data_in” = 1 o FF tem de
Desta informação podemos deduzir a tabela de alteração dos estados do FF, em função das variáveis
“write”e “data_in”.
write data_in 𝑸𝒕+𝝏

0 0 𝑄𝑡
0 1 𝑄𝑡
1 0 0
1 1 1
Tabela 33 – Tabela de estado seguinte em função de “write” e “data_in”
Daqui, podemos então deduzir que valores de J e K teremos de ter em cada caso.
write data_in 𝑸𝒕+𝝏 J K

0 0 𝑄𝑡 0 0
0 1 𝑄𝑡 0 0
1 0 0 0 1
1 1 1 1 0
Tabela 34 – Tabela de excitação de J e K em função de “write” e “data_in”
Deduzir as equações de J e K como funções de write e data_in é então bastante linear:
• 𝐽 = 𝑤𝑟𝑖𝑡𝑒. 𝑑𝑎𝑡𝑎_𝑖𝑛
• ̅̅̅̅̅̅̅̅̅̅
𝐾 = 𝑤𝑟𝑖𝑡𝑒. 𝑑𝑎𝑡𝑎_𝑖𝑛
O que se traduz no seguinte circuito.

126
Circuito 51 – Circuito da operação de escrita de um bit.
Nota: De notar que estamos a utilizar um FF JK com clear assíncrono, o que quer dizer que se a entrada
CLR for a zero, o FF fica com o valor zero instantaneamente. O nosso princípio é o da construção de um
registo síncrono, o que significa que o seu valor só pode ser alterado na presença de um sinal de Clock.
É esta a razão pela qual a entrada CLR está ligada a VCC.
A LEITURA
A operação de leitura tem por objetivo consultar o valor armazenado no nosso registo. Se esquecermos
o objetivo de ligarmos este registo mais tarde a outros registos podíamos considerar a utilização da saída
Q do flip-flop. Contudo é nosso objectivo interligar todos os registos através de um BUS. Para tal vamos
recorrer a uma porta tristate. A activação do sinal de leitura (RCI) nesta montagem garante que o valor
memorizado fica disponível à saída do registo. No caso do sinal RCI não estar activo, a saída do registo
(Dout) está em alta impedância.
Circuito 52 – Circuito da operação leitura de um bit.
Nota: O buffer apresentado é activo a zero (active low) razão pela qual usamos o inversor.
A LIMPEZA (RESET)
A operação de limpeza “reset” consiste em forçar o valor zero no registo. A activação do sinal de reset
força assim um registo ao valor zero.
A abordagem pode ser a mesma que utilizámos para o write; i.e. enquanto o sinal reset estiver a zero o
FF mantém o seu valor. Quando reset vai a um, o FF passa a ter o valor 0.
reset 𝑸𝒕+𝝏
0 𝑄𝑡
1 0
Tabela 35 – Tabela de estado seguinte em função de “reset”

127
reset 𝑸𝒕+𝝏 J K
0 𝑄𝑡 0 0
1 0 0 1
Tabela 36 – Tabela de excitação de J e K em função de “reset”
É então fácil deduzir os valores de J e K como funções de reset:
• 𝐽=0
• 𝐾 = 𝑟𝑒𝑠𝑒𝑡
Circuito 53 – Circuito da operação de leitura de um bit.
O INCREMENTO
Para analisar o incremento um bit não basta. Incrementar um número em binário é passar para a
configuração de bits que representa o número decimal seguinte.
Vejamos um exemplo a 4 bits

128
Incrementar um número é passar da configuração de bits de uma linha para a configuração de bits da
linha seguinte.
Se reparamos o caso do bit menos significativo (bit 0), sempre que passamos para a linha seguinte esse
bit inverte o seu valor.
O bit seguinte (bit 1) já não se comporta da mesma forma. De facto, verificamos que ele só inverte o seu
valor se na linha de partida o bit menos significativo estiver a um. Situação semelhante se verifica no caso
do bit 2. Este só inverte o seu valor se o bit 1 estiver a 1 e o bit 0 estiver a 1. Para o caso do bit três, este
só inverte o seu valor, se todos os bits menos significativos estiverem a 1.
Assim, de uma forma genérica, cada bit só inverte o seu valor se todos os que o antecedem estiverem a
1.
A operação de incremento é então muito simples num FF JK (incrementar em binário é inverter o bit)
contudo só deve ser realizada quando todos os bits anteriores estão a um. Esta característica é assim
singular pois necessita conhecer o valor dos bits anteriores (bits de ordem inferior) para decidir se é
necessário incrementar ou não o valor no registo corrente.
Usando um raciocínio modular projectamos um bit de saída (Gout) que indica que os bits anteriores (Gin)
e o actual estão a um. O Gout do andar N será o Gin do andar N+1.

129
Circuito 54 – Circuito da operação de incremento de um bit.
O COMPLEMENTO
A operação de complemento consiste a inverter o valor memorizado. Desta forma se o registo memoriza
zero passará a armazenar um, e vice-versa.
Sigamos a abordagem utilizada para o write e reset; i.e. enquanto o sinal complement estiver a zero o FF
mantém o seu valor. Quando complemente vai a um, o FF inverte o seu valor.
complement 𝑸𝒕+𝝏
0 𝑄𝑡
1 ̅̅̅
𝑄𝑡
Tabela 37 – Tabela de estado seguinte em função de “complement”
complement 𝑸𝒕+𝝏 J K
0 𝑄𝑡 0 0
1 ̅̅̅
𝑄𝑡 1 1
Tabela 38 – Tabela de excitação de J e K em função de “reset”
É então fácil deduzir os valores de J e K como funções de complement:
• 𝐽 = 𝑐𝑜𝑚𝑝𝑙𝑒𝑚𝑒𝑛𝑡
• 𝐾 = 𝑐𝑜𝑚𝑝𝑙𝑒𝑚𝑒𝑛𝑡
Donde é fácil produzir o seguinte circuito.

130
Circuito 55 – Circuito da operação de complemento de um bit.
JUNTANDO AS OPERAÇÕES
Agora que criámos de forma individual todas as operações que necessitamos para o nosso FF JK,
verificamos que, de uma forma geral, cada uma delas produziu funções para J e para K. Falta realizar o
último passo, juntar todas as operações num único circuito. Como decidimos, por especificação, que a
activação das operações acontece com sinais mutuamente exclusivo com valor um podemos realizar a
junção dos circuitos com duas portas lógicas OR para o J e para o K. Resultando assim no esquema que se
apresenta.
Circuito 56 – Registo de um bit com as cinco operações base.
SIMULAÇÃO DO REGISTO DE 1 BIT

Todas as simulações apresentadas foram geradas com a aplicação informática Xilinx versão J.36 release
9.2i com as seguintes configurações:
Figura 78 – Configuração de sinais no Xilinx

131
Repare que os sinais de entrada e de saídas estão em avanço 15 ns em relação ao clock. Esta opção
permite configurar a simulação assumindo que os valores estão estáveis no momento da transição do
clock. Observe com atenção as simulações e conseguirá verificar o adiantamento dos sinais.
Figura 79 – simulação do registo de 1 bit
FINALMENTE OS 8 BITS
O passo seguinte é o mais simples, garantir um registo de 8 bits. Como já foi referido um registo de 8 bits
(um byte) não é mais do que 8 registos de um bit solidários, isto é, partilhando entre si as linhas de
comando de operações, assim como clock. Desta forma, apesar de termos 8 registos, continuamos a ter
o mesmo número de sinais de activação das operações e um clock.
Na implementação apresentada é possível identificar as entradas e as saídas escritas em forma de BUS. O

que se identifica no esquema eléctrico através de um fio mais escuro. Nesta montagem cada registo
corresponde a um bit. o registo mais à esquerda será o bit de maior peso e o mais à direita de novo peso.
São apresentados 3 BUS que correspondem ao BUS de entrada, ao BUS de saída em baixo impedância
(ligado diretamente às saídas Q dos flip-flops) e ao BUS de saída com proteção de tristate.
Circuito 57 – Registo de oito bits
Note que para o incremento funcionar, o bit Gout de cada registo de um bit é ligado ao bit Gin do registo
mais significativo. Existem no entanto duas excepções:
• O Gout do último bit fica no ar (não existe nenhum bit mais significativo que o bit 7;
• O Gin do bit zero está ligado a VCC. Note que o princípio do Gin é verificar se todos os bits
inferiores ao presente estão a um. Considerando que não existe nenhum bit no nosso registo
inferior ao bit 0, então podemos assumir que todos os que lhe são inferiores estão a um. É este

132
facto que permite que o bit 0 do nosso registo mude o seu valor quando o sinal de incremento
está a um e existe um clock.
SIMULAÇÃO DO REGISTO DE 8 BITS

Para teste do nosso circuito decidimos fazer as seguintes operações: reset; ler; incrementar; ler; escrever;
ler; complementar. Repare que forçamos o valor do din a 55.
Obtivermos a simulação apresentada de seguida:
Figura 80 – simulação do registo de 8 bits
INTERLIGANDO REGISTOS ATRAVÉS DE BUS DE DADOS

Um BUS não é mais do que um conjunto de fios. A cada fio é atribuído uma identificação que no caso
presente será a sua posição. Consideramos assim que vamos ter o bit0, que corresponde ao bit de menor
peso, e todos os outros até ao de maior peso. Como optamos por uma arquitectura de 8 bits vamos ter 8
fios marcados de bit0 a bit7.
O BUS é usado para ligar diversos componentes. Permitindo assim a comunicação entre todos.
Figura 81 – Esquema de quatro registos interligados por BUS de dados
Desta forma é possível ler e escrever entre todos os registos sem que sejam necessários fios dedicados
para realizar todas as ligações possíveis.
Esta solução só é possível porque projectámos um registo que mantém as suas saídas em alta impedância
até o sinal de leitura ser activado. Ler de A e escrever em B consiste assim em activar o sinal RA e WB e
aguardar pelo flanco ascendente do clock.

133
A MEMÓRIA
A memória é um elemento indispensável para o funcionamento do CPU. A memória complementa a

capacidade de registo e consulta de informação do CPU. A memória pode ser vista como um vector de
registos sobre os quais se podem fazer operações de escrita e de leitura, identificando o registo através
de um número, o seu endereço.
QUATRO ENDEREÇOS DE UM BIT
Vamos começar por construir uma pequena unidade de memória com quatro endereços e um bit de
capacidade de armazenamento.
Faremos recurso a FFD com clock, a um descodificador, a um multiplexer, a quatro portas AND e um
tristate.
Circuito 58 – A RAM de quatro elementos de um bit
A ESCRITA
O descodificador quando activado pelo sinal de W/nR activa uma das AND deixando passar o sinal de clock
para o respectivo FFD. A saída do descodificador que é activada depende das suas entradas de selecção
A1 e A0, que são interpretadas no módulo final como os endereços das RAM.

134
A LEITURA
Para permitir a ligação da RAM a um BUS é necessário garantir que a saída está em alta impedância até o
sinal de leitura ser accionado. Neste sentido opta-se por usar um tristate usando o sinal W/nR como sinal
de controlo. Assumimos um tristate active low. Desta forma a RAM força um valor à sua saída sempre que
o sinal W/nR apresenta o valor 0. A selecção da saída a apresentar é realizada com o recurso a um
multiplexer que partilha as linhas de endereço com o descodificador de entrada (escrita).
ENABLE DA RAM
Para podermos facilmente activar ou desactivar a RAM vamos projectar um sinal de enable.
A RAM só deve apresentar o comportamento descrito caso tenha o sinal de enable activo, caso contrário
não grava valores e deixa a sua saída em alta impedância. Dito por outras palavras, a RAM só é sensível
aos sinais de controlo: R/nW, A1, A0 e clock, se o enable tiver o valor um.
Circuito 59 – Enable da RAM.
A saída do AND será então ligada à entrada CLK Circuito 58 (A RAM de quatro elementos de um bit) e a
saída do OR ligada à entrada WnR do mesmo circuito. Note que quando o sinal enable estiver a zero, o
OR vai produzir o valor um fazendo com que o sinal WnR do Circuito 58 não possa ir a zero. Desta forma
a saída ficará em alta impedância quando enable estiver a zero.
UMA MEMÓRIA DE QUATRO BYTES
O projecto de uma memória de oito bytes é agora simples. Juntemos oito unidades de um bit e liguemos
de forma solidária as entradas de endereço, clock e W/nr por forma todas partilhem os mesmos valores
nos mesmos sinal. As saídas e entradas correspondem aos bits do nosso byte.

135
Figura 82 – Esquema da RAM de 4 bits
UMA MEMÓRIA DE N BYTES
A expansão para maiores dimensões passa pelo dimensionamento dos nossos elementos. O
endereçamento binário força a dimensões múltiplas de dois. Pelo que os bits de endereço são sempre
logaritmo de 2 da dimensão pretendida. Dito de outra forma, dois elevado à potência do número de bits
define a dimensão da nossa memória.
As alterações terão de ser efectuadas em todo o sistema, contudo é uma questão de escala. Descodificar
e multiplexar com entradas de seleção para a dimensão pretendida. FFD e portas AND que suprimam as
necessidades.
Alternativamente podemos tirar partido da nossa memória de 4 bytes e agrupar duas para obter uma
memória de 8 bytes. Uma vez mais os sinais de controlo A1, A0, CLK, WnR e enable servem em simultâneo
para os dois módulos de 4 bytes, os bits de entrada e de saída são juntos, para só ter 8 bits de entrada e
8 de saída. A selecção de se estamos a endereçar os 4 bytes mais baixos de memória ou os 4 mais altos é
efectuada por um bit de endereço adicional A2 que irá actuar nos enables.
INTERLIGANDO OS REGISTOS E A MEMÓRIA
O mesmo BUS de dados que interliga os registos serve também para ligar a memória. Criamos com esta
montagem uma plataforma que passa a acrescentar à comunicação entre os registos e capacidade de
troca de informação entre registos e a memória.
A escrita ou leitura na memória obriga a identificar via BUS de endereço de qual o elemento a afectar.
Relembre que numa arquitectura de 8 bits de endereçamento pode ter uma memória com 256 posições
distintas.

136
Figura 83 – Plataforma com 4 registos (A,B,C,D) e uma memória
USANDO A PLATAFORMA
A realização de operações sobre a plataforma passa por activar os sinais necessários pela ordem que
garante a acção que queremos executar.
Exemplo 1: Considere que quer transferir o valor do registo A para o registo B, corresponde à instrução
MOV B, A. O que fazer?
A realização desta operação obriga a activar o LerA(RA) e EscreveB(WB).
Recorde que o sinal RA leva o tristate a deixar o estado de alta impedância o que garante que o valor do
registo A passa a estar presente no BUS de dados. A presença do sinal de WB vai por sua vez garantir a
escrita do valor presente no BUS de dados no registo B efectuando a operação pretendia.
NOTA: Os restantes sinais de controlo da plataforma têm de estar a zero.
Exemplo 2: Considere agora que quer ler de B e escrever na posição 10 da memória.
Para realizar esta operação necessita activar os seguintes sinais:
• RB – para dar ordem de leitura do registo B

• enable – para activar a memória

137
• BUS de endereço – tem que assumir o valor 10

• WnR – para escrever na memória
Controlar o que acontece na nossa plataforma passa assim por activar os sinais que permitem realizar as
acções desejadas.

138
A ALU – UNIDADE ARITMÉTICA E LÓGICA
Uma das funções mais relevantes dos processadores é realizar operações aritméticas e lógicas. Estas
operações são realizadas num módulo especializado da plataforma que assume o nome de ALU – Unidade
Aritmética e Lógica.
Os dados são comunicados à ALU através do BUS de entrada e os resultados após operação são
exportados pelo mesmo BUS (e como veremos no futuro, as características do valor obtido como
resultado da operação aritmética ou lógica são passados através das FLAGS), um módulo que será
integrado na nossa plataforma.
Contudo vamos começar por criar uma ALU muito simples que se limita a somar. Para tal vamos fazer uso
de um somador completo (full adder).
Circuito 60 – A primeira ALU com registo temporário, somador e operação unitária.
Por simplificação optou-se por representar somente os registos A e B deixando de fora os registos C e D
assim como a memória. Notem ainda que nos registos presentes nesta figura, por simplificação, é omitido
o sinal de CLOCK que é o mesmo para todos os registos.
A ALU realiza operações sobre um ou dois operados. Neste momento temos como operação unária a
identidade. Com 2 operandos implementamos a soma. A ALU tem como parâmetros de entrada o(s)
operando(s) e os sinais de controlo que permitem decidir qual a operação a realizar. À semelhança do que
acontece nos registos, não é possível ativar 2 operações em simultâneo (LDTMP e RDADD), pois podem
causar curto-circuitos no BUS interno da ALU.
A ALU possui um registo temporário que armazena o resultado das operações. A existência do BUS interno
na ALU permite um único registo de saída e simplifica a inclusão de novas operações desde que acedam
aos operandos através do BUS de entrada e disponibilizem o resultado isolado por tristate.

139
A IDENTIDADE
O valor apresentado no BUS de dados deve ser gravado no registo temporário da ALU sem alterações. Ou
seja é realizada uma cópia bit a bit. Basta uma porta tristate activada pelo sinal LDTMP que isola o BUS de
dados do CPU do BUS interno da ALU e a capacidade de escrita em simultâneo (num mesmo ciclo de clock)
no registo temporário.
A SOMA
A soma é implementada com o recurso a um somador completo (Full Adder). Uma das entradas é ligada
ao BUS de dados e a outra às saídas em baixo impedância do registo TMP (Saídas Qout ligadas
directamente às saídas Q dos FF). As saídas do somador são ligadas ao BUS interno da ALU com o recurso
a um tristate controlado pelo sinal de RDADD. De notar que à semelhança do que acontece na operação
de Identidade, para que o resultado da soma seja guardado no registo TMP, terão de ser activados no
mesmo ciclo de relógio os sinais RDADD e WTMP.
Nesta fase deve ser evidente que com recurso a esta funcionalidade podemos realizar operações quer de
soma quer de subtracção, se considerarmos que 𝑥 − 𝑦 = 𝑥 + (−𝑦). Basta assim que o subtraendo seja
transformado no seu complemento para 2 e que se realize a adição das duas parcelas.

140
O CONTROLADOR
O controlador é o subsistema do CPU que permite gerar os sinais que realizam as operações que
desejamos. A sua construção é realizada com o recurso a uma máquina de estado.
Relembramos que uma máquina de estados avalia, a cada transição de clock, as entradas e tendo em
consideração o estado corrente decide qual o estado futuro.
Cada estado activa (coloca a um) um conjunto de sinais que são utilizados para realizar as operações
pretendidas. De notar que todos os sinais que não forem referidos num determinado estado estarão a
zero.
É assim que vamos controlar a nossa arquitectura e realizar as operações que o programador decide.
O programador vai condicionar o comportamento da máquina de estados através da memória da nossa

plataforma.
Pensemos em duas instruções base: a cópia de valores entre registos e a soma de valores entre registos:
MOV <REG>, <REG> A instrução MOV copia o valor do registo referenciado como segundo operando para
o registo do primeiro operando.
Exemplos:
MOV A , B – copia o valor de B para A
MOV B , A – copia o valor de A para B
ADD <REG>, <REG> A instrução ADD soma os valores dos registos referenciados nos operandos e guarda
o resultado no primeiro operando.
Exemplos:
ADD A , B – soma o valor de A e B e armazena o resultado em A
ADD B , A – soma o valor de A e B e armazena o resultado em B
Temos agora que decidir como nomear estas instruções, atribuindo códigos de instrução, os chamados
OPCODE. Teremos que atribuir códigos distintos para cada instrução por forma a que o nosso controlador
consiga identificar qual o desejo do programador. Vamos a título de exemplo arbitrar valores. Podiam ser
outros, mas decidimos que seriam estes:
Mnemónica OPCODE Comentário
MOV A,B 0010 1111 (2Fh) ; A=B
MOV B,A 0000 1110 (0Eh) ; B=A

141
ADD A,B 0000 0010 (02h) ; A= A+B
Tabela 39 – Exemplo de codificação de instruções
Arbitramos assim que a sequência de bits 0010 1111 será interpretada como cópia do valor do registo B
para o registo A.
Exercício. Faça o seu primeiro programa que deixa em A e B o dobro do valor de B.
A tarefa não é complexa basta copiar o valor de B para A, fazer a soma dos dois e copiar o resultado de A
para B. Desta forma fica não só assegurado que calculamos o dobro de B como deixamos o resultado nos
dois registos.
A Figura 84 mostra o programa e faz o seu carregamento na memória. Repare que como usamos OPCODE
de 8 bits cada instrução ocupa uma posição de memória.
Figura 84 – Instruções Assembly, opcode e carregamento na memória
O nosso controlador terá assim que ser capaz de consultar a memória para saber qual a instrução a
executar (Fase de Fetch) e passar a executar a instrução (Fase Execute).
AS DUAS FASES DO CONTROLADOR
A máquina de estados que implementa o controlador tem duas fases. A fase de FETCH que serve para
transferir da memória para o controlador o OPCODE da próxima instrução e a fase de EXECUTE, especifica
para cada instrução, e que gera os sinais desejados pelo programador.
Para garantir o suporte a realização das operações do controlador surge a necessidade dos seguintes
registos: o IP (Instruction Pointer), o IR (Instruction Register) e o MAR (Memory Address Register).
O IP (INSTRUCTION POINTER)
O IP é mais um registo de oito bits, contudo está dedicado a armazenar do endereço da próxima instrução.
Podemos encarar assim o IP como um registo apontador para a memória. Veremos no futuro que as
instruções podem ter dimensões de vários bytes mas para já podemos assumir que o valor presente no IP
é sempre o endereço da próxima instrução que será executada. O IP pode também designar-se de
Program Counter (PC) nalguns microprocessadores.

142
O IR (INSTRUCTION REGIST ER).

O IR é mais um registo auxiliar que tem como função única armazenar o OPCODE da instrução que tem
que será executada pelo controlador na FASE EXECUTE. As saídas Q (QOut) do IR são entradas do
controlador, a que chamaremos de OP. E são estas entradas que vão definir qual o próximo estado após
a fase de FETCH; i.e. qual o ramo da máquina de estados do controlador que vai ser executado para
realizar a instrução que tem esse OPCODE. Por outra palavra, no FETCH o controlador lê a posição de
memória apontada pelo IP para o IR e quando acontece novo clock é a sequência de bits armazenada no
IR (o OPCODE da instrução) que define qual o estado o próximo estado do controlador. Esse estado é o
primeiro de uma sequência que realiza as operações necessárias à execução da instrução pretendida pelo
programador.
MAR (MEMORY ADDRESS REGISTER)

O MAR tem a função de fazer a ponte entre o BUS de dados e BUS de endereço. As saídas DOut do MAR
não estão ligadas ao BUS de dados mas sim ao BUS de endereço. Ou seja lê do BUS de dados e escreve no
BUS de endereço. Assim, o Bus de endereço só deixa de estar em alta impedância quando o sinal RMAR
está activo.
O PRIMEIRO CONTROLADOR
Estamos assim em condições de desenharmos o controlador.
Figura 85 – O controlador com as duas fases FETCH e EXECUTE
A INICIALIZAÇÃO
O estado 0 que só acontece quando se aciona o sinal de RESET ou quando se liga o computador, força o
valor do PC (IP) a zero. A opção RESET permite reinicializar o controlador e é o garante que a primeira
instrução a ser executada é sempre a que está localizada no endereço 0000h do espaço de
endereçamento da memória.

143
A FASE DE FETCH
A fase de FETCH do controlador está por agora definida somente com dois estados.
Os dois estados, marcados a amarelo, são responsáveis por lerem o OPCODE da próxima instrução, na
posição de memória apontada por IP, e deixar o seu valor no registo IR.
O primeiro estado lê o PC e escreve no MAR, assegurando assim que o MAR passa a ter o endereço da
posição de memória onde se encontra a próxima instrução. O estado seguinte efectua a leitura da posição
de memoria apontada pelo MAR e escreve o valor lido no IR. É também neste estado que se incrementa
o PC.
Estado Descritivo Sinais activos
1 MAR=PC RPC, WMAR
2 IR=RAM[MAR] RMAR, enable, WIR, IPC
PC=PC+1
Tabela 40 – Fase FETCH
Como o PC, ao entrar no FETCH, aponta sempre para a próxima instrução estes dois estados garantem
que o OPCODE é lido da memória e escrito no IR.
O próximo estado depende da variável OP do controlador que como sabemos tem o valor das saídas QOut
do IR. É este mecanismo que permite ao programador decidir, sem o saber, qual o próximo estado.
O comportamento da nossa máquina de estados passa a sim a ser condicionado pelo programador através
dos valores que escreve na memória. Para que tudo corra bem só temos de garantir que todos os valores
de OPCODE têm correspondência num ramo de máquina de estado específica na fase de EXECUTE.
DIAGRAMA TEMPORAL
O diagrama temporal do FETCH incluindo o sinal assíncrono de RESET para um programa que inicia com a
instrução com o OPCODE 07H.

144
Figura 86 - Diagrama temporal da fase FETCH do controlador.
As entradas nos estados acontecem no flanco descendente do clock do controlador.
Em T0 entramos no estado inicial que só acontece porque é provocado pelo sinal RESET. Enquanto existir
RESET a máquina de estados permanece no estado inicial, mantendo o bus de dados e bus de endereço
em alta impedância. Neste estado o único sinal activo é o ZPC.
Quando o RESET termina a máquina passa a estar sensível ao clock permanecendo no estado inicial até
ao flanco descendente (T2).
Em T2, transita para o estado 1 (RPC, WRMAR). No data bus observamos o valor zero do PC que será
escrito no MAR no flanco ascendente do clock.
Em T3, passamos finalmente para o estado 2 (RMAR, enable, WIR, IPC) o que força a leitura da memória
do valor registado no MAR, que sabemos ser Zero, o que corresponde à leitura do código de operação
(opcode=07H) da primeira instrução do programa. Analisando os sinais observamos que surge no bus de
endereço o valor zero, e que a RAM força o valor 07H (opcode da instrução) valor que será gravado no IR
por acção do WRIR. Repare que o valor de IR só muda no flanco ascendente do clock.
Em T4, entramos na fase de execute da instrução 07H.
Se a instrução fosse outra, em T3 surgirá o opcode correspondente, que será gravado no IR conduzindo à
execução de outra instrução.
Qual a primeira instrução a executar? É uma decisão do programador.
A FASE DE EXECUTE
Esta fase é distinta para cada instrução. Contudo não há surpresas, cada instrução realiza um conjunto
de acções que implementam a instrução solicitada pelo programador. Como a cada instrução corresponde
um OPCODE único fica assegurado com a transição da fase de FETCH para a fase de EXECUTE que a
sequência de estados realiza o trabalho pretendido.

145
Com excepção dos saltos condicionais os estados a executar são sequências.
O último estado de uma instrução tem sempre como próximo estado o primeiro estado do FETCH com
honrosas excepções, a instrução STOP e a HALT, que analisaremos mais tarde.
Claro que é possível imaginar otimizações que evitem estados distintos que activam os mesmos sinais,
mas não nos debrucemos sobre esse assunto por agora.
O CLOCK DA MÁQUI NA DE ESTADOS E DA PLATAFORMA
Num modelo teórico podemos assumir que os sinais são todos síncronos, contudo, na prática é necessário
assumir um atraso entre os sinais de saída da máquina de estado e nas funções de saída e o clock da
restante máquina.
Por exemplo, os sinais de leitura activam os tristates forçando valores no BUS a que estão ligados. É
simples entender que existem atrasos até o BUS apresentar o valor pretendido, uma vez que tem que
deixar de estar em alta impedância.
Caso não seja claro, pense que existem pelo menos os seguintes atrasos desde o momento que a máquina
sente o clock que força a mudança de estado:
• os FF têm que ler as entradas e forçar os valores à saída (EF);

• as funções que implementam as variáveis de saída têm que reagir (FS)
• os sinais de leitura têm de atuar nos tristate (ET),
• os tristate têm que forçar os valores no BUS até chegarem à entrada de todos os registos que
potencialmente podem ser escritos (OT)
Estes valores que acontecem em lógica TTL em valores de nanossegundos e somam-se ao momento inicial
definido pelo clock que actua na máquina de estado.
Se tivermos em consideração que as acções de escrita são síncronas e também dependem de um clock
fica claro que é impossível usar o mesmo clock para a máquina de estados e para a plataforma.
Assim, para que a escrita seja correcta vamos atrasar em meio período o clock dos registos da
plataforma. Em resumo, o controlador muda de estado no flanco descente e a plataforma no flanco
ascendente do clock.
Claro que é possível pensar na solução inversa.
Uma vez assegurado que o meio clock de atraso é suficiente para garantir a estabilidade dos sinais para o
caso mais lento teremos o problema dos atrasos resolvido e podemos voltar a pensar no modelo teórico.

146
Figura 87 - Diagrama temporal de representação de atrasos de sinais.

147
A PRIMEIRA VERSÃO DO NOSSO CPU
Juntando todos os componentes podemos finalmente vislumbrar a primeira versão do nosso processador.
Figura 88 – Arquitectura V1 - Primeira versão do nosso processador.
Pode parecer muito simples, mas apresenta já as mais importantes características presentes em todos os
processadores, a saber:
• capacidade de transferência de informação entre registos internos.

• uma unidade dedicada às operações aritméticas e lógicas que recebe operandos e devolve
resultados
• condicionamento do seu comportamento via instruções que são registadas na memória pelo
programador.
O nosso próximo passo será melhorar o leque de instruções.
Comecemos por acrescentando a capacidade de interagir com a memória. Como é sabido só existem duas
operações possíveis ler ou escrever na memória.
LER E ESCREVER DA MEMÓRIA VARIÁVEIS E CONSTANTES
Vamos reutilizar a mnemónica MOV contudo vamos agora permitir que um dos operandos seja registo e
o outro uma posição de memória. Resulta assim que:
MOV <OP1>, <OP2> A instrução MOV copia o valor do OP2 referenciado como segundo operando para o
OP1 referenciado como primeiro operando. Recorde que o valor de OP2 permanece inalterado.
Acrescentemos a ambos os operandos, mas em exclusivo (ou seja em XOR), a possibilidade de um dos
operandos ser um endereço de memória; i.e. não existe a hipótese de ambos os operandos serem
memória. Ficamos com a seguintes possibilidades:
• MOV <OP1>, [ADDR] Transferir para o registo OP1 o valor da posição de memória ADDR (Leitura
da memória)

148
• MOV [ADDR], <OP2> Transferir o valor do registo OP2 para uma posição de memória ADDR
(Escrita na memória)
Os parenteses rectos indicam que o valor referido no interior é um apontador ou seja:
• MOV A, [10] - Transferir para o registo A o valor da posição de memória 10 (Leitura do valor da
memória da posição 10 para A)
• MOV [10], A – Transferir o valor do registo A para uma posição de memória 10 (Escrita na
memória, na posição 10 o valor do registo A)
Aproveitamos para acrescentar outra instrução muito útil que é transferir uma constante para um registo,
resultando na seguinte notação:
• MOV <OP1>, VALUE Transferir para o registo OP1 o valor VALUE
Acrescentamos assim mais três novas instruções para cada registo. E, por conseguinte, reservamos mais
três OPCODE por cada registo, num total de 12 novos OPCODE.
Teremos de fazer outra alteração, estas operações passam a ocupar dois bytes. O primeiro byte, o
OPCODE, deixa de descrever totalmente a instrução, passando nestes casos a indicar somente tipo da
instrução (ler de um endereço para registo, escrever de registo para um endereço e ler um valor para um
registo). O segundo byte indica o valor do endereço ou da constante.
Endereço Binário Hex Assembly Comentário
00h 0010 0001 21h MOV A, [10] ; Escreve em A o valor da posição 10 da memória
01h 0000 1010 0Ah
02h 0010 0110 26h MOV B, 20 ; Escreve o valor 20 no registo B
03h 0001 0010 12h
04h 0010 0101 25h MOV [10], B ;Escreve na posição 10 da memória o valor de B (20)
05h 0000 1010 0Ah
Tabela 41 – Escrevendo e lendo da memória
Passamos assim a poder escrever e ler da memória variáveis e constantes.
INSTRUÇÕES DE SALTO
Vamos agora acrescentar as instruções de salto (os “jump”) condicionais e incondicionais. Estas instruções
permitem alterar o valor do PC (“efectuar um salto”) alterando assim a próxima instrução a ser executada
pelo CPU. Relembre que até ao momento as instruções são executadas sequencialmente seguindo a
ordem pré-definida pelo programador. Contudo, e quem já programou sabe bem que a execução de um
código tem de conter ciclos e momentos de decisão.
Forcemos a necessidade das novas instruções com um pequeno desafio.
Exercício: Crie um programa em Assembly que some os valores armazenados nas posições 16 e 17 da
memória e que deixe o resultado na posição 18.

149
01h 0001 0000 10h
02h 0010 0010 22h MOV B, [17] ; Escreve em B o valor da posição 17 da memória
03h 0001 0001 11h
04h 0000 0001 01h ADD A,B ; Adiciona A a B e deixa o valor em A
05h 0001 0010 12h MOV [18], A ;Escreve na posição 18 da memória o valor de B
06h 0001 0010 12h
Tabela 42 – Soma de duas variáveis sem carry
Este programa sofre de um problema de fundo que é ignorar o Carry da soma. Analise com atenção qual
será o resultado sempre que o resultado da soma for superior a 255.
Sempre que somamos dois números com N dígitos podemos obter um resultado com N+1 dígitos.
Qualquer que seja a base. Na nossa arquitectura de 8 bits a soma de dois números pode resultar num
número de 9 bits. O que obriga o programador a reservar um byte extra para o resultado o que pode
parecer excessivo, mas não nos resta outra solução uma vez que o acesso à memória é por palavras de 8
bits.
O cuidado da reserva do byte extra na memória fica a cargo do programador e nada temos que alterar na
nossa arquitectura, contudo ficam a faltar as instruções que permite ao programador saber o que
aconteceu ao Carry e como reagir em conformidade. A solução é assim criar a instrução de salto
condicionado caso ocorra Carry.
01h 0001 0000 10h
02h 0010 0010 22h MOV B, [17] ; Escreve em B o valor da posição 17 da memória
03h 0001 0001 11h
04h 0000 0001 01h ADD A, B ; Adiciona A a B e deixa o resultado em A
05h 0001 0010 12h MOV [18], A ;Escreve na posição 18 da memória o valor de B
06h 0001 0010 12h
07h 0010 0011 23h MOV A, 1 ; Escreve 1 no registo A
08h 0000 0001 01h
09h 0001 0011 13h MOV [19], A ; Escreve o registo A (1) na posição 19
0Ah 0001 0011 13h ; Assume, por omissão que existiu carry
0Bh 0100 0000 40h JC FIM ; Salta para FIM caso exista CARRY
0Ch 0001 0001 11h ; porque já tratámos deste caso. FIM é a posição 011h
0Dh 0010 0011 23h MOV A, 0 ; Escreve 0 no registo A
0Eh 0000 0000 00h ;
0Fh 0010 0010 22h MOV [19], A ; Escreve o registo A (0) na posição 19
10h 0001 0011 13h ; repõe o byte mais significativo a zero
11h 0000 0000 FIM: STOP ; Instrução de paragem para o processador
Tabela 43 – Soma de duas variáveis sem carry

150
O algoritmo utilizado transfere os valores da memória e soma os valores em registo. Em seguida transfere
o resultado para a parte baixa e força a parte alta do resultado a 1, assumimos assim que o resultado
ultrapassa os 8 bits. Caso exista carry pode saltar para o fim do programa (dado que foi esta a nossa
assumpção), ou seja, salta para a label FIM localizada na posição 11h. Caso não exista corrigir a parte alta
do resultado com 0.
Existem diversos tipos de saltos condicionais. A maioria está relacionada com o resultado obtido pela
realização de operações aritméticas e lógicas e dependem do estado das FLAGS.
AS FLAGS
As FLAGS registam factos relacionados com as operações aritméticas e lógicas.
As FLAGS acrescentam informação ao resultado (Carry, Zero, Sinal), detectam situações de erro
(overflow), ou podem ser utilizadas como meio de informação para detecção de erro no futuro (paridade).
São assim sinais que resultam da análise do resultado obtido.
FLAG ZERO
A FLAG zero assinala que o resultado da operação é zero. A sua implementação pode ser realizada com
uma porta lógica NOR de oito entradas. Esta porta só apresenta o valor verdade à saída se todos as
entradas estiverem a zero.
Circuito 61 – Implementação da FLAG zero com NOR de 8 entradas.
Como as FLAGS analisam o resultado obtido pela operação aritmética ou lógica, este valor deve ser obtido
por inspecção do Bus interno da ALU (AIB – ALU Internal Bus) no exacto momento em que obtemos o
resultado final da operação aritmética ou lógica no AIB e vamos escrever esse valor no registo temporário
da ALU. O mesmo ocorre com as demais flags que analisaremos de seguida.
FLAG SINAL
A FLAG sinal detecta que o resultado da operação é positivo ou negativo. Esta a é FLAG mais fácil de
implementar basta para usar o bit de maior peso. Relembramos que em código de complementos para 2
o sinal de um número é assinalado através do bit de maior peso. Assim, quando este bit é 1, estamos na
presença de um resultado negativo e quando é zero o resultado é positivo. Esta FLAG só faz sentido
quando se estiver a trabalhar com números inteiros; i.e. positivos e negativos. Se estiver a trabalhar
exclusivamente com números sem sinal esta FLAG é irrelevante. Contudo será igualmente calculada.
FLAG OVERFLOW

151
A FLAG detecta a existência de overflow na soma. Este sinal obtém-se directamente do somador
completo.
FLAG CARRY (E VAI UM)

A FLAG detecta a existência de carry na soma. Este sinal obtém-se igualmente do somador completo.
FLAG PARIDADE
A FLAG paridade assinala o facto de o número de uns presentes no resultado ser par ou ímpar. Para gerar
o bit de paridade utiliza-se um XOR de oito entradas. Relembramos que o XOR apresenta o valor zero à
saída sempre que for par o número de uns à entrada. Zero uns é um número par de uns. O zero é par em
binário.
Circuito 62 – Implementação da Paridade com XOR de 8 entradas.
FLAG INTERRUPÇÃO
A FLAG interrupção é uma excepção e tem como objectivo informar o processador se tem o mecanismo
de interrupções activo. Fica aqui esta nota. Elaboraremos mais sobre o assunto mais à frente.
UMA ALU COM FLAGS
A nossa nova ALU possui agora a lógica booleana necessária para implementar os sinais das FLAGS e
disponibiliza o seu valor para o exterior como resultados temporários.

152
Figura 89 – ALU com sinais de FLAGS.
O REGISTO DAS FLAGS
As saídas dos circuitos que implementam as FLAGs estão todas ligadas ao BUS interno da ALU. As suas
saídas estão sempre a apresentar valores mesmo quando o BUS da ALU está em alta impedância.
Relembre que as portas lógicas apresentam valores à saídas mesmo que as suas entradas estejam em alta
impedância. Este facto não é problemático.
Porém, não podemos perder o nosso objectivo. Queremos usar as FLAGS com as instruções de salto
condicional. Ou seja, temos de armazenar o seu valor. Só desta forma teremos o valor correcto da última
instrução aritmética ou lógica executada.
Relembre que o momento correcto para armazenar o valor das FLAGS é quando escrevemos o resultado
final da operação no registo temporário. É neste preciso momento, no momento da gravação do registo
temporário, que as FLAGS têm significado. Antes e depois os valores apresentados nas FLAGS são
irrelevantes pois são resultado de leituras do BUS interno em que está em alta impedância ou possui
valores intermédios na realização da operação.
Como no futuro vamos querer escrever no registo das FLAGS via BUS interno do CPU vamos utilizar
tristates para podermos gravar bits provenientes do BUS de dados ou em alternativa das FLAGS.
O sinal RfB/nRfA faz a selecção do tristate de 8 bits que deve fiar activo. Quando tiver o valor um
estaremos a ler do BUS do CPU, quando estiver a zero a leitura será das FLAGS.

153
Figura 90 – O registo das FLAGS e as suas entradas.

154
ARQUITECTURA V3
Juntando de novo todos os módulos obtemos a arquitectura actual. Repare que existem duas entradas
no registo de FLAGS permitindo a leitura do BUS interno de dados e dos sinais de saídas das FLAGS da
ALU.
Figura 91 – Arquitectura V2.

155
GLOSSÁRIO
Set: Preset - Levar um registo a um
Clear: Reset – Levar um registo a zero.
SOP: soma-de-produtos
POS: produto-de-somas

156
BIBLIOGRAFIA
Circuitos Digitais e Microprocessadores - Herbert Taub - McGraw-Hill – ISBN 0-07-066595-8
Digital Design - Principles and Practice - John F. Wakerly - Prentice-Hall -ISBN 0-13-082599-9
Digital Fundamentals, Thomas L Floyd, Pearson International Edition - Prentice Hall, ISBN 0-13-814646-2
Digital Logic circuit analysis & design. NELSON, V. P.; NAGLE H. T.; IRWIN J. D.; CARROLL B.D. Prentice Hall
Digital Logic Circuit Analysis & Design - Victor P. Nelson, H. Troy Nagle, J. David Irwin, Bill D. Carroll -
Prentice Hall - ISBN 0-13-463894-8
Digital Systems: principles and applications. 9th ed., TOCCI, R. J.; WIDMER, N. S.; MOSS, G. L.., Prentice-
Hall, 2004.
Engenharia do Projeto Lógico Digital: Conceitos e Prática. FREGNI, E.; SARAIVA, A. M. Editora Edgard
Blücher Ltda, 1995.
Engineering Digital Design, Richard F. Tinder, Academic Press, ISBN 0-12-691295-5
Logic and Computer Design Fundamentals - M. Morris Mano, Charles Kime -Prentice-Hall - ISBN 0-13-
182098-2
Practical Electronics for Inventors, Paul Scherz, McGraw Hill, Chapter 12, ISBN 0-07-058078-2
Projectos de sistemas digitais, Editorial Presença, Colecção: Edições Escolares - ISBN 972-23-1770-9
Sebenta de Sistemas Lógicos, Adolfo Steiger Garção
TTL Data Book. Fairchild Semiconductor. Mountain View, California, 1978.


Sebenta Sistemas Logicos v13

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sebenta Sistemas Logicos v13

Enviado por

Direitos autorais:

Formatos disponíveis

Universidade Nova de Lisboa

Pedro Alexandre da Costa Sousa

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

ASCII – Código alfanumerico de caracteres ................................................................................... 30

A função disjunção ou soma booleano - OR (74LS32) ................................................... 38

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

E em mapas com 4 variáveis ......................................................................................................... 68

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Flip-flop D (clock) ....................................................................................................................... 100

Modelo Moore e diagrama de estados ...................................................................... 108

Detector de sequência 101 sem sobreposição ........................................................... 119

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Simulação do registo de 8 bits ................................................................................... 132

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

FLAG PARIDADE ......................................................................................................................... 151

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Figura 1 - Sinal analógico e sinal digital ................................................................................................. 17

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Figura 32 – Mapa-k de 3 variáveis com exemplos de agrupamentos de duas células .............................. 68

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Figura 63 – Modelo de operação, diagrama lógico e símbolos lógicos (Copyright Datasheet de ON

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Tabela 1 - Equivalência decimal-binário ................................................................................................ 20

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Tabela 33 – Tabela de estado seguinte em função de “write” e “data_in” ........................................... 125

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Circuito 1 - variável binária ................................................................................................................... 18

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Circuito 32 – Circuito diferença entre dois bits de peso 0. ..................................................................... 91

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Ana Margarida Tomé Gonçalves, 59769

Beatriz Antunes Monteiro de Sousa, 59924

Gonçalo Miguel Lanita Pereira, 65688

João Pedro Freixo Castro Ferreira, 60325

João Nuno Colaço Borges, 64087

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Existem centenas de definições formais para a palavra sistema. Tentemos uma.

Um sistema pode incluir outros sistemas.

Figura 1 - Sinal analógico e sinal digital

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Figura 2 - Níveis de tensão e valores lógicos

Circuito 1 - variável binária

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Zero – Falso: associado à tensão abaixo de 0,7V (normalmente a 0V)

O SIGNIFICADO DA VARIÁVEL BINÁRIA

567 = 7 × 100 + 6 × 101 + 5 × 102

Em que 𝑎𝑖 = 0,1, … , (𝑏 − 1) e n depende da dimensão do número em causa.

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

1 × 20 + 1 × 21 + 0 × 22 + 1 × 23 que na base 2 (binário) poderá ser escrito do seguinte modo N=1011

TABELA DE EQUIVALÊNCIA BASE DECIMAL E BINÁRIA

5 bit 4 bit 3 bit 2 bit 1 bit

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

= (1011)2 × 160 + (0000)2 × 161 =

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

TABELA DE EQUIVALÊNCIA DECIMAL, OCTAL, BINÁRIO E HEXADECIMAL

Decimal Binário Octal Hexadecimal

CONVERSÃO DA BASE DECIMAL PARA OUTRA BASE

Documento de trabalho (RASCUNHO) – Contém erros e omissões que carecem de

Seja o número N escrito na base 10:

𝑁10 = 0.123 = 1 × 10−1 + 2 × 10−2 + 3 × 10−3

Na base b, a parte fraccionária de um número N será escrito sob a forma:

, em que, uma vez mais, 𝑎𝑖 = 0,1, … , (𝑏 − 1)