Projete um contador crescente/decrescente com quatro entradas de controle: countup que habilita a contagem crescente, countdown que habilita a contagem decrescente, um clear síncrono e um set síncrono. Se duas ou mais entradas de controle são 1 s então o contador mantém seu valor corrente de contagem. Use um registrador de carga paralela.
Passo 1
Beleza, vamos entender o que a questão está pedindo. Precisamos projetar um contador que pode contar para cima ou para baixo com quatro entradas de controle: countup para contar pra cima, countdown para contar pra baixo, um clear síncrono para zerar o contador e um set síncrono para definir um valor específico. Além disso, se duas ou mais dessas entradas estiverem ativadas ao mesmo tempo (ou seja, forem 1), o contador deve manter o valor atual, sem contar para cima ou para baixo. Para isso, vamos usar um registrador de carga paralela, que nos permite carregar diretamente um valor específico no contador quando necessário.
Passo 2
Primeiro, vamos entender os componentes básicos que vamos usar:
Contador Up/Down: É um contador que pode aumentar ou diminuir seu valor com base nas entradas de controle.
Clear Síncrono: Reseta o contador para zero quando ativado, sincronizado com o clock.
Set Síncrono: Define o contador para um valor específico quando ativado, também sincronizado com o clock.
Registrador de Carga Paralela: Permite carregar um valor específico no contador através de múltiplas linhas de dados simultaneamente.
Passo 3
Vamos definir as entradas de controle:
countup: Ativa a contagem crescente.
countdown: Ativa a contagem decrescente.
clear: Reseta o contador para zero.
set: Define o contador para um valor específico.
De acordo com a questão, se duas ou mais dessas entradas forem 1 ao mesmo tempo, o contador deve manter seu valor atual. Isso significa que temos que priorizar as operações de contagem e evitar que múltiplas ações ocorram simultaneamente.
Passo 4
Vamos criar uma tabela verdade para determinar o que acontece com o contador baseado nas combinações dessas entradas:
countup
countdown
clear
set
Ação
0
0
0
0
Nenhuma ação (mantém)
1
0
0
0
Conta para cima
0
1
0
0
Conta para baixo
0
0
1
0
Clear (zera o contador)
0
0
0
1
Set (define valor)
1
1
0
0
Mantém valor (duas entradas ativas)
1
0
1
0
Mantém valor
1
0
0
1
Mantém valor
0
1
1
0
Mantém valor
0
1
0
1
Mantém valor
0
0
1
1
Mantém valor
1
1
1
0
Mantém valor
1
1
0
1
Mantém valor
1
0
1
1
Mantém valor
0
1
1
1
Mantém valor
1
1
1
1
Mantém valor
Passo 5
Com base na tabela verdade, podemos observar que apenas quando uma única entrada está ativa, o contador realiza a ação correspondente (contar para cima, para baixo, clear ou set). Em qualquer outra combinação, o contador mantém seu valor atual.
Passo 6
Agora, vamos definir as condições para cada operação:
Contagem para cima: countup = 1 e countdown = 0 e clear = 0 e set = 0
Contagem para baixo: countdown = 1 e countup = 0 e clear = 0 e set = 0
Clear: clear = 1 e countup = 0 e countdown = 0 e set = 0
Set: set = 1 e countup = 0 e countdown = 0 e clear = 0
Manter valor: Qualquer outra combinação (duas ou mais entradas ativas)
Passo 7
Vamos usar a lógica combinacional para determinar qual ação deve ser executada com base nas entradas. Podemos usar portas lógicas para criar sinais que ativam cada operação exclusivamente quando suas condições forem atendidas.
Por exemplo, para a contagem para cima, podemos usar:
Isso significa que Enable_Up só será 1 quando countup for 1 e todas as outras entradas forem 0.
Fazemos o mesmo para as outras operações:
Passo 8
Com esses sinais de habilitação, podemos controlar as entradas do registrador de carga paralela. O registrador vai carregar o valor incrementado, decrementado, zerado ou definido com base nas habilitações.
Contar para cima: Carrega o valor atual + 1
Contar para baixo: Carrega o valor atual - 1
Clear: Carrega 0
Set: Carrega um valor pré-definido
Se nenhuma dessas habilitações estiver ativa (duas ou mais entradas ativas), o registrador simplesmente mantém o valor atual.
Passo 9
Finalmente, vamos resumir como o contador vai funcionar:
Monitorar as entradas de controle (countup, countdown, clear, set).
Determinar qual operação realizar com base nas entradas, usando as equações de habilitação.
Atualizar o valor do contador de acordo com a operação selecionada usando o registrador de carga paralela.
Garantir que, em caso de múltiplas entradas ativas, o contador mantenha seu valor atual.
Resposta
Desenvolvemos um contador up/down com quatro entradas de controle (countup, countdown, clear, set) que utiliza um registrador de carga paralela. As operações de contagem para cima, para baixo, clear e set são habilitadas exclusivamente quando apenas uma entrada está ativa. Quando duas ou mais entradas estão ativas, o contador mantém seu valor atual. Isso é realizado através de lógica combinacional que assegura que apenas a operação correta seja executada com base nas entradas de controle.